pi-subagents 0.14.0 → 0.15.0

package/subagent-runner.ts

@@ -503,10 +503,12 @@ async function runSingleStep(
 			sessionDir,
 			sessionFile: step.sessionFile,
 			model: candidate,
+			inheritProjectContext: step.inheritProjectContext,
+			inheritSkills: step.inheritSkills,
 			tools: step.tools,
 			extensions: step.extensions,
-			skills: step.skills,
 			systemPrompt: step.systemPrompt,
+			systemPromptMode: step.systemPromptMode,
 			mcpDirectTools: step.mcpDirectTools,
 			promptFileStem: step.agent,
 		});
@@ -555,12 +557,12 @@ async function runSingleStep(
 	}
 	if (resolvedOutput.savedPath) {
 		outputForSummary = outputForSummary
-			? `${outputForSummary}\n\n📄 Output saved to: ${resolvedOutput.savedPath}`
-			: `📄 Output saved to: ${resolvedOutput.savedPath}`;
+			? `${outputForSummary}\n\nOutput saved to: ${resolvedOutput.savedPath}`
+			: `Output saved to: ${resolvedOutput.savedPath}`;
 	} else if (resolvedOutput.saveError && step.outputPath && finalResult?.exitCode === 0) {
 		outputForSummary = outputForSummary
-			? `${outputForSummary}\n\n⚠️ Failed to save output to: ${step.outputPath}\n${resolvedOutput.saveError}`
-			: `⚠️ Failed to save output to: ${step.outputPath}\n${resolvedOutput.saveError}`;
+			? `${outputForSummary}\n\nFailed to save output to: ${step.outputPath}\n${resolvedOutput.saveError}`
+			: `Failed to save output to: ${step.outputPath}\n${resolvedOutput.saveError}`;
 	}
 
 	if (artifactPaths && ctx.artifactConfig?.enabled !== false) {
@@ -740,7 +742,6 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 	let previousCumulativeTokens: TokenUsage = { input: 0, output: 0, total: 0 };
 	let latestSessionFile: string | undefined;
 
-	// Flatten steps for status tracking (parallel groups expand to individual entries)
 	const flatSteps = flattenSteps(steps);
 	const sessionEnabled = Boolean(config.sessionDir)
 		|| shareEnabled
@@ -780,14 +781,12 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 		}),
 	);
 
-	// Track the flat index into statusPayload.steps across sequential + parallel steps
 	let flatIndex = 0;
 
 	for (let stepIndex = 0; stepIndex < steps.length; stepIndex++) {
 		const step = steps[stepIndex];
 
 		if (isParallelGroup(step)) {
-			// === PARALLEL STEP GROUP ===
 			const group = step;
 			const concurrency = group.concurrency ?? MAX_PARALLEL_CONCURRENCY;
 			const failFast = group.failFast ?? false;
@@ -915,7 +914,6 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 
 				flatIndex += group.parallel.length;
 
-				// Aggregate token usage from parallel task session dirs
 				if (config.sessionDir) {
 					for (let t = 0; t < group.parallel.length; t++) {
 						const taskSessionDir = path.join(config.sessionDir, `parallel-${t}`);
@@ -935,7 +933,6 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 					writeJson(statusPath, statusPayload);
 				}
 
-				// Collect results
 				for (const pr of parallelResults) {
 					results.push({
 						agent: pr.agent,
@@ -969,7 +966,6 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 					success: parallelResults.every((r) => r.exitCode === 0 || r.exitCode === -1),
 				}));
 
-				// If any parallel task failed (not skipped), stop the chain
 				if (parallelResults.some((r) => r.exitCode !== 0 && r.exitCode !== -1)) {
 					break;
 				}
@@ -977,7 +973,6 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 				if (worktreeSetup) cleanupWorktrees(worktreeSetup);
 			}
 		} else {
-			// === SEQUENTIAL STEP ===
 			const seqStep = step as SubagentStep;
 			const stepStartTime = Date.now();
 			statusPayload.currentStep = flatIndex;

package/types.ts

@@ -85,7 +85,7 @@ export interface SingleResult {
 	exitCode: number;
 	detached?: boolean;
 	detachedReason?: string;
-	messages: Message[];
+	messages?: Message[];
 	usage: Usage;
 	model?: string;
 	attemptedModels?: string[];

package/utils.ts

@@ -6,19 +6,23 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { Message } from "@mariozechner/pi-ai";
-import type { AsyncStatus, DisplayItem, ErrorInfo, SingleResult } from "./types.ts";
+import type { AgentProgress, AsyncStatus, Details, DisplayItem, ErrorInfo, SingleResult } from "./types.ts";
 
 // ============================================================================
 // File System Utilities
 // ============================================================================
 
-// Cache for status file reads - avoid re-reading unchanged files
 const statusCache = new Map<string, { mtime: number; status: AsyncStatus }>();
 
 function getErrorMessage(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
 }
 
+export function resolveChildCwd(baseCwd: string, childCwd: string | undefined): string {
+	if (!childCwd) return baseCwd;
+	return path.isAbsolute(childCwd) ? childCwd : path.resolve(baseCwd, childCwd);
+}
+
 function isNotFoundError(error: unknown): boolean {
 	return typeof error === "object"
 		&& error !== null
@@ -74,7 +78,6 @@ export function readStatus(asyncDir: string): AsyncStatus | null {
 	return status;
 }
 
-// Cache for output tail reads - avoid re-reading unchanged files
 const outputTailCache = new Map<string, { mtime: number; size: number; lines: string[] }>();
 
 /**
@@ -87,7 +90,6 @@ export function getOutputTail(outputFile: string | undefined, maxLines: number =
 		const stat = fs.statSync(outputFile);
 		if (stat.size === 0) return [];
 
-		// Check cache using both mtime and size (size changes more frequently during writes)
 		const cached = outputTailCache.get(outputFile);
 		if (cached && cached.mtime === stat.mtimeMs && cached.size === stat.size) {
 			return cached.lines;
@@ -102,9 +104,7 @@ export function getOutputTail(outputFile: string | undefined, maxLines: number =
 		const allLines = content.split("\n").filter((l) => l.trim());
 		const lines = allLines.slice(-maxLines).map((l) => l.slice(0, 120) + (l.length > 120 ? "..." : ""));
 
-		// Cache the result
 		outputTailCache.set(outputFile, { mtime: stat.mtimeMs, size: stat.size, lines });
-		// Limit cache size
 		if (outputTailCache.size > 20) {
 			const firstKey = outputTailCache.keys().next().value;
 			if (firstKey) outputTailCache.delete(firstKey);
@@ -112,12 +112,15 @@ export function getOutputTail(outputFile: string | undefined, maxLines: number =
 
 		return lines;
 	} catch {
+		// Output tails are UI-only hints; unreadable or missing files should render as no tail.
 		return [];
 	} finally {
 		if (fd !== null) {
 			try {
 				fs.closeSync(fd);
-			} catch {}
+			} catch {
+				// Closing the best-effort tail file handle should not surface over the main status view.
+			}
 		}
 	}
 }
@@ -125,16 +128,16 @@ export function getOutputTail(outputFile: string | undefined, maxLines: number =
 /**
  * Get human-readable last activity time for a file
  */
-export function getLastActivity(outputFile: string | undefined): string {
+	export function getLastActivity(outputFile: string | undefined): string {
 	if (!outputFile) return "";
 	try {
-		// Single stat call - throws if file doesn't exist
 		const stat = fs.statSync(outputFile);
 		const ago = Date.now() - stat.mtimeMs;
 		if (ago < 1000) return "active now";
 		if (ago < 60000) return `active ${Math.floor(ago / 1000)}s ago`;
 		return `active ${Math.floor(ago / 60000)}m ago`;
 	} catch {
+		// Last-activity text is best effort; missing files should simply omit the hint.
 		return "";
 	}
 }
@@ -201,13 +204,14 @@ export function getFinalOutput(messages: Message[]): string {
 }
 
 export function getSingleResultOutput(result: Pick<SingleResult, "finalOutput" | "messages">): string {
-	return result.finalOutput ?? getFinalOutput(result.messages);
+	return result.finalOutput ?? getFinalOutput(result.messages ?? []);
 }
 
 /**
  * Extract display items (text and tool calls) from messages
  */
-export function getDisplayItems(messages: Message[]): DisplayItem[] {
+export function getDisplayItems(messages: Message[] | undefined): DisplayItem[] {
+	if (!messages || messages.length === 0) return [];
 	const items: DisplayItem[] = [];
 	for (const msg of messages) {
 		if (msg.role === "assistant") {
@@ -220,6 +224,43 @@ export function getDisplayItems(messages: Message[]): DisplayItem[] {
 	return items;
 }
 
+function compactCompletedProgress(progress: AgentProgress): AgentProgress {
+	if (progress.status === "running") return progress;
+	return {
+		index: progress.index,
+		agent: progress.agent,
+		status: progress.status,
+		task: progress.task,
+		skills: progress.skills,
+		toolCount: progress.toolCount,
+		tokens: progress.tokens,
+		durationMs: progress.durationMs,
+		error: progress.error,
+		failedTool: progress.failedTool,
+		recentTools: [],
+		recentOutput: [],
+	};
+}
+
+export function compactForegroundResult(result: SingleResult): SingleResult {
+	if (result.progress?.status === "running") return result;
+	return {
+		...result,
+		messages: undefined,
+		progress: undefined,
+	};
+}
+
+export function compactForegroundDetails(details: Details): Details {
+	return {
+		...details,
+		results: details.results.map(compactForegroundResult),
+		progress: details.progress
+			? details.progress.map(compactCompletedProgress)
+			: undefined,
+	};
+}
+
 /**
  * Detect errors in subagent execution from messages (only errors with no subsequent success)
  */
@@ -358,4 +399,4 @@ export function extractTextFromContent(content: unknown): string {
 // Concurrency Utilities
 // ============================================================================
 
-export { mapConcurrent } from "./parallel-utils.js";
+export { mapConcurrent } from "./parallel-utils.ts";

package/worktree.ts

@@ -139,7 +139,8 @@ export function findWorktreeTaskCwdConflict(
 	for (let index = 0; index < tasks.length; index++) {
 		const task = tasks[index]!;
 		if (!task.cwd) continue;
-		if (normalizeComparableCwd(task.cwd) === normalizedSharedCwd) continue;
+		const taskCwd = path.isAbsolute(task.cwd) ? task.cwd : path.resolve(sharedCwd, task.cwd);
+		if (normalizeComparableCwd(taskCwd) === normalizedSharedCwd) continue;
 		return { index, agent: task.agent, cwd: task.cwd };
 	}
 	return undefined;