@fitchmultz/pi-subagents 0.0.0-stage → 0.44.4

package/dist/slash/slash-commands.js

@@ -0,0 +1,607 @@
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Key, matchesKey } from "@earendil-works/pi-tui";
+import { discoverAgents, discoverAgentsAll } from "../agents/agents.js";
+import { isDynamicParallelStep, isParallelStep } from "../shared/settings.js";
+import { assertJsonSchemaObject } from "../runs/shared/structured-output.js";
+import { applySlashUpdate, buildSlashInitialResult, failSlashResult, finalizeSlashResult, } from "./slash-live-state.js";
+import { SLASH_RESULT_TYPE, SLASH_SUBAGENT_CANCEL_EVENT, SLASH_SUBAGENT_REQUEST_EVENT, SLASH_SUBAGENT_RESPONSE_EVENT, SLASH_SUBAGENT_STARTED_EVENT, SLASH_SUBAGENT_UPDATE_EVENT, } from "../shared/types.js";
+import { isTuiContext } from "../shared/ui-mode.js";
+import { resolveExecutionCwd } from "../shared/execution-cwd.js";
+const parseInlineConfig = (raw) => {
+    const config = {};
+    for (const part of raw.split(",")) {
+        const trimmed = part.trim();
+        if (!trimmed)
+            continue;
+        const eq = trimmed.indexOf("=");
+        if (eq === -1) {
+            if (trimmed !== "progress")
+                throw new Error(`Unknown inline option '${trimmed}'.`);
+            config.progress = true;
+            continue;
+        }
+        const key = trimmed.slice(0, eq).trim();
+        const val = trimmed.slice(eq + 1).trim();
+        switch (key) {
+            case "output":
+                config.output = val === "false" ? false : val;
+                break;
+            case "outputMode":
+                if (val !== "inline" && val !== "file-only")
+                    throw new Error("outputMode must be inline or file-only.");
+                config.outputMode = val;
+                break;
+            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":
+                if (val !== "true" && val !== "false")
+                    throw new Error("progress must be true or false.");
+                config.progress = val === "true";
+                break;
+            default: throw new Error(`Unknown inline option '${key}'.`);
+        }
+    }
+    return config;
+};
+const parseAgentToken = (token) => {
+    const bracket = token.indexOf("[");
+    if (bracket === -1)
+        return { name: token, config: {} };
+    const end = token.lastIndexOf("]");
+    if (end !== token.length - 1 || end < bracket)
+        throw new Error(`Malformed inline options in '${token}'; close the trailing ].`);
+    const name = token.slice(0, bracket);
+    if (!name)
+        throw new Error("Agent name is required before inline options.");
+    return { name, config: parseInlineConfig(token.slice(bracket + 1, end)) };
+};
+const unwrapQuotedTask = (task) => {
+    const match = task.match(/^(?:"([\s\S]*)"|'([\s\S]*)')$/);
+    return match ? (match[1] ?? match[2] ?? "") : task;
+};
+const extractExecutionFlags = (rawArgs) => {
+    let args = rawArgs.trim();
+    let asyncMode;
+    let fork = false;
+    while (true) {
+        if (args.endsWith(" --bg") || args === "--bg") {
+            if (asyncMode === false)
+                return { args, fork, error: "Choose only one of --bg or --fg" };
+            asyncMode = true;
+            args = args === "--bg" ? "" : args.slice(0, -5).trim();
+            continue;
+        }
+        if (args.endsWith(" --fg") || args === "--fg") {
+            if (asyncMode === true)
+                return { args, fork, error: "Choose only one of --bg or --fg" };
+            asyncMode = false;
+            args = args === "--fg" ? "" : args.slice(0, -5).trim();
+            continue;
+        }
+        if (args.endsWith(" --fork") || args === "--fork") {
+            fork = true;
+            args = args === "--fork" ? "" : args.slice(0, -7).trim();
+            continue;
+        }
+        break;
+    }
+    return { args, async: asyncMode, fork };
+};
+const projectTrusted = (state) => state.lastUiContext ? state.lastUiContext.isProjectTrusted() : true;
+const completionCwd = (pi, state) => {
+    try {
+        return state.lastUiContext ? resolveExecutionCwd(pi, state.lastUiContext) : state.baseCwd;
+    }
+    catch {
+        return null;
+    }
+};
+const makeAgentCompletions = (pi, state, multiAgent) => (prefix) => {
+    const cwd = completionCwd(pi, state);
+    if (!cwd)
+        return null;
+    const agents = discoverAgents(cwd, "both", { projectTrusted: projectTrusted(state) }).agents;
+    if (!multiAgent) {
+        if (prefix.includes(" "))
+            return null;
+        return agents.filter((a) => a.name.startsWith(prefix)).map((a) => ({ value: a.name, label: a.name }));
+    }
+    const lastArrow = prefix.lastIndexOf(" -> ");
+    const segment = lastArrow !== -1 ? prefix.slice(lastArrow + 4) : prefix;
+    if (segment.includes(" -- ") || segment.includes('"') || segment.includes("'"))
+        return null;
+    const lastWord = (prefix.match(/(\S*)$/) || ["", ""])[1];
+    const beforeLastWord = prefix.slice(0, prefix.length - lastWord.length);
+    if (lastWord === "->") {
+        return agents.map((a) => ({ value: `${prefix} ${a.name}`, label: a.name }));
+    }
+    return agents.filter((a) => a.name.startsWith(lastWord)).map((a) => ({ value: `${beforeLastWord}${a.name}`, label: a.name }));
+};
+const discoverSavedChains = (cwd, projectTrusted) => {
+    const chainsByName = new Map();
+    for (const chain of discoverAgentsAll(cwd, { projectTrusted }).chains) {
+        const existing = chainsByName.get(chain.name);
+        const projectOverride = existing?.source === "user" && chain.source === "project";
+        const sameScopeJsonOverride = existing?.source === chain.source && chain.filePath.endsWith(".chain.json") && !existing.filePath.endsWith(".chain.json");
+        if (!existing || projectOverride || sameScopeJsonOverride)
+            chainsByName.set(chain.name, chain);
+    }
+    return Array.from(chainsByName.values());
+};
+const makeChainCompletions = (pi, state) => (prefix) => {
+    const cwd = completionCwd(pi, state);
+    if (prefix.includes(" ") || !cwd)
+        return null;
+    return discoverSavedChains(cwd, projectTrusted(state))
+        .filter((chain) => chain.name.startsWith(prefix))
+        .map((chain) => ({ value: chain.name, label: chain.name }));
+};
+function loadSavedOutputSchema(chain, stepAgent, outputSchema) {
+    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"));
+        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, worktree = false) => {
+    return chain.steps.map((step) => {
+        if (isParallelStep(step)) {
+            const parallel = step.parallel.map((task) => {
+                const { outputSchema: rawOutputSchema, ...rest } = task;
+                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;
+            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.outputSchema);
+        return {
+            agent: step.agent,
+            ...(step.task ? { task: step.task } : {}),
+            ...(step.cwd !== undefined ? { cwd: step.cwd } : {}),
+            ...(step.phase ? { phase: step.phase } : {}),
+            ...(step.label ? { label: step.label } : {}),
+            ...(step.as ? { as: step.as } : {}),
+            ...(outputSchema ? { outputSchema } : {}),
+            output: step.output,
+            outputMode: step.outputMode,
+            reads: step.reads,
+            progress: step.progress,
+            skill: step.skill ?? step.skills,
+            model: step.model,
+            ...(step.acceptance !== undefined ? { acceptance: step.acceptance } : {}),
+        };
+    });
+};
+async function requestSlashRun(pi, ctx, requestId, params, executionCwd) {
+    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) => {
+            if (done || !data || typeof data !== "object")
+                return;
+            if (data.requestId !== requestId)
+                return;
+            started = true;
+            clearTimeout(startTimeout);
+            if (ctx.hasUI)
+                ctx.ui.setStatus("subagent-slash", "running...");
+        };
+        const onResponse = (data) => {
+            if (done || !data || typeof data !== "object")
+                return;
+            const response = data;
+            if (response.requestId !== requestId)
+                return;
+            clearTimeout(startTimeout);
+            finish(() => resolve(response));
+        };
+        const onUpdate = (data) => {
+            if (done || !data || typeof data !== "object")
+                return;
+            const update = data;
+            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 = isTuiContext(ctx)
+            ? 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) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(startTimeout);
+            unsubStarted();
+            unsubResponse();
+            unsubUpdate();
+            onTerminalInput?.();
+            next();
+        };
+        pi.events.emit(SLASH_SUBAGENT_REQUEST_EVENT, { requestId, params, ...(executionCwd ? { executionCwd } : {}) });
+        // 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) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((part) => part?.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n");
+}
+function formatExportPathList(paths) {
+    return paths.map((file) => `- \`${file}\``).join("\n");
+}
+function collectResultPaths(results, getPath) {
+    return results
+        .map(getPath)
+        .filter((file) => typeof file === "string" && file.length > 0);
+}
+function buildSlashExportText(response) {
+    const output = extractSlashMessageText(response.result.content) || response.errorText || "(no output)";
+    const results = response.result.details?.results ?? [];
+    const sessionFiles = collectResultPaths(results, (result) => result.sessionFile);
+    const savedOutputs = collectResultPaths(results, (result) => result.savedOutputPath);
+    const artifactOutputs = collectResultPaths(results, (result) => result.artifactPaths?.outputPath);
+    const sections = ["## Subagent result", output];
+    if (sessionFiles.length > 0)
+        sections.push("## Child session exports", formatExportPathList(sessionFiles));
+    if (savedOutputs.length > 0)
+        sections.push("## Saved outputs", formatExportPathList(savedOutputs));
+    if (artifactOutputs.length > 0)
+        sections.push("## Artifact outputs", formatExportPathList(artifactOutputs));
+    return sections.join("\n\n");
+}
+async function runSlashSubagent(pi, ctx, params, executionCwd) {
+    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, executionCwd);
+        const finalDetails = finalizeSlashResult(response);
+        pi.sendMessage({
+            customType: SLASH_RESULT_TYPE,
+            content: buildSlashExportText(response),
+            display: false,
+            details: finalDetails,
+        });
+        if (ctx.hasUI) {
+            ctx.ui.setStatus("subagent-slash", undefined);
+        }
+        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);
+        pi.sendMessage({
+            customType: SLASH_RESULT_TYPE,
+            content: `## Subagent result\n\n${message}`,
+            display: false,
+            details: failedDetails,
+        });
+        if (ctx.hasUI) {
+            ctx.ui.setStatus("subagent-slash", undefined);
+        }
+        if (message === "Cancelled") {
+            if (ctx.hasUI)
+                ctx.ui.notify("Cancelled", "warning");
+            return;
+        }
+        if (ctx.hasUI)
+            ctx.ui.notify(message, "error");
+    }
+}
+const parseAgentArgs = (cwd, args, command, ctx) => {
+    const input = args.trim();
+    const usage = `Usage: /${command} agent1 "task1" -> agent2 "task2"`;
+    let steps;
+    let sharedTask;
+    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;
+            let agentPart;
+            let task;
+            const qMatch = trimmed.match(/^(\S+(?:\[[^\]]*\])?)\s+(?:"([^"]*)"|'([^']*)')$/);
+            if (qMatch) {
+                agentPart = qMatch[1];
+                task = (qMatch[2] ?? qMatch[3]) || undefined;
+            }
+            else {
+                const dashIdx = trimmed.indexOf(" -- ");
+                if (dashIdx !== -1) {
+                    agentPart = trimmed.slice(0, dashIdx).trim();
+                    task = trimmed.slice(dashIdx + 4).trim() || undefined;
+                }
+                else {
+                    agentPart = trimmed;
+                }
+            }
+            try {
+                const parsed = parseAgentToken(agentPart);
+                steps.push({ ...parsed, task });
+            }
+            catch (error) {
+                ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+                return null;
+            }
+        }
+        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;
+        }
+        try {
+            steps = agentsPart.split(/\s+/).filter(Boolean).map((token) => parseAgentToken(token));
+        }
+        catch (error) {
+            ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+            return null;
+        }
+    }
+    if (steps.length === 0) {
+        ctx.ui.notify(usage, "error");
+        return null;
+    }
+    const agents = discoverAgents(cwd, "both", { projectTrusted: ctx.isProjectTrusted() }).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 };
+};
+export function registerSlashCommands(pi, state) {
+    pi.registerCommand("run", {
+        description: "Run a subagent directly: /run agent[output=file] [task] [--bg|--fg] [--fork]",
+        getArgumentCompletions: makeAgentCompletions(pi, state, false),
+        handler: async (args, ctx) => {
+            const flags = extractExecutionFlags(args);
+            if (flags.error) {
+                ctx.ui.notify(flags.error, "error");
+                return;
+            }
+            const { args: cleanedArgs, async: asyncMode, fork } = flags;
+            const input = cleanedArgs.trim();
+            const firstSpace = input.indexOf(" ");
+            if (!input) {
+                ctx.ui.notify("Usage: /run <agent> [task] [--bg|--fg] [--fork]", "error");
+                return;
+            }
+            let parsedAgent;
+            try {
+                parsedAgent = parseAgentToken(firstSpace === -1 ? input : input.slice(0, firstSpace));
+            }
+            catch (error) {
+                ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+                return;
+            }
+            const { name: agentName, config: inline } = parsedAgent;
+            const task = firstSpace === -1 ? "" : unwrapQuotedTask(input.slice(firstSpace + 1).trim());
+            const cwd = resolveExecutionCwd(pi, ctx);
+            const agents = discoverAgents(cwd, "both", { projectTrusted: ctx.isProjectTrusted() }).agents;
+            if (!agents.find((a) => a.name === agentName)) {
+                ctx.ui.notify(`Unknown agent: ${agentName}`, "error");
+                return;
+            }
+            let finalTask = task;
+            if (inline.reads && Array.isArray(inline.reads) && inline.reads.length > 0) {
+                finalTask = `[Read from: ${inline.reads.join(", ")}]\n\n${finalTask}`;
+            }
+            const params = { agent: agentName, task: finalTask, clarify: false, agentScope: "both" };
+            if (inline.output !== undefined)
+                params.output = inline.output;
+            if (inline.outputMode !== undefined)
+                params.outputMode = inline.outputMode;
+            if (inline.skill !== undefined)
+                params.skill = inline.skill;
+            if (inline.model)
+                params.model = inline.model;
+            if (inline.progress !== undefined)
+                params.progress = inline.progress;
+            if (asyncMode !== undefined)
+                params.async = asyncMode;
+            if (fork)
+                params.context = "fork";
+            await runSlashSubagent(pi, ctx, params, cwd);
+        },
+    });
+    pi.registerCommand("chain", {
+        description: "Run agents in sequence: /chain scout \"task\" -> oracle [--bg|--fg] [--fork]",
+        getArgumentCompletions: makeAgentCompletions(pi, state, true),
+        handler: async (args, ctx) => {
+            const flags = extractExecutionFlags(args);
+            if (flags.error) {
+                ctx.ui.notify(flags.error, "error");
+                return;
+            }
+            const { args: cleanedArgs, async: asyncMode, fork } = flags;
+            const cwd = resolveExecutionCwd(pi, ctx);
+            const parsed = parseAgentArgs(cwd, cleanedArgs, "chain", ctx);
+            if (!parsed)
+                return;
+            const chain = parsed.steps.map(({ name, config, task: stepTask }, i) => ({
+                agent: name,
+                ...(stepTask ? { task: stepTask } : i === 0 && parsed.task ? { task: 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 = { chain, task: parsed.task, clarify: false, agentScope: "both" };
+            if (asyncMode !== undefined)
+                params.async = asyncMode;
+            if (fork)
+                params.context = "fork";
+            await runSlashSubagent(pi, ctx, params, cwd);
+        },
+    });
+    pi.registerCommand("run-chain", {
+        description: "Run a saved chain: /run-chain chainName -- task [--bg|--fg] [--fork]",
+        getArgumentCompletions: makeChainCompletions(pi, state),
+        handler: async (args, ctx) => {
+            const flags = extractExecutionFlags(args);
+            if (flags.error) {
+                ctx.ui.notify(flags.error, "error");
+                return;
+            }
+            const { args: cleanedArgs, async: asyncMode, fork } = flags;
+            const delimiterIndex = cleanedArgs.indexOf(" -- ");
+            const usage = "Usage: /run-chain <chainName> -- <task> [--bg|--fg] [--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;
+            }
+            const cwd = resolveExecutionCwd(pi, ctx);
+            const chain = discoverSavedChains(cwd, ctx.isProjectTrusted()).find((candidate) => candidate.name === chainName);
+            if (!chain) {
+                ctx.ui.notify(`Unknown chain: ${chainName}`, "error");
+                return;
+            }
+            let savedSteps;
+            try {
+                savedSteps = mapSavedChainSteps(chain);
+            }
+            catch (error) {
+                ctx.ui.notify(`Cannot load chain '${chainName}': ${error instanceof Error ? error.message : String(error)}`, "error");
+                return;
+            }
+            const params = { chain: savedSteps, task, clarify: false, agentScope: "both" };
+            if (asyncMode !== undefined)
+                params.async = asyncMode;
+            if (fork)
+                params.context = "fork";
+            await runSlashSubagent(pi, ctx, params, cwd);
+        },
+    });
+    pi.registerCommand("parallel", {
+        description: "Run agents in parallel: /parallel scout \"task1\" -> oracle \"task2\" [--bg|--fg] [--fork]",
+        getArgumentCompletions: makeAgentCompletions(pi, state, true),
+        handler: async (args, ctx) => {
+            const flags = extractExecutionFlags(args);
+            if (flags.error) {
+                ctx.ui.notify(flags.error, "error");
+                return;
+            }
+            const { args: cleanedArgs, async: asyncMode, fork } = flags;
+            const cwd = resolveExecutionCwd(pi, ctx);
+            const parsed = parseAgentArgs(cwd, 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 = { tasks, clarify: false, agentScope: "both" };
+            if (asyncMode !== undefined)
+                params.async = asyncMode;
+            if (fork)
+                params.context = "fork";
+            await runSlashSubagent(pi, ctx, params, cwd);
+        },
+    });
+    pi.registerCommand("subagents-doctor", {
+        description: "Show subagent diagnostics",
+        handler: async (_args, ctx) => {
+            await runSlashSubagent(pi, ctx, { action: "doctor" });
+        },
+    });
+}