pi-subagents 0.18.0 → 0.19.0

package/skills.ts

@@ -210,9 +210,70 @@ function collectSettingsSkillPaths(cwd: string): SkillSearchPath[] {
 	return results;
 }
 
+function isSafePackagePath(value: string): boolean {
+	return value.length > 0
+		&& !path.isAbsolute(value)
+		&& value.split(/[\\/]/).every((part) => part.length > 0 && part !== "." && part !== "..");
+}
+
+function parseNpmPackageName(source: string): string | undefined {
+	const spec = source.slice(4).trim();
+	if (!spec) return undefined;
+	const match = spec.match(/^(@?[^@]+(?:\/[^@]+)?)(?:@(.+))?$/);
+	const packageName = match?.[1] ?? spec;
+	return isSafePackagePath(packageName) ? packageName : undefined;
+}
+
+function stripGitRef(repoPath: string): string {
+	const atIndex = repoPath.indexOf("@");
+	const hashIndex = repoPath.indexOf("#");
+	const refIndex = [atIndex, hashIndex].filter((index) => index >= 0).sort((a, b) => a - b)[0];
+	return refIndex === undefined ? repoPath : repoPath.slice(0, refIndex);
+}
+
+function parseGitPackagePath(source: string): { host: string; repoPath: string } | undefined {
+	const spec = source.slice(4).trim();
+	if (!spec) return undefined;
+
+	let host = "";
+	let repoPath = "";
+	const scpLike = spec.match(/^git@([^:]+):(.+)$/);
+	if (scpLike) {
+		host = scpLike[1] ?? "";
+		repoPath = scpLike[2] ?? "";
+	} else if (/^[a-z][a-z0-9+.-]*:\/\//i.test(spec)) {
+		try {
+			const url = new URL(spec);
+			host = url.hostname;
+			repoPath = url.pathname.replace(/^\/+/, "");
+		} catch {
+			return undefined;
+		}
+	} else {
+		const slashIndex = spec.indexOf("/");
+		if (slashIndex < 0) return undefined;
+		host = spec.slice(0, slashIndex);
+		repoPath = spec.slice(slashIndex + 1);
+	}
+
+	const normalizedPath = stripGitRef(repoPath).replace(/\.git$/, "").replace(/^\/+/, "");
+	if (!host || !isSafePackagePath(host) || !isSafePackagePath(normalizedPath) || normalizedPath.split(/[\\/]/).length < 2) {
+		return undefined;
+	}
+	return { host, repoPath: normalizedPath };
+}
+
 function resolveSettingsPackageRoot(source: string, baseDir: string): string | undefined {
 	const trimmed = source.trim();
 	if (!trimmed) return undefined;
+	if (trimmed.startsWith("git:")) {
+		const parsed = parseGitPackagePath(trimmed);
+		return parsed ? path.join(baseDir, "git", parsed.host, parsed.repoPath) : undefined;
+	}
+	if (trimmed.startsWith("npm:")) {
+		const packageName = parseNpmPackageName(trimmed);
+		return packageName ? path.join(baseDir, "npm", "node_modules", packageName) : undefined;
+	}
 	const normalized = trimmed.startsWith("file:") ? trimmed.slice(5) : trimmed;
 	if (normalized === "~") return os.homedir();
 	if (normalized.startsWith("~/")) return path.join(os.homedir(), normalized.slice(2));

package/slash-commands.ts

@@ -1,4 +1,6 @@
 import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { Key, matchesKey } from "@mariozechner/pi-tui";
 import { discoverAgents, discoverAgentsAll } from "./agents.ts";
@@ -6,6 +8,7 @@ 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,
@@ -20,6 +23,7 @@ import {
 	SLASH_SUBAGENT_RESPONSE_EVENT,
 	SLASH_SUBAGENT_STARTED_EVENT,
 	SLASH_SUBAGENT_UPDATE_EVENT,
+	type SingleResult,
 	type SubagentState,
 } from "./types.ts";
 
@@ -194,6 +198,46 @@ function extractSlashMessageText(content: string | Array<{ type?: string; text?:
 		.join("\n");
 }
 
+function formatExportPathList(paths: string[]): string {
+	return paths.map((file) => `- \`${file}\``).join("\n");
+}
+
+function collectResultPaths(results: SingleResult[], getPath: (result: SingleResult) => string | undefined): string[] {
+	return results
+		.map(getPath)
+		.filter((file): file is string => typeof file === "string" && file.length > 0);
+}
+
+function buildSlashExportText(response: SlashSubagentResponse): string {
+	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");
+}
+
+function persistSlashSessionSnapshot(ctx: ExtensionContext): void {
+	try {
+		if (!ctx.sessionManager) return;
+		const sessionManager = ctx.sessionManager as typeof ctx.sessionManager & {
+			_rewriteFile?: () => void;
+			flushed?: boolean;
+		};
+		const sessionFile = sessionManager.getSessionFile();
+		if (!sessionFile || typeof sessionManager._rewriteFile !== "function") return;
+		fs.mkdirSync(path.dirname(sessionFile), { recursive: true });
+		sessionManager._rewriteFile();
+		sessionManager.flushed = true;
+	} catch (error) {
+		console.error("Failed to persist slash session snapshot for export:", error);
+	}
+}
+
 async function runSlashSubagent(
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,
@@ -208,17 +252,18 @@ async function runSlashSubagent(
 		display: true,
 		details: initialDetails,
 	});
+	persistSlashSessionSnapshot(ctx);
 
 	try {
 		const response = await requestSlashRun(pi, ctx, requestId, params);
 		const finalDetails = finalizeSlashResult(response);
-		const text = extractSlashMessageText(response.result.content) || response.errorText || "(no output)";
 		pi.sendMessage({
 			customType: SLASH_RESULT_TYPE,
-			content: text,
-			display: false,
+			content: buildSlashExportText(response),
+			display: true,
 			details: finalDetails,
 		});
+		persistSlashSessionSnapshot(ctx);
 		if (ctx.hasUI) {
 			ctx.ui.setStatus("subagent-slash", undefined);
 		}
@@ -227,13 +272,14 @@ async function runSlashSubagent(
 		}
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		const failedDetails = failSlashResult(requestId, params, message === "Cancelled" ? "Cancelled" : message);
+		const failedDetails = failSlashResult(requestId, params, message);
 		pi.sendMessage({
 			customType: SLASH_RESULT_TYPE,
-			content: message,
-			display: false,
+			content: `## Subagent result\n\n${message}`,
+			display: true,
 			details: failedDetails,
 		});
+		persistSlashSessionSnapshot(ctx);
 		if (ctx.hasUI) {
 			ctx.ui.setStatus("subagent-slash", undefined);
 		}
@@ -263,48 +309,43 @@ 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",
+		const chainParam = (result.chain.steps as unknown as ChainStep[]).map((step) => {
+			if (isParallelStep(step)) return result.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 as typeof step & { skills?: string[] | false }).skills,
+				model: step.model,
+			};
 		});
+		await runSlashSubagent(pi, ctx, { chain: chainParam, 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 } : {}),
 		});
 	}
 }
@@ -398,16 +439,15 @@ export function registerSlashCommands(
 	});
 
 	pi.registerCommand("run", {
-		description: "Run a subagent directly: /run agent[output=file] task [--bg] [--fork]",
+		description: "Run a subagent directly: /run agent[output=file] [task] [--bg] [--fork]",
 		getArgumentCompletions: makeAgentCompletions(state, false),
 		handler: async (args, ctx) => {
 			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
 			const input = cleanedArgs.trim();
 			const firstSpace = input.indexOf(" ");
-			if (firstSpace === -1) { ctx.ui.notify("Usage: /run <agent> <task> [--bg] [--fork]", "error"); return; }
-			const { name: agentName, config: inline } = parseAgentToken(input.slice(0, firstSpace));
-			const task = input.slice(firstSpace + 1).trim();
-			if (!task) { ctx.ui.notify("Usage: /run <agent> <task> [--bg] [--fork]", "error"); return; }
+			if (!input) { ctx.ui.notify("Usage: /run <agent> [task] [--bg] [--fork]", "error"); return; }
+			const { name: agentName, config: inline } = parseAgentToken(firstSpace === -1 ? input : input.slice(0, firstSpace));
+			const task = firstSpace === -1 ? "" : input.slice(firstSpace + 1).trim();
 
 			const agents = discoverAgents(state.baseCwd, "both").agents;
 			if (!agents.find((a) => a.name === agentName)) { ctx.ui.notify(`Unknown agent: ${agentName}`, "error"); return; }
@@ -459,8 +499,11 @@ export function registerSlashCommands(
 				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;

package/slash-live-state.ts

@@ -278,11 +278,9 @@ export function restoreSlashFinalSnapshots(entries: unknown[]): void {
 	liveSnapshots.clear();
 	finalSnapshots.clear();
 	for (const entry of entries) {
-		const e = entry as { type?: string; message?: { role?: string; customType?: string; display?: boolean; details?: unknown } };
-		if (e?.type !== "message") continue;
-		const m = e.message;
-		if (!m || m.role !== "custom" || m.customType !== SLASH_RESULT_TYPE || m.display !== false) continue;
-		const details = resolveSlashMessageDetails(m.details);
+		const e = entry as { type?: string; customType?: string; details?: unknown };
+		if (e?.type !== "custom_message" || e.customType !== SLASH_RESULT_TYPE) continue;
+		const details = resolveSlashMessageDetails(e.details);
 		if (!details) continue;
 		finalSnapshots.set(details.requestId, { result: details.result, version: nextVersion() });
 	}

package/subagent-executor.ts

@@ -14,16 +14,20 @@ import { resolveModelCandidate } from "./model-fallback.ts";
 import { aggregateParallelOutputs } from "./parallel-utils.ts";
 import { recordRun } from "./run-history.ts";
 import {
+	buildChainInstructions,
+	writeInitialProgressFile,
 	getStepAgents,
 	isParallelStep,
 	resolveStepBehavior,
 	type ChainStep,
+	type ResolvedStepBehavior,
 	type SequentialStep,
+	type StepOverrides,
 } from "./settings.ts";
 import { discoverAvailableSkills, normalizeSkillInput } from "./skills.ts";
 import { executeAsyncChain, executeAsyncSingle, isAsyncAvailable } from "./async-execution.ts";
 import { createForkContextResolver } from "./fork-context.ts";
-import { applyIntercomBridgeToAgent, resolveIntercomBridge, resolveIntercomSessionTarget, resolveSubagentIntercomTarget, type IntercomBridgeState } from "./intercom-bridge.ts";
+import { applyIntercomBridgeToAgent, INTERCOM_BRIDGE_MARKER, resolveIntercomBridge, resolveIntercomSessionTarget, resolveSubagentIntercomTarget, type IntercomBridgeState } from "./intercom-bridge.ts";
 import { formatControlIntercomMessage, formatControlNoticeMessage, resolveControlConfig, shouldNotifyControlEvent } from "./subagent-control.ts";
 import { finalizeSingleOutput, injectSingleOutputInstruction, resolveSingleOutputPath } from "./single-output.ts";
 import { compactForegroundDetails, getSingleResultOutput, mapConcurrent, readStatus, resolveChildCwd } from "./utils.ts";
@@ -46,6 +50,7 @@ import {
 	type ControlEvent,
 	type Details,
 	type ExtensionConfig,
+	type IntercomEventBus,
 	type MaxOutputConfig,
 	type ResolvedControlConfig,
 	type SingleResult,
@@ -68,6 +73,9 @@ interface TaskParam {
 	task: string;
 	cwd?: string;
 	count?: number;
+	output?: string | boolean;
+	reads?: string[] | boolean;
+	progress?: boolean;
 	model?: string;
 	skill?: string | string[] | boolean;
 }
@@ -326,7 +334,7 @@ function validateExecutionInput(
 function getRequestedModeLabel(params: SubagentParamsLike): Details["mode"] {
 	if ((params.chain?.length ?? 0) > 0) return "chain";
 	if ((params.tasks?.length ?? 0) > 0) return "parallel";
-	if (params.agent && params.task) return "single";
+	if (params.agent) return "single";
 	return "single";
 }
 
@@ -483,7 +491,7 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 	} = data;
 	const hasChain = (params.chain?.length ?? 0) > 0;
 	const hasTasks = (params.tasks?.length ?? 0) > 0;
-	const hasSingle = Boolean(params.agent && params.task);
+	const hasSingle = !hasChain && !hasTasks && Boolean(params.agent);
 	if (!effectiveAsync) return null;
 
 	if (hasChain && params.chain) {
@@ -544,6 +552,9 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 			cwd: task.cwd,
 			...(modelOverrides[index] ? { model: modelOverrides[index] } : {}),
 			...(skillOverrides[index] !== undefined ? { skill: skillOverrides[index] } : {}),
+			...(task.output === true ? (agentConfigs[index]?.output ? { output: agentConfigs[index]!.output } : {}) : task.output !== undefined ? { output: task.output } : {}),
+			...(task.reads !== undefined && task.reads !== true ? { reads: task.reads } : {}),
+			...(task.progress !== undefined ? { progress: task.progress } : {}),
 		}));
 		return executeAsyncChain(id, {
 			chain: [{
@@ -614,7 +625,7 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 		const modelOverride = resolveModelCandidate((params.model as string | undefined) ?? a.model, availableModels, currentProvider);
 		return executeAsyncSingle(id, {
 			agent: params.agent!,
-			task: params.context === "fork" ? wrapForkTask(params.task!) : params.task!,
+			task: params.context === "fork" ? wrapForkTask(params.task ?? "") : (params.task ?? ""),
 			agentConfig: a,
 			ctx: asyncCtx,
 			availableModels,
@@ -669,6 +680,7 @@ async function runChainPath(data: ExecutionContextData, deps: ExecutorDeps): Pro
 		task: params.task,
 		agents,
 		ctx,
+		intercomEvents: deps.pi.events,
 		signal,
 		runId,
 		cwd: effectiveCwd,
@@ -741,6 +753,7 @@ interface ForegroundParallelRunInput {
 	taskTexts: string[];
 	agents: AgentConfig[];
 	ctx: ExtensionContext;
+	intercomEvents: IntercomEventBus;
 	signal: AbortSignal;
 	runId: string;
 	sessionDirForIndex: (idx?: number) => string | undefined;
@@ -749,12 +762,12 @@ interface ForegroundParallelRunInput {
 	artifactConfig: ArtifactConfig;
 	artifactsDir: string;
 	maxOutput?: MaxOutputConfig;
-	paramsCwd?: string;
+	paramsCwd: string;
 	maxSubagentDepths: number[];
 	availableModels: ModelInfo[];
 	modelOverrides: (string | undefined)[];
-	skillOverrides: (string[] | false | undefined)[];
 	behaviors: Array<ReturnType<typeof resolveStepBehavior>>;
+	firstProgressIndex: number;
 	controlConfig: ResolvedControlConfig;
 	onControlEvent?: (event: ControlEvent) => void;
 	childIntercomTarget?: (agent: string, index: number) => string | undefined;
@@ -822,12 +835,11 @@ function buildChainWorktreeTaskCwdError(chain: ChainStep[], sharedCwd: string):
 
 function resolveParallelTaskCwd(
 	task: TaskParam,
-	paramsCwd: string | undefined,
+	paramsCwd: string,
 	worktreeSetup: WorktreeSetup | undefined,
 	index: number,
-): string | undefined {
+): string {
 	if (worktreeSetup) return worktreeSetup.worktrees[index]!.agentCwd;
-	if (!paramsCwd) return task.cwd;
 	return resolveChildCwd(paramsCwd, task.cwd);
 }
 
@@ -842,11 +854,46 @@ function buildParallelWorktreeSuffix(
 	return formatWorktreeDiffSummary(diffs);
 }
 
+function findDuplicateParallelOutputPath(input: {
+	tasks: TaskParam[];
+	behaviors: ResolvedStepBehavior[];
+	paramsCwd: string;
+	ctxCwd: string;
+	worktreeSetup?: WorktreeSetup;
+}): string | undefined {
+	const seen = new Map<string, { index: number; agent: string }>();
+	for (let index = 0; index < input.tasks.length; index++) {
+		const behavior = input.behaviors[index];
+		if (!behavior?.output) continue;
+		const task = input.tasks[index]!;
+		const taskCwd = resolveParallelTaskCwd(task, input.paramsCwd, input.worktreeSetup, index);
+		const outputPath = resolveSingleOutputPath(behavior.output, input.ctxCwd, taskCwd);
+		if (!outputPath) continue;
+		const previous = seen.get(outputPath);
+		if (previous) {
+			return `Parallel tasks ${previous.index + 1} (${previous.agent}) and ${index + 1} (${task.agent}) resolve output to the same path: ${outputPath}. Use distinct output paths.`;
+		}
+		seen.set(outputPath, { index, agent: task.agent });
+	}
+	return undefined;
+}
+
 async function runForegroundParallelTasks(input: ForegroundParallelRunInput): Promise<SingleResult[]> {
 	return mapConcurrent(input.tasks, input.concurrencyLimit, async (task, index) => {
-		const overrideSkills = input.skillOverrides[index];
-		const effectiveSkills = overrideSkills === undefined ? input.behaviors[index]?.skills : overrideSkills;
+		const behavior = input.behaviors[index];
+		const effectiveSkills = behavior?.skills;
 		const taskCwd = resolveParallelTaskCwd(task, input.paramsCwd, input.worktreeSetup, index);
+		const readInstructions = behavior
+			? buildChainInstructions({ ...behavior, output: false, progress: false }, taskCwd, false)
+			: { prefix: "", suffix: "" };
+		const progressInstructions = behavior
+			? buildChainInstructions({ ...behavior, output: false, reads: false }, input.paramsCwd, index === input.firstProgressIndex)
+			: { prefix: "", suffix: "" };
+		const outputPath = resolveSingleOutputPath(behavior?.output, input.ctx.cwd, taskCwd);
+		const taskText = injectSingleOutputInstruction(
+			`${readInstructions.prefix}${input.taskTexts[index]!}${progressInstructions.suffix}`,
+			outputPath,
+		);
 		const interruptController = new AbortController();
 		if (input.foregroundControl) {
 			input.foregroundControl.currentAgent = task.agent;
@@ -861,10 +908,13 @@ async function runForegroundParallelTasks(input: ForegroundParallelRunInput): Pr
 				return true;
 			};
 		}
-		return runSync(input.ctx.cwd, input.agents, task.agent, input.taskTexts[index]!, {
+		const agentConfig = input.agents.find((agent) => agent.name === task.agent);
+		return runSync(input.ctx.cwd, input.agents, task.agent, taskText, {
 			cwd: taskCwd,
 			signal: input.signal,
 			interruptSignal: interruptController.signal,
+			allowIntercomDetach: agentConfig?.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
+			intercomEvents: input.intercomEvents,
 			runId: input.runId,
 			index,
 			sessionDir: input.sessionDirForIndex(index),
@@ -873,6 +923,7 @@ async function runForegroundParallelTasks(input: ForegroundParallelRunInput): Pr
 			artifactsDir: input.artifactConfig.enabled ? input.artifactsDir : undefined,
 			artifactConfig: input.artifactConfig,
 			maxOutput: input.maxOutput,
+			outputPath,
 			maxSubagentDepth: input.maxSubagentDepths[index],
 			controlConfig: input.controlConfig,
 			onControlEvent: input.onControlEvent,
@@ -983,16 +1034,23 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 		fullId: `${m.provider}/${m.id}`,
 	}));
 	let taskTexts = tasks.map((t) => t.task);
-	const modelOverrides: (string | undefined)[] = tasks.map((t, i) =>
-		resolveModelCandidate(t.model ?? agentConfigs[i]?.model, availableModels, currentProvider),
-	);
 	const skillOverrides: (string[] | false | undefined)[] = tasks.map((t) =>
 		normalizeSkillInput(t.skill),
 	);
+	const behaviorOverrides: StepOverrides[] = tasks.map((task, index) => ({
+		...(task.output !== undefined ? { output: task.output === true ? agentConfigs[index]?.output ?? false : task.output } : {}),
+		...(task.reads !== undefined && task.reads !== true ? { reads: task.reads } : {}),
+		...(task.progress !== undefined ? { progress: task.progress } : {}),
+		...(skillOverrides[index] !== undefined ? { skills: skillOverrides[index] } : {}),
+		...(task.model ? { model: task.model } : {}),
+	}));
+	const modelOverrides: (string | undefined)[] = tasks.map((_, i) =>
+		resolveModelCandidate(behaviorOverrides[i]?.model ?? agentConfigs[i]?.model, availableModels, currentProvider),
+	);
 
 	if (params.clarify === true && ctx.hasUI) {
 		const behaviors = agentConfigs.map((c, i) =>
-			resolveStepBehavior(c, { skills: skillOverrides[i] }),
+			resolveStepBehavior(c, behaviorOverrides[i]!),
 		);
 		const availableSkills = discoverAvailableSkills(effectiveCwd);
 
@@ -1021,8 +1079,17 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 		taskTexts = result.templates;
 		for (let i = 0; i < result.behaviorOverrides.length; i++) {
 			const override = result.behaviorOverrides[i];
-			if (override?.model) modelOverrides[i] = override.model;
-			if (override?.skills !== undefined) skillOverrides[i] = override.skills;
+			if (override?.model) {
+				modelOverrides[i] = override.model;
+				behaviorOverrides[i]!.model = override.model;
+			}
+			if (override?.output !== undefined) behaviorOverrides[i]!.output = override.output;
+			if (override?.reads !== undefined) behaviorOverrides[i]!.reads = override.reads;
+			if (override?.progress !== undefined) behaviorOverrides[i]!.progress = override.progress;
+			if (override?.skills !== undefined) {
+				skillOverrides[i] = override.skills;
+				behaviorOverrides[i]!.skills = override.skills;
+			}
 		}
 
 		if (result.runInBackground) {
@@ -1046,6 +1113,9 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 				cwd: t.cwd,
 				...(modelOverrides[i] ? { model: modelOverrides[i] } : {}),
 				...(skillOverrides[i] !== undefined ? { skill: skillOverrides[i] } : {}),
+				...(behaviorOverrides[i]?.output !== undefined ? { output: behaviorOverrides[i]!.output } : {}),
+				...(behaviorOverrides[i]?.reads !== undefined ? { reads: behaviorOverrides[i]!.reads } : {}),
+				...(behaviorOverrides[i]?.progress !== undefined ? { progress: behaviorOverrides[i]!.progress } : {}),
 			}));
 			return executeAsyncChain(id, {
 				chain: [{ parallel: parallelTasks, concurrency: parallelConcurrency, worktree: params.worktree }],
@@ -1070,7 +1140,8 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 		}
 	}
 
-	const behaviors = agentConfigs.map((config) => resolveStepBehavior(config, {}));
+	const behaviors = agentConfigs.map((config, index) => resolveStepBehavior(config, behaviorOverrides[index]!));
+	const firstProgressIndex = behaviors.findIndex((behavior) => behavior.progress);
 	const liveResults: (SingleResult | undefined)[] = new Array(tasks.length).fill(undefined);
 	const liveProgress: (AgentProgress | undefined)[] = new Array(tasks.length).fill(undefined);
 	const foregroundControl = deps.state.foregroundControls.get(runId);
@@ -1085,6 +1156,18 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 	if (errorResult) return errorResult;
 
 	try {
+		const duplicateOutputError = findDuplicateParallelOutputPath({
+			tasks,
+			behaviors,
+			paramsCwd: effectiveCwd,
+			ctxCwd: ctx.cwd,
+			worktreeSetup,
+		});
+		if (duplicateOutputError) return buildParallelModeError(duplicateOutputError);
+
+		const parallelProgressPrecreated = firstProgressIndex !== -1;
+		if (parallelProgressPrecreated) writeInitialProgressFile(effectiveCwd);
+
 		if (params.context === "fork") {
 			for (let i = 0; i < taskTexts.length; i++) {
 				taskTexts[i] = wrapForkTask(taskTexts[i]!);
@@ -1096,6 +1179,7 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 			taskTexts,
 			agents,
 			ctx,
+			intercomEvents: deps.pi.events,
 			signal,
 			runId,
 			sessionDirForIndex,
@@ -1107,8 +1191,8 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 			paramsCwd: effectiveCwd,
 			availableModels,
 			modelOverrides,
-			skillOverrides,
 			behaviors,
+			firstProgressIndex: parallelProgressPrecreated ? -1 : firstProgressIndex,
 			controlConfig,
 			onControlEvent,
 			childIntercomTarget: childIntercomTarget ? (agent, index) => childIntercomTarget(runId, agent, index) : undefined,
@@ -1211,7 +1295,7 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 		id: m.id,
 		fullId: `${m.provider}/${m.id}`,
 	}));
-	let task = params.task!;
+	let task = params.task ?? "";
 	let modelOverride: string | undefined = resolveModelCandidate(
 		(params.model as string | undefined) ?? agentConfig.model,
 		availableModels,
@@ -1345,7 +1429,7 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 		cwd: effectiveCwd,
 		signal,
 		interruptSignal: interruptController.signal,
-		allowIntercomDetach: agentConfig.systemPrompt?.includes("Intercom orchestration channel:") === true,
+		allowIntercomDetach: agentConfig.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
 		intercomEvents: deps.pi.events,
 		runId,
 		sessionDir: sessionDirForIndex(0),
@@ -1548,7 +1632,7 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 		const shareEnabled = effectiveParams.share === true;
 		const hasChain = (effectiveParams.chain?.length ?? 0) > 0;
 		const hasTasks = (effectiveParams.tasks?.length ?? 0) > 0;
-		const hasSingle = Boolean(effectiveParams.agent && effectiveParams.task);
+		const hasSingle = !hasChain && !hasTasks && Boolean(effectiveParams.agent);
 		const allowClarifyTaskPrompt = hasChain
 			&& effectiveParams.clarify === true
 			&& ctx.hasUI
@@ -1602,6 +1686,8 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 		}
 		const sessionDirForIndex = (idx?: number) =>
 			path.join(sessionRoot, `run-${idx ?? 0}`);
+		const childSessionFileForIndex = (idx?: number) =>
+			sessionFileForIndex(idx) ?? path.join(sessionDirForIndex(idx), "session.jsonl");
 
 		const onUpdateWithContext = onUpdate
 			? (r: AgentToolResult<Details>) => onUpdate(withForkContext(r, effectiveParams.context))
@@ -1618,7 +1704,7 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 			shareEnabled,
 			sessionRoot,
 			sessionDirForIndex,
-			sessionFileForIndex,
+			sessionFileForIndex: childSessionFileForIndex,
 			artifactConfig,
 			artifactsDir,
 			backgroundRequestedWhileClarifying,

package/subagent-runner.ts

@@ -51,6 +51,7 @@ import {
 	formatWorktreeTaskCwdConflict,
 	type WorktreeSetup,
 } from "./worktree.ts";
+import { writeInitialProgressFile } from "./settings.ts";
 
 interface SubagentRunConfig {
 	id: string;
@@ -817,6 +818,12 @@ function appendParallelWorktreeSummary(
 	return `${previousOutput}\n\n${diffSummary}`;
 }
 
+function ensureParallelProgressFile(cwd: string, group: Extract<RunnerStep, { parallel: SubagentStep[] }>): void {
+	const progressPath = path.join(cwd, "progress.md");
+	if (!group.parallel.some((task) => task.task.includes(`Update progress at: ${progressPath}`))) return;
+	writeInitialProgressFile(cwd);
+}
+
 async function runSubagent(config: SubagentRunConfig): Promise<void> {
 	const { id, steps, resultPath, cwd, placeholder, taskIndex, totalTasks, maxOutput, artifactsDir, artifactConfig } =
 		config;
@@ -1039,6 +1046,7 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 			}
 
 			try {
+				if (group.worktree) ensureParallelProgressFile(cwd, group);
 				const groupStartTime = Date.now();
 				markParallelGroupRunning({
 					statusPayload,