pi-subagents 0.3.0 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-subagents",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Pi extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification",
   "author": "Nico Bailon",
   "license": "MIT",
@@ -21,7 +21,7 @@
     "cli"
   ],
   "bin": {
-    "pi-subagents": "./install.mjs"
+    "pi-subagents": "install.mjs"
   },
   "files": [
     "*.ts",

package/render.ts

@@ -0,0 +1,308 @@
+/**
+ * Rendering functions for subagent results
+ */
+
+import type { AgentToolResult } from "@mariozechner/pi-agent-core";
+import { getMarkdownTheme, type ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { Container, Markdown, Spacer, Text, type Widget } from "@mariozechner/pi-tui";
+import {
+	type AsyncJobState,
+	type Details,
+	MAX_WIDGET_JOBS,
+	WIDGET_KEY,
+} from "./types.js";
+import { formatTokens, formatUsage, formatDuration, formatToolCall, shortenPath } from "./formatters.js";
+import { getFinalOutput, getDisplayItems, getOutputTail, getLastActivity } from "./utils.js";
+
+type Theme = ExtensionContext["ui"]["theme"];
+
+// Track last rendered widget state to avoid no-op re-renders
+let lastWidgetHash = "";
+
+/**
+ * Compute a simple hash of job states for change detection
+ */
+function computeWidgetHash(jobs: AsyncJobState[]): string {
+	return jobs.slice(0, MAX_WIDGET_JOBS).map(job =>
+		`${job.asyncId}:${job.status}:${job.currentStep}:${job.updatedAt}:${job.totalTokens?.total ?? 0}`
+	).join("|");
+}
+
+/**
+ * Render the async jobs widget
+ */
+export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void {
+	if (!ctx.hasUI) return;
+	if (jobs.length === 0) {
+		if (lastWidgetHash !== "") {
+			lastWidgetHash = "";
+			ctx.ui.setWidget(WIDGET_KEY, undefined);
+		}
+		return;
+	}
+
+	// Check if anything changed since last render
+	// Always re-render if any displayed job is running (output tail updates constantly)
+	const displayedJobs = jobs.slice(0, MAX_WIDGET_JOBS);
+	const hasRunningJobs = displayedJobs.some(job => job.status === "running");
+	const newHash = computeWidgetHash(jobs);
+	if (!hasRunningJobs && newHash === lastWidgetHash) {
+		return; // Skip re-render, nothing changed
+	}
+	lastWidgetHash = newHash;
+
+	const theme = ctx.ui.theme;
+	const lines: string[] = [];
+	lines.push(theme.fg("accent", "Async subagents"));
+
+	for (const job of displayedJobs) {
+		const id = job.asyncId.slice(0, 6);
+		const status =
+			job.status === "complete"
+				? theme.fg("success", "complete")
+				: job.status === "failed"
+					? theme.fg("error", "failed")
+					: theme.fg("warning", "running");
+
+		const stepsTotal = job.stepsTotal ?? (job.agents?.length ?? 1);
+		const stepIndex = job.currentStep !== undefined ? job.currentStep + 1 : undefined;
+		const stepText = stepIndex !== undefined ? `step ${stepIndex}/${stepsTotal}` : `steps ${stepsTotal}`;
+		const endTime = (job.status === "complete" || job.status === "failed") ? (job.updatedAt ?? Date.now()) : Date.now();
+		const elapsed = job.startedAt ? formatDuration(endTime - job.startedAt) : "";
+		const agentLabel = job.agents ? job.agents.join(" -> ") : (job.mode ?? "single");
+
+		const tokenText = job.totalTokens ? ` | ${formatTokens(job.totalTokens.total)} tok` : "";
+		const activityText = job.status === "running" ? getLastActivity(job.outputFile) : "";
+		const activitySuffix = activityText ? ` | ${theme.fg("dim", activityText)}` : "";
+
+		lines.push(`- ${id} ${status} | ${agentLabel} | ${stepText}${elapsed ? ` | ${elapsed}` : ""}${tokenText}${activitySuffix}`);
+
+		if (job.status === "running" && job.outputFile) {
+			const tail = getOutputTail(job.outputFile, 3);
+			for (const line of tail) {
+				lines.push(theme.fg("dim", `  > ${line}`));
+			}
+		}
+	}
+
+	ctx.ui.setWidget(WIDGET_KEY, lines);
+}
+
+/**
+ * Render a subagent result
+ */
+export function renderSubagentResult(
+	result: AgentToolResult<Details>,
+	_options: { expanded: boolean },
+	theme: Theme,
+): Widget {
+	const d = result.details;
+	if (!d || !d.results.length) {
+		const t = result.content[0];
+		return new Text(t?.type === "text" ? t.text : "(no output)", 0, 0);
+	}
+
+	const mdTheme = getMarkdownTheme();
+
+	if (d.mode === "single" && d.results.length === 1) {
+		const r = d.results[0];
+		const isRunning = r.progress?.status === "running";
+		const icon = isRunning
+			? theme.fg("warning", "...")
+			: r.exitCode === 0
+				? theme.fg("success", "ok")
+				: theme.fg("error", "X");
+		const output = r.truncation?.text || getFinalOutput(r.messages);
+
+		const progressInfo = isRunning && r.progress
+			? ` | ${r.progress.toolCount} tools, ${formatTokens(r.progress.tokens)} tok, ${formatDuration(r.progress.durationMs)}`
+			: r.progressSummary
+				? ` | ${r.progressSummary.toolCount} tools, ${formatTokens(r.progressSummary.tokens)} tok, ${formatDuration(r.progressSummary.durationMs)}`
+				: "";
+
+		const c = new Container();
+		c.addChild(new Text(`${icon} ${theme.fg("toolTitle", theme.bold(r.agent))}${progressInfo}`, 0, 0));
+		c.addChild(new Spacer(1));
+		c.addChild(
+			new Text(theme.fg("dim", `Task: ${r.task.slice(0, 150)}${r.task.length > 150 ? "..." : ""}`), 0, 0),
+		);
+		c.addChild(new Spacer(1));
+
+		const items = getDisplayItems(r.messages);
+		for (const item of items) {
+			if (item.type === "tool")
+				c.addChild(new Text(theme.fg("muted", formatToolCall(item.name, item.args)), 0, 0));
+		}
+		if (items.length) c.addChild(new Spacer(1));
+
+		if (output) c.addChild(new Markdown(output, 0, 0, mdTheme));
+		c.addChild(new Spacer(1));
+		c.addChild(new Text(theme.fg("dim", formatUsage(r.usage, r.model)), 0, 0));
+		if (r.sessionFile) {
+			c.addChild(new Text(theme.fg("dim", `Session: ${shortenPath(r.sessionFile)}`), 0, 0));
+		}
+
+		if (r.artifactPaths) {
+			c.addChild(new Spacer(1));
+			c.addChild(new Text(theme.fg("dim", `Artifacts: ${shortenPath(r.artifactPaths.outputPath)}`), 0, 0));
+		}
+		return c;
+	}
+
+	const hasRunning = d.progress?.some((p) => p.status === "running") 
+		|| d.results.some((r) => r.progress?.status === "running");
+	const ok = d.results.filter((r) => r.progress?.status === "completed" || (r.exitCode === 0 && r.progress?.status !== "running")).length;
+	const icon = hasRunning
+		? theme.fg("warning", "...")
+		: ok === d.results.length
+			? theme.fg("success", "ok")
+			: theme.fg("error", "X");
+
+	const totalSummary =
+		d.progressSummary ||
+		d.results.reduce(
+			(acc, r) => {
+				const prog = r.progress || r.progressSummary;
+				if (prog) {
+					acc.toolCount += prog.toolCount;
+					acc.tokens += prog.tokens;
+					acc.durationMs =
+						d.mode === "chain"
+							? acc.durationMs + prog.durationMs
+							: Math.max(acc.durationMs, prog.durationMs);
+				}
+				return acc;
+			},
+			{ toolCount: 0, tokens: 0, durationMs: 0 },
+		);
+
+	const summaryStr =
+		totalSummary.toolCount || totalSummary.tokens
+			? ` | ${totalSummary.toolCount} tools, ${formatTokens(totalSummary.tokens)} tok, ${formatDuration(totalSummary.durationMs)}`
+			: "";
+
+	const modeLabel = d.mode === "parallel" ? "parallel (no live progress)" : d.mode;
+	// For parallel-in-chain, show task count (results) for consistency with step display
+	// For sequential chains, show logical step count
+	const hasParallelInChain = d.chainAgents?.some((a) => a.startsWith("["));
+	const totalCount = hasParallelInChain ? d.results.length : (d.totalSteps ?? d.results.length);
+	const currentStep = d.currentStepIndex !== undefined ? d.currentStepIndex + 1 : ok + 1;
+	const stepInfo = hasRunning ? ` ${currentStep}/${totalCount}` : ` ${ok}/${totalCount}`;
+	
+	// Build chain visualization: "scout → planner" with status icons
+	// Note: Only works correctly for sequential chains. Chains with parallel steps
+	// (indicated by "[agent1+agent2]" format) have multiple results per step,
+	// breaking the 1:1 mapping between chainAgents and results.
+	const chainVis = d.chainAgents?.length && !hasParallelInChain
+		? d.chainAgents
+				.map((agent, i) => {
+					const result = d.results[i];
+					const isFailed = result && result.exitCode !== 0 && result.progress?.status !== "running";
+					const isComplete = result && result.exitCode === 0 && result.progress?.status !== "running";
+					const isCurrent = i === (d.currentStepIndex ?? d.results.length);
+					const icon = isFailed
+						? theme.fg("error", "✗")
+						: isComplete
+							? theme.fg("success", "✓")
+							: isCurrent && hasRunning
+								? theme.fg("warning", "●")
+								: theme.fg("dim", "○");
+					return `${icon} ${agent}`;
+				})
+				.join(theme.fg("dim", " → "))
+		: null;
+
+	const c = new Container();
+	c.addChild(
+		new Text(
+			`${icon} ${theme.fg("toolTitle", theme.bold(modeLabel))}${stepInfo}${summaryStr}`,
+			0,
+			0,
+		),
+	);
+	// Show chain visualization
+	if (chainVis) {
+		c.addChild(new Text(`  ${chainVis}`, 0, 0));
+	}
+
+	// === STATIC STEP LAYOUT (like clarification UI) ===
+	// Each step gets a fixed section with task/output/status
+	// Note: For chains with parallel steps, chainAgents indices don't map 1:1 to results
+	// (parallel steps produce multiple results). Fall back to result-based iteration.
+	const useResultsDirectly = hasParallelInChain || !d.chainAgents?.length;
+	const stepsToShow = useResultsDirectly ? d.results.length : d.chainAgents!.length;
+
+	c.addChild(new Spacer(1));
+
+	for (let i = 0; i < stepsToShow; i++) {
+		const r = d.results[i];
+		const agentName = useResultsDirectly 
+			? (r?.agent || `step-${i + 1}`)
+			: (d.chainAgents![i] || r?.agent || `step-${i + 1}`);
+
+		if (!r) {
+			// Pending step
+			c.addChild(new Text(theme.fg("dim", `  Step ${i + 1}: ${agentName}`), 0, 0));
+			c.addChild(new Text(theme.fg("dim", `    status: ○ pending`), 0, 0));
+			c.addChild(new Spacer(1));
+			continue;
+		}
+
+		const progressFromArray = d.progress?.find((p) => p.index === i) 
+			|| d.progress?.find((p) => p.agent === r.agent && p.status === "running");
+		const rProg = r.progress || progressFromArray || r.progressSummary;
+		const rRunning = rProg?.status === "running";
+
+		// Step header with status
+		const statusIcon = rRunning
+			? theme.fg("warning", "●")
+			: r.exitCode === 0
+				? theme.fg("success", "✓")
+				: theme.fg("error", "✗");
+		const stats = rProg ? ` | ${rProg.toolCount} tools, ${formatDuration(rProg.durationMs)}` : "";
+		const stepHeader = rRunning
+			? `${statusIcon} Step ${i + 1}: ${theme.bold(theme.fg("warning", r.agent))}${stats}`
+			: `${statusIcon} Step ${i + 1}: ${theme.bold(r.agent)}${stats}`;
+		c.addChild(new Text(stepHeader, 0, 0));
+
+		// Task (truncated)
+		const taskPreview = r.task.slice(0, 120) + (r.task.length > 120 ? "..." : "");
+		c.addChild(new Text(theme.fg("dim", `    task: ${taskPreview}`), 0, 0));
+
+		// Output target (extract from task)
+		const outputMatch = r.task.match(/[Oo]utput(?:\s+to)?\s+([^\s]+\.(?:md|txt|json))/);
+		if (outputMatch) {
+			c.addChild(new Text(theme.fg("dim", `    output: ${outputMatch[1]}`), 0, 0));
+		}
+
+		if (rRunning && rProg) {
+			// Current tool for running step
+			if (rProg.currentTool) {
+				const toolLine = rProg.currentToolArgs
+					? `${rProg.currentTool}: ${rProg.currentToolArgs.slice(0, 100)}${rProg.currentToolArgs.length > 100 ? "..." : ""}`
+					: rProg.currentTool;
+				c.addChild(new Text(theme.fg("warning", `    > ${toolLine}`), 0, 0));
+			}
+			// Recent tools
+			if (rProg.recentTools?.length) {
+				for (const t of rProg.recentTools.slice(0, 3)) {
+					const args = t.args.slice(0, 90) + (t.args.length > 90 ? "..." : "");
+					c.addChild(new Text(theme.fg("dim", `      ${t.tool}: ${args}`), 0, 0));
+				}
+			}
+			// Recent output (limited)
+			const recentLines = (rProg.recentOutput ?? []).slice(-5);
+			for (const line of recentLines) {
+				c.addChild(new Text(theme.fg("dim", `      ${line.slice(0, 100)}${line.length > 100 ? "..." : ""}`), 0, 0));
+			}
+		}
+
+		c.addChild(new Spacer(1));
+	}
+
+	if (d.artifacts) {
+		c.addChild(new Spacer(1));
+		c.addChild(new Text(theme.fg("dim", `Artifacts dir: ${shortenPath(d.artifacts.dir)}`), 0, 0));
+	}
+	return c;
+}

package/schemas.ts

@@ -0,0 +1,90 @@
+/**
+ * TypeBox schemas for subagent tool parameters
+ */
+
+import { Type } from "@sinclair/typebox";
+
+export const TaskItem = Type.Object({ 
+	agent: Type.String(), 
+	task: Type.String(), 
+	cwd: Type.Optional(Type.String()) 
+});
+
+// Sequential chain step (single agent)
+export const SequentialStepSchema = Type.Object({
+	agent: Type.String(),
+	task: Type.Optional(Type.String({ description: "Task template. Use {task}, {previous}, {chain_dir}. Required for first step." })),
+	cwd: Type.Optional(Type.String()),
+	// Chain behavior overrides
+	output: Type.Optional(Type.Union([
+		Type.String(),
+		Type.Boolean(),
+	], { description: "Override output filename (string), or false for text-only" })),
+	reads: Type.Optional(Type.Union([
+		Type.Array(Type.String()),
+		Type.Boolean(),
+	], { description: "Override files to read from {chain_dir} (array), or false to disable" })),
+	progress: Type.Optional(Type.Boolean({ description: "Override progress tracking" })),
+});
+
+// Parallel task item (within a parallel step)
+export const ParallelTaskSchema = Type.Object({
+	agent: Type.String(),
+	task: Type.Optional(Type.String({ description: "Task template. Defaults to {previous}." })),
+	cwd: Type.Optional(Type.String()),
+	output: Type.Optional(Type.Union([
+		Type.String(),
+		Type.Boolean(),
+	], { description: "Override output filename (string), or false for text-only" })),
+	reads: Type.Optional(Type.Union([
+		Type.Array(Type.String()),
+		Type.Boolean(),
+	], { description: "Override files to read from {chain_dir} (array), or false to disable" })),
+	progress: Type.Optional(Type.Boolean({ description: "Override progress tracking" })),
+});
+
+// Parallel chain step (multiple agents running concurrently)
+export const ParallelStepSchema = Type.Object({
+	parallel: Type.Array(ParallelTaskSchema, { minItems: 1, description: "Tasks to run in parallel" }),
+	concurrency: Type.Optional(Type.Number({ description: "Max concurrent tasks (default: 4)" })),
+	failFast: Type.Optional(Type.Boolean({ description: "Stop on first failure (default: false)" })),
+});
+
+// Chain item can be either sequential or parallel
+export const ChainItem = Type.Union([SequentialStepSchema, ParallelStepSchema]);
+
+export const MaxOutputSchema = Type.Optional(
+	Type.Object({
+		bytes: Type.Optional(Type.Number({ description: "Max bytes (default: 204800)" })),
+		lines: Type.Optional(Type.Number({ description: "Max lines (default: 5000)" })),
+	}),
+);
+
+export const SubagentParams = Type.Object({
+	agent: Type.Optional(Type.String({ description: "Agent name (SINGLE mode)" })),
+	task: Type.Optional(Type.String({ description: "Task (SINGLE mode)" })),
+	tasks: Type.Optional(Type.Array(TaskItem, { description: "PARALLEL mode: [{agent, task}, ...]" })),
+	chain: Type.Optional(Type.Array(ChainItem, { description: "CHAIN mode: [{agent}, {agent, task:'{previous}'}] - sequential pipeline" })),
+	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: 'user')" })),
+	cwd: Type.Optional(Type.String()),
+	maxOutput: MaxOutputSchema,
+	artifacts: Type.Optional(Type.Boolean({ description: "Write debug artifacts (default: true)" })),
+	includeProgress: Type.Optional(Type.Boolean({ description: "Include full progress in result (default: false)" })),
+	share: Type.Optional(Type.Boolean({ description: "Create shareable session log (default: true)", default: true })),
+	sessionDir: Type.Optional(
+		Type.String({ description: "Directory to store session logs (default: temp; enables sessions even if share=false)" }),
+	),
+	// Chain clarification TUI
+	clarify: Type.Optional(Type.Boolean({ description: "Show TUI to clarify chain templates (default: true for chains). Implies sync mode." })),
+	// Solo agent output override
+	output: Type.Optional(Type.Union([
+		Type.String(),
+		Type.Boolean(),
+	], { description: "Override output file for single agent (string), or false to disable (uses agent default if omitted)" })),
+});
+
+export const StatusParams = Type.Object({
+	id: Type.Optional(Type.String({ description: "Async run id or prefix" })),
+	dir: Type.Optional(Type.String({ description: "Async run directory (overrides id search)" })),
+});

package/settings.ts

@@ -1,30 +1,14 @@
 /**
- * Subagent settings, chain behavior, and template management
+ * Chain behavior, template resolution, and directory management
  */
 
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
 import type { AgentConfig } from "./agents.js";
 
-const SETTINGS_PATH = path.join(os.homedir(), ".pi", "agent", "settings.json");
 const CHAIN_RUNS_DIR = "/tmp/pi-chain-runs";
 const CHAIN_DIR_MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
 
-// =============================================================================
-// Settings Types
-// =============================================================================
-
-export interface ChainTemplates {
-	[chainKey: string]: {
-		[agentName: string]: string;
-	};
-}
-
-export interface SubagentSettings {
-	chains?: ChainTemplates;
-}
-
 // =============================================================================
 // Behavior Resolution Types
 // =============================================================================
@@ -83,10 +67,6 @@ export function isParallelStep(step: ChainStep): step is ParallelStep {
 	return "parallel" in step && Array.isArray((step as ParallelStep).parallel);
 }
 
-export function isSequentialStep(step: ChainStep): step is SequentialStep {
-	return "agent" in step && !("parallel" in step);
-}
-
 /** Get all agent names in a step (single for sequential, multiple for parallel) */
 export function getStepAgents(step: ChainStep): string[] {
 	if (isParallelStep(step)) {
@@ -95,51 +75,6 @@ export function getStepAgents(step: ChainStep): string[] {
 	return [step.agent];
 }
 
-/** Get total task count in a step */
-export function getStepTaskCount(step: ChainStep): number {
-	if (isParallelStep(step)) {
-		return step.parallel.length;
-	}
-	return 1;
-}
-
-// =============================================================================
-// Settings Management
-// =============================================================================
-
-export function loadSubagentSettings(): SubagentSettings {
-	try {
-		const data = JSON.parse(fs.readFileSync(SETTINGS_PATH, "utf-8"));
-		return (data.subagent as SubagentSettings) ?? {};
-	} catch {
-		return {};
-	}
-}
-
-export function saveChainTemplate(chainKey: string, templates: Record<string, string>): void {
-	let settings: Record<string, unknown> = {};
-	try {
-		settings = JSON.parse(fs.readFileSync(SETTINGS_PATH, "utf-8"));
-	} catch {}
-
-	if (!settings.subagent) settings.subagent = {};
-	const subagent = settings.subagent as Record<string, unknown>;
-	if (!subagent.chains) subagent.chains = {};
-	const chains = subagent.chains as Record<string, unknown>;
-
-	chains[chainKey] = templates;
-
-	const dir = path.dirname(SETTINGS_PATH);
-	if (!fs.existsSync(dir)) {
-		fs.mkdirSync(dir, { recursive: true });
-	}
-	fs.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2));
-}
-
-export function getChainKey(agents: string[]): string {
-	return agents.join("->");
-}
-
 // =============================================================================
 // Chain Directory Management
 // =============================================================================
@@ -183,36 +118,6 @@ export function cleanupOldChainDirs(): void {
 // Template Resolution
 // =============================================================================
 
-/**
- * Resolve templates for each step in a chain.
- * Priority: inline task > saved template > default
- * Default for step 0: "{task}", for others: "{previous}"
- */
-export function resolveChainTemplates(
-	agentNames: string[],
-	inlineTasks: (string | undefined)[],
-	settings: SubagentSettings,
-): string[] {
-	const chainKey = getChainKey(agentNames);
-	const savedTemplates = settings.chains?.[chainKey] ?? {};
-
-	return agentNames.map((agent, i) => {
-		// Priority: inline > saved > default
-		const inline = inlineTasks[i];
-		if (inline) return inline;
-
-		const saved = savedTemplates[agent];
-		if (saved) return saved;
-
-		// Default: first step uses {task}, others use {previous}
-		return i === 0 ? "{task}" : "{previous}";
-	});
-}
-
-// =============================================================================
-// Parallel-Aware Template Resolution
-// =============================================================================
-
 /** Resolved templates for a chain - string for sequential, string[] for parallel */
 export type ResolvedTemplates = (string | string[])[];
 
@@ -220,9 +125,8 @@ export type ResolvedTemplates = (string | string[])[];
  * Resolve templates for a chain with parallel step support.
  * Returns string for sequential steps, string[] for parallel steps.
  */
-export function resolveChainTemplatesV2(
+export function resolveChainTemplates(
 	steps: ChainStep[],
-	settings: SubagentSettings,
 ): ResolvedTemplates {
 	return steps.map((step, i) => {
 		if (isParallelStep(step)) {
@@ -241,43 +145,6 @@ export function resolveChainTemplatesV2(
 	});
 }
 
-/**
- * Flatten templates for display (TUI navigation needs flat list)
- */
-export function flattenTemplates(templates: ResolvedTemplates): string[] {
-	const result: string[] = [];
-	for (const t of templates) {
-		if (Array.isArray(t)) {
-			result.push(...t);
-		} else {
-			result.push(t);
-		}
-	}
-	return result;
-}
-
-/**
- * Unflatten templates back to structured form
- */
-export function unflattenTemplates(
-	flat: string[],
-	steps: ChainStep[],
-): ResolvedTemplates {
-	const result: ResolvedTemplates = [];
-	let idx = 0;
-	for (const step of steps) {
-		if (isParallelStep(step)) {
-			const count = step.parallel.length;
-			result.push(flat.slice(idx, idx + count));
-			idx += count;
-		} else {
-			result.push(flat[idx]!);
-			idx++;
-		}
-	}
-	return result;
-}
-
 // =============================================================================
 // Behavior Resolution
 // =============================================================================
@@ -311,20 +178,6 @@ export function resolveStepBehavior(
 	return { output, reads, progress };
 }
 
-/**
- * Find index of first agent in chain that has progress enabled
- */
-export function findFirstProgressAgentIndex(
-	agentConfigs: AgentConfig[],
-	stepOverrides: StepOverrides[],
-): number {
-	return agentConfigs.findIndex((config, i) => {
-		const override = stepOverrides[i];
-		if (override?.progress !== undefined) return override.progress;
-		return config.defaultProgress ?? false;
-	});
-}
-
 // =============================================================================
 // Chain Instruction Injection
 // =============================================================================
@@ -472,21 +325,4 @@ export function aggregateParallelOutputs(results: ParallelTaskResult[]): string
 		.join("\n\n");
 }
 
-/**
- * Check if any parallel task failed
- */
-export function hasParallelFailures(results: ParallelTaskResult[]): boolean {
-	return results.some((r) => r.exitCode !== 0);
-}
 
-/**
- * Get failure summary for parallel step
- */
-export function getParallelFailureSummary(results: ParallelTaskResult[]): string {
-	const failures = results.filter((r) => r.exitCode !== 0);
-	if (failures.length === 0) return "";
-
-	return failures
-		.map((f) => `- Task ${f.taskIndex + 1} (${f.agent}): ${f.error || "failed"}`)
-		.join("\n");
-}