pi-subagents 0.18.1 → 0.19.1

package/doctor.ts

@@ -0,0 +1,198 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { discoverAgentsAll, type AgentSource } from "./agents.ts";
+import { isAsyncAvailable } from "./async-execution.ts";
+import { diagnoseIntercomBridge, type IntercomBridgeDiagnostic } from "./intercom-bridge.ts";
+import { discoverAvailableSkills, type SkillSource } from "./skills.ts";
+import {
+	ASYNC_DIR,
+	CHAIN_RUNS_DIR,
+	RESULTS_DIR,
+	TEMP_ROOT_DIR,
+	type ExtensionConfig,
+	type SubagentState,
+} from "./types.ts";
+
+interface DoctorPaths {
+	tempRootDir: string;
+	asyncDir: string;
+	resultsDir: string;
+	chainRunsDir: string;
+}
+
+interface DoctorDeps {
+	isAsyncAvailable: () => boolean;
+	discoverAgentsAll: typeof discoverAgentsAll;
+	discoverAvailableSkills: typeof discoverAvailableSkills;
+	diagnoseIntercomBridge: typeof diagnoseIntercomBridge;
+}
+
+export interface DoctorReportInput {
+	cwd: string;
+	config: ExtensionConfig;
+	state: SubagentState;
+	context?: "fresh" | "fork";
+	requestedSessionDir?: string;
+	currentSessionFile?: string | null;
+	currentSessionId?: string | null;
+	orchestratorTarget?: string;
+	sessionError?: string;
+	expandTilde?: (value: string) => string;
+	paths?: DoctorPaths;
+	deps?: Partial<DoctorDeps>;
+}
+
+const DEFAULT_PATHS: DoctorPaths = {
+	tempRootDir: TEMP_ROOT_DIR,
+	asyncDir: ASYNC_DIR,
+	resultsDir: RESULTS_DIR,
+	chainRunsDir: CHAIN_RUNS_DIR,
+};
+
+const DEFAULT_DEPS: DoctorDeps = {
+	isAsyncAvailable,
+	discoverAgentsAll,
+	discoverAvailableSkills,
+	diagnoseIntercomBridge,
+};
+
+function errorText(error: unknown): string {
+	return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+}
+
+function lineFromCheck(label: string, check: () => string): string {
+	try {
+		return check();
+	} catch (error) {
+		return `- ${label}: failed — ${errorText(error)}`;
+	}
+}
+
+function formatExistingDirectory(label: string, dirPath: string): string {
+	try {
+		if (!fs.existsSync(dirPath)) return `- ${label}: missing (${dirPath})`;
+		const stats = fs.statSync(dirPath);
+		if (!stats.isDirectory()) throw new Error(`not a directory: ${dirPath}`);
+		fs.accessSync(dirPath, fs.constants.R_OK | fs.constants.W_OK);
+		return `- ${label}: ok (${dirPath})`;
+	} catch (error) {
+		return `- ${label}: failed (${dirPath}) — ${errorText(error)}`;
+	}
+}
+
+function formatSourceCounts(counts: Record<AgentSource, number>): string {
+	return `builtin ${counts.builtin}, user ${counts.user}, project ${counts.project}`;
+}
+
+function formatSkillSourceCounts(skills: Array<{ source: SkillSource }>): string {
+	const counts = new Map<SkillSource, number>();
+	for (const skill of skills) counts.set(skill.source, (counts.get(skill.source) ?? 0) + 1);
+	const ordered: SkillSource[] = [
+		"project",
+		"project-settings",
+		"project-package",
+		"user",
+		"user-settings",
+		"user-package",
+		"extension",
+		"builtin",
+		"unknown",
+	];
+	const parts = ordered
+		.map((source) => `${source} ${counts.get(source) ?? 0}`)
+		.filter((part) => !part.endsWith(" 0"));
+	return parts.length > 0 ? parts.join(", ") : "none";
+}
+
+function formatConfiguredSessionDir(input: DoctorReportInput): string {
+	if (input.requestedSessionDir) {
+		return path.resolve(input.expandTilde?.(input.requestedSessionDir) ?? input.requestedSessionDir);
+	}
+	if (input.config.defaultSessionDir) {
+		return path.resolve(input.expandTilde?.(input.config.defaultSessionDir) ?? input.config.defaultSessionDir);
+	}
+	return "not configured";
+}
+
+function formatSessionLines(input: DoctorReportInput): string[] {
+	const sessionFile = input.currentSessionFile ?? null;
+	const lines = [
+		lineFromCheck("configured session dir", () => `- configured session dir: ${formatConfiguredSessionDir(input)}`),
+		`- current session file: ${sessionFile ?? "not available"}`,
+		`- current session dir: ${sessionFile ? path.dirname(sessionFile) : "not available"}`,
+		`- current session id: ${input.currentSessionId ?? input.state.currentSessionId ?? "not available"}`,
+	];
+	if (input.sessionError) lines.push(`- session manager: failed — ${input.sessionError}`);
+	return lines;
+}
+
+function formatDiscovery(input: DoctorReportInput, deps: DoctorDeps): string[] {
+	return [
+		lineFromCheck("agents/chains", () => {
+			const discovered = deps.discoverAgentsAll(input.cwd);
+			const agentCounts = {
+				builtin: discovered.builtin.length,
+				user: discovered.user.length,
+				project: discovered.project.length,
+			};
+			const chainCounts = discovered.chains.reduce<Record<AgentSource, number>>((counts, chain) => {
+				counts[chain.source] += 1;
+				return counts;
+			}, { builtin: 0, user: 0, project: 0 });
+			return [
+				`- agents: total ${agentCounts.builtin + agentCounts.user + agentCounts.project} (${formatSourceCounts(agentCounts)})`,
+				`- chains: total ${discovered.chains.length} (${formatSourceCounts(chainCounts)})`,
+			].join("\n");
+		}),
+		lineFromCheck("skills", () => {
+			const skills = deps.discoverAvailableSkills(input.cwd);
+			return `- skills: total ${skills.length} (${formatSkillSourceCounts(skills)})`;
+		}),
+	];
+}
+
+function formatIntercomDiagnostic(diagnostic: IntercomBridgeDiagnostic, context: "fresh" | "fork" | undefined): string[] {
+	const lines = [
+		`- bridge: ${diagnostic.active ? "active" : "inactive"}${diagnostic.reason ? ` (${diagnostic.reason})` : ""}`,
+		`- mode: ${diagnostic.mode}; context: ${context ?? "unspecified"}`,
+		`- orchestrator target: ${diagnostic.orchestratorTarget ?? "not available"}`,
+		`- pi-intercom: ${diagnostic.piIntercomAvailable ? "available" : "unavailable"} at ${diagnostic.extensionDir}`,
+	];
+	if (diagnostic.configPath && diagnostic.intercomConfigEnabled !== undefined) {
+		lines.push(`- intercom config: ${diagnostic.intercomConfigEnabled === false ? "disabled" : "enabled or absent"} (${diagnostic.configPath})`);
+	}
+	if (diagnostic.intercomConfigError) {
+		lines.push(`- intercom config warning: ${diagnostic.intercomConfigError}; runtime assumes enabled`);
+	}
+	return lines;
+}
+
+export function buildDoctorReport(input: DoctorReportInput): string {
+	const paths = input.paths ?? DEFAULT_PATHS;
+	const deps = { ...DEFAULT_DEPS, ...input.deps };
+	const lines = [
+		"Subagents doctor report",
+		"",
+		"Runtime",
+		`- cwd: ${input.cwd}`,
+		lineFromCheck("async support", () => `- async support: ${deps.isAsyncAvailable() ? "available" : "unavailable"}`),
+		...formatSessionLines(input),
+		"",
+		"Filesystem",
+		formatExistingDirectory("temp root", paths.tempRootDir),
+		formatExistingDirectory("async runs", paths.asyncDir),
+		formatExistingDirectory("results", paths.resultsDir),
+		formatExistingDirectory("chain runs", paths.chainRunsDir),
+		"",
+		"Discovery",
+		...formatDiscovery(input, deps),
+		"",
+		"Intercom bridge",
+		...lineFromCheck("intercom bridge", () => formatIntercomDiagnostic(deps.diagnoseIntercomBridge({
+			config: input.config.intercomBridge,
+			context: input.context,
+			orchestratorTarget: input.orchestratorTarget,
+		}), input.context).join("\n")).split("\n"),
+	];
+	return lines.join("\n");
+}

package/execution.ts

@@ -243,13 +243,11 @@ async function runSingleAttempt(
 		};
 
 		const unsubscribeIntercomDetach = options.intercomEvents?.on?.(INTERCOM_DETACH_REQUEST_EVENT, (payload) => {
-			if (!options.allowIntercomDetach || detached || processClosed) return;
+			if (!options.allowIntercomDetach || detached || processClosed || !intercomStarted) return;
 			if (!payload || typeof payload !== "object") return;
 			const requestId = (payload as { requestId?: unknown }).requestId;
 			if (typeof requestId !== "string" || requestId.length === 0) return;
-			const accepted = intercomStarted;
-			options.intercomEvents?.emit(INTERCOM_DETACH_RESPONSE_EVENT, { requestId, accepted });
-			if (!accepted) return;
+			options.intercomEvents?.emit(INTERCOM_DETACH_RESPONSE_EVENT, { requestId, accepted: true });
 			detachForIntercom();
 		});
 

package/index.ts

@@ -401,7 +401,7 @@ EXECUTION (use exactly ONE mode):
 • Before executing, use { action: "list" } to inspect configured agents/chains. Only execute agents listed as executable/non-disabled.
 • SINGLE: { agent, task? } - one task; omit task for self-contained agents
 • CHAIN: { chain: [{agent:"agent-a"}, {parallel:[{agent:"agent-b",count:3}]}] } - sequential pipeline with optional parallel fan-out
-• PARALLEL: { tasks: [{agent,task,count?}, ...], concurrency?: number, worktree?: true } - concurrent execution (worktree: isolate each task in a git worktree)
+• PARALLEL: { tasks: [{agent,task,count?,output?,reads?,progress?}, ...], concurrency?: number, worktree?: true } - concurrent execution (worktree: isolate each task in a git worktree)
 • Optional context: { context: "fresh" | "fork" } (default: "fresh")
 
 CHAIN TEMPLATE VARIABLES (use in task strings):
@@ -421,7 +421,10 @@ MANAGEMENT (use action field, omit agent/task/chain/tasks):
 
 CONTROL:
 • { action: "status", id: "..." } - inspect an async/background run by id or prefix
-• { action: "interrupt", id?: "..." } - soft-interrupt the current child turn and leave the run paused`,
+• { action: "interrupt", id?: "..." } - soft-interrupt the current child turn and leave the run paused
+
+DIAGNOSTICS:
+• { action: "doctor" } - read-only report for runtime paths, discovery, sessions, and intercom`,
 		parameters: SubagentParams,
 
 		execute(id, params, signal, onUpdate, ctx) {

package/intercom-bridge.ts

@@ -8,14 +8,14 @@ const DEFAULT_INTERCOM_EXTENSION_DIR = path.join(os.homedir(), ".pi", "agent", "
 const DEFAULT_INTERCOM_CONFIG_PATH = path.join(os.homedir(), ".pi", "agent", "intercom", "config.json");
 const DEFAULT_SUBAGENT_CONFIG_DIR = path.join(os.homedir(), ".pi", "agent", "extensions", "subagent");
 const DEFAULT_INTERCOM_TARGET_PREFIX = "subagent-chat";
-const INTERCOM_BRIDGE_MARKER = "Intercom orchestration channel:";
+export const INTERCOM_BRIDGE_MARKER = "Intercom orchestration channel:";
 const DEFAULT_INTERCOM_BRIDGE_TEMPLATE = `The inherited thread is reference-only. Do not continue that conversation or send questions, status updates, or completion handoffs to the orchestrator in normal assistant text.
 
 Use intercom only for coordination with the orchestrator session "{orchestratorTarget}".
 - Need a decision or blocked: intercom({ action: "ask", to: "{orchestratorTarget}", message: "<question>" })
-- Need to report progress or a completion handoff: intercom({ action: "send", to: "{orchestratorTarget}", message: "DONE: <summary>" })
+- Blocked or explicitly asked to send progress: intercom({ action: "send", to: "{orchestratorTarget}", message: "UPDATE: <summary>" })
 
-If no upstream coordination is needed, continue the task normally and return a focused task result.`;
+Do not send routine completion handoffs through intercom. If no coordination is needed, return a focused task result.`;
 
 export interface IntercomBridgeState {
 	active: boolean;
@@ -25,6 +25,19 @@ export interface IntercomBridgeState {
 	instruction: string;
 }
 
+export interface IntercomBridgeDiagnostic {
+	active: boolean;
+	mode: IntercomBridgeMode;
+	wantsIntercom: boolean;
+	piIntercomAvailable: boolean;
+	extensionDir: string;
+	configPath?: string;
+	orchestratorTarget?: string;
+	reason?: string;
+	intercomConfigEnabled?: boolean;
+	intercomConfigError?: string;
+}
+
 interface ResolveIntercomBridgeInput {
 	config: ExtensionConfig["intercomBridge"];
 	context: "fresh" | "fork" | undefined;
@@ -68,14 +81,13 @@ function resolveIntercomBridgeConfig(value: ExtensionConfig["intercomBridge"]):
 	};
 }
 
-function intercomEnabled(configPath: string): boolean {
-	if (!fs.existsSync(configPath)) return true;
+function intercomConfigStatus(configPath: string): { enabled: boolean; error?: unknown } {
+	if (!fs.existsSync(configPath)) return { enabled: true };
 	try {
 		const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8")) as { enabled?: unknown };
-		return parsed.enabled !== false;
+		return { enabled: parsed.enabled !== false };
 	} catch (error) {
-		console.warn(`Failed to parse intercom config at '${configPath}'. Assuming enabled.`, error);
-		return true;
+		return { enabled: true, error };
 	}
 }
 
@@ -119,6 +131,44 @@ function buildIntercomBridgeInstruction(orchestratorTarget: string, template: st
 ${instruction}`;
 }
 
+export function diagnoseIntercomBridge(input: ResolveIntercomBridgeInput): IntercomBridgeDiagnostic {
+	const config = resolveIntercomBridgeConfig(input.config);
+	const mode = config.mode;
+	const extensionDir = path.resolve(input.extensionDir ?? DEFAULT_INTERCOM_EXTENSION_DIR);
+	const orchestratorTarget = input.orchestratorTarget?.trim();
+	const configPath = path.resolve(input.configPath ?? DEFAULT_INTERCOM_CONFIG_PATH);
+	const wantsIntercom = mode !== "off" && !(mode === "fork-only" && input.context !== "fork");
+	const piIntercomAvailable = fs.existsSync(extensionDir);
+	let configStatus: ReturnType<typeof intercomConfigStatus> | undefined;
+	let reason: string | undefined;
+	if (mode === "off") reason = "bridge mode is off";
+	else if (mode === "fork-only" && input.context !== "fork") reason = "bridge mode is fork-only and context is not fork";
+	else if (!orchestratorTarget) reason = "orchestrator target is not available";
+	else if (!piIntercomAvailable) reason = "pi-intercom extension was not found";
+	else {
+		configStatus = intercomConfigStatus(configPath);
+		if (!configStatus.enabled) reason = "intercom config is disabled";
+	}
+	let intercomConfigError: string | undefined;
+	if (configStatus?.error) {
+		const error = configStatus.error;
+		intercomConfigError = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+	}
+
+	return {
+		active: reason === undefined,
+		mode,
+		wantsIntercom,
+		piIntercomAvailable,
+		extensionDir,
+		configPath,
+		...(orchestratorTarget ? { orchestratorTarget } : {}),
+		...(reason ? { reason } : {}),
+		...(configStatus ? { intercomConfigEnabled: configStatus.enabled } : {}),
+		...(intercomConfigError ? { intercomConfigError } : {}),
+	};
+}
+
 export function resolveIntercomBridge(input: ResolveIntercomBridgeInput): IntercomBridgeState {
 	const config = resolveIntercomBridgeConfig(input.config);
 	const mode = config.mode;
@@ -144,7 +194,9 @@ export function resolveIntercomBridge(input: ResolveIntercomBridgeInput): Interc
 	}
 
 	const configPath = path.resolve(input.configPath ?? DEFAULT_INTERCOM_CONFIG_PATH);
-	if (!intercomEnabled(configPath)) {
+	const intercomStatus = intercomConfigStatus(configPath);
+	if (intercomStatus.error) console.warn(`Failed to parse intercom config at '${configPath}'. Assuming enabled.`, intercomStatus.error);
+	if (!intercomStatus.enabled) {
 		return { active: false, mode, extensionDir, instruction: defaultInstruction };
 	}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-subagents",
-  "version": "0.18.1",
+  "version": "0.19.1",
   "description": "Pi extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification",
   "author": "Nico Bailon",
   "license": "MIT",
@@ -31,6 +31,7 @@
     "*.mjs",
     "agents/",
     "skills/**/*",
+    "prompts/**/*",
     "README.md",
     "CHANGELOG.md"
   ],
@@ -46,6 +47,9 @@
     ],
     "skills": [
       "./skills"
+    ],
+    "prompts": [
+      "./prompts"
     ]
   },
   "peerDependencies": {

package/prompts/parallel-review.md

@@ -0,0 +1,8 @@
+---
+description: Parallel subagents review
+---
+Great. Now let's launch parallel reviewers to conduct an adversarial review.
+
+Important: launch reviewers with fresh context, not forked context. Reviewers should inspect the repository and current diff directly from files and commands, without inheriting the main agent chat. Use forked context only if I explicitly ask for it.
+
+$@

package/schemas.ts

@@ -26,6 +26,9 @@ export const TaskItem = Type.Object({
 	task: Type.String(), 
 	cwd: Type.Optional(Type.String()),
 	count: Type.Optional(Type.Integer({ minimum: 1, description: "Repeat this parallel task N times with the same settings." })),
+	output: Type.Optional(OutputOverride),
+	reads: Type.Optional(ReadsOverride),
+	progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking for this task" })),
 	model: Type.Optional(Type.String({ description: "Override model for this task (e.g. 'google/gemini-3-pro')" })),
 	skill: Type.Optional(SkillOverride),
 });
@@ -103,7 +106,7 @@ export const SubagentParams = Type.Object({
 	task: Type.Optional(Type.String({ description: "Task (SINGLE mode, optional for self-contained agents)" })),
 	// Management action (when present, tool operates in management mode)
 	action: Type.Optional(Type.String({
-		description: "Action: management ('list','get','create','update','delete') or control ('status','interrupt'). Omit for execution mode."
+		description: "Action: 'list', 'get', 'create', 'update', 'delete', 'status', 'interrupt', or 'doctor'. Omit for execution mode."
 	})),
 	id: Type.Optional(Type.String({
 		description: "Run id or prefix for action='status' or action='interrupt'."
@@ -124,7 +127,7 @@ export const SubagentParams = Type.Object({
 		additionalProperties: true,
 		description: "Agent or chain config for create/update. Agent: name, description, scope ('user'|'project', default 'user'), systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, model, tools (comma-separated), extensions (comma-separated), skills (comma-separated), thinking, output, reads, progress, maxSubagentDepth. Chain: name, description, scope, steps (array of {agent, task?, output?, reads?, model?, skills?, progress?}). Presence of 'steps' creates a chain instead of an agent. String values must be valid JSON."
 	})),
-	tasks: Type.Optional(Type.Array(TaskItem, { description: "PARALLEL mode: [{agent, task, count?}, ...]" })),
+	tasks: Type.Optional(Type.Array(TaskItem, { description: "PARALLEL mode: [{agent, task, count?, output?, reads?, progress?}, ...]" })),
 	concurrency: Type.Optional(Type.Integer({ minimum: 1, description: "Top-level PARALLEL mode only: max concurrent tasks. Defaults to config.parallel.concurrency or 4." })),
 	worktree: Type.Optional(Type.Boolean({
 		description: "Create isolated git worktrees for each parallel task. " +

package/settings.ts

@@ -8,6 +8,7 @@ import type { AgentConfig } from "./agents.ts";
 import { normalizeSkillInput } from "./skills.ts";
 import { CHAIN_RUNS_DIR } from "./types.ts";
 const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
+const INITIAL_PROGRESS_CONTENT = "# Progress\n\n## Status\nIn Progress\n\n## Tasks\n\n## Files Changed\n\n## Notes\n";
 
 // =============================================================================
 // Behavior Resolution Types
@@ -224,6 +225,10 @@ function resolveChainPath(filePath: string, chainDir: string): string {
  * Build chain instructions from resolved behavior.
  * These are appended to the task to tell the agent what to read/write.
  */
+export function writeInitialProgressFile(progressDir: string): void {
+	fs.writeFileSync(path.join(progressDir, "progress.md"), INITIAL_PROGRESS_CONTENT);
+}
+
 export function buildChainInstructions(
 	behavior: ResolvedStepBehavior,
 	chainDir: string,

package/slash-commands.ts

@@ -3,11 +3,12 @@ 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.ts";
+import { discoverAgents, discoverAgentsAll, type ChainConfig } from "./agents.ts";
 import { AgentManagerComponent, type ManagerResult } from "./agent-manager.ts";
 import { SubagentsStatusComponent } from "./subagents-status.ts";
 import { discoverAvailableSkills } from "./skills.ts";
 import type { SubagentParamsLike } from "./subagent-executor.ts";
+import { isParallelStep, type ChainStep } from "./settings.ts";
 import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
 import {
 	applySlashUpdate,
@@ -107,6 +108,36 @@ const makeAgentCompletions = (state: SubagentState, multiAgent: boolean) => (pre
 	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(" ")) return null;
+	return discoverSavedChains(state.baseCwd)
+		.filter((chain) => chain.name.startsWith(prefix))
+		.map((chain) => ({ value: chain.name, label: chain.name }));
+};
+
+const mapSavedChainSteps = (chain: ChainConfig, worktree = false): ChainStep[] => {
+	return (chain.steps as Array<ChainStep & { skills?: string[] | false }>).map((step) => {
+		if (isParallelStep(step)) return worktree ? { ...step, worktree: true } : { ...step };
+		return {
+			agent: step.agent,
+			task: step.task || undefined,
+			output: step.output,
+			reads: step.reads,
+			progress: step.progress,
+			skill: step.skill ?? step.skills,
+			model: step.model,
+		};
+	});
+};
+
 async function requestSlashRun(
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,
@@ -308,48 +339,31 @@ async function openAgentManager(
 	);
 	if (!result) return;
 
+	const launchOptions: SubagentParamsLike = {
+		clarify: !result.skipClarify && !result.background,
+		agentScope: "both",
+		...(result.fork ? { context: "fork" as const } : {}),
+		...(result.background ? { async: true } : {}),
+	};
+
 	if (result.action === "chain") {
 		const chain = result.agents.map((name, i) => ({
 			agent: name,
 			...(i === 0 ? { task: result.task } : {}),
 		}));
-		await runSlashSubagent(pi, ctx, {
-			chain,
-			task: result.task,
-			clarify: true,
-			agentScope: "both",
-		});
+		await runSlashSubagent(pi, ctx, { chain, task: result.task, ...launchOptions });
 		return;
 	}
 
 	if (result.action === "launch") {
-		await runSlashSubagent(pi, ctx, {
-			agent: result.agent,
-			task: result.task,
-			clarify: !result.skipClarify,
-			agentScope: "both",
-		});
+		await runSlashSubagent(pi, ctx, { agent: result.agent, task: result.task, ...launchOptions });
 	} else if (result.action === "launch-chain") {
-		const chainParam = result.chain.steps.map((step) => ({
-			agent: step.agent,
-			task: step.task || undefined,
-			output: step.output,
-			reads: step.reads,
-			progress: step.progress,
-			skill: step.skills,
-			model: step.model,
-		}));
-		await runSlashSubagent(pi, ctx, {
-			chain: chainParam,
-			task: result.task,
-			clarify: !result.skipClarify,
-			agentScope: "both",
-		});
+		await runSlashSubagent(pi, ctx, { chain: mapSavedChainSteps(result.chain, result.worktree), task: result.task, ...launchOptions });
 	} else if (result.action === "parallel") {
 		await runSlashSubagent(pi, ctx, {
 			tasks: result.tasks,
-			clarify: !result.skipClarify,
-			agentScope: "both",
+			...launchOptions,
+			...(result.worktree ? { worktree: true } : {}),
 		});
 	}
 }
@@ -493,21 +507,53 @@ export function registerSlashCommands(
 		},
 	});
 
+	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;
+			}
+			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";
+			await runSlashSubagent(pi, ctx, params);
+		},
+	});
+
 	pi.registerCommand("parallel", {
 		description: "Run agents in parallel: /parallel scout \"task1\" -> reviewer \"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.model ? { model: config.model } : {}),
-					...(config.skill !== undefined ? { skill: config.skill } : {}),
-				}));
-				const params: SubagentParamsLike = { tasks, clarify: false, agentScope: "both" };
-				if (bg) params.async = 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.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";
 			await runSlashSubagent(pi, ctx, params);
 		},
@@ -523,6 +569,13 @@ export function registerSlashCommands(
 		},
 	});
 
+	pi.registerCommand("subagents-doctor", {
+		description: "Show subagent diagnostics",
+		handler: async (_args, ctx) => {
+			await runSlashSubagent(pi, ctx, { action: "doctor" });
+		},
+	});
+
 	pi.registerShortcut("ctrl+shift+a", {
 		handler: async (ctx) => {
 			await openAgentManager(pi, ctx);

package/slash-live-state.ts

@@ -1,8 +1,8 @@
 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";
+import type { SubagentParamsLike } from "./subagent-executor.ts";
+import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
+import { type Details, type SingleResult, type Usage, SLASH_RESULT_TYPE } from "./types.ts";
 
 export interface SlashMessageDetails {
 	requestId: string;