pi-subagents 0.13.4 → 0.14.1

package/chain-execution.ts

@@ -28,7 +28,7 @@ import {
 import { discoverAvailableSkills, normalizeSkillInput } from "./skills.ts";
 import { runSync } from "./execution.ts";
 import { buildChainSummary } from "./formatters.ts";
-import { getSingleResultOutput, mapConcurrent } from "./utils.ts";
+import { compactForegroundDetails, getSingleResultOutput, mapConcurrent } from "./utils.ts";
 import { recordRun } from "./run-history.ts";
 import {
 	cleanupWorktrees,
@@ -91,7 +91,7 @@ interface ParallelChainRunInput {
 }
 
 function buildChainExecutionDetails(input: ChainExecutionDetailsInput): Details {
-	return {
+	return compactForegroundDetails({
 		mode: "chain",
 		results: input.results,
 		progress: input.includeProgress ? input.allProgress : undefined,
@@ -99,7 +99,7 @@ function buildChainExecutionDetails(input: ChainExecutionDetailsInput): Details
 		chainAgents: input.chainAgents,
 		totalSteps: input.totalSteps,
 		currentStepIndex: input.currentStepIndex,
-	};
+	});
 }
 
 function buildChainExecutionErrorResult(message: string, input: ChainExecutionDetailsInput): ChainExecutionResult {
@@ -175,8 +175,8 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 
 			const taskAgentConfig = input.agents.find((agent) => agent.name === task.agent);
 			const effectiveModel =
-				(task.model ? resolveModelCandidate(task.model, input.availableModels) : null)
-				?? resolveModelCandidate(taskAgentConfig?.model, input.availableModels);
+				(task.model ? resolveModelCandidate(task.model, input.availableModels, input.ctx.model?.provider) : null)
+				?? resolveModelCandidate(taskAgentConfig?.model, input.availableModels, input.ctx.model?.provider);
 			const maxSubagentDepth = resolveChildMaxSubagentDepth(input.maxSubagentDepth, taskAgentConfig?.maxSubagentDepth);
 
 			const taskCwd = input.worktreeSetup
@@ -201,6 +201,7 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 				maxSubagentDepth,
 				modelOverride: effectiveModel,
 				availableModels: input.availableModels,
+				preferredModelProvider: input.ctx.model?.provider,
 				skills: behavior.skills === false ? [] : behavior.skills,
 				onUpdate: input.onUpdate
 					? (progressUpdate) => {
@@ -293,7 +294,6 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 	const allProgress: AgentProgress[] = [];
 	const allArtifactPaths: ArtifactPaths[] = [];
 
-	// Compute chain metadata for observability
 	const chainAgents: string[] = chainSteps.map((step) =>
 		isParallelStep(step)
 			? `[${step.parallel.map((t) => t.agent).join("+")}]`
@@ -301,39 +301,24 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 	);
 	const totalSteps = chainSteps.length;
 
-	// Get original task from params or first step
 	const firstStep = chainSteps[0]!;
 	const originalTask = params.task
 		?? (isParallelStep(firstStep) ? firstStep.parallel[0]!.task! : (firstStep as SequentialStep).task!);
 
-	// Create chain directory
 	const chainDir = createChainDir(runId, chainDirBase);
-
-	// Check if chain has any parallel steps
 	const hasParallelSteps = chainSteps.some(isParallelStep);
-
-	// Resolve templates (parallel-aware)
 	let templates: ResolvedTemplates = resolveChainTemplates(chainSteps);
-
-	// For TUI: only show if no parallel steps (TUI v1 doesn't support parallel display)
 	const shouldClarify = clarify !== false && ctx.hasUI && !hasParallelSteps;
-
-	// Behavior overrides from TUI (set if TUI is shown, undefined otherwise)
 	let tuiBehaviorOverrides: (BehaviorOverride | undefined)[] | undefined;
-
-	// Get available models for model resolution (used in TUI and execution)
 	const availableModels: ModelInfo[] = ctx.modelRegistry.getAvailable().map((m) => ({
 		provider: m.provider,
 		id: m.id,
 		fullId: `${m.provider}/${m.id}`,
 	}));
-	const availableSkills = discoverAvailableSkills(ctx.cwd);
+	const availableSkills = discoverAvailableSkills(cwd ?? ctx.cwd);
 
 	if (shouldClarify) {
-		// Sequential-only chain: use existing TUI
 		const seqSteps = chainSteps as SequentialStep[];
-
-		// Load agent configs for sequential steps
 		const agentConfigs: AgentConfig[] = [];
 		for (const step of seqSteps) {
 			const config = agents.find((a) => a.name === step.agent);
@@ -348,7 +333,6 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			agentConfigs.push(config);
 		}
 
-		// Build step overrides
 		const stepOverrides: StepOverrides[] = seqSteps.map((step) => ({
 			output: step.output,
 			reads: step.reads,
@@ -357,12 +341,9 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			model: step.model,
 		}));
 
-		// Pre-resolve behaviors for TUI display
 		const resolvedBehaviors = agentConfigs.map((config, i) =>
 			resolveStepBehavior(config, stepOverrides[i]!, chainSkills),
 		);
-
-		// Flatten templates for TUI (all strings for sequential)
 		const flatTemplates = templates as string[];
 
 		const result = await ctx.ui.custom<ChainClarifyResult>(
@@ -376,6 +357,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 					chainDir,
 					resolvedBehaviors,
 					availableModels,
+					ctx.model?.provider,
 					availableSkills,
 					done,
 				),
@@ -393,16 +375,14 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			};
 		}
 
-		// User requested background execution - return early so caller can dispatch to async
 		if (result.runInBackground) {
-			removeChainDir(chainDir); // Will be recreated by async runner
-			// Apply TUI edits (templates + behavior overrides) to chain steps
-			const updatedChain = chainSteps.map((step, i) => {
-				if (isParallelStep(step)) return step; // Parallel steps unchanged (TUI skipped for parallel chains)
+			removeChainDir(chainDir);
+			const updatedChain: ChainStep[] = chainSteps.map((step, i) => {
+				if (isParallelStep(step)) return step;
 				const override = result.behaviorOverrides[i];
 				return {
 					...step,
-					task: result.templates[i] as string, // Always use edited template
+					task: result.templates[i]!,
 					...(override?.model ? { model: override.model } : {}),
 					...(override?.output !== undefined ? { output: override.output } : {}),
 					...(override?.reads !== undefined ? { reads: override.reads } : {}),
@@ -413,21 +393,18 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			return {
 				content: [{ type: "text", text: "Launching in background..." }],
 				details: { mode: "chain", results: [] },
-				requestedAsync: { chain: updatedChain as ChainStep[], chainSkills },
+				requestedAsync: { chain: updatedChain, chainSkills },
 			};
 		}
 
-		// Update templates from TUI result
 		templates = result.templates;
-		// Store behavior overrides from TUI (used below in sequential step execution)
 		tuiBehaviorOverrides = result.behaviorOverrides;
 	}
 
-	// Execute chain (handles both sequential and parallel steps)
 	const results: SingleResult[] = [];
 	let prev = "";
-	let globalTaskIndex = 0; // For unique artifact naming
-	let progressCreated = false; // Track if progress.md has been created
+	let globalTaskIndex = 0;
+	let progressCreated = false;
 
 	for (let stepIndex = 0; stepIndex < chainSteps.length; stepIndex++) {
 		const step = chainSteps[stepIndex]!;
@@ -572,11 +549,9 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				if (worktreeSetup) cleanupWorktrees(worktreeSetup);
 			}
 		} else {
-			// === SEQUENTIAL STEP EXECUTION ===
 			const seqStep = step as SequentialStep;
 			const stepTemplate = stepTemplates as string;
 
-			// Get agent config
 			const agentConfig = agents.find((a) => a.name === seqStep.agent);
 			if (!agentConfig) {
 				removeChainDir(chainDir);
@@ -587,7 +562,6 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				};
 			}
 
-			// Resolve behavior first (TUI overrides take precedence over step config)
 			const tuiOverride = tuiBehaviorOverrides?.[stepIndex];
 			const stepOverride: StepOverrides = {
 				output: tuiOverride?.output !== undefined ? tuiOverride.output : seqStep.output,
@@ -600,38 +574,31 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			};
 			const behavior = resolveStepBehavior(agentConfig, stepOverride, chainSkills);
 
-			// Determine if this is the first agent to create progress.md
 			const isFirstProgress = behavior.progress && !progressCreated;
 			if (isFirstProgress) {
 				progressCreated = true;
 			}
 
-			// Build chain instructions (prefix goes BEFORE task, suffix goes AFTER)
 			const templateHasPrevious = stepTemplate.includes("{previous}");
 			const { prefix, suffix } = buildChainInstructions(
-				behavior, 
-				chainDir, 
-				isFirstProgress, 
-				templateHasPrevious ? undefined : prev
+				behavior,
+				chainDir,
+				isFirstProgress,
+				templateHasPrevious ? undefined : prev,
 			);
 
-			// Build task string with variable substitution
 			let stepTask = stepTemplate;
 			stepTask = stepTask.replace(/\{task\}/g, originalTask);
 			stepTask = stepTask.replace(/\{previous\}/g, prev);
 			stepTask = stepTask.replace(/\{chain_dir\}/g, chainDir);
 			const cleanTask = stepTask;
-
-			// Assemble final task: prefix (READ/WRITE instructions) + task + suffix (progress, previous summary)
 			stepTask = prefix + stepTask + suffix;
 
-			// Resolve model: TUI override (already full format) or agent's model resolved to full format
 			const effectiveModel =
 				tuiOverride?.model
-				?? (seqStep.model ? resolveModelCandidate(seqStep.model, availableModels) : null)
-				?? resolveModelCandidate(agentConfig.model, availableModels);
+				?? (seqStep.model ? resolveModelCandidate(seqStep.model, availableModels, ctx.model?.provider) : null)
+				?? resolveModelCandidate(agentConfig.model, availableModels, ctx.model?.provider);
 
-			// Run step
 			const outputPath = typeof behavior.output === "string"
 				? (path.isAbsolute(behavior.output) ? behavior.output : path.join(chainDir, behavior.output))
 				: undefined;
@@ -651,10 +618,10 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				maxSubagentDepth,
 				modelOverride: effectiveModel,
 				availableModels,
+				preferredModelProvider: ctx.model?.provider,
 				skills: behavior.skills === false ? [] : behavior.skills,
 				onUpdate: onUpdate
 					? (p) => {
-							// Use concat instead of spread for better performance
 							const stepResults = p.details?.results || [];
 							const stepProgress = p.details?.progress || [];
 							onUpdate({
@@ -678,28 +645,24 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			if (r.progress) allProgress.push(r.progress);
 			if (r.artifactPaths) allArtifactPaths.push(r.artifactPaths);
 
-			// Validate expected output file was created
 			if (behavior.output && r.exitCode === 0) {
 				try {
 					const expectedPath = path.isAbsolute(behavior.output)
-						? behavior.output 
+						? behavior.output
 						: path.join(chainDir, behavior.output);
 					if (!fs.existsSync(expectedPath)) {
-						// Look for similar files that might have been created instead
 						const dirFiles = fs.readdirSync(chainDir);
-						const mdFiles = dirFiles.filter(f => f.endsWith(".md") && f !== "progress.md");
-						const warning = mdFiles.length > 0 
+						const mdFiles = dirFiles.filter((file) => file.endsWith(".md") && file !== "progress.md");
+						const warning = mdFiles.length > 0
 							? `Agent wrote to different file(s): ${mdFiles.join(", ")} instead of ${behavior.output}`
 							: `Agent did not create expected output file: ${behavior.output}`;
-						// Add warning to result but don't fail
-						r.error = r.error ? `${r.error}\n⚠️ ${warning}` : `⚠️ ${warning}`;
+						r.error = r.error ? `${r.error}\n${warning}` : warning;
 					}
 				} catch {
 					// Ignore validation errors - this is just a diagnostic
 				}
 			}
 
-			// On failure, leave chain_dir for debugging
 			if (r.exitCode !== 0) {
 				const summary = buildChainSummary(chainSteps, results, chainDir, "failed", {
 					index: stepIndex,
@@ -707,15 +670,16 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				});
 				return {
 					content: [{ type: "text", text: summary }],
-					details: {
-						mode: "chain",
+					details: buildChainExecutionDetails({
 						results,
-						progress: includeProgress ? allProgress : undefined,
-						artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
+						includeProgress,
+						allProgress,
+						allArtifactPaths,
+						artifactsDir,
 						chainAgents,
 						totalSteps,
 						currentStepIndex: stepIndex,
-					},
+					}),
 					isError: true,
 				};
 			}
@@ -724,20 +688,18 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 		}
 	}
 
-	// Chain complete - return summary with paths
-	// Chain dir left for inspection (cleaned up after 24h)
 	const summary = buildChainSummary(chainSteps, results, chainDir, "completed");
 
 	return {
 		content: [{ type: "text", text: summary }],
-		details: {
-			mode: "chain",
+		details: buildChainExecutionDetails({
 			results,
-			progress: includeProgress ? allProgress : undefined,
-			artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
+			includeProgress,
+			allProgress,
+			allArtifactPaths,
+			artifactsDir,
 			chainAgents,
 			totalSteps,
-			// currentStepIndex omitted for completed chains
-		},
+		}),
 	};
 }

package/execution.ts

@@ -31,7 +31,7 @@ import {
 	extractToolArgsPreview,
 	extractTextFromContent,
 } from "./utils.ts";
-import { buildSkillInjection, resolveSkills } from "./skills.ts";
+import { buildSkillInjection, resolveSkillsWithFallback } from "./skills.ts";
 import { getPiSpawnCommand } from "./pi-spawn.ts";
 import { createJsonlWriter } from "./jsonl-writer.ts";
 import { applyThinkingSuffix, buildPiArgs, cleanupTempDir } from "./pi-args.ts";
@@ -186,61 +186,64 @@ async function runSingleAttempt(
 		const processLine = (line: string) => {
 			if (!line.trim()) return;
 			jsonlWriter.writeLine(line);
+			let evt: { type?: string; message?: Message; toolName?: string; args?: unknown };
 			try {
-				const evt = JSON.parse(line) as { type?: string; message?: Message; toolName?: string; args?: unknown };
-				const now = Date.now();
-				progress.durationMs = now - startTime;
+				evt = JSON.parse(line) as { type?: string; message?: Message; toolName?: string; args?: unknown };
+			} catch {
+				// Non-JSON stdout lines are expected; only structured events are parsed.
+				return;
+			}
 
-				if (evt.type === "tool_execution_start") {
-					if (options.allowIntercomDetach && evt.toolName === "intercom") {
-						intercomStarted = true;
-					}
-					progress.toolCount++;
-					progress.currentTool = evt.toolName;
-					progress.currentToolArgs = extractToolArgsPreview((evt.args || {}) as Record<string, unknown>);
-					fireUpdate();
-				}
+			const now = Date.now();
+			progress.durationMs = now - startTime;
 
-				if (evt.type === "tool_execution_end") {
-					if (progress.currentTool) {
-						progress.recentTools.push({
-							tool: progress.currentTool,
-							args: progress.currentToolArgs || "",
-							endMs: now,
-						});
-					}
-					progress.currentTool = undefined;
-					progress.currentToolArgs = undefined;
-					fireUpdate();
+			if (evt.type === "tool_execution_start") {
+				if (options.allowIntercomDetach && evt.toolName === "intercom") {
+					intercomStarted = true;
 				}
+				progress.toolCount++;
+				progress.currentTool = evt.toolName;
+				progress.currentToolArgs = extractToolArgsPreview((evt.args || {}) as Record<string, unknown>);
+				fireUpdate();
+			}
 
-				if (evt.type === "message_end" && evt.message) {
-					result.messages.push(evt.message);
-					if (evt.message.role === "assistant") {
-						result.usage.turns++;
-						const u = evt.message.usage;
-						if (u) {
-							result.usage.input += u.input || 0;
-							result.usage.output += u.output || 0;
-							result.usage.cacheRead += u.cacheRead || 0;
-							result.usage.cacheWrite += u.cacheWrite || 0;
-							result.usage.cost += u.cost?.total || 0;
-							progress.tokens = result.usage.input + result.usage.output;
-						}
-						if (!result.model && evt.message.model) result.model = evt.message.model;
-						if (evt.message.errorMessage) result.error = evt.message.errorMessage;
-						appendRecentOutput(progress, extractTextFromContent(evt.message.content).split("\n").slice(-10));
-					}
-					fireUpdate();
+			if (evt.type === "tool_execution_end") {
+				if (progress.currentTool) {
+					progress.recentTools.push({
+						tool: progress.currentTool,
+						args: progress.currentToolArgs || "",
+						endMs: now,
+					});
 				}
+				progress.currentTool = undefined;
+				progress.currentToolArgs = undefined;
+				fireUpdate();
+			}
 
-				if (evt.type === "tool_result_end" && evt.message) {
-					result.messages.push(evt.message);
+			if (evt.type === "message_end" && evt.message) {
+				result.messages.push(evt.message);
+				if (evt.message.role === "assistant") {
+					result.usage.turns++;
+					const u = evt.message.usage;
+					if (u) {
+						result.usage.input += u.input || 0;
+						result.usage.output += u.output || 0;
+						result.usage.cacheRead += u.cacheRead || 0;
+						result.usage.cacheWrite += u.cacheWrite || 0;
+						result.usage.cost += u.cost?.total || 0;
+						progress.tokens = result.usage.input + result.usage.output;
+					}
+					if (!result.model && evt.message.model) result.model = evt.message.model;
+					if (evt.message.errorMessage) result.error = evt.message.errorMessage;
 					appendRecentOutput(progress, extractTextFromContent(evt.message.content).split("\n").slice(-10));
-					fireUpdate();
 				}
-			} catch {
-				// Non-JSON stdout lines are expected; only structured events are parsed.
+				fireUpdate();
+			}
+
+			if (evt.type === "tool_result_end" && evt.message) {
+				result.messages.push(evt.message);
+				appendRecentOutput(progress, extractTextFromContent(evt.message.content).split("\n").slice(-10));
+				fireUpdate();
 			}
 		};
 
@@ -368,7 +371,8 @@ export async function runSync(
 	const sessionEnabled = Boolean(options.sessionFile || options.sessionDir) || shareEnabled;
 	const outputSnapshot = captureSingleOutputSnapshot(options.outputPath);
 	const skillNames = options.skills ?? agent.skills ?? [];
-	const { resolved: resolvedSkills, missing: missingSkills } = resolveSkills(skillNames, runtimeCwd);
+	const skillCwd = options.cwd ?? runtimeCwd;
+	const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, skillCwd, runtimeCwd);
 	let systemPrompt = agent.systemPrompt?.trim() || "";
 	if (resolvedSkills.length > 0) {
 		const skillInjection = buildSkillInjection(resolvedSkills);
@@ -379,6 +383,7 @@ export async function runSync(
 		options.modelOverride ?? agent.model,
 		agent.fallbackModels,
 		options.availableModels,
+		options.preferredModelProvider,
 	);
 	const attemptedModels: string[] = [];
 	const modelAttempts: ModelAttempt[] = [];

package/index.ts

@@ -259,7 +259,7 @@ EXECUTION (use exactly ONE mode):
 CHAIN TEMPLATE VARIABLES (use in task strings):
 • {task} - The original task/request from the user
 • {previous} - Text response from the previous step (empty for first step)
-• {chain_dir} - Shared directory for chain files (e.g., <tmpdir>/pi-chain-runs/abc123/)
+• {chain_dir} - Shared directory for chain files (e.g., <tmpdir>/pi-subagents-<scope>/chain-runs/abc123/)
 
 Example: { chain: [{agent:"scout", task:"Analyze {task}"}, {agent:"planner", task:"Plan based on {previous}"}] }
 

package/install.mjs

@@ -38,7 +38,7 @@ if (isRemove) {
 	if (fs.existsSync(EXTENSION_DIR)) {
 		console.log(`Removing ${EXTENSION_DIR}...`);
 		fs.rmSync(EXTENSION_DIR, { recursive: true });
-		console.log("✓ pi-subagents removed");
+		console.log("pi-subagents removed");
 	} else {
 		console.log("pi-subagents is not installed");
 	}
@@ -61,7 +61,7 @@ if (fs.existsSync(EXTENSION_DIR)) {
 		console.log("Updating existing installation...");
 		try {
 			execSync("git pull", { cwd: EXTENSION_DIR, stdio: "inherit" });
-			console.log("\n✓ pi-subagents updated");
+			console.log("\npi-subagents updated");
 		} catch (err) {
 			console.error("Failed to update. Try removing and reinstalling:");
 			console.error("  npx pi-subagents --remove && npx pi-subagents");
@@ -77,7 +77,7 @@ if (fs.existsSync(EXTENSION_DIR)) {
 	console.log(`Cloning to ${EXTENSION_DIR}...`);
 	try {
 		execSync(`git clone ${REPO_URL} "${EXTENSION_DIR}"`, { stdio: "inherit" });
-		console.log("\n✓ pi-subagents installed");
+		console.log("\npi-subagents installed");
 	} catch (err) {
 		console.error("Failed to clone repository");
 		process.exit(1);

package/model-fallback.ts

@@ -14,7 +14,7 @@ export interface ModelAttemptSummary {
 	usage?: Usage;
 }
 
-function splitThinkingSuffix(model: string): { baseModel: string; thinkingSuffix: string } {
+export function splitThinkingSuffix(model: string): { baseModel: string; thinkingSuffix: string } {
 	const colonIdx = model.lastIndexOf(":");
 	if (colonIdx === -1) return { baseModel: model, thinkingSuffix: "" };
 	return {
@@ -26,6 +26,7 @@ function splitThinkingSuffix(model: string): { baseModel: string; thinkingSuffix
 export function resolveModelCandidate(
 	model: string | undefined,
 	availableModels: AvailableModelInfo[] | undefined,
+	preferredProvider?: string,
 ): string | undefined {
 	if (!model) return undefined;
 	if (model.includes("/")) return model;
@@ -33,6 +34,10 @@ export function resolveModelCandidate(
 
 	const { baseModel, thinkingSuffix } = splitThinkingSuffix(model);
 	const matches = availableModels.filter((entry) => entry.id === baseModel);
+	if (preferredProvider) {
+		const preferredMatch = matches.find((entry) => entry.provider === preferredProvider);
+		if (preferredMatch) return `${preferredMatch.fullId}${thinkingSuffix}`;
+	}
 	if (matches.length !== 1) return model;
 	return `${matches[0]!.fullId}${thinkingSuffix}`;
 }
@@ -41,12 +46,13 @@ export function buildModelCandidates(
 	primaryModel: string | undefined,
 	fallbackModels: string[] | undefined,
 	availableModels: AvailableModelInfo[] | undefined,
+	preferredProvider?: string,
 ): string[] {
 	const seen = new Set<string>();
 	const candidates: string[] = [];
 	for (const raw of [primaryModel, ...(fallbackModels ?? [])]) {
 		if (!raw) continue;
-		const normalized = resolveModelCandidate(raw.trim(), availableModels);
+		const normalized = resolveModelCandidate(raw.trim(), availableModels, preferredProvider);
 		if (!normalized || seen.has(normalized)) continue;
 		seen.add(normalized);
 		candidates.push(normalized);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-subagents",
-  "version": "0.13.4",
+  "version": "0.14.1",
   "description": "Pi extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification",
   "author": "Nico Bailon",
   "license": "MIT",

package/parallel-utils.ts

@@ -102,15 +102,15 @@ export function aggregateParallelOutputs(
 			const hasOutput = Boolean(r.output?.trim());
 			const status =
 				r.exitCode === -1
-					? "⏭️ SKIPPED"
+					? "SKIPPED"
 					: r.exitCode !== 0 && r.exitCode !== null
-						? `⚠️ FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}`
+						? `FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}`
 						: r.error
-							? `⚠️ WARNING: ${r.error}`
+							? `WARNING: ${r.error}`
 							: !hasOutput && r.outputTargetPath && r.outputTargetExists === false
-								? `⚠️ EMPTY OUTPUT (expected output file missing: ${r.outputTargetPath})`
+								? `EMPTY OUTPUT (expected output file missing: ${r.outputTargetPath})`
 								: !hasOutput && !r.outputTargetPath
-									? "⚠️ EMPTY OUTPUT (no textual response returned)"
+									? "EMPTY OUTPUT (no textual response returned)"
 							: "";
 			const body = status ? (hasOutput ? `${status}\n${r.output}` : status) : r.output;
 			return `${header}\n${body}`;

package/prompt-template-bridge.ts

@@ -78,6 +78,7 @@ interface PromptTemplateBridgeResult {
 		results?: Array<{
 			agent?: string;
 			messages?: unknown[];
+			finalOutput?: string;
 			exitCode?: number;
 			error?: string;
 			model?: string;
@@ -180,12 +181,13 @@ function sanitizeRecentTools(
 	tools: Array<{ tool?: string; args?: string }> | undefined,
 ): Array<{ tool: string; args: string }> | undefined {
 	if (!tools || tools.length === 0) return undefined;
-	const sanitized = tools
-		.filter((entry) => typeof entry.tool === "string" && entry.tool.trim().length > 0)
-		.map((entry) => ({
-			tool: entry.tool as string,
+	const sanitized = tools.flatMap((entry) => {
+		if (typeof entry.tool !== "string" || entry.tool.trim().length === 0) return [];
+		return [{
+			tool: entry.tool,
 			args: typeof entry.args === "string" ? entry.args : String(entry.args ?? ""),
-		}));
+		}];
+	});
 	return sanitized.length > 0 ? sanitized : undefined;
 }
 
@@ -207,6 +209,15 @@ function resolveProgressModel(
 	return firstWithModel?.model;
 }
 
+function buildDelegationMessages(result: { messages?: unknown[]; finalOutput?: string }, fallbackText?: string): unknown[] {
+	if (Array.isArray(result.messages) && result.messages.length > 0) return result.messages;
+	const text = typeof result.finalOutput === "string" && result.finalOutput.trim().length > 0
+		? result.finalOutput.trim()
+		: fallbackText;
+	if (!text) return [];
+	return [{ role: "assistant", content: [{ type: "text", text }] }];
+}
+
 function toDelegationUpdate(requestId: string, update: PromptTemplateBridgeResult): PromptTemplateDelegationUpdate | undefined {
 	const progress = update.details?.progress?.[0];
 	const taskProgress = update.details?.progress?.map((entry) => {
@@ -324,7 +335,8 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 					options.events.emit(PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT, payload);
 				},
 			);
-			const messages = result.details?.results?.[0]?.messages ?? [];
+			const contentText = firstTextContent(result.content);
+			const messages = buildDelegationMessages(result.details?.results?.[0] ?? {}, contentText);
 			const parallelResults = request.tasks
 				? request.tasks.map<PromptTemplateDelegationParallelResult>((task, index) => {
 					const step = result.details?.results?.[index];
@@ -340,13 +352,12 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 					const errorText = step.error;
 					return {
 						agent: step.agent ?? task.agent,
-						messages: step.messages ?? [],
+						messages: buildDelegationMessages(step),
 						isError: (exitCode !== undefined && exitCode !== 0) || !!errorText,
 						errorText: errorText || undefined,
 					};
 				})
 				: undefined;
-			const contentText = firstTextContent(result.content);
 			const response: PromptTemplateDelegationResponse = {
 				...request,
 				messages,