@draht/coding-agent 2026.3.2-2

package/dist/extensions/gsd-commands.ts

@@ -0,0 +1,338 @@
+/**
+ * GSD — Get Shit Done
+ *
+ * Batteries-included phase commands for structured AI-assisted development.
+ *
+ * Full workflow:
+ *   /discuss <feature>          — clarify requirements before planning
+ *   /plan    <feature>          — architect produces implementation plan
+ *   /execute <task1, task2...>  — parallel implement → review → commit
+ *   /verify                     — parallel lint/typecheck/tests + security audit
+ *
+ * Utilities:
+ *   /review  <scope>            — ad-hoc code review + security audit
+ *   /fix     <issue>            — targeted fix plan for a failing task
+ *   /quick   <task>             — one-shot implement + commit (skip full GSD)
+ *   /resume                     — pick up interrupted work from CONTINUE-HERE.md
+ *   /status                     — show .planning/STATE.md overview
+ *   /new-project <name> [path]  — create project dir, git init, scaffold .draht/
+ *   /init-project               — scaffold .draht/ in existing project
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ExtensionAPI } from "@draht/coding-agent";
+
+function isBusy(ctx: { isIdle: () => boolean }, ui: { notify: (msg: string, level: string) => void }): boolean {
+	if (!ctx.isIdle()) {
+		ui.notify("Agent is busy", "warning");
+		return true;
+	}
+	return false;
+}
+
+export default function (pi: ExtensionAPI) {
+	// ── /discuss ─────────────────────────────────────────────────────────────
+	pi.registerCommand("discuss", {
+		description: "Clarify requirements before planning. Architect asks questions and defines scope. Usage: /discuss <feature>",
+		handler: async (args, ctx) => {
+			if (!args.trim()) {
+				ctx.ui.notify("Usage: /discuss <feature description>", "warning");
+				return;
+			}
+			if (isBusy(ctx, ctx.ui)) return;
+
+			pi.sendUserMessage(
+				`Use the subagent tool to delegate to the architect agent with this task:
+
+"We are in the DISCUSS phase for: ${args.trim()}
+
+Your job is NOT to plan yet. First:
+1. Read relevant existing code to understand the current state
+2. Identify ambiguities, unknowns, and risks
+3. List clarifying questions that need answers before planning can begin
+4. Define a clear, bounded scope for what will and won't be built
+5. Output a DISCUSS summary with: scope, assumptions, open questions, risks
+
+Do not produce file lists or implementation details yet."
+
+Set agentScope to "project".`,
+			);
+		},
+	});
+
+	// ── /plan ────────────────────────────────────────────────────────────────
+	pi.registerCommand("plan", {
+		description: "Plan a feature — architect reads codebase and produces structured implementation plan. Usage: /plan <feature>",
+		handler: async (args, ctx) => {
+			if (!args.trim()) {
+				ctx.ui.notify("Usage: /plan <feature description>", "warning");
+				return;
+			}
+			if (isBusy(ctx, ctx.ui)) return;
+
+			pi.sendUserMessage(
+				`Use the subagent tool to delegate to the architect agent with this task: "${args.trim()}"\n\nSet agentScope to "project".`,
+			);
+		},
+	});
+
+	// ── /execute ─────────────────────────────────────────────────────────────
+	pi.registerCommand("execute", {
+		description: "Execute tasks in parallel, then chain reviewer + git-committer. Usage: /execute task1, task2, task3",
+		handler: async (args, ctx) => {
+			if (!args.trim()) {
+				ctx.ui.notify("Usage: /execute task1, task2, task3", "warning");
+				return;
+			}
+			if (isBusy(ctx, ctx.ui)) return;
+
+			const tasks = args.split(",").map((t) => t.trim()).filter(Boolean);
+
+			if (tasks.length === 1) {
+				pi.sendUserMessage(
+					`Use the subagent tool in chain mode with agentScope "project":
+1. agent: implementer — task: "${tasks[0]}"
+2. agent: reviewer    — task: "Review the changes just made: {previous}"
+3. agent: git-committer — task: "Commit all changes. Review context: {previous}"`,
+				);
+			} else {
+				const parallelList = tasks.map((t, i) => `${i + 1}. agent: implementer — task: "${t}"`).join("\n");
+				pi.sendUserMessage(
+					`Use the subagent tool with agentScope "project":
+
+Step 1 — PARALLEL mode (run all simultaneously):
+${parallelList}
+
+Step 2 — CHAIN mode (after all parallel tasks complete):
+1. agent: reviewer      — task: "Review all changes just implemented"
+2. agent: git-committer — task: "Commit all changes. Review findings: {previous}"`,
+				);
+			}
+		},
+	});
+
+	// ── /verify ──────────────────────────────────────────────────────────────
+	pi.registerCommand("verify", {
+		description: "Parallel verification: lint, typecheck, tests, and security audit",
+		handler: async (_args, ctx) => {
+			if (isBusy(ctx, ctx.ui)) return;
+
+			pi.sendUserMessage(
+				`Use the subagent tool in PARALLEL mode with agentScope "project":
+1. agent: verifier        — task: "Run all lint, typecheck, and test checks"
+2. agent: security-auditor — task: "Audit all recent changes for security vulnerabilities"
+
+After both complete, merge findings into a single prioritized report. List what must be fixed before this is production-ready.`,
+			);
+		},
+	});
+
+	// ── /review ──────────────────────────────────────────────────────────────
+	pi.registerCommand("review", {
+		description: "Ad-hoc code review + security audit. Usage: /review <scope or files>",
+		handler: async (args, ctx) => {
+			if (isBusy(ctx, ctx.ui)) return;
+
+			const scope = args.trim() || "all recent changes";
+			pi.sendUserMessage(
+				`Use the subagent tool in PARALLEL mode with agentScope "project":
+1. agent: reviewer        — task: "Review ${scope} for correctness, type safety, and conventions"
+2. agent: security-auditor — task: "Audit ${scope} for security vulnerabilities"
+
+After both complete, merge into a single prioritized findings report.`,
+			);
+		},
+	});
+
+	// ── /fix ─────────────────────────────────────────────────────────────────
+	pi.registerCommand("fix", {
+		description: "Create a targeted fix plan for a failing task or bug. Usage: /fix <description of what's broken>",
+		handler: async (args, ctx) => {
+			if (!args.trim()) {
+				ctx.ui.notify("Usage: /fix <description of what's broken>", "warning");
+				return;
+			}
+			if (isBusy(ctx, ctx.ui)) return;
+
+			pi.sendUserMessage(
+				`Use the subagent tool in chain mode with agentScope "project":
+1. agent: architect  — task: "Diagnose this issue and produce a minimal fix plan: ${args.trim()}. Read the relevant code first. Output: root cause, exact files to change, fix steps."
+2. agent: implementer — task: "Apply this fix plan exactly: {previous}"
+3. agent: reviewer    — task: "Verify the fix is correct and doesn't introduce regressions: {previous}"
+4. agent: git-committer — task: "Commit the fix. Fix summary: {previous}"`,
+			);
+		},
+	});
+
+	// ── /quick ───────────────────────────────────────────────────────────────
+	pi.registerCommand("quick", {
+		description: "One-shot task: implement + commit. Skips full GSD workflow. Usage: /quick <task>",
+		handler: async (args, ctx) => {
+			if (!args.trim()) {
+				ctx.ui.notify("Usage: /quick <task description>", "warning");
+				return;
+			}
+			if (isBusy(ctx, ctx.ui)) return;
+
+			pi.sendUserMessage(
+				`Use the subagent tool in chain mode with agentScope "project":
+1. agent: implementer   — task: "${args.trim()}"
+2. agent: git-committer — task: "Commit the changes just made: {previous}"`,
+			);
+		},
+	});
+
+	// ── /resume ──────────────────────────────────────────────────────────────
+	pi.registerCommand("resume", {
+		description: "Resume interrupted work — reads CONTINUE-HERE.md and picks up where we left off",
+		handler: async (_args, ctx) => {
+			if (isBusy(ctx, ctx.ui)) return;
+
+			const continueFile = path.join(ctx.cwd, ".planning", "CONTINUE-HERE.md");
+			const stateFile = path.join(ctx.cwd, ".planning", "STATE.md");
+
+			if (!fs.existsSync(continueFile) && !fs.existsSync(stateFile)) {
+				ctx.ui.notify("No .planning/CONTINUE-HERE.md or STATE.md found. Nothing to resume.", "warning");
+				return;
+			}
+
+			let context = "";
+			if (fs.existsSync(continueFile)) {
+				context += `\nCONTINUE-HERE.md:\n${fs.readFileSync(continueFile, "utf-8")}`;
+			}
+			if (fs.existsSync(stateFile)) {
+				context += `\nSTATE.md:\n${fs.readFileSync(stateFile, "utf-8")}`;
+			}
+
+			pi.sendUserMessage(
+				`Read the following project state and resume work from where it was interrupted. Identify the next incomplete task and proceed with it using the appropriate subagent.${context}`,
+			);
+		},
+	});
+
+	// ── /status ──────────────────────────────────────────────────────────────
+	pi.registerCommand("status", {
+		description: "Show current GSD project state from .planning/STATE.md",
+		handler: async (_args, ctx) => {
+			const stateFile = path.join(ctx.cwd, ".planning", "STATE.md");
+			const logFile = path.join(ctx.cwd, ".planning", "execution-log.jsonl");
+
+			if (!fs.existsSync(stateFile)) {
+				ctx.ui.notify("No .planning/STATE.md found. Run /init-project or /new-project first.", "warning");
+				return;
+			}
+
+			let output = fs.readFileSync(stateFile, "utf-8");
+
+			if (fs.existsSync(logFile)) {
+				const entries = fs.readFileSync(logFile, "utf-8")
+					.split("\n").filter(Boolean)
+					.map((l) => { try { return JSON.parse(l); } catch { return null; } })
+					.filter(Boolean);
+
+				const passed = entries.filter((e) => e.status === "pass").length;
+				const failed = entries.filter((e) => e.status === "fail").length;
+				const skipped = entries.filter((e) => e.status === "skip").length;
+				output += `\n\n---\n**Execution log:** ${passed} passed, ${failed} failed, ${skipped} skipped`;
+			}
+
+			pi.sendUserMessage(`Here is the current project state:\n\n${output}`);
+		},
+	});
+
+	// ── /new-project ─────────────────────────────────────────────────────────
+	pi.registerCommand("new-project", {
+		description: "Create a new project: mkdir, git init, scaffold .draht/. Usage: /new-project <name> [/base/path]",
+		handler: async (args, ctx) => {
+			const parts = args.trim().split(/\s+/);
+			const name = parts[0];
+			if (!name) {
+				ctx.ui.notify("Usage: /new-project <name> [/optional/base/path]", "warning");
+				return;
+			}
+
+			const basePath = parts[1] ?? ctx.cwd;
+			const projectDir = path.join(basePath, name);
+
+			if (fs.existsSync(projectDir)) {
+				ctx.ui.notify(`Directory already exists: ${projectDir}`, "warning");
+				return;
+			}
+
+			fs.mkdirSync(projectDir, { recursive: true });
+
+			const { execSync } = await import("node:child_process");
+			execSync("git init", { cwd: projectDir });
+
+			// Scaffold .draht/ from global agents
+			const agentSrc = path.join(process.env.HOME ?? "~", ".draht", "agent", "agents");
+			const agentDest = path.join(projectDir, ".draht", "agents");
+			const extDest = path.join(projectDir, ".draht", "extensions");
+			fs.mkdirSync(agentDest, { recursive: true });
+			fs.mkdirSync(extDest, { recursive: true });
+
+			let agentsCopied = 0;
+			if (fs.existsSync(agentSrc)) {
+				for (const file of fs.readdirSync(agentSrc)) {
+					if (!file.endsWith(".md")) continue;
+					fs.copyFileSync(path.join(agentSrc, file), path.join(agentDest, file));
+					agentsCopied++;
+				}
+			}
+
+			// Copy shipped extensions into the new project
+			const extSrc = path.dirname(new URL(import.meta.url).pathname);
+			for (const file of ["subagent.ts", "gsd-commands.ts"]) {
+				const src = path.join(extSrc, file);
+				if (fs.existsSync(src)) {
+					fs.copyFileSync(src, path.join(extDest, file));
+				}
+			}
+
+			fs.writeFileSync(path.join(projectDir, ".gitignore"), "node_modules/\n.env\n.env.local\n");
+
+			ctx.ui.notify(
+				`✓ ${projectDir} created — ${agentsCopied} agents, git initialized. Customize .draht/agents/*.md for your stack.`,
+				"info",
+			);
+
+			pi.sendUserMessage(
+				`New project "${name}" created at ${projectDir} with ${agentsCopied} GSD agents scaffolded. What should we build first?`,
+			);
+		},
+	});
+
+	// ── /init-project ────────────────────────────────────────────────────────
+	pi.registerCommand("init-project", {
+		description: "Scaffold .draht/ config into an existing project from global agent defaults",
+		handler: async (_args, ctx) => {
+			const targetDir = path.join(ctx.cwd, ".draht");
+
+			if (fs.existsSync(targetDir)) {
+				ctx.ui.notify(".draht/ already exists in this project", "warning");
+				return;
+			}
+
+			const agentSrc = path.join(process.env.HOME ?? "~", ".draht", "agent", "agents");
+			const agentDest = path.join(targetDir, "agents");
+			const extDest = path.join(targetDir, "extensions");
+			fs.mkdirSync(agentDest, { recursive: true });
+			fs.mkdirSync(extDest, { recursive: true });
+
+			let copied = 0;
+			if (fs.existsSync(agentSrc)) {
+				for (const file of fs.readdirSync(agentSrc)) {
+					if (!file.endsWith(".md")) continue;
+					fs.copyFileSync(path.join(agentSrc, file), path.join(agentDest, file));
+					copied++;
+				}
+			}
+
+			ctx.ui.notify(
+				`.draht/ scaffolded with ${copied} agents. Customize .draht/agents/*.md for this project's stack.`,
+				"info",
+			);
+		},
+	});
+}

package/dist/extensions/subagent.ts

@@ -0,0 +1,312 @@
+/**
+ * Subagent Tool for Draht — adapted from the pi subagent example
+ *
+ * Spawns isolated draht processes for delegated tasks.
+ * Agents are defined in .draht/agents/*.md (project) or ~/.draht/agent/agents/*.md (global).
+ *
+ * Modes:
+ *   single   — { agent, task }
+ *   parallel — { tasks: [{ agent, task }] }  (max 8, concurrency 4)
+ *   chain    — { chain: [{ agent, task }] }  (sequential, {previous} placeholder)
+ */
+
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import type { Message } from "@draht/ai";
+import { StringEnum } from "@draht/ai";
+import { type ExtensionAPI, getAgentDir, parseFrontmatter } from "@draht/coding-agent";
+import { Type } from "@sinclair/typebox";
+
+const MAX_PARALLEL = 8;
+const MAX_CONCURRENCY = 4;
+// Use the same binary that's currently running
+const DRAHT_BIN = process.execPath;
+
+// ─── Agent discovery ────────────────────────────────────────────────────────
+
+interface AgentConfig {
+	name: string;
+	description: string;
+	tools?: string[];
+	model?: string;
+	systemPrompt: string;
+	source: "user" | "project";
+}
+
+function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig[] {
+	if (!fs.existsSync(dir)) return [];
+	let entries: fs.Dirent[];
+	try {
+		entries = fs.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+	const agents: AgentConfig[] = [];
+	for (const entry of entries) {
+		if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+		try {
+			const content = fs.readFileSync(path.join(dir, entry.name), "utf-8");
+			const { frontmatter, body } = parseFrontmatter<Record<string, string>>(content);
+			if (!frontmatter.name || !frontmatter.description) continue;
+			const tools = frontmatter.tools?.split(",").map((t: string) => t.trim()).filter(Boolean);
+			agents.push({
+				name: frontmatter.name,
+				description: frontmatter.description,
+				tools: tools?.length ? tools : undefined,
+				model: frontmatter.model,
+				systemPrompt: body,
+				source,
+			});
+		} catch {
+			continue;
+		}
+	}
+	return agents;
+}
+
+function findProjectAgentsDir(cwd: string): string | null {
+	let dir = cwd;
+	while (true) {
+		const candidate = path.join(dir, ".draht", "agents");
+		try {
+			if (fs.statSync(candidate).isDirectory()) return candidate;
+		} catch {}
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+
+type AgentScope = "user" | "project" | "both";
+
+function discoverAgents(cwd: string, scope: AgentScope): AgentConfig[] {
+	const userDir = path.join(getAgentDir(), "agents");
+	const projectDir = findProjectAgentsDir(cwd);
+	const userAgents = scope !== "project" ? loadAgentsFromDir(userDir, "user") : [];
+	const projectAgents = scope !== "user" && projectDir ? loadAgentsFromDir(projectDir, "project") : [];
+	const map = new Map<string, AgentConfig>();
+	for (const a of userAgents) map.set(a.name, a);
+	for (const a of projectAgents) map.set(a.name, a); // project overrides global
+	return Array.from(map.values());
+}
+
+// ─── Runner ─────────────────────────────────────────────────────────────────
+
+interface RunResult {
+	agent: string;
+	task: string;
+	exitCode: number;
+	output: string;
+	stderr: string;
+	step?: number;
+}
+
+function writeTemp(name: string, content: string): { file: string; dir: string } {
+	const dir = fs.mkdtempSync(path.join(os.tmpdir(), "draht-subagent-"));
+	const file = path.join(dir, `${name.replace(/[^\w.-]/g, "_")}.md`);
+	fs.writeFileSync(file, content, { encoding: "utf-8", mode: 0o600 });
+	return { file, dir };
+}
+
+function cleanTemp(file: string, dir: string) {
+	try { fs.unlinkSync(file); } catch {}
+	try { fs.rmdirSync(dir); } catch {}
+}
+
+function getFinalText(messages: Message[]): string {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role === "assistant") {
+			for (const part of msg.content) {
+				if (part.type === "text") return part.text;
+			}
+		}
+	}
+	return "";
+}
+
+async function runAgent(
+	cwd: string,
+	agent: AgentConfig,
+	task: string,
+	signal?: AbortSignal,
+	step?: number,
+): Promise<RunResult> {
+	const args: string[] = ["--mode", "json", "-p", "--no-session"];
+	if (agent.model) args.push("--model", agent.model);
+	if (agent.tools?.length) args.push("--tools", agent.tools.join(","));
+
+	let tmpFile: string | null = null;
+	let tmpDir: string | null = null;
+
+	if (agent.systemPrompt.trim()) {
+		const tmp = writeTemp(agent.name, agent.systemPrompt);
+		tmpFile = tmp.file;
+		tmpDir = tmp.dir;
+		args.push("--append-system-prompt", tmpFile);
+	}
+
+	args.push(`Task: ${task}`);
+
+	const messages: Message[] = [];
+	let stderr = "";
+
+	try {
+		const exitCode = await new Promise<number>((resolve) => {
+			const proc = spawn(DRAHT_BIN, args, { cwd, shell: false, stdio: ["ignore", "pipe", "pipe"] });
+			let buf = "";
+
+			const processLine = (line: string) => {
+				if (!line.trim()) return;
+				try {
+					const event = JSON.parse(line);
+					if ((event.type === "message_end" || event.type === "tool_result_end") && event.message) {
+						messages.push(event.message as Message);
+					}
+				} catch {}
+			};
+
+			proc.stdout.on("data", (d) => {
+				buf += d.toString();
+				const lines = buf.split("\n");
+				buf = lines.pop() || "";
+				for (const l of lines) processLine(l);
+			});
+			proc.stderr.on("data", (d) => { stderr += d.toString(); });
+			proc.on("close", (code) => {
+				if (buf.trim()) processLine(buf);
+				resolve(code ?? 0);
+			});
+			proc.on("error", () => resolve(1));
+
+			if (signal) {
+				const kill = () => { proc.kill("SIGTERM"); setTimeout(() => { if (!proc.killed) proc.kill("SIGKILL"); }, 5000); };
+				if (signal.aborted) kill();
+				else signal.addEventListener("abort", kill, { once: true });
+			}
+		});
+
+		return { agent: agent.name, task, exitCode, output: getFinalText(messages), stderr, step };
+	} finally {
+		if (tmpFile && tmpDir) cleanTemp(tmpFile, tmpDir);
+	}
+}
+
+async function runParallel<T>(
+	items: T[],
+	concurrency: number,
+	fn: (item: T, i: number) => Promise<T extends unknown ? RunResult : never>,
+): Promise<RunResult[]> {
+	const results: RunResult[] = new Array(items.length);
+	let next = 0;
+	await Promise.all(
+		Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+			while (true) {
+				const i = next++;
+				if (i >= items.length) return;
+				results[i] = await (fn as (item: T, i: number) => Promise<RunResult>)(items[i], i);
+			}
+		}),
+	);
+	return results;
+}
+
+// ─── Extension ──────────────────────────────────────────────────────────────
+
+const TaskItem = Type.Object({
+	agent: Type.String({ description: "Agent name" }),
+	task: Type.String({ description: "Task description" }),
+});
+
+const ChainItem = Type.Object({
+	agent: Type.String({ description: "Agent name" }),
+	task: Type.String({ description: "Task, optionally using {previous} placeholder" }),
+});
+
+const Params = Type.Object({
+	agent: Type.Optional(Type.String()),
+	task: Type.Optional(Type.String()),
+	tasks: Type.Optional(Type.Array(TaskItem, { description: "Parallel tasks" })),
+	chain: Type.Optional(Type.Array(ChainItem, { description: "Chained tasks" })),
+	agentScope: Type.Optional(
+		StringEnum(["user", "project", "both"] as const, { default: "both" }),
+	),
+});
+
+export default function (pi: ExtensionAPI) {
+	pi.registerTool({
+		name: "subagent",
+		label: "Subagent",
+		description:
+			"Delegate to specialized agents. single: {agent,task} | parallel: {tasks:[]} | chain: {chain:[]} with {previous} placeholder. agentScope: 'both' (default) uses project .draht/agents/ + global.",
+		parameters: Params,
+
+		async execute(_id, params, signal, _onUpdate, ctx) {
+			const scope: AgentScope = (params.agentScope as AgentScope) ?? "both";
+			const agents = discoverAgents(ctx.cwd, scope);
+			const available = agents.map((a) => a.name).join(", ") || "none";
+
+			const find = (name: string) => agents.find((a) => a.name === name);
+			const notFound = (name: string) => ({
+				content: [{ type: "text" as const, text: `Unknown agent "${name}". Available: ${available}` }],
+				isError: true,
+			});
+
+			// ── Chain mode ──
+			if (params.chain?.length) {
+				let previous = "";
+				const results: RunResult[] = [];
+				for (let i = 0; i < params.chain.length; i++) {
+					const step = params.chain[i];
+					const agent = find(step.agent);
+					if (!agent) return notFound(step.agent);
+					const task = step.task.replace(/\{previous\}/g, previous);
+					const result = await runAgent(ctx.cwd, agent, task, signal, i + 1);
+					results.push(result);
+					if (result.exitCode !== 0) {
+						return {
+							content: [{ type: "text" as const, text: `Chain failed at step ${i + 1} (${step.agent}):\n${result.output || result.stderr}` }],
+							isError: true,
+						};
+					}
+					previous = result.output;
+				}
+				return { content: [{ type: "text" as const, text: results[results.length - 1].output || "(no output)" }] };
+			}
+
+			// ── Parallel mode ──
+			if (params.tasks?.length) {
+				if (params.tasks.length > MAX_PARALLEL) {
+					return { content: [{ type: "text" as const, text: `Too many tasks (max ${MAX_PARALLEL})` }], isError: true };
+				}
+				for (const t of params.tasks) { if (!find(t.agent)) return notFound(t.agent); }
+
+				const results = await runParallel(params.tasks, MAX_CONCURRENCY, async (t, i) => {
+					return runAgent(ctx.cwd, find(t.agent)!, t.task, signal);
+				});
+
+				const ok = results.filter((r) => r.exitCode === 0).length;
+				const summary = results
+					.map((r) => `[${r.agent}] ${r.exitCode === 0 ? "✓" : "✗"} ${r.output.slice(0, 200)}`)
+					.join("\n\n");
+				return { content: [{ type: "text" as const, text: `Parallel: ${ok}/${results.length} succeeded\n\n${summary}` }] };
+			}
+
+			// ── Single mode ──
+			if (params.agent && params.task) {
+				const agent = find(params.agent);
+				if (!agent) return notFound(params.agent);
+				const result = await runAgent(ctx.cwd, agent, params.task, signal);
+				const isError = result.exitCode !== 0;
+				return {
+					content: [{ type: "text" as const, text: result.output || result.stderr || "(no output)" }],
+					...(isError ? { isError: true } : {}),
+				};
+			}
+
+			return { content: [{ type: "text" as const, text: `Provide exactly one mode. Available agents: ${available}` }], isError: true };
+		},
+	});
+}