pi-subagents 0.13.4 → 0.14.0

package/chain-execution.ts

@@ -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,
@@ -724,8 +687,6 @@ 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 {
@@ -737,7 +698,6 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
 			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/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.0",
   "description": "Pi extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification",
   "author": "Nico Bailon",
   "license": "MIT",

package/schemas.ts

@@ -83,7 +83,7 @@ export const SubagentParams = Type.Object({
 		enum: ["fresh", "fork"],
 		description: "'fresh' (default) or 'fork' to branch from parent session",
 	})),
-	chainDir: Type.Optional(Type.String({ description: "Persistent directory for chain artifacts. Default: <tmpdir>/pi-chain-runs/ (auto-cleaned after 24h)" })),
+	chainDir: Type.Optional(Type.String({ description: "Persistent directory for chain artifacts. Default: a user-scoped temp directory under <tmpdir>/ (auto-cleaned after 24h)" })),
 	async: Type.Optional(Type.Boolean({ description: "Run in background (default: false, or per config)" })),
 	agentScope: Type.Optional(Type.String({ description: "Agent discovery scope: 'user', 'project', or 'both' (default: 'both'; project wins on name collisions)" })),
 	cwd: Type.Optional(Type.String()),

package/settings.ts

@@ -3,12 +3,10 @@
  */
 
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentConfig } from "./agents.ts";
 import { normalizeSkillInput } from "./skills.ts";
-
-const CHAIN_RUNS_DIR = path.join(os.tmpdir(), "pi-chain-runs");
+import { CHAIN_RUNS_DIR } from "./types.ts";
 const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
 
 // =============================================================================
@@ -100,7 +98,9 @@ export function createChainDir(runId: string, baseDir?: string): string {
 export function removeChainDir(chainDir: string): void {
 	try {
 		fs.rmSync(chainDir, { recursive: true });
-	} catch {}
+	} catch {
+		// Chain cleanup is best-effort. Runs can already have cleaned their temp dir.
+	}
 }
 
 export function cleanupOldChainDirs(): void {
@@ -110,6 +110,8 @@ export function cleanupOldChainDirs(): void {
 	try {
 		dirs = fs.readdirSync(CHAIN_RUNS_DIR);
 	} catch {
+		// Startup cleanup is best-effort. If the scoped temp root is unreadable,
+		// skip cleanup instead of failing extension startup.
 		return;
 	}