@selesai/code 0.6.2 → 0.7.0

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

@@ -3,7 +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, type Component, type TUI } from "@earendil-works/pi-tui";
-import { BUILTIN_AGENT_NAMES, discoverAgents, discoverAgentsAll, type ChainConfig } from "../agents/agents.ts";
+import { BUILTIN_AGENT_NAMES, discoverAgents } from "../agents/agents.ts";
+import { registerInlineSubagentInvocation } from "./inline-subagents.ts";
 import {
 	DEFAULT_PROVIDER_MODELS_MAX_AGE_DAYS,
 	applySubagentProfile,
@@ -14,14 +15,11 @@ import {
 	refreshProviderModelCatalog,
 } from "../profiles/profiles.ts";
 import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
-import { isDynamicParallelStep, isParallelStep, type ChainStep } from "../shared/settings.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 { scheduledRunStorePath } from "../runs/background/scheduled-runs.ts";
+import { listScheduledRunSummaries } from "../runs/background/scheduled-runs.ts";
 import { SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/pi-args.ts";
-import { assertJsonSchemaObject } from "../runs/shared/structured-output.ts";
-import { validateAcceptanceInput } from "../runs/shared/acceptance.ts";
 import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
 import { registerPromptWorkflowCommands } from "./prompt-workflows.ts";
 import { openSubagentsAdmin } from "./subagents-admin.ts";
@@ -41,7 +39,7 @@ import {
 	SLASH_SUBAGENT_RESPONSE_EVENT,
 	SLASH_SUBAGENT_STARTED_EVENT,
 	SLASH_SUBAGENT_UPDATE_EVENT,
-	ASYNC_DIR,
+	DIRS,
 	type Details,
 	type JsonSchemaObject,
 	type SingleResult,
@@ -55,14 +53,6 @@ interface InlineConfig {
 	reads?: string[] | false;
 	model?: string;
 	skill?: string[] | false;
-	progress?: boolean;
-	as?: string;
-	label?: string;
-	phase?: string;
-	cwd?: string;
-	count?: number;
-	outputSchema?: string;
-	acceptance?: string;
 }
 
 const parseInlineConfig = (raw: string): InlineConfig => {
@@ -71,10 +61,7 @@ const parseInlineConfig = (raw: string): InlineConfig => {
 		const trimmed = part.trim();
 		if (!trimmed) continue;
 		const eq = trimmed.indexOf("=");
-		if (eq === -1) {
-			if (trimmed === "progress") config.progress = true;
-			continue;
-		}
+		if (eq === -1) continue;
 		const key = trimmed.slice(0, eq).trim();
 		const val = trimmed.slice(eq + 1).trim();
 		switch (key) {
@@ -83,14 +70,6 @@ const parseInlineConfig = (raw: string): InlineConfig => {
 			case "reads": config.reads = val === "false" ? false : val.split("+").filter(Boolean); break;
 			case "model": config.model = val || undefined; break;
 			case "skill": case "skills": config.skill = val === "false" ? false : val.split("+").filter(Boolean); break;
-			case "progress": config.progress = val !== "false"; break;
-			case "as": config.as = val || undefined; break;
-			case "label": config.label = val || undefined; break;
-			case "phase": config.phase = val || undefined; break;
-			case "cwd": config.cwd = val || undefined; break;
-			case "count": { const n = Number(val); if (Number.isInteger(n) && n > 0) config.count = n; break; }
-			case "outputSchema": config.outputSchema = val || undefined; break;
-			case "acceptance": config.acceptance = val || undefined; break;
 		}
 	}
 	return config;
@@ -125,69 +104,11 @@ const extractExecutionFlags = (rawArgs: string): { args: string; bg: boolean; fo
 	return { args, bg, fork };
 };
 
-const makeAgentCompletions = (state: SubagentState, multiAgent: boolean) => (prefix: string) => {
-	if (!state.baseCwd) return null;
-	const agents = discoverAgents(state.baseCwd, "both").agents;
-	if (!multiAgent) {
-		if (prefix.includes(" ")) return null;
-		return agents.filter((a) => a.name.startsWith(prefix)).map((a) => ({ value: a.name, label: a.name }));
-	}
-
-	// Find the start of the current chain step: after the last top-level `->` arrow or `(`,
-	// or after a `|` *inside* a group. A `|` at depth 0 is plain task text (only `(` opens a
-	// group), so it must not restart agent completion — otherwise `scout -- do x | wr` would
-	// wrongly resume suggesting agents past the `--` task. Quotes are tracked so separators
-	// inside a task are ignored.
-	let inSingle = false, inDouble = false, depth = 0, segStart = 0;
-	for (let i = 0; i < prefix.length; i++) {
-		const ch = prefix[i]!;
-		if (inSingle) { if (ch === "'") inSingle = false; continue; }
-		if (inDouble) { if (ch === '"') inDouble = false; continue; }
-		if (ch === "'") { inSingle = true; continue; }
-		if (ch === '"') { inDouble = true; continue; }
-		if (ch === "(") {
-			if (!prefix.slice(segStart, i).includes(" -- ")) {
-				depth++;
-				segStart = i + 1;
-			}
-		}
-		else if (ch === ")") {
-			if (depth > 0) {
-				depth--;
-				segStart = i + 1;
-			}
-		}
-		else if (ch === "|" && depth > 0) segStart = i + 1;
-		else if (ch === ">" && prefix[i - 1] === "-" && depth === 0) segStart = i + 1;
-	}
-	// Inside an open quote, or once the task has started (`--` / a quote), we are no
-	// longer typing an agent name.
-	if (inSingle || inDouble) return null;
-	const segment = prefix.slice(segStart);
-	if (segment.includes(" -- ") || segment.includes('"') || segment.includes("'")) return null;
-
-	const lastWord = (segment.match(/(\S*)$/) || ["", ""])[1];
-	let beforeLastWord = prefix.slice(0, prefix.length - lastWord.length);
-	// A bare `->` or `|` just typed (no trailing space) needs a separating space;
-	// `(` glues naturally to the agent name.
-	if (lastWord === "" && /[>|]$/.test(beforeLastWord)) beforeLastWord = `${beforeLastWord} `;
-
-	return agents.filter((a) => a.name.startsWith(lastWord)).map((a) => ({ value: `${beforeLastWord}${a.name}`, label: a.name }));
-};
-
-const discoverSavedChains = (cwd: string): ChainConfig[] => {
-	const chainsByName = new Map<string, ChainConfig>();
-	for (const chain of discoverAgentsAll(cwd).chains) {
-		chainsByName.set(chain.name, chain);
-	}
-	return Array.from(chainsByName.values());
-};
-
-const makeChainCompletions = (state: SubagentState) => (prefix: string) => {
-	if (prefix.includes(" ") || !state.baseCwd) return null;
-	return discoverSavedChains(state.baseCwd)
-		.filter((chain) => chain.name.startsWith(prefix))
-		.map((chain) => ({ value: chain.name, label: chain.name }));
+const makeAgentCompletions = (state: SubagentState) => (prefix: string) => {
+	if (!state.baseCwd || prefix.includes(" ")) return null;
+	return discoverAgents(state.baseCwd, "both").agents
+		.filter((agent) => agent.name.startsWith(prefix))
+		.map((agent) => ({ value: agent.name, label: agent.name }));
 };
 
 const makeBuiltinAgentNameCompletions = () => (prefix: string) => {
@@ -241,7 +162,7 @@ type StopSelectorResult = { confirmed: boolean; target?: StopSelectorTarget };
 
 function commandForTarget(target: StopSelectorTarget): string {
 	return target.kind === "scheduled"
-		? `subagent({ action: "schedule-cancel", id: ${JSON.stringify(target.id)} })`
+		? `subagent({ action: "schedule.pause", id: ${JSON.stringify(target.id)} })`
 		: `subagent({ action: "stop", id: ${JSON.stringify(target.id)} })`;
 }
 
@@ -257,35 +178,26 @@ function formatAsyncStopTarget(run: AsyncRunSummary): StopSelectorTarget {
 	};
 }
 
-function scheduledStopTargets(ctx: ExtensionContext, state: SubagentState): StopSelectorTarget[] {
-	const sessionId = state.currentSessionId ?? ctx.sessionManager.getSessionId();
-	if (!sessionId) return [];
-	const storePath = scheduledRunStorePath(ctx.cwd, sessionId);
-	if (!fs.existsSync(storePath)) return [];
-	let parsed: unknown;
+function scheduledStopTargets(ctx: ExtensionContext, _state: SubagentState): StopSelectorTarget[] {
 	try {
-		parsed = JSON.parse(fs.readFileSync(storePath, "utf-8"));
+		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 [];
 	}
-	const jobs = parsed && typeof parsed === "object" && Array.isArray((parsed as { jobs?: unknown }).jobs)
-		? (parsed as { jobs: Array<Record<string, unknown>> }).jobs
-		: [];
-	return jobs
-		.filter((job) => job.state === "scheduled" && typeof job.id === "string" && typeof job.name === "string" && typeof job.runAt === "number")
-		.sort((left, right) => Number(left.runAt) - Number(right.runAt))
-		.map((job) => ({
-			kind: "scheduled" as const,
-			id: String(job.id),
-			label: `${String(job.id)} · ${String(job.name)}`,
-			detail: `scheduled · ${new Date(Number(job.runAt)).toISOString()}`,
-			actionLabel: "cancel scheduled run",
-		}));
 }
 
 function discoverStopTargets(ctx: ExtensionContext, state: SubagentState): StopSelectorTarget[] {
 	const sessionId = state.currentSessionId ?? ctx.sessionManager.getSessionId() ?? undefined;
-	const asyncTargets = listAsyncRuns(ASYNC_DIR, {
+	const asyncTargets = listAsyncRuns(DIRS.async, {
 		states: ["queued", "running"],
 		...(sessionId ? { sessionId } : {}),
 	}).map(formatAsyncStopTarget);
@@ -367,6 +279,8 @@ class SubagentsStopSelector implements Component {
 		}
 	}
 
+	invalidate(): void {}
+
 	render(width: number): string[] {
 		const contentWidth = Math.max(40, Math.min(this.width, width || this.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."), ""];
@@ -509,63 +423,11 @@ function parseSingleRequiredArg(args: string, usage: string): { ok: true; value:
 	return { ok: true, value: parts[0]! };
 }
 
-function getProfileBuilderModel(profile: { subagents?: { agentOverrides?: Record<string, { model?: string }> } }): string | undefined {
+function getProfileWorkerModel(profile: { subagents?: { agentOverrides?: Record<string, { model?: string }> } }): string | undefined {
 	const model = profile.subagents?.agentOverrides?.builder?.model;
 	return typeof model === "string" && model.trim() ? model.trim() : undefined;
 }
 
-function loadSavedOutputSchema(chain: ChainConfig, stepAgent: string, outputSchema: unknown): JsonSchemaObject | undefined {
-	if (outputSchema === undefined) return undefined;
-	if (typeof outputSchema === "string") {
-		const schemaPath = path.isAbsolute(outputSchema)
-			? outputSchema
-			: path.join(path.dirname(chain.filePath), outputSchema);
-		const parsed = JSON.parse(fs.readFileSync(schemaPath, "utf-8")) as unknown;
-		assertJsonSchemaObject(parsed, `outputSchema for chain '${chain.name}' step '${stepAgent}' (${schemaPath})`);
-		return parsed;
-	}
-	assertJsonSchemaObject(outputSchema, `outputSchema for chain '${chain.name}' step '${stepAgent}'`);
-	return outputSchema;
-}
-
-const mapSavedChainSteps = (chain: ChainConfig, worktree = false): ChainStep[] => {
-	return (chain.steps as unknown as Array<ChainStep & { skills?: string[] | false }>).map((step) => {
-		if (isParallelStep(step)) {
-			const parallel = step.parallel.map((task) => {
-				const { outputSchema: rawOutputSchema, ...rest } = task as typeof task & { outputSchema?: unknown };
-				const outputSchema = loadSavedOutputSchema(chain, task.agent, rawOutputSchema);
-				return { ...rest, ...(outputSchema ? { outputSchema } : {}) };
-			});
-			return { ...step, parallel, ...(worktree ? { worktree: true } : {}) };
-		}
-		if (isDynamicParallelStep(step)) {
-			const { outputSchema: rawOutputSchema, ...parallelRest } = step.parallel as typeof step.parallel & { outputSchema?: unknown };
-			const outputSchema = loadSavedOutputSchema(chain, step.parallel.agent, rawOutputSchema);
-			const collectSchema = loadSavedOutputSchema(chain, `${step.collect.as} collection`, step.collect.outputSchema);
-			return {
-				...step,
-				parallel: { ...parallelRest, ...(outputSchema ? { outputSchema } : {}) },
-				collect: { ...step.collect, ...(collectSchema ? { outputSchema: collectSchema } : {}) },
-			};
-		}
-		const outputSchema = loadSavedOutputSchema(chain, step.agent, (step as { outputSchema?: unknown }).outputSchema);
-		return {
-			agent: step.agent,
-			task: step.task || undefined,
-			...(step.phase ? { phase: step.phase } : {}),
-			...(step.label ? { label: step.label } : {}),
-			...(step.as ? { as: step.as } : {}),
-			...(outputSchema ? { outputSchema } : {}),
-			...((step as { acceptance?: unknown }).acceptance !== undefined ? { acceptance: (step as { acceptance?: unknown }).acceptance } : {}),
-			output: step.output,
-			outputMode: step.outputMode,
-			reads: step.reads,
-			progress: step.progress,
-			skill: step.skill ?? step.skills,
-			model: step.model,
-		};
-	});
-};
 
 async function requestSlashRun(
 	pi: ExtensionAPI,
@@ -752,7 +614,7 @@ async function runSlashSubagent(
 	}
 }
 
-function launchSlashSubagent(
+export function launchSlashSubagent(
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,
 	params: SubagentParamsLike,
@@ -760,405 +622,13 @@ function launchSlashSubagent(
 	void runSlashSubagent(pi, ctx, params);
 }
 
-export interface GroupConfig { concurrency?: number; failFast?: boolean; worktree?: boolean }
-export interface ParsedStep { kind: "step"; name: string; config: InlineConfig; task?: string }
-export interface ParsedGroup { kind: "group"; tasks: ParsedStep[]; config: GroupConfig }
-export type ParsedGroupStep = ParsedStep | ParsedGroup;
-
-export const PARALLEL_GROUP_USAGE =
-	'Usage: /chain agent "task" -> (agent2 "task" | agent3 "task") -> agent4';
-
-export class SlashParseError extends Error {}
-
-// Walk `input` tracking quote/paren state; returns true if parens are unbalanced.
-function findUnmatchedCloseParen(input: string): boolean {
-	let depth = 0, inSingle = false, inDouble = false;
-	for (let i = 0; i < input.length; i++) {
-		const ch = input[i]!;
-		if (inSingle) { if (ch === "'") inSingle = false; continue; }
-		if (inDouble) { if (ch === '"') inDouble = false; continue; }
-		if (ch === "'") { inSingle = true; continue; }
-		if (ch === '"') { inDouble = true; continue; }
-		if (ch === "(") depth++;
-		else if (ch === ")") { depth--; if (depth < 0) return true; }
-	}
-	return depth !== 0;
-}
-
-// Split on top-level " -> ", ignoring arrows inside quotes or parentheses.
-function splitOnArrow(input: string): string[] {
-	const segments: string[] = [];
-	let depth = 0, inSingle = false, inDouble = false, start = 0;
-	for (let i = 0; i < input.length; i++) {
-		const ch = input[i]!;
-		if (inSingle) { if (ch === "'") inSingle = false; continue; }
-		if (inDouble) { if (ch === '"') inDouble = false; continue; }
-		if (ch === "'") { inSingle = true; continue; }
-		if (ch === '"') { inDouble = true; continue; }
-		if (ch === "(") depth++;
-		else if (ch === ")") depth--;
-		else if (depth === 0 && ch === "-" && input[i + 1] === ">" && input[i + 2] === " ") {
-			segments.push(input.slice(start, i));
-			i += 2;
-			start = i + 1;
-		}
-	}
-	segments.push(input.slice(start));
-	return segments;
-}
-
-// Split a group's inner text on top-level " | ", ignoring pipes inside quotes/parens.
-function splitGroupTasks(inner: string): string[] {
-	const parts: string[] = [];
-	let depth = 0, inSingle = false, inDouble = false, start = 0;
-	for (let i = 0; i < inner.length; i++) {
-		const ch = inner[i]!;
-		if (inSingle) { if (ch === "'") inSingle = false; continue; }
-		if (inDouble) { if (ch === '"') inDouble = false; continue; }
-		if (ch === "'") { inSingle = true; continue; }
-		if (ch === '"') { inDouble = true; continue; }
-		if (ch === "(") depth++;
-		else if (ch === ")") depth--;
-		else if (ch === "|" && depth === 0) {
-			parts.push(inner.slice(start, i));
-			start = i + 1;
-		}
-	}
-	parts.push(inner.slice(start));
-	return parts;
-}
-
-export function parseSingleTaskToken(token: string): ParsedStep {
-	let agentPart: string;
-	let task: string | undefined;
-	const qMatch = token.match(/^(\S+(?:\[[^\]]*\])?)\s+(?:"([^"]*)"|'([^']*)')$/);
-	if (qMatch) {
-		agentPart = qMatch[1]!;
-		task = (qMatch[2] ?? qMatch[3]) || undefined;
-	} else {
-		const dashIdx = token.indexOf(" -- ");
-		if (dashIdx !== -1) {
-			agentPart = token.slice(0, dashIdx).trim();
-			task = token.slice(dashIdx + 4).trim() || undefined;
-		} else {
-			agentPart = token;
-		}
-	}
-	return { kind: "step", ...parseAgentToken(agentPart), task };
-}
-
-const parseGroupConfig = (raw: string): GroupConfig => {
-	const config: GroupConfig = {};
-	for (const part of raw.split(",")) {
-		const trimmed = part.trim();
-		if (!trimmed) continue;
-		const eq = trimmed.indexOf("=");
-		const key = eq === -1 ? trimmed : trimmed.slice(0, eq).trim();
-		const val = eq === -1 ? "" : trimmed.slice(eq + 1).trim();
-		switch (key) {
-			case "concurrency": { const n = Number(val); if (Number.isInteger(n) && n > 0) config.concurrency = n; break; }
-			case "failFast": config.failFast = eq === -1 ? true : val !== "false"; break;
-			case "worktree": config.worktree = eq === -1 ? true : val !== "false"; break;
-		}
-	}
-	return config;
-};
-
-// Split `(...)` from an optional trailing `[...]` group-config suffix, respecting
-// quotes and nested parens. Returns the inner group text and the parsed config.
-const splitGroupBody = (trimmed: string): { inner: string; config: GroupConfig } => {
-	let depth = 0, inSingle = false, inDouble = false, closeIdx = -1;
-	for (let i = 0; i < trimmed.length; i++) {
-		const ch = trimmed[i]!;
-		if (inSingle) { if (ch === "'") inSingle = false; continue; }
-		if (inDouble) { if (ch === '"') inDouble = false; continue; }
-		if (ch === "'") { inSingle = true; continue; }
-		if (ch === '"') { inDouble = true; continue; }
-		if (ch === "(") depth++;
-		else if (ch === ")") { depth--; if (depth === 0) { closeIdx = i; break; } }
-	}
-	if (closeIdx === -1) throw new SlashParseError(`Unmatched parentheses in group: '${trimmed}'`);
-	const inner = trimmed.slice(1, closeIdx);
-	const suffix = trimmed.slice(closeIdx + 1).trim();
-	if (!suffix) return { inner, config: {} };
-	if (!suffix.startsWith("[") || !suffix.endsWith("]")) {
-		throw new SlashParseError(`Group options must be wrapped in [...]: '${suffix}'`);
-	}
-	return { inner, config: parseGroupConfig(suffix.slice(1, -1)) };
-};
-
-export function parseGroupSegment(segment: string): ParsedGroup {
-	const trimmed = segment.trim();
-	if (!trimmed.startsWith("(")) {
-		throw new SlashParseError(`Parallel group must be wrapped in parentheses: '${trimmed}'`);
-	}
-	const { inner, config } = splitGroupBody(trimmed);
-	const rawParts = splitGroupTasks(inner).map((p) => p.trim()).filter((p) => p.length > 0);
-	if (rawParts.length < 2) {
-		throw new SlashParseError("Parallel group must contain at least two tasks separated by ' | '");
-	}
-	return { kind: "group", tasks: rawParts.map((part) => parseSingleTaskToken(part)), config };
-}
-
-// True if `input` uses inline parallel-group syntax. A group is a *step* that begins
-// with `(` at the top level, so we split on top-level ` -> ` arrows and look for a
-// segment that opens with `(`. Parentheses appearing inside a task (e.g.
-// `scout -- inspect auth (backend)`) do not count, which keeps legacy shared-task
-// `-- task` parsing — including a bare `|` inside the task — on the single-agent path.
-export function hasGroupSyntax(input: string): boolean {
-	return splitOnArrow(input).some((seg) => seg.trim().startsWith("("));
-}
-
-export function parseChainExpression(input: string): { steps: ParsedGroupStep[] } {
-	const trimmed = input.trim();
-	if (!trimmed.includes(" -> ")) {
-		throw new SlashParseError('Parallel groups in /chain require " -> " between steps');
-	}
-	if (findUnmatchedCloseParen(trimmed)) {
-		throw new SlashParseError("Unmatched parentheses in /chain expression");
-	}
-	const steps: ParsedGroupStep[] = [];
-	for (const seg of splitOnArrow(trimmed)) {
-		const t = seg.trim();
-		if (!t) continue;
-		if (t.startsWith("(")) {
-			steps.push(parseGroupSegment(t));
-			continue;
-		}
-		if (findUnmatchedCloseParen(t)) {
-			throw new SlashParseError(`Unmatched parentheses in chain segment: '${t}'`);
-		}
-		steps.push(parseSingleTaskToken(t));
-	}
-	if (steps.length === 0) {
-		throw new SlashParseError("/chain expression must include at least one step");
-	}
-	return { steps };
-}
-
-const parseAgentArgs = (
-	state: SubagentState,
-	args: string,
-	command: string,
-	ctx: ExtensionContext,
-): { steps: ParsedStep[]; task: string } | null => {
-	const input = args.trim();
-	const usage = `Usage: /${command} agent1 "task1" -> agent2 "task2"`;
-	let steps: ParsedStep[];
-	let sharedTask: string;
-	let perStep = false;
-
-	if (input.includes(" -> ")) {
-		perStep = true;
-		const segments = input.split(" -> ");
-		steps = [];
-		for (const seg of segments) {
-			const trimmed = seg.trim();
-			if (!trimmed) continue;
-			steps.push(parseSingleTaskToken(trimmed));
-		}
-		sharedTask = steps.find((s) => s.task)?.task ?? "";
-	} else {
-		const delimiterIndex = input.indexOf(" -- ");
-		if (delimiterIndex === -1) {
-			ctx.ui.notify(usage, "error");
-			return null;
-		}
-		const agentsPart = input.slice(0, delimiterIndex).trim();
-		sharedTask = input.slice(delimiterIndex + 4).trim();
-		if (!agentsPart || !sharedTask) {
-			ctx.ui.notify(usage, "error");
-			return null;
-		}
-		steps = agentsPart.split(/\s+/).filter(Boolean).map((t) => parseSingleTaskToken(t));
-	}
-
-	if (steps.length === 0) {
-		ctx.ui.notify(usage, "error");
-		return null;
-	}
-	if (!state.baseCwd) {
-		ctx.ui.notify("Subagent session cwd is not initialized yet", "error");
-		return null;
-	}
-	const agents = discoverAgents(state.baseCwd, "both").agents;
-	for (const step of steps) {
-		if (!agents.find((a) => a.name === step.name)) {
-			ctx.ui.notify(`Unknown agent: ${step.name}`, "error");
-			return null;
-		}
-	}
-	if (command === "chain" && !steps[0]?.task && (perStep || !sharedTask)) {
-		ctx.ui.notify(`First step must have a task: /chain agent "task" -> agent2`, "error");
-		return null;
-	}
-	if (command === "parallel" && !steps.some((s) => s.task) && !sharedTask) {
-		ctx.ui.notify("At least one step must have a task", "error");
-		return null;
-	}
-	return { steps, task: sharedTask };
-};
-
-type ChainStepObject = {
-	agent: string;
-	task?: string;
-	output?: string | false;
-	outputMode?: "inline" | "file-only";
-	reads?: string[] | false;
-	model?: string;
-	skill?: string[] | false;
-	progress?: boolean;
-	as?: string;
-	label?: string;
-	phase?: string;
-	cwd?: string;
-	count?: number;
-	outputSchema?: JsonSchemaObject;
-	acceptance?: string;
-};
-
-const INLINE_ACCEPTANCE_LEVELS = new Set(["auto", "attested", "checked"]);
-
-function validateInlineAcceptanceInput(value: string, agent: string): void {
-	const errors = validateAcceptanceInput(value, `acceptance for step '${agent}'`);
-	if (errors.length > 0) throw new SlashParseError(errors[0]!);
-	if (!INLINE_ACCEPTANCE_LEVELS.has(value)) {
-		throw new SlashParseError(`Inline acceptance for step '${agent}' supports auto, attested, or checked. Use the subagent tool API or a saved .chain.json file for none, verified, or review requirements; reviewed is an achieved status, not an input level.`);
-	}
-}
-
-// Load an inline `outputSchema=<path>` JSON file, resolved against the session cwd.
-// Throws (SlashParseError / fs / JSON) on a missing or malformed schema.
-function loadInlineOutputSchema(baseCwd: string, agent: string, value: string): JsonSchemaObject {
-	const schemaPath = path.isAbsolute(value) ? value : path.join(baseCwd, value);
-	const label = `outputSchema for step '${agent}' (${schemaPath})`;
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(fs.readFileSync(schemaPath, "utf-8"));
-	} catch (error) {
-		throw new SlashParseError(`Cannot read ${label}: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	assertJsonSchemaObject(parsed, label);
-	return parsed;
-}
-
-// Build a ChainStep object from a parsed token. `inGroup` enables `count` (parallel-only).
-// May throw SlashParseError for an invalid acceptance level or outputSchema path.
-const mapParsedTaskToStepObject = (
-	step: ParsedStep,
-	fallbackTask: string | undefined,
-	isFirst: boolean,
-	opts: { baseCwd: string; inGroup: boolean },
-): ChainStepObject => {
-	const { name, config, task: stepTask } = step;
-	if (config.acceptance !== undefined) validateInlineAcceptanceInput(config.acceptance, name);
-	return {
-		agent: name,
-		...(stepTask ? { task: stepTask } : isFirst && fallbackTask ? { task: fallbackTask } : {}),
-		...(config.output !== undefined ? { output: config.output } : {}),
-		...(config.outputMode !== undefined ? { outputMode: config.outputMode } : {}),
-		...(config.reads !== undefined ? { reads: config.reads } : {}),
-		...(config.model ? { model: config.model } : {}),
-		...(config.skill !== undefined ? { skill: config.skill } : {}),
-		...(config.progress !== undefined ? { progress: config.progress } : {}),
-		...(config.as ? { as: config.as } : {}),
-		...(config.label ? { label: config.label } : {}),
-		...(config.phase ? { phase: config.phase } : {}),
-		...(config.cwd ? { cwd: config.cwd } : {}),
-		...(opts.inGroup && config.count !== undefined ? { count: config.count } : {}),
-		...(config.outputSchema ? { outputSchema: loadInlineOutputSchema(opts.baseCwd, name, config.outputSchema) } : {}),
-		...(config.acceptance ? { acceptance: config.acceptance } : {}),
-	};
-};
-
-export function buildChainExpressionSteps(
-	state: SubagentState,
-	input: string,
-	ctx: ExtensionContext,
-): { chain: ChainStep[]; task: string } | null {
-	const notify = (message: string) => ctx.ui.notify(message, "error");
-	if (!hasGroupSyntax(input)) {
-		const parsed = parseAgentArgs(state, input, "chain", ctx);
-		if (!parsed) return null;
-		const baseCwd = state.baseCwd!; // parseAgentArgs already verified baseCwd is set
-		try {
-			const chain: ChainStep[] = parsed.steps.map((step, i) =>
-				mapParsedTaskToStepObject(step, parsed.task || undefined, i === 0, { baseCwd, inGroup: false }),
-			);
-			return { chain, task: parsed.task };
-		} catch (error) {
-			notify(error instanceof Error ? error.message : String(error));
-			return null;
-		}
-	}
-
-	let expression: { steps: ParsedGroupStep[] };
-	try {
-		expression = parseChainExpression(input);
-	} catch (error) {
-		notify(error instanceof Error ? error.message : String(error));
-		return null;
-	}
-	if (!state.baseCwd) {
-		notify("Subagent session cwd is not initialized yet");
-		return null;
-	}
-	const agents = discoverAgents(state.baseCwd, "both").agents;
-	const stepAgentNames = expression.steps.flatMap((step) =>
-		step.kind === "group" ? step.tasks.map((t) => t.name) : [step.name],
-	);
-	for (const name of stepAgentNames) {
-		if (!agents.find((a) => a.name === name)) {
-			notify(`Unknown agent: ${name}`);
-			return null;
-		}
-	}
-	// Every task inside a parallel group needs its own task; there is no shared-task fallback.
-	for (const step of expression.steps) {
-		if (step.kind === "group" && step.tasks.some((t) => !t.task)) {
-			notify('Each task in a parallel group needs a task: (agent "a" | agent "b")');
-			return null;
-		}
-	}
-	const firstStep = expression.steps[0]!;
-	const firstHasTask =
-		firstStep.kind === "group"
-			? firstStep.tasks.some((t) => Boolean(t.task))
-			: Boolean(firstStep.task);
-	if (!firstHasTask) {
-		notify('First step must have a task: /chain agent "task" -> agent2');
-		return null;
-	}
-	const sharedTask =
-		firstStep.kind === "group"
-			? (firstStep.tasks.find((t) => t.task)?.task ?? "")
-			: (firstStep.task ?? "");
-	const baseCwd = state.baseCwd;
-	let chain: ChainStep[];
-	try {
-		chain = expression.steps.map((step) => {
-			if (step.kind === "group") {
-				const parallel = step.tasks.map((t) => mapParsedTaskToStepObject(t, undefined, false, { baseCwd, inGroup: true }));
-				return {
-					parallel,
-					...(step.config.concurrency !== undefined ? { concurrency: step.config.concurrency } : {}),
-					...(step.config.failFast !== undefined ? { failFast: step.config.failFast } : {}),
-					...(step.config.worktree !== undefined ? { worktree: step.config.worktree } : {}),
-				};
-			}
-			return mapParsedTaskToStepObject(step, sharedTask || undefined, false, { baseCwd, inGroup: false });
-		});
-	} catch (error) {
-		notify(error instanceof Error ? error.message : String(error));
-		return null;
-	}
-	return { chain, task: sharedTask };
-}
 
 export function registerSlashCommands(
 	pi: ExtensionAPI,
 	state: SubagentState,
 ): void {
+	registerInlineSubagentInvocation(pi, state);
+
 	let fleetOpen = false;
 	const showFleet = async (ctx: ExtensionContext) => {
 		state.lastUiContext = ctx;
@@ -1172,7 +642,7 @@ export function registerSlashCommands(
 		}
 		fleetOpen = true;
 		try {
-			await openSubagentFleet(ctx, state);
+			await openSubagentFleet(ctx, state, { asyncDirRoot: DIRS.async, resultsDir: DIRS.results });
 		} finally {
 			fleetOpen = false;
 		}
@@ -1187,7 +657,7 @@ export function registerSlashCommands(
 
 	pi.registerCommand("run", {
 		description: "Run a subagent directly: /run agent[output=file] [task] [--bg] [--fork]",
-		getArgumentCompletions: makeAgentCompletions(state, false),
+		getArgumentCompletions: makeAgentCompletions(state),
 		handler: async (args, ctx) => {
 			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
 			const input = cleanedArgs.trim();
@@ -1215,74 +685,6 @@ export function registerSlashCommands(
 		},
 	});
 
-	pi.registerCommand("chain", {
-		description: "Run agents in sequence: /chain explorer \"task\" -> architect [--bg] [--fork]",
-		getArgumentCompletions: makeAgentCompletions(state, true),
-		handler: async (args, ctx) => {
-			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
-			const built = buildChainExpressionSteps(state, cleanedArgs, ctx);
-			if (!built) return;
-			const params: SubagentParamsLike = { chain: built.chain, task: built.task, clarify: false, agentScope: "both" };
-			if (bg) params.async = true;
-			if (fork) params.context = "fork";
-			launchSlashSubagent(pi, ctx, params);
-		},
-	});
-
-	pi.registerCommand("run-chain", {
-		description: "Run a saved chain: /run-chain chainName -- task [--bg] [--fork]",
-		getArgumentCompletions: makeChainCompletions(state),
-		handler: async (args, ctx) => {
-			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
-			const delimiterIndex = cleanedArgs.indexOf(" -- ");
-			const usage = "Usage: /run-chain <chainName> -- <task> [--bg] [--fork]";
-			if (delimiterIndex === -1) {
-				ctx.ui.notify(usage, "error");
-				return;
-			}
-			const chainName = cleanedArgs.slice(0, delimiterIndex).trim();
-			const task = cleanedArgs.slice(delimiterIndex + 4).trim();
-			if (!chainName || !task) {
-				ctx.ui.notify(usage, "error");
-				return;
-			}
-			if (!state.baseCwd) { ctx.ui.notify("Subagent session cwd is not initialized yet", "error"); return; }
-			const chain = discoverSavedChains(state.baseCwd).find((candidate) => candidate.name === chainName);
-			if (!chain) {
-				ctx.ui.notify(`Unknown chain: ${chainName}`, "error");
-				return;
-			}
-			const params: SubagentParamsLike = { chain: mapSavedChainSteps(chain), task, clarify: false, agentScope: "both" };
-			if (bg) params.async = true;
-			if (fork) params.context = "fork";
-			launchSlashSubagent(pi, ctx, params);
-		},
-	});
-
-	pi.registerCommand("parallel", {
-		description: "Run agents in parallel: /parallel explorer \"task1\" -> commentator \"task2\" [--bg] [--fork]",
-		getArgumentCompletions: makeAgentCompletions(state, true),
-		handler: async (args, ctx) => {
-			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
-			const parsed = parseAgentArgs(state, cleanedArgs, "parallel", ctx);
-			if (!parsed) return;
-			const tasks = parsed.steps.map(({ name, config, task: stepTask }) => ({
-				agent: name,
-				task: stepTask ?? parsed.task,
-				...(config.output !== undefined ? { output: config.output } : {}),
-				...(config.outputMode !== undefined ? { outputMode: config.outputMode } : {}),
-				...(config.reads !== undefined ? { reads: config.reads } : {}),
-				...(config.model ? { model: config.model } : {}),
-				...(config.skill !== undefined ? { skill: config.skill } : {}),
-				...(config.progress !== undefined ? { progress: config.progress } : {}),
-			}));
-			const params: SubagentParamsLike = { tasks, clarify: false, agentScope: "both" };
-			if (bg) params.async = true;
-			if (fork) params.context = "fork";
-			launchSlashSubagent(pi, ctx, params);
-		},
-	});
-
 	pi.registerCommand("subagent-cost", {
 		description: "Show parent and subagent child usage cost for this session",
 		handler: async (_args, ctx) => {
@@ -1371,7 +773,7 @@ export function registerSlashCommands(
 			);
 			if (!result?.confirmed || !result.target) return;
 			if (result.target.kind === "scheduled") {
-				await runSlashSubagent(pi, ctx, { action: "schedule-cancel", id: result.target.id });
+				await runSlashSubagent(pi, ctx, { action: "schedule.pause", id: result.target.id });
 				return;
 			}
 			await runSlashSubagent(pi, ctx, { action: "stop", id: result.target.id });
@@ -1430,14 +832,14 @@ export function registerSlashCommands(
 		},
 		handler: async (args, ctx) => {
 			const parsed = parseSingleRequiredArg(args, "Usage: /subagents-load-profile <name>");
-			if (!parsed.ok) {
+			if (parsed.ok === false) {
 				ctx.ui.notify(parsed.message, "error");
 				return;
 			}
 			try {
 				await withSlashStatus(ctx, `Loading profile ${parsed.value}…`, async () => {
 					const { profile } = readSubagentProfile(parsed.value);
-					const builderModel = getProfileBuilderModel(profile);
+					const workerModel = getProfileWorkerModel(profile);
 					const result = applySubagentProfile(parsed.value);
 					const lines = [
 						`Loaded subagent profile: ${parsed.value}`,
@@ -1445,24 +847,24 @@ export function registerSlashCommands(
 						`Updated: ${result.settingsPath}`,
 					];
 
-					if (builderModel && typeof pi.setModel === "function" && typeof ctx.modelRegistry?.find === "function" && typeof ctx.modelRegistry?.getAvailable === "function") {
+					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${builderModel}`,
+							`Profile loaded. Also switch this session to the profile builder model?\n\n${workerModel}`,
 						);
 						if (shouldSwitch) {
-							const modelInfo = findModelInfo(builderModel, ctx.modelRegistry.getAvailable().map(toModelInfo));
+							const modelInfo = findModelInfo(workerModel, ctx.modelRegistry.getAvailable().map(toModelInfo));
 							const model = modelInfo ? ctx.modelRegistry.find(modelInfo.provider, modelInfo.id) : undefined;
 							if (!modelInfo || !model) {
-								lines.push(`Could not switch current session model: '${builderModel}' is not available in the current model registry.`);
+								lines.push(`Could not switch current session model: '${workerModel}' is not available in the current model registry.`);
 							} else {
 								const success = await pi.setModel(model);
 								if (success) lines.push(`Current session model switched to: ${modelInfo.fullId}`);
-								else lines.push(`Could not switch current session model to '${builderModel}': no API key or provider access is available.`);
+								else lines.push(`Could not switch current session model to '${workerModel}': no API key or provider access is available.`);
 							}
 						}
-					} else if (builderModel) {
-						lines.push(`Profile builder model: ${builderModel}`);
+					} else if (workerModel) {
+						lines.push(`Profile builder model: ${workerModel}`);
 					}
 
 					sendSlashText(pi, lines.join("\n"));
@@ -1481,7 +883,7 @@ export function registerSlashCommands(
 			const force = /(?:^|\s)--force$/.test(trimmed) || /(?:^|\s)force$/.test(trimmed);
 			const withoutForce = trimmed.replace(/(?:^|\s)(?:--force|force)$/, "").trim();
 			const parsed = parseSingleRequiredArg(withoutForce, "Usage: /subagents-refresh-provider-models <provider> [--force]");
-			if (!parsed.ok) {
+			if (parsed.ok === false) {
 				ctx.ui.notify(parsed.message, "error");
 				return;
 			}
@@ -1512,7 +914,7 @@ export function registerSlashCommands(
 		getArgumentCompletions: makeProviderCompletions(state),
 		handler: async (args, ctx) => {
 			const parsed = parseSingleRequiredArg(args, "Usage: /subagents-generate-profiles <provider>");
-			if (!parsed.ok) {
+			if (parsed.ok === false) {
 				ctx.ui.notify(parsed.message, "error");
 				return;
 			}
@@ -1555,7 +957,7 @@ export function registerSlashCommands(
 		},
 		handler: async (args, ctx) => {
 			const parsed = parseSingleRequiredArg(args, "Usage: /subagents-check-profile <name>");
-			if (!parsed.ok) {
+			if (parsed.ok === false) {
 				ctx.ui.notify(parsed.message, "error");
 				return;
 			}