pi-subagents 0.18.1 → 0.19.0

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

@@ -8,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,
@@ -308,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 } : {}),
 		});
 	}
 }
@@ -503,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/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;
 }
@@ -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: [{
@@ -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,
@@ -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),

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,