pi-subagents 0.11.8 → 0.11.10

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [Unreleased]
 
+## [0.11.10] - 2026-03-21
+
+### Changed
+- Trimmed tool schema and description to reduce per-turn token cost by ~166 tokens (13%). Removed `maxOutput` from the LLM-facing schema (still accepted internally), shortened `context` and `output` descriptions, removed redundant CHAIN DATA FLOW section from tool description, condensed MANAGEMENT bullet points.
+
+## [0.11.9] - 2026-03-21
+
+### Fixed
+- `/agents` overlay launches (single, chain, parallel) and slash commands (`/run`, `/chain`, `/parallel`) now render an inline result card in chat instead of relaying through `sendUserMessage`.
+- `/agents` overlay chain launches no longer bypass the executor for async fallback, fixing a path where async chain errors were silently swallowed.
+
+### Changed
+- All slash and overlay subagent execution now routes through an event bus request/response protocol (`slash-bridge.ts`), matching the pattern used by pi-prompt-template-model. This replaces both the old `sendUserMessage` relay and the direct `executeChain` call in the overlay handler.
+- Slash launches show a live inline card immediately on start that streams current tool, recent tools, and output in real time, rather than appearing only after completion.
+- `/parallel` now uses the native `tasks` parameter directly instead of wrapping through `{ chain: [{ parallel: tasks }] }`.
+
+### Added
+- `slash-bridge.ts` — event bus bridge for slash command execution. Manages AbortController lifecycle, cancel-before-start races, and progress streaming via `subagent:slash:*` events.
+- `slash-live-state.ts` — request-id keyed snapshot store that drives live inline card rendering during execution and restores finalized results from session entries on reload.
+- Clarified README Usage section to distinguish LLM tool parameters from user-facing slash commands.
+
 ## [0.11.8] - 2026-03-21
 
 ### Added

package/README.md

@@ -97,9 +97,11 @@ Semantics:
 
 When `extensions` is present, it takes precedence over extension paths implied by `tools` entries.
 
-**MCP Tools**
+**MCP Tools (optional)**
 
-Agents can use MCP server tools directly (requires the [pi-mcp-adapter](https://github.com/nicobailon/pi-mcp-adapter) extension). Add `mcp:` prefixed entries to the `tools` field:
+If you have the [pi-mcp-adapter](https://github.com/nicobailon/pi-mcp-adapter) extension installed, subagents can use MCP server tools directly. Without that extension, everything below is ignored — MCP integration is entirely optional.
+
+Add `mcp:` prefixed entries to the `tools` field in agent frontmatter:
 
 ```yaml
 # All tools from a server
@@ -118,7 +120,7 @@ The `mcp:` items are additive — they don't affect which builtins the agent get
 
 Subagents only get direct MCP tools when `mcp:` items are explicitly listed. Even if your `mcp.json` has `directTools: true` globally, a subagent without `mcp:` in its frontmatter won't get any direct tools — keeping it lean. The `mcp` proxy tool is still available for discovery if needed.
 
-The MCP adapter's metadata cache must be populated for direct tools to work. On the first session with a new MCP server, tools will only be available through the `mcp` proxy. Restart Pi after the first session and direct tools become available.
+> **First-run caveat:** The MCP adapter caches tool metadata at startup. The first time you connect to a new MCP server, that cache is empty, so tools are only available through the generic `mcp` proxy. After that first session, restart pi and direct tools become available.
 
 **Resolution priority:** step override > agent frontmatter > disabled
 
@@ -425,7 +427,9 @@ Skills are specialized instructions loaded from SKILL.md files and injected into
 
 ## Usage
 
-**subagent tool:**
+These are the parameters the **LLM agent** passes when it calls the `subagent` tool — not something you type directly. The agent decides to use these based on your conversation. For user-facing commands, see [Quick Commands](#quick-commands) above.
+
+**subagent tool parameters:**
 ```typescript
 // Single agent
 { agent: "worker", task: "refactor auth" }

package/index.ts

@@ -15,8 +15,9 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import type { AgentToolResult } from "@mariozechner/pi-agent-core";
 import { type ExtensionAPI, type ExtensionContext, type ToolDefinition } from "@mariozechner/pi-coding-agent";
-import { Text } from "@mariozechner/pi-tui";
+import { Box, Container, Spacer, Text } from "@mariozechner/pi-tui";
 import { discoverAgents } from "./agents.js";
 import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "./artifacts.js";
 import { cleanupOldChainDirs } from "./settings.js";
@@ -28,6 +29,8 @@ import { createAsyncJobTracker } from "./async-job-tracker.js";
 import { createResultWatcher } from "./result-watcher.js";
 import { registerSlashCommands } from "./slash-commands.js";
 import { registerPromptTemplateDelegationBridge } from "./prompt-template-bridge.js";
+import { registerSlashSubagentBridge } from "./slash-bridge.js";
+import { clearSlashSnapshots, getSlashRenderableSnapshot, resolveSlashMessageDetails, restoreSlashFinalSnapshots, type SlashMessageDetails } from "./slash-live-state.js";
 import {
 	type Details,
 	type ExtensionConfig,
@@ -35,6 +38,7 @@ import {
 	ASYNC_DIR,
 	DEFAULT_ARTIFACT_CONFIG,
 	RESULTS_DIR,
+	SLASH_RESULT_TYPE,
 	WIDGET_KEY,
 } from "./types.js";
 
@@ -92,6 +96,48 @@ function ensureAccessibleDir(dirPath: string): void {
 	}
 }
 
+function isSlashResultRunning(result: { details?: Details }): boolean {
+	return result.details?.progress?.some((entry) => entry.status === "running")
+		|| result.details?.results.some((entry) => entry.progress?.status === "running")
+		|| false;
+}
+
+function isSlashResultError(result: { details?: Details }): boolean {
+	return result.details?.results.some((entry) => entry.exitCode !== 0 && entry.progress?.status !== "running") || false;
+}
+
+function rebuildSlashResultContainer(
+	container: Container,
+	result: AgentToolResult<Details>,
+	options: { expanded: boolean },
+	theme: ExtensionContext["ui"]["theme"],
+): void {
+	container.clear();
+	container.addChild(new Spacer(1));
+	const boxTheme = isSlashResultRunning(result) ? "toolPendingBg" : isSlashResultError(result) ? "toolErrorBg" : "toolSuccessBg";
+	const box = new Box(1, 1, (text: string) => theme.bg(boxTheme, text));
+	box.addChild(renderSubagentResult(result, options, theme));
+	container.addChild(box);
+}
+
+function createSlashResultComponent(
+	details: SlashMessageDetails,
+	options: { expanded: boolean },
+	theme: ExtensionContext["ui"]["theme"],
+): Container {
+	const container = new Container();
+	let lastVersion = -1;
+	container.render = (width: number): string[] => {
+		const snapshot = getSlashRenderableSnapshot(details);
+		if (snapshot.version !== lastVersion) {
+			lastVersion = snapshot.version;
+			rebuildSlashResultContainer(container, snapshot.result, options, theme);
+		}
+		return Container.prototype.render.call(container, width);
+	};
+	return container;
+}
+
 export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	ensureAccessibleDir(RESULTS_DIR);
 	ensureAccessibleDir(ASYNC_DIR);
@@ -139,6 +185,19 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 		discoverAgents,
 	});
 
+	pi.registerMessageRenderer<SlashMessageDetails>(SLASH_RESULT_TYPE, (message, options, theme) => {
+		const details = resolveSlashMessageDetails(message.details);
+		if (!details) return undefined;
+		return createSlashResultComponent(details, options, theme);
+	});
+
+	const slashBridge = registerSlashSubagentBridge({
+		events: pi.events,
+		getContext: () => state.lastUiContext,
+		execute: (id, params, signal, onUpdate, ctx) =>
+			executor.execute(id, params, signal, onUpdate, ctx),
+	});
+
 	const promptTemplateBridge = registerPromptTemplateDelegationBridge({
 		events: pi.events,
 		getContext: () => state.lastUiContext,
@@ -192,20 +251,15 @@ CHAIN TEMPLATE VARIABLES (use in task strings):
 • {previous} - Text response from the previous step (empty for first step)
 • {chain_dir} - Shared directory for chain files (e.g., <tmpdir>/pi-chain-runs/abc123/)
 
-CHAIN DATA FLOW:
-1. Each step's text response automatically becomes {previous} for the next step
-2. Steps can also write files to {chain_dir} (via agent's "output" config)
-3. Later steps can read those files (via agent's "reads" config)
-
 Example: { chain: [{agent:"scout", task:"Analyze {task}"}, {agent:"planner", task:"Plan based on {previous}"}] }
 
-MANAGEMENT (use action field — omit agent/task/chain/tasks):
-• { action: "list" } - discover available agents and chains
-• { action: "get", agent: "name" } - full agent detail with system prompt
-• { action: "create", config: { name, description, systemPrompt, ... } } - create agent/chain
-• { action: "update", agent: "name", config: { ... } } - modify fields (merge)
-• { action: "delete", agent: "name" } - remove definition
-• Use chainName instead of agent for chain operations`,
+MANAGEMENT (use action field, omit agent/task/chain/tasks):
+• { action: "list" } - discover agents/chains
+• { action: "get", agent: "name" } - full agent detail
+• { action: "create", config: { name, systemPrompt, ... } }
+• { action: "update", agent: "name", config: { ... } } - merge
+• { action: "delete", agent: "name" }
+• Use chainName for chain operations`,
 		parameters: SubagentParams,
 
 		execute(id, params, signal, onUpdate, ctx) {
@@ -340,7 +394,7 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 
 	pi.registerTool(tool);
 	pi.registerTool(statusTool);
-	registerSlashCommands(pi, state, getSubagentSessionRoot);
+	registerSlashCommands(pi, state);
 
 	pi.events.on("subagent:started", handleStarted);
 	pi.events.on("subagent:complete", handleComplete);
@@ -372,6 +426,7 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 		state.lastUiContext = ctx;
 		cleanupSessionArtifacts(ctx);
 		resetJobs(ctx);
+		restoreSlashFinalSnapshots(ctx.sessionManager.getEntries());
 	};
 
 	pi.on("session_start", (_event, ctx) => {
@@ -392,6 +447,9 @@ MANAGEMENT (use action field — omit agent/task/chain/tasks):
 		}
 		state.cleanupTimers.clear();
 		state.asyncJobs.clear();
+		clearSlashSnapshots();
+		slashBridge.cancelAll();
+		slashBridge.dispose();
 		promptTemplateBridge.cancelAll();
 		promptTemplateBridge.dispose();
 		if (state.lastUiContext?.hasUI) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-subagents",
-  "version": "0.11.8",
+  "version": "0.11.10",
   "description": "Pi extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification",
   "author": "Nico Bailon",
   "license": "MIT",

package/render.ts

@@ -220,6 +220,36 @@ export function renderSubagentResult(
 		);
 		c.addChild(new Spacer(1));
 
+		if (isRunning && r.progress) {
+			if (r.progress.currentTool) {
+				const maxToolArgsLen = Math.max(50, w - 20);
+				const toolArgsPreview = r.progress.currentToolArgs
+					? (r.progress.currentToolArgs.length > maxToolArgsLen
+						? `${r.progress.currentToolArgs.slice(0, maxToolArgsLen)}...`
+						: r.progress.currentToolArgs)
+					: "";
+				const toolLine = toolArgsPreview
+					? `${r.progress.currentTool}: ${toolArgsPreview}`
+					: r.progress.currentTool;
+				c.addChild(new Text(truncLine(theme.fg("warning", `> ${toolLine}`), w), 0, 0));
+			}
+			if (r.progress.recentTools?.length) {
+				for (const t of r.progress.recentTools.slice(-3)) {
+					const maxArgsLen = Math.max(40, w - 24);
+					const argsPreview = t.args.length > maxArgsLen
+						? `${t.args.slice(0, maxArgsLen)}...`
+						: t.args;
+					c.addChild(new Text(truncLine(theme.fg("dim", `${t.tool}: ${argsPreview}`), w), 0, 0));
+				}
+			}
+			for (const line of (r.progress.recentOutput ?? []).slice(-5)) {
+				c.addChild(new Text(truncLine(theme.fg("dim", `  ${line}`), w), 0, 0));
+			}
+			if (r.progress.currentTool || r.progress.recentTools?.length || r.progress.recentOutput?.length) {
+				c.addChild(new Spacer(1));
+			}
+		}
+
 		const items = getDisplayItems(r.messages);
 		for (const item of items) {
 			if (item.type === "tool")

package/schemas.ts

@@ -52,13 +52,6 @@ export const ParallelStepSchema = Type.Object({
 // Note: Using Type.Any() for Google API compatibility (doesn't support anyOf)
 export const ChainItem = Type.Any({ description: "Chain step: either {agent, task?, ...} for sequential or {parallel: [...]} for concurrent execution" });
 
-export const MaxOutputSchema = Type.Optional(
-	Type.Object({
-		bytes: Type.Optional(Type.Number({ description: "Max bytes (default: 204800)" })),
-		lines: Type.Optional(Type.Number({ description: "Max lines (default: 5000)" })),
-	}),
-);
-
 export const SubagentParams = Type.Object({
 	agent: Type.Optional(Type.String({ description: "Agent name (SINGLE mode) or target for management get/update/delete" })),
 	task: Type.Optional(Type.String({ description: "Task (SINGLE mode)" })),
@@ -78,13 +71,12 @@ export const SubagentParams = Type.Object({
 	chain: Type.Optional(Type.Array(ChainItem, { description: "CHAIN mode: sequential pipeline where each step's response becomes {previous} for the next. Use {task}, {previous}, {chain_dir} in task templates." })),
 	context: Type.Optional(Type.String({
 		enum: ["fresh", "fork"],
-		description: "Execution context mode: 'fresh' (default) starts clean, 'fork' starts from a real fork of the parent session leaf",
+		description: "'fresh' (default) or 'fork' to branch from parent session",
 	})),
 	chainDir: Type.Optional(Type.String({ description: "Persistent directory for chain artifacts. Default: <tmpdir>/pi-chain-runs/ (auto-cleaned after 24h)" })),
 	async: Type.Optional(Type.Boolean({ description: "Run in background (default: false, or per config)" })),
 	agentScope: Type.Optional(Type.String({ description: "Agent discovery scope: 'user', 'project', or 'both' (default: 'both'; project wins on name collisions)" })),
 	cwd: Type.Optional(Type.String()),
-	maxOutput: MaxOutputSchema,
 	artifacts: Type.Optional(Type.Boolean({ description: "Write debug artifacts (default: true)" })),
 	includeProgress: Type.Optional(Type.Boolean({ description: "Include full progress in result (default: false)" })),
 	share: Type.Optional(Type.Boolean({ description: "Upload session to GitHub Gist for sharing (default: false)" })),
@@ -94,7 +86,7 @@ export const SubagentParams = Type.Object({
 	// Clarification TUI
 	clarify: Type.Optional(Type.Boolean({ description: "Show TUI to preview/edit before execution (default: true for chains, false for single/parallel). Implies sync mode." })),
 	// Solo agent overrides
-	output: Type.Optional(Type.Any({ description: "Override output file for single agent (string), or false to disable (uses agent default if omitted). Absolute paths are used as-is; relative paths resolve against cwd." })),
+	output: Type.Optional(Type.Any({ description: "Output file for single agent (string), or false to disable. Relative paths resolve against cwd." })),
 	skill: Type.Optional(SkillOverride),
 	model: Type.Optional(Type.String({ description: "Override model for single agent (e.g. 'anthropic/claude-sonnet-4')" })),
 });

package/slash-bridge.ts

@@ -0,0 +1,174 @@
+import type { AgentToolResult } from "@mariozechner/pi-agent-core";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { SubagentParamsLike } from "./subagent-executor.js";
+import {
+	SLASH_SUBAGENT_CANCEL_EVENT,
+	SLASH_SUBAGENT_REQUEST_EVENT,
+	SLASH_SUBAGENT_RESPONSE_EVENT,
+	SLASH_SUBAGENT_STARTED_EVENT,
+	SLASH_SUBAGENT_UPDATE_EVENT,
+	type Details,
+} from "./types.js";
+
+export interface SlashSubagentRequest {
+	requestId: string;
+	params: SubagentParamsLike;
+}
+
+export interface SlashSubagentResponse {
+	requestId: string;
+	result: AgentToolResult<Details>;
+	isError: boolean;
+	errorText?: string;
+}
+
+export interface SlashSubagentUpdate {
+	requestId: string;
+	progress?: Details["progress"];
+	currentTool?: string;
+	toolCount?: number;
+}
+
+interface EventBus {
+	on(event: string, handler: (data: unknown) => void): (() => void) | void;
+	emit(event: string, data: unknown): void;
+}
+
+interface SlashBridgeOptions {
+	events: EventBus;
+	getContext: () => ExtensionContext | null;
+	execute: (
+		id: string,
+		params: SubagentParamsLike,
+		signal: AbortSignal,
+		onUpdate: ((r: AgentToolResult<Details>) => void) | undefined,
+		ctx: ExtensionContext,
+	) => Promise<AgentToolResult<Details>>;
+}
+
+export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
+	cancelAll: () => void;
+	dispose: () => void;
+} {
+	const controllers = new Map<string, AbortController>();
+	const pendingCancels = new Set<string>();
+	const subscriptions: Array<() => void> = [];
+
+	const subscribe = (event: string, handler: (data: unknown) => void): void => {
+		const unsubscribe = options.events.on(event, handler);
+		if (typeof unsubscribe === "function") subscriptions.push(unsubscribe);
+	};
+
+	subscribe(SLASH_SUBAGENT_CANCEL_EVENT, (data) => {
+		if (!data || typeof data !== "object") return;
+		const requestId = (data as { requestId?: unknown }).requestId;
+		if (typeof requestId !== "string") return;
+		const controller = controllers.get(requestId);
+		if (controller) {
+			controller.abort();
+			return;
+		}
+		pendingCancels.add(requestId);
+	});
+
+	subscribe(SLASH_SUBAGENT_REQUEST_EVENT, async (data) => {
+		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;
+
+		const ctx = options.getContext();
+		if (!ctx) {
+			const response: SlashSubagentResponse = {
+				requestId,
+				result: {
+					content: [{ type: "text", text: "No active extension context for slash subagent execution." }],
+					details: { mode: "single" as const, results: [] },
+				},
+				isError: true,
+				errorText: "No active extension context.",
+			};
+			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+			return;
+		}
+
+		const controller = new AbortController();
+		controllers.set(requestId, controller);
+
+		if (pendingCancels.delete(requestId)) {
+			controller.abort();
+			const response: SlashSubagentResponse = {
+				requestId,
+				result: {
+					content: [{ type: "text", text: "Cancelled." }],
+					details: { mode: "single" as const, results: [] },
+				},
+				isError: true,
+				errorText: "Cancelled before start.",
+			};
+			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+			controllers.delete(requestId);
+			return;
+		}
+
+		options.events.emit(SLASH_SUBAGENT_STARTED_EVENT, { requestId });
+
+		try {
+			const result = await options.execute(
+				requestId,
+				params,
+				controller.signal,
+				(update) => {
+					const progress = update.details?.progress;
+					const first = progress?.[0];
+					const payload: SlashSubagentUpdate = {
+						requestId,
+						progress,
+						currentTool: first?.currentTool,
+						toolCount: first?.toolCount,
+					};
+					options.events.emit(SLASH_SUBAGENT_UPDATE_EVENT, payload);
+				},
+				ctx,
+			);
+
+			const response: SlashSubagentResponse = {
+				requestId,
+				result,
+				isError: (result as { isError?: boolean }).isError === true,
+				errorText: (result as { isError?: boolean }).isError
+					? result.content.find((c) => c.type === "text")?.text
+					: undefined,
+			};
+			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+		} catch (error) {
+			const response: SlashSubagentResponse = {
+				requestId,
+				result: {
+					content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+					details: { mode: "single" as const, results: [] },
+				},
+				isError: true,
+				errorText: error instanceof Error ? error.message : String(error),
+			};
+			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+		} finally {
+			controllers.delete(requestId);
+		}
+	});
+
+	return {
+		cancelAll: () => {
+			for (const controller of controllers.values()) {
+				controller.abort();
+			}
+			controllers.clear();
+			pendingCancels.clear();
+		},
+		dispose: () => {
+			for (const unsubscribe of subscriptions) unsubscribe();
+			subscriptions.length = 0;
+			pendingCancels.clear();
+		},
+	};
+}

package/slash-commands.ts

@@ -1,15 +1,27 @@
 import { randomUUID } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { Key, matchesKey } from "@mariozechner/pi-tui";
 import { discoverAgents, discoverAgentsAll } from "./agents.js";
-import { executeAsyncChain, isAsyncAvailable } from "./async-execution.js";
-import { executeChain } from "./chain-execution.js";
 import { AgentManagerComponent, type ManagerResult } from "./agent-manager.js";
 import { discoverAvailableSkills } from "./skills.js";
-import { getArtifactsDir } from "./artifacts.js";
-import { DEFAULT_ARTIFACT_CONFIG, MAX_PARALLEL, type SubagentState, type ArtifactConfig } from "./types.js";
-import type { SequentialStep } from "./settings.js";
+import type { SubagentParamsLike } from "./subagent-executor.js";
+import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.js";
+import {
+	applySlashUpdate,
+	buildSlashInitialResult,
+	failSlashResult,
+	finalizeSlashResult,
+} from "./slash-live-state.js";
+import {
+	MAX_PARALLEL,
+	SLASH_RESULT_TYPE,
+	SLASH_SUBAGENT_CANCEL_EVENT,
+	SLASH_SUBAGENT_REQUEST_EVENT,
+	SLASH_SUBAGENT_RESPONSE_EVENT,
+	SLASH_SUBAGENT_STARTED_EVENT,
+	SLASH_SUBAGENT_UPDATE_EVENT,
+	type SubagentState,
+} from "./types.js";
 
 interface InlineConfig {
 	output?: string | false;
@@ -71,25 +83,6 @@ const extractExecutionFlags = (rawArgs: string): { args: string; bg: boolean; fo
 	return { args, bg, fork };
 };
 
-function setupDirectRun(ctx: ExtensionContext, getSubagentSessionRoot: (parentSessionFile: string | null) => string) {
-	const runId = randomUUID().slice(0, 8);
-	const parentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
-	const sessionRoot = path.join(getSubagentSessionRoot(parentSessionFile), runId);
-	try {
-		fs.mkdirSync(sessionRoot, { recursive: true });
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`Failed to create session directory '${sessionRoot}': ${message}`);
-	}
-	return {
-		runId,
-		shareEnabled: false,
-		sessionDirForIndex: (idx?: number) => path.join(sessionRoot, `run-${idx ?? 0}`),
-		artifactsDir: getArtifactsDir(parentSessionFile),
-		artifactConfig: { ...DEFAULT_ARTIFACT_CONFIG } as ArtifactConfig,
-	};
-}
-
 const makeAgentCompletions = (state: SubagentState, multiAgent: boolean) => (prefix: string) => {
 	const agents = discoverAgents(state.baseCwd, "both").agents;
 	if (!multiAgent) {
@@ -111,11 +104,145 @@ const makeAgentCompletions = (state: SubagentState, multiAgent: boolean) => (pre
 	return agents.filter((a) => a.name.startsWith(lastWord)).map((a) => ({ value: `${beforeLastWord}${a.name}`, label: a.name }));
 };
 
+async function requestSlashRun(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	requestId: string,
+	params: SubagentParamsLike,
+): Promise<SlashSubagentResponse> {
+	return new Promise((resolve, reject) => {
+		let done = false;
+		let started = false;
+
+		const startTimeoutMs = 15_000;
+		const startTimeout = setTimeout(() => {
+			finish(() => reject(new Error(
+				"Slash subagent bridge did not start within 15s. Ensure the extension is loaded correctly.",
+			)));
+		}, startTimeoutMs);
+
+		const onStarted = (data: unknown) => {
+			if (done || !data || typeof data !== "object") return;
+			if ((data as { requestId?: unknown }).requestId !== requestId) return;
+			started = true;
+			clearTimeout(startTimeout);
+			if (ctx.hasUI) ctx.ui.setStatus("subagent-slash", "running...");
+		};
+
+		const onResponse = (data: unknown) => {
+			if (done || !data || typeof data !== "object") return;
+			const response = data as Partial<SlashSubagentResponse>;
+			if (response.requestId !== requestId) return;
+			clearTimeout(startTimeout);
+			finish(() => resolve(response as SlashSubagentResponse));
+		};
+
+		const onUpdate = (data: unknown) => {
+			if (done || !data || typeof data !== "object") return;
+			const update = data as SlashSubagentUpdate;
+			if (update.requestId !== requestId) return;
+			applySlashUpdate(requestId, update);
+			if (!ctx.hasUI) return;
+			const tool = update.currentTool ? ` ${update.currentTool}` : "";
+			const count = update.toolCount ?? 0;
+			ctx.ui.setStatus("subagent-slash", `${count} tools${tool}`);
+		};
+
+		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")));
+				return { consume: true };
+			})
+			: undefined;
+
+		const unsubStarted = pi.events.on(SLASH_SUBAGENT_STARTED_EVENT, onStarted);
+		const unsubResponse = pi.events.on(SLASH_SUBAGENT_RESPONSE_EVENT, onResponse);
+		const unsubUpdate = pi.events.on(SLASH_SUBAGENT_UPDATE_EVENT, onUpdate);
+
+		const finish = (next: () => void) => {
+			if (done) return;
+			done = true;
+			clearTimeout(startTimeout);
+			unsubStarted();
+			unsubResponse();
+			unsubUpdate();
+			onTerminalInput?.();
+			if (ctx.hasUI) ctx.ui.setStatus("subagent-slash", undefined);
+			next();
+		};
+
+		pi.events.emit(SLASH_SUBAGENT_REQUEST_EVENT, { requestId, params });
+
+		// Bridge emits STARTED synchronously during REQUEST emit.
+		// If not started, no bridge received the request.
+		if (!started && done) return;
+		if (!started) {
+			finish(() => reject(new Error(
+				"No slash subagent bridge responded. Ensure the subagent extension is loaded correctly.",
+			)));
+		}
+	});
+}
+
+function extractSlashMessageText(content: string | Array<{ type?: string; text?: string }>): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.filter((part): part is { type: "text"; text: string } => part?.type === "text" && typeof part.text === "string")
+		.map((part) => part.text)
+		.join("\n");
+}
+
+async function runSlashSubagent(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	params: SubagentParamsLike,
+): Promise<void> {
+	const requestId = randomUUID();
+	const initialDetails = buildSlashInitialResult(requestId, params);
+	const initialText = extractSlashMessageText(initialDetails.result.content) || "Running subagent...";
+	pi.sendMessage({
+		customType: SLASH_RESULT_TYPE,
+		content: initialText,
+		display: true,
+		details: initialDetails,
+	});
+
+	try {
+		const response = await requestSlashRun(pi, ctx, requestId, params);
+		const finalDetails = finalizeSlashResult(response);
+		const text = extractSlashMessageText(response.result.content) || response.errorText || "(no output)";
+		pi.sendMessage({
+			customType: SLASH_RESULT_TYPE,
+			content: text,
+			display: false,
+			details: finalDetails,
+		});
+		if (response.isError && ctx.hasUI) {
+			ctx.ui.notify(response.errorText || "Subagent failed", "error");
+		}
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		const failedDetails = failSlashResult(requestId, params, message === "Cancelled" ? "Cancelled" : message);
+		pi.sendMessage({
+			customType: SLASH_RESULT_TYPE,
+			content: message,
+			display: false,
+			details: failedDetails,
+		});
+		if (message === "Cancelled") {
+			if (ctx.hasUI) ctx.ui.notify("Cancelled", "warning");
+			return;
+		}
+		if (ctx.hasUI) ctx.ui.notify(message, "error");
+	}
+}
+
 async function openAgentManager(
 	pi: ExtensionAPI,
-	state: SubagentState,
 	ctx: ExtensionContext,
-	getSubagentSessionRoot: (parentSessionFile: string | null) => string,
 ): Promise<void> {
 	const agentData = { ...discoverAgentsAll(ctx.cwd), cwd: ctx.cwd };
 	const models = ctx.modelRegistry.getAvailable().map((m) => ({
@@ -132,54 +259,26 @@ async function openAgentManager(
 	if (!result) return;
 
 	if (result.action === "chain") {
-		const agents = discoverAgents(state.baseCwd, "both").agents;
-		const exec = setupDirectRun(ctx, getSubagentSessionRoot);
-		const chain: SequentialStep[] = result.agents.map((name, i) => ({
+		const chain = result.agents.map((name, i) => ({
 			agent: name,
 			...(i === 0 ? { task: result.task } : {}),
 		}));
-		executeChain({ chain, task: result.task, agents, ctx, ...exec, clarify: true })
-			.then((r) => {
-				if (r.requestedAsync) {
-					if (!isAsyncAvailable()) {
-						pi.sendUserMessage("Background mode requires jiti for TypeScript execution but it could not be found.");
-						return;
-					}
-					const id = randomUUID();
-					const asyncCtx = { pi, cwd: ctx.cwd, currentSessionId: ctx.sessionManager.getSessionId() ?? id };
-					const asyncSessionRoot = getSubagentSessionRoot(ctx.sessionManager.getSessionFile() ?? null);
-					fs.mkdirSync(asyncSessionRoot, { recursive: true });
-					executeAsyncChain(id, {
-						chain: r.requestedAsync.chain,
-						agents,
-						ctx: asyncCtx,
-						maxOutput: undefined,
-						artifactsDir: exec.artifactsDir,
-						artifactConfig: exec.artifactConfig,
-						shareEnabled: false,
-						sessionRoot: asyncSessionRoot,
-						chainSkills: r.requestedAsync.chainSkills,
-					}).then((asyncResult) => {
-						pi.sendUserMessage(asyncResult.content[0]?.text || "(launched in background)");
-					}).catch((err) => {
-						pi.sendUserMessage(`Async launch failed: ${err instanceof Error ? err.message : String(err)}`);
-					});
-					return;
-				}
-				pi.sendUserMessage(r.content[0]?.text || "(no output)");
-			})
-			.catch((err) => pi.sendUserMessage(`Chain failed: ${err instanceof Error ? err.message : String(err)}`));
+		await runSlashSubagent(pi, ctx, {
+			chain,
+			task: result.task,
+			clarify: true,
+			agentScope: "both",
+		});
 		return;
 	}
 
-	const sendToolCall = (params: Record<string, unknown>) => {
-		pi.sendUserMessage(
-			`Call the subagent tool with these exact parameters: ${JSON.stringify({ ...params, agentScope: "both" })}`,
-		);
-	};
-
 	if (result.action === "launch") {
-		sendToolCall({ agent: result.agent, task: result.task, clarify: !result.skipClarify });
+		await runSlashSubagent(pi, ctx, {
+			agent: result.agent,
+			task: result.task,
+			clarify: !result.skipClarify,
+			agentScope: "both",
+		});
 	} else if (result.action === "launch-chain") {
 		const chainParam = result.chain.steps.map((step) => ({
 			agent: step.agent,
@@ -190,9 +289,18 @@ async function openAgentManager(
 			skill: step.skills,
 			model: step.model,
 		}));
-		sendToolCall({ chain: chainParam, task: result.task, clarify: !result.skipClarify });
+		await runSlashSubagent(pi, ctx, {
+			chain: chainParam,
+			task: result.task,
+			clarify: !result.skipClarify,
+			agentScope: "both",
+		});
 	} else if (result.action === "parallel") {
-		sendToolCall({ tasks: result.tasks, clarify: !result.skipClarify });
+		await runSlashSubagent(pi, ctx, {
+			tasks: result.tasks,
+			clarify: !result.skipClarify,
+			agentScope: "both",
+		});
 	}
 }
 
@@ -276,12 +384,11 @@ const parseAgentArgs = (
 export function registerSlashCommands(
 	pi: ExtensionAPI,
 	state: SubagentState,
-	getSubagentSessionRoot: (parentSessionFile: string | null) => string,
 ): void {
 	pi.registerCommand("agents", {
 		description: "Open the Agents Manager",
 		handler: async (_args, ctx) => {
-			await openAgentManager(pi, state, ctx, getSubagentSessionRoot);
+			await openAgentManager(pi, ctx);
 		},
 	});
 
@@ -304,13 +411,13 @@ export function registerSlashCommands(
 			if (inline.reads && Array.isArray(inline.reads) && inline.reads.length > 0) {
 				finalTask = `[Read from: ${inline.reads.join(", ")}]\n\n${finalTask}`;
 			}
-			const params: Record<string, unknown> = { agent: agentName, task: finalTask, clarify: false };
+			const params: SubagentParamsLike = { agent: agentName, task: finalTask, clarify: false, agentScope: "both" };
 			if (inline.output !== undefined) params.output = inline.output;
 			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";
-			pi.sendUserMessage(`Call the subagent tool with these exact parameters: ${JSON.stringify({ ...params, agentScope: "both" })}`);
+			await runSlashSubagent(pi, ctx, params);
 		},
 	});
 
@@ -330,10 +437,10 @@ export function registerSlashCommands(
 				...(config.skill !== undefined ? { skill: config.skill } : {}),
 				...(config.progress !== undefined ? { progress: config.progress } : {}),
 			}));
-			const params: Record<string, unknown> = { chain, task: parsed.task, clarify: false, agentScope: "both" };
+			const params: SubagentParamsLike = { chain, task: parsed.task, clarify: false, agentScope: "both" };
 			if (bg) params.async = true;
 			if (fork) params.context = "fork";
-			pi.sendUserMessage(`Call the subagent tool with these exact parameters: ${JSON.stringify(params)}`);
+			await runSlashSubagent(pi, ctx, params);
 		},
 	});
 
@@ -354,16 +461,16 @@ export function registerSlashCommands(
 				...(config.skill !== undefined ? { skill: config.skill } : {}),
 				...(config.progress !== undefined ? { progress: config.progress } : {}),
 			}));
-			const params: Record<string, unknown> = { chain: [{ parallel: tasks }], task: parsed.task, clarify: false, agentScope: "both" };
+			const params: SubagentParamsLike = { tasks, clarify: false, agentScope: "both" };
 			if (bg) params.async = true;
 			if (fork) params.context = "fork";
-			pi.sendUserMessage(`Call the subagent tool with these exact parameters: ${JSON.stringify(params)}`);
+			await runSlashSubagent(pi, ctx, params);
 		},
 	});
 
 	pi.registerShortcut("ctrl+shift+a", {
 		handler: async (ctx) => {
-			await openAgentManager(pi, state, ctx, getSubagentSessionRoot);
+			await openAgentManager(pi, ctx);
 		},
 	});
 }

package/slash-live-state.ts

@@ -0,0 +1,294 @@
+import type { AgentToolResult } from "@mariozechner/pi-agent-core";
+import type { Message } from "@mariozechner/pi-ai";
+import type { SubagentParamsLike } from "./subagent-executor.js";
+import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.js";
+import { type Details, type SingleResult, type Usage, SLASH_RESULT_TYPE } from "./types.js";
+
+export interface SlashMessageDetails {
+	requestId: string;
+	result: AgentToolResult<Details>;
+}
+
+interface SlashSnapshot {
+	result: AgentToolResult<Details>;
+	version: number;
+}
+
+interface SequentialChainStepLike {
+	agent: string;
+	task?: string;
+}
+
+interface ParallelChainStepLike {
+	parallel: Array<{ agent: string; task?: string }>;
+}
+
+type ChainStepLike = SequentialChainStepLike | ParallelChainStepLike;
+
+const liveSnapshots = new Map<string, SlashSnapshot>();
+const finalSnapshots = new Map<string, SlashSnapshot>();
+let versionCounter = 1;
+
+const EMPTY_MESSAGES: Message[] = [];
+const EMPTY_USAGE: Usage = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	cost: 0,
+	turns: 0,
+};
+
+function nextVersion(): number {
+	return versionCounter++;
+}
+
+function cloneUsage(): Usage {
+	return { ...EMPTY_USAGE };
+}
+
+function createPlaceholderResult(
+	agent: string,
+	task: string,
+	status: "pending" | "running",
+	index?: number,
+): SingleResult {
+	return {
+		agent,
+		task,
+		exitCode: 0,
+		messages: EMPTY_MESSAGES,
+		usage: cloneUsage(),
+		progress: {
+			...(index !== undefined ? { index } : {}),
+			agent,
+			status,
+			task,
+			recentTools: [],
+			recentOutput: [],
+			toolCount: 0,
+			tokens: 0,
+			durationMs: 0,
+		},
+	};
+}
+
+function buildParallelInitialResult(params: SubagentParamsLike): AgentToolResult<Details> {
+	const tasks = params.tasks ?? [];
+	return {
+		content: [{ type: "text", text: tasks.map((task) => `${task.agent}: ${task.task}`).join("\n\n") }],
+		details: {
+			mode: "parallel",
+			...(params.context ? { context: params.context } : {}),
+			results: tasks.map((task, index) => createPlaceholderResult(task.agent, task.task, "running", index)),
+			progress: tasks.map((task, index) => ({
+				index,
+				agent: task.agent,
+				status: "running" as const,
+				task: task.task,
+				recentTools: [],
+				recentOutput: [],
+				toolCount: 0,
+				tokens: 0,
+				durationMs: 0,
+			})),
+		},
+	};
+}
+
+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 ?? "";
+	return {
+		content: [{ type: "text", text: task }],
+		details: {
+			mode: "single",
+			...(params.context ? { context: params.context } : {}),
+			results: [createPlaceholderResult(agent, task, "running")],
+			progress: [{
+				agent,
+				status: "running",
+				task,
+				recentTools: [],
+				recentOutput: [],
+				toolCount: 0,
+				tokens: 0,
+				durationMs: 0,
+			}],
+		},
+	};
+}
+
+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);
+	liveSnapshots.set(requestId, { result, version: nextVersion() });
+	finalSnapshots.delete(requestId);
+	return { requestId, result };
+}
+
+function cloneResultsWithProgress(
+	results: SingleResult[],
+	progress: NonNullable<Details["progress"]> | undefined,
+): SingleResult[] {
+	return results.map((result, index) => {
+		const nextProgress = progress?.find((entry) => entry.index === index)
+			?? progress?.[index]
+			?? result.progress;
+		return nextProgress ? { ...result, progress: nextProgress } : result;
+	});
+}
+
+export function applySlashUpdate(requestId: string, update: SlashSubagentUpdate): void {
+	const snapshot = liveSnapshots.get(requestId);
+	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 } : {}),
+	};
+	liveSnapshots.set(requestId, {
+		result: {
+			...snapshot.result,
+			details: nextDetails,
+		},
+		version: nextVersion(),
+	});
+}
+
+export function finalizeSlashResult(response: SlashSubagentResponse): SlashMessageDetails {
+	const snapshot = {
+		result: response.result,
+		version: nextVersion(),
+	};
+	finalSnapshots.set(response.requestId, snapshot);
+	liveSnapshots.delete(response.requestId);
+	return {
+		requestId: response.requestId,
+		result: response.result,
+	};
+}
+
+export function failSlashResult(requestId: string, params: SubagentParamsLike, message: string): SlashMessageDetails {
+	const initial = buildSlashInitialResult(requestId, params).result;
+	const failedResults = initial.details.results.map((result) => ({
+		...result,
+		exitCode: 1,
+		error: message,
+		progress: result.progress ? { ...result.progress, status: "failed" as const } : result.progress,
+	}));
+	const result: AgentToolResult<Details> = {
+		content: [{ type: "text", text: message }],
+		details: {
+			...initial.details,
+			results: failedResults,
+			progress: failedResults.map((entry) => entry.progress!).filter(Boolean),
+		},
+	};
+	const snapshot = { result, version: nextVersion() };
+	finalSnapshots.set(requestId, snapshot);
+	liveSnapshots.delete(requestId);
+	return { requestId, result };
+}
+
+function isSlashMessageDetails(value: unknown): value is SlashMessageDetails {
+	if (!value || typeof value !== "object") return false;
+	const v = value as { requestId?: string; result?: { content?: unknown; details?: { results?: unknown } } };
+	if (typeof v.requestId !== "string" || !v.requestId) return false;
+	if (!v.result || !Array.isArray(v.result.content)) return false;
+	return !!v.result.details && Array.isArray(v.result.details.results);
+}
+
+export function resolveSlashMessageDetails(value: unknown): SlashMessageDetails | undefined {
+	return isSlashMessageDetails(value) ? value : undefined;
+}
+
+export function getSlashRenderableSnapshot(details: SlashMessageDetails): SlashSnapshot {
+	return finalSnapshots.get(details.requestId)
+		?? liveSnapshots.get(details.requestId)
+		?? { result: details.result, version: 0 };
+}
+
+export function restoreSlashFinalSnapshots(entries: unknown[]): void {
+	liveSnapshots.clear();
+	finalSnapshots.clear();
+	for (const entry of entries) {
+		const e = entry as { type?: string; message?: { role?: string; customType?: string; display?: boolean; details?: unknown } };
+		if (e?.type !== "message") continue;
+		const m = e.message;
+		if (!m || m.role !== "custom" || m.customType !== SLASH_RESULT_TYPE || m.display !== false) continue;
+		const details = resolveSlashMessageDetails(m.details);
+		if (!details) continue;
+		finalSnapshots.set(details.requestId, { result: details.result, version: nextVersion() });
+	}
+}
+
+export function clearSlashSnapshots(): void {
+	liveSnapshots.clear();
+	finalSnapshots.clear();
+}

package/subagent-executor.ts

@@ -51,7 +51,7 @@ interface TaskParam {
 	progress?: boolean;
 }
 
-interface SubagentParamsLike {
+export interface SubagentParamsLike {
 	action?: string;
 	agent?: string;
 	task?: string;
@@ -107,6 +107,7 @@ function validateExecutionInput(
 	hasChain: boolean,
 	hasTasks: boolean,
 	hasSingle: boolean,
+	allowClarifyTaskPrompt: boolean,
 ): AgentToolResult<Details> | null {
 	if (Number(hasChain) + Number(hasTasks) + Number(hasSingle) !== 1) {
 		return {
@@ -139,7 +140,7 @@ function validateExecutionInput(
 					details: { mode: "chain" as const, results: [] },
 				};
 			}
-		} else if (!(firstStep as SequentialStep).task && !params.task) {
+		} else if (!(firstStep as SequentialStep).task && !params.task && !allowClarifyTaskPrompt) {
 			return {
 				content: [{ type: "text", text: "First step in chain must have a task" }],
 				isError: true,
@@ -806,8 +807,19 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 		const hasChain = (params.chain?.length ?? 0) > 0;
 		const hasTasks = (params.tasks?.length ?? 0) > 0;
 		const hasSingle = Boolean(params.agent && params.task);
+		const allowClarifyTaskPrompt = hasChain
+			&& params.clarify === true
+			&& ctx.hasUI
+			&& !(params.chain?.some(isParallelStep) ?? false);
 
-		const validationError = validateExecutionInput(params, agents, hasChain, hasTasks, hasSingle);
+		const validationError = validateExecutionInput(
+			params,
+			agents,
+			hasChain,
+			hasTasks,
+			hasSingle,
+			allowClarifyTaskPrompt,
+		);
 		if (validationError) return validationError;
 
 		let sessionFileForIndex: (idx?: number) => string | undefined = () => undefined;

package/types.ts

@@ -263,6 +263,12 @@ export const MAX_CONCURRENCY = 4;
 export const RESULTS_DIR = path.join(os.tmpdir(), "pi-async-subagent-results");
 export const ASYNC_DIR = path.join(os.tmpdir(), "pi-async-subagent-runs");
 export const WIDGET_KEY = "subagent-async";
+export const SLASH_RESULT_TYPE = "subagent-slash-result";
+export const SLASH_SUBAGENT_REQUEST_EVENT = "subagent:slash:request";
+export const SLASH_SUBAGENT_STARTED_EVENT = "subagent:slash:started";
+export const SLASH_SUBAGENT_RESPONSE_EVENT = "subagent:slash:response";
+export const SLASH_SUBAGENT_UPDATE_EVENT = "subagent:slash:update";
+export const SLASH_SUBAGENT_CANCEL_EVENT = "subagent:slash:cancel";
 export const POLL_INTERVAL_MS = 250;
 export const MAX_WIDGET_JOBS = 4;
 export const DEFAULT_SUBAGENT_MAX_DEPTH = 2;