pi-taskflow 0.0.5 → 0.0.7

package/extensions/interpolate.ts

@@ -20,7 +20,7 @@ export interface InterpolationContext {
 	locals?: Record<string, unknown>;
 }
 
-const PLACEHOLDER = /\{([a-zA-Z0-9_]+(?:\.[a-zA-Z0-9_]+)*)\}/g;
+const PLACEHOLDER = /\{([a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*)\}/g;
 
 export interface InterpolationResult {
 	text: string;
@@ -149,3 +149,234 @@ export function coerceArray(value: unknown): unknown[] | null {
 	}
 	return null;
 }
+
+// ---------------------------------------------------------------------------
+// Conditional expressions (phase.when)
+// ---------------------------------------------------------------------------
+//
+// A tiny, safe boolean expression language — NO eval / Function. Operands are
+// either interpolation placeholders `{...}` (resolved to their raw value) or
+// literals (quoted string, number, true/false/null, or a bare word treated as
+// a string). Operators, by precedence (low → high):
+//
+//   ||   logical or
+//   &&   logical and
+//   ==  != == >= <= > <   comparison
+//   !    logical not / unary
+//   ( )  grouping
+//
+// A bare operand is evaluated for truthiness. Parse errors fail OPEN (return
+// true) so a malformed guard never silently drops a phase.
+
+type Tok =
+	| { t: "ref"; v: string }
+	| { t: "str"; v: string }
+	| { t: "num"; v: number }
+	| { t: "bool"; v: boolean }
+	| { t: "null" }
+	| { t: "op"; v: string };
+
+const OPS = ["&&", "||", "==", "!=", ">=", "<=", ">", "<", "!", "(", ")"];
+
+function tokenize(input: string): Tok[] {
+	const toks: Tok[] = [];
+	let i = 0;
+	const n = input.length;
+	while (i < n) {
+		const c = input[i];
+		if (c === " " || c === "\t" || c === "\n" || c === "\r") {
+			i++;
+			continue;
+		}
+		// placeholder {path.to.value}
+		if (c === "{") {
+			const end = input.indexOf("}", i);
+			if (end === -1) throw new Error("unterminated placeholder");
+			toks.push({ t: "ref", v: input.slice(i + 1, end).trim() });
+			i = end + 1;
+			continue;
+		}
+		// quoted string
+		if (c === '"' || c === "'") {
+			const end = input.indexOf(c, i + 1);
+			if (end === -1) throw new Error("unterminated string");
+			toks.push({ t: "str", v: input.slice(i + 1, end) });
+			i = end + 1;
+			continue;
+		}
+		// multi/single char operators
+		const op = OPS.find((o) => input.startsWith(o, i));
+		if (op) {
+			toks.push({ t: "op", v: op });
+			i += op.length;
+			continue;
+		}
+		// number
+		const numMatch = /^-?\d+(?:\.\d+)?/.exec(input.slice(i));
+		if (numMatch) {
+			toks.push({ t: "num", v: Number(numMatch[0]) });
+			i += numMatch[0].length;
+			continue;
+		}
+		// bareword → literal (true/false/null keywords, else string)
+		const word = /^[^\s&|!=<>()"'{}]+/.exec(input.slice(i));
+		if (word) {
+			const w = word[0];
+			if (w === "true") toks.push({ t: "bool", v: true });
+			else if (w === "false") toks.push({ t: "bool", v: false });
+			else if (w === "null") toks.push({ t: "null" });
+			else toks.push({ t: "str", v: w });
+			i += w.length;
+			continue;
+		}
+		throw new Error(`unexpected char '${c}'`);
+	}
+	return toks;
+}
+
+function isNumeric(v: unknown): boolean {
+	if (typeof v === "number") return Number.isFinite(v);
+	if (typeof v === "string" && v.trim() !== "") return Number.isFinite(Number(v));
+	return false;
+}
+
+function truthy(v: unknown): boolean {
+	if (v === undefined || v === null) return false;
+	if (typeof v === "boolean") return v;
+	if (typeof v === "number") return v !== 0;
+	if (typeof v === "string") {
+		const s = v.trim().toLowerCase();
+		return !(s === "" || s === "false" || s === "0" || s === "no" || s === "off" || s === "null");
+	}
+	if (Array.isArray(v)) return v.length > 0;
+	if (typeof v === "object") return Object.keys(v as object).length > 0;
+	return Boolean(v);
+}
+
+function compare(a: unknown, op: string, b: unknown): boolean {
+	if (isNumeric(a) && isNumeric(b)) {
+		const x = Number(a);
+		const y = Number(b);
+		switch (op) {
+			case "==": return x === y;
+			case "!=": return x !== y;
+			case ">": return x > y;
+			case "<": return x < y;
+			case ">=": return x >= y;
+			case "<=": return x <= y;
+		}
+	}
+	const sa = a === undefined || a === null ? "" : String(a);
+	const sb = b === undefined || b === null ? "" : String(b);
+	switch (op) {
+		case "==": return sa === sb;
+		case "!=": return sa !== sb;
+		case ">": return sa > sb;
+		case "<": return sa < sb;
+		case ">=": return sa >= sb;
+		case "<=": return sa <= sb;
+	}
+	return false;
+}
+
+/** Recursive-descent parser/evaluator over the token stream. */
+class CondParser {
+	private pos = 0;
+	private readonly toks: Tok[];
+	private readonly ctx: InterpolationContext;
+	constructor(toks: Tok[], ctx: InterpolationContext) {
+		this.toks = toks;
+		this.ctx = ctx;
+	}
+
+	parse(): unknown {
+		const v = this.parseOr();
+		if (this.pos < this.toks.length) throw new Error("trailing tokens");
+		return v;
+	}
+	private peek(): Tok | undefined {
+		return this.toks[this.pos];
+	}
+	private eat(op: string): boolean {
+		const t = this.peek();
+		if (t && t.t === "op" && t.v === op) {
+			this.pos++;
+			return true;
+		}
+		return false;
+	}
+	private parseOr(): unknown {
+		let left = this.parseAnd();
+		while (this.eat("||")) {
+			const right = this.parseAnd();
+			left = truthy(left) || truthy(right);
+		}
+		return left;
+	}
+	private parseAnd(): unknown {
+		let left = this.parseNot();
+		while (this.eat("&&")) {
+			const right = this.parseNot();
+			left = truthy(left) && truthy(right);
+		}
+		return left;
+	}
+	private parseNot(): unknown {
+		if (this.eat("!")) return !truthy(this.parseNot());
+		return this.parseComparison();
+	}
+	private parseComparison(): unknown {
+		const left = this.parsePrimary();
+		const t = this.peek();
+		if (t && t.t === "op" && ["==", "!=", ">", "<", ">=", "<="].includes(t.v)) {
+			this.pos++;
+			const right = this.parsePrimary();
+			return compare(left, t.v, right);
+		}
+		return left;
+	}
+	private parsePrimary(): unknown {
+		if (this.eat("(")) {
+			const v = this.parseOr();
+			if (!this.eat(")")) throw new Error("missing )");
+			return v;
+		}
+		const t = this.peek();
+		if (!t) throw new Error("unexpected end");
+		this.pos++;
+		switch (t.t) {
+			case "ref": return resolvePath(t.v, this.ctx);
+			case "str": return t.v;
+			case "num": return t.v;
+			case "bool": return t.v;
+			case "null": return null;
+			default: throw new Error(`unexpected operator '${(t as { v: string }).v}'`);
+		}
+	}
+}
+
+/**
+ * Evaluate a `when` expression to a boolean. Returns `{ value, error }`.
+ * Parse errors set `error` and fail OPEN (`value: true`) so a broken guard
+ * never silently drops a phase.
+ */
+export function tryEvaluateCondition(
+	expr: string,
+	ctx: InterpolationContext,
+): { value: boolean; error?: string } {
+	const trimmed = (expr ?? "").trim();
+	if (!trimmed) return { value: true };
+	try {
+		const toks = tokenize(trimmed);
+		if (toks.length === 0) return { value: true };
+		const result = new CondParser(toks, ctx).parse();
+		return { value: truthy(result) };
+	} catch (e) {
+		return { value: true, error: e instanceof Error ? e.message : String(e) };
+	}
+}
+
+/** Boolean convenience wrapper over {@link tryEvaluateCondition}. */
+export function evaluateCondition(expr: string, ctx: InterpolationContext): boolean {
+	return tryEvaluateCondition(expr, ctx).value;
+}

package/extensions/render.ts

@@ -7,7 +7,7 @@
 
 import { getMarkdownTheme, type Theme } from "@earendil-works/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
-import { formatTokens, type UsageStats } from "./runner.ts";
+import { type UsageStats } from "./usage.ts";
 import type { PhaseState, RunState } from "./store.ts";
 import { dependenciesOf, type Phase, topoLayers } from "./schema.ts";
 
@@ -62,23 +62,16 @@ function miniBar(done: number, total: number, theme: Theme, width = 8): string {
 	return theme.fg("accent", "━".repeat(filled)) + theme.fg("dim", "─".repeat(width - filled));
 }
 
-function compactUsage(usage: UsageStats | undefined, theme: Theme): string {
-	if (!usage) return "";
-	const parts: string[] = [];
-	if (usage.turns) parts.push(theme.fg("dim", `${usage.turns}t`));
-	if (usage.input) parts.push(theme.fg("dim", `↑${formatTokens(usage.input)}`));
-	if (usage.output) parts.push(theme.fg("dim", `↓${formatTokens(usage.output)}`));
-	if (usage.cost) parts.push(theme.fg("muted", `$${usage.cost.toFixed(3)}`));
-	return parts.join(" ");
+function agentRole(phase: Phase, ps: PhaseState | undefined, theme: Theme): string {
+	const role = phase.agent ?? phase.type ?? "agent";
+	const model = ps?.model ? shortModel(ps.model) : "";
+	if (!model) return theme.fg("accent", role);
+	return theme.fg("accent", role) + theme.fg("dim", `（${model}）`);
 }
 
-function liveUsageStr(usage: UsageStats | undefined, theme: Theme): string {
-	if (!usage) return "";
-	const parts: string[] = [];
-	if (usage.input) parts.push(theme.fg("dim", `↑${formatTokens(usage.input)}`));
-	if (usage.output) parts.push(theme.fg("dim", `↓${formatTokens(usage.output)}`));
-	if (usage.cost) parts.push(theme.fg("muted", `$${usage.cost.toFixed(3)}`));
-	return parts.join(" ");
+function costStr(usage: UsageStats | undefined, theme: Theme): string {
+	if (!usage?.cost) return "";
+	return theme.fg("muted", `$${usage.cost.toFixed(3)}`);
 }
 
 function aggregateCost(state: RunState): number {
@@ -118,10 +111,10 @@ function phaseDetail(phase: Phase, ps: PhaseState | undefined, theme: Theme): st
 	if (ps.status === "skipped") {
 		const reason = (ps.error ?? "upstream failed").replace(/\s+/g, " ");
 		const snip = reason.length > 52 ? `${reason.slice(0, 52)}…` : reason;
-		return theme.fg("muted", `skipped · ${snip}`);
+		return theme.fg("muted", `skipped · ${snip}`) + (ps.warnings?.length ? theme.fg("warning", `  ⚠${ps.warnings.length}`) : "");
 	}
 
-	const isFanout = type === "map" || type === "parallel";
+	const isFanout = type === "map" || type === "parallel" || type === "flow";
 
 	if (ps.status === "failed") {
 		const e = (ps.error ?? "failed").replace(/\s+/g, " ");
@@ -131,30 +124,34 @@ function phaseDetail(phase: Phase, ps: PhaseState | undefined, theme: Theme): st
 			return (
 				theme.fg("toolOutput", `${done - failed}/${total}`) +
 				theme.fg("error", ` ${failed}✗`) +
-				(snip ? theme.fg("error", `  ${snip}`) : "")
+				(snip ? theme.fg("error", `  ${snip}`) : "") +
+				(ps.warnings?.length ? theme.fg("warning", `  ⚠${ps.warnings.length}`) : "")
 			);
 		}
-		return theme.fg("error", snip);
+		return theme.fg("error", snip) + (ps.warnings?.length ? theme.fg("warning", `  ⚠${ps.warnings.length}`) : "");
 	}
 
 	const t = phaseElapsed(ps);
 	const time = t ? theme.fg("dim", elapsed(t)) : "";
 
 	if (ps.status === "running") {
-		const model = shortModel(ps.model);
-		const tokens = liveUsageStr(ps.usage, theme);
+		const roleLabel = agentRole(phase, ps, theme);
+		const cost = costStr(ps.usage, theme);
 		if (isFanout && ps.subProgress) {
 			const { done, total, running, failed } = ps.subProgress;
 			let s = `${miniBar(done, total, theme)} ${theme.fg("toolOutput", `${done}/${total}`)}`;
 			if (running) s += theme.fg("dim", ` · ${running} run`);
 			if (failed) s += theme.fg("error", ` · ${failed}✗`);
-			if (tokens) s += `  ${tokens}`;
+			s += `  ${roleLabel}`;
+			if (cost) s += `  ${cost}`;
 			if (time) s += `  ${time}`;
+			if (ps.warnings?.length) s += theme.fg("warning", `  ⚠${ps.warnings.length}`);
 			return s;
 		}
-		let s = model ? theme.fg("accent", model) : theme.fg("warning", "running…");
-		if (tokens) s += `  ${tokens}`;
+		let s = roleLabel;
+		if (cost) s += `  ${cost}`;
 		if (time) s += `  ${time}`;
+		if (ps.warnings?.length) s += theme.fg("warning", `  ⚠${ps.warnings.length}`);
 		return s;
 	}
 
@@ -163,14 +160,24 @@ function phaseDetail(phase: Phase, ps: PhaseState | undefined, theme: Theme): st
 		const { done = 0, total = 0, failed = 0 } = ps.subProgress ?? {};
 		let s = theme.fg("success", `${total}✓`);
 		if (failed) s = theme.fg("toolOutput", `${done - failed}/${total}`) + theme.fg("error", ` ${failed}✗`);
-		const u = compactUsage(ps.usage, theme);
-		if (u) s += `  ${u}`;
+		const cost = costStr(ps.usage, theme);
+		if (cost) s += `  ${cost}`;
 		if (time) s += `  ${time}`;
+		if (ps.warnings?.length) s += theme.fg("warning", `  ⚠${ps.warnings.length}`);
 		return s;
 	}
 	// single-agent done
-	const model = shortModel(ps.model);
-	const u = compactUsage(ps.usage, theme);
+	const roleLabel = agentRole(phase, ps, theme);
+	const cost = costStr(ps.usage, theme);
+	if (ps.approval) {
+		const d = ps.approval.decision;
+		const color = d === "reject" ? "error" : d === "edit" ? "warning" : "success";
+		let a = theme.fg("warning", "⚠") + " " + theme.fg(color as Parameters<typeof theme.fg>[0], theme.bold(d.toUpperCase()));
+		if (ps.approval.auto) a += theme.fg("dim", " auto");
+		if (time) a += `  ${time}`;
+		if (ps.warnings?.length) a += theme.fg("warning", `  ⚠${ps.warnings.length}`);
+		return a;
+	}
 	if (ps.gate) {
 		const badge =
 			ps.gate.verdict === "block" ? theme.fg("error", theme.bold("BLOCK")) : theme.fg("success", "PASS");
@@ -179,15 +186,18 @@ function phaseDetail(phase: Phase, ps: PhaseState | undefined, theme: Theme): st
 			const r = ps.gate.reason.replace(/\s+/g, " ");
 			g += theme.fg("dim", ` ${r.length > 44 ? `${r.slice(0, 44)}…` : r}`);
 		}
-		if (model) g += `  ${theme.fg("dim", model)}`;
+		const cost = costStr(ps.usage, theme);
+		if (cost) g += `  ${cost}`;
 		if (time) g += `  ${time}`;
+		if (ps.warnings?.length) g += theme.fg("warning", `  ⚠${ps.warnings.length}`);
 		return g;
 	}
-	let s = "";
-	if (model) s += theme.fg("accent", model);
-	if (u) s += (s ? "  " : "") + u;
+	let s = roleLabel;
+	if (cost) s += `  ${cost}`;
+	if (ps.attempts && ps.attempts > 1) s += theme.fg("warning", `  ↻${ps.attempts - 1}`);
 	if (time) s += `  ${time}`;
-	return s || theme.fg("dim", "done");
+	if (ps.warnings?.length) s += theme.fg("warning", `  ⚠${ps.warnings.length}`);
+	return s;
 }
 
 /** Header line: status glyph + name + compact totals. */
@@ -217,7 +227,9 @@ function headerLine(state: RunState, theme: Theme): string {
 	if (failed) line += theme.fg("error", ` · ${failed}✗`);
 	if (state.status === "blocked") line += theme.fg("error", " · blocked");
 	const cost = aggregateCost(state);
-	if (cost) line += theme.fg("muted", ` · $${cost.toFixed(3)}`);
+	const budget = state.def.budget;
+	if (budget?.maxUSD !== undefined) line += theme.fg("muted", ` · $${cost.toFixed(3)}/$${budget.maxUSD}`);
+	else if (cost) line += theme.fg("muted", ` · $${cost.toFixed(3)}`);
 	const el = runElapsed(state);
 	if (el) line += theme.fg("dim", ` · ${elapsed(el)}`);
 	return line;

package/extensions/runner.ts

@@ -11,20 +11,7 @@ import * as path from "node:path";
 import type { Message } from "@earendil-works/pi-ai";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import type { AgentConfig } from "./agents.ts";
-
-export interface UsageStats {
-	input: number;
-	output: number;
-	cacheRead: number;
-	cacheWrite: number;
-	cost: number;
-	contextTokens: number;
-	turns: number;
-}
-
-export function emptyUsage(): UsageStats {
-	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 };
-}
+import { emptyUsage, type UsageStats } from "./usage.ts";
 
 export interface RunResult {
 	agent: string;
@@ -36,6 +23,8 @@ export interface RunResult {
 	model?: string;
 	stopReason?: string;
 	errorMessage?: string;
+	/** Total subagent attempts incl. retries (set by the runtime's retry wrapper). */
+	attempts?: number;
 }
 
 export interface LiveUpdate {
@@ -59,18 +48,123 @@ export function isFailed(r: RunResult): boolean {
 	return r.exitCode !== 0 || r.stopReason === "error" || r.stopReason === "aborted";
 }
 
+/** Placeholder written to a failed phase's `output` so downstream interpolation
+ *  can detect "upstream failed" without being polluted by raw HTML/JSON. */
+export const TRANSPORT_ERROR_PLACEHOLDER = "(upstream error: subagent failed; see error)";
+
+/** Hard cap on the errorMessage field stored in PhaseState (≈ 4 KB). */
+export const ERROR_MESSAGE_MAX_LEN = 4096;
+
+/** Cheap HTML/JSON detector so we can summarize upstream garbage. */
+export function looksLikeHtmlOrJson(s: string): boolean {
+	const t = s.trimStart();
+	if (!t) return false;
+	if (t.startsWith("<")) {
+		// HTML/XML/Cloudflare challenge pages
+		return /^<(?:!doctype\s+html|html|head|body|script|svg|div|iframe|span|p)\b/i.test(t);
+	}
+	if (t.startsWith("{")) {
+		// Truncated JSON. A genuine JSON envelope is fine to keep; an unwrapped
+		// {error: "..."} from an SDK is short. We only treat it as "garbage" if
+		// it parses and is huge — but that's caught by the size cap below.
+		return false;
+	}
+	return false;
+}
+
+/**
+ * Truncate and (when obviously HTML) summarize an errorMessage before it is
+ * persisted. Returns the cleaned string. Empty input returns empty.
+ */
+export function sanitizeErrorMessage(raw: string | undefined): string {
+	if (!raw) return "";
+	const cleaned = raw.replace(/\s+/g, " ").trim();
+	if (!cleaned) return "";
+	// Decide the sanitization branch on the RAW length, not the whitespace-
+	// collapsed length — otherwise an HTML page padded with spaces would slip
+	// through the "looks like HTML" branch and be persisted as-is.
+	const rawLen = raw.length;
+	if (rawLen > ERROR_MESSAGE_MAX_LEN) {
+		const head = cleaned.slice(0, 200);
+		const tail = cleaned.slice(-200);
+		return `${head} ... [truncated ${rawLen - 400} chars] ... ${tail}`;
+	}
+	if (looksLikeHtmlOrJson(cleaned)) {
+		// Any document-like HTML (Cloudflare challenge pages, proxy error pages,
+		// gateway error pages) is a strong signal the upstream returned a page
+		// instead of JSON. Summarize it instead of letting HTML pollute the
+		// phase's error and downstream interpolation contexts.
+		const title = cleaned.match(/<title[^>]*>([^<]*)<\/title>/i)?.[1]?.trim();
+		const stripped = cleaned.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+		const m = stripped.match(/(?:Unable to load site|Ray ID[: ]+([A-Za-z0-9]+)|[A-Z][a-z]+Error[: ]+(.{0,200}))/i);
+		const hint = title || (m ? (m[1] || m[0]).trim() : stripped.slice(0, 200));
+		return `Upstream returned non-JSON response (${rawLen} chars). Hint: ${hint}`;
+	}
+	return cleaned;
+}
+
 function getFinalOutput(messages: Message[]): string {
 	for (let i = messages.length - 1; i >= 0; i--) {
 		const msg = messages[i];
 		if (msg.role === "assistant") {
 			for (const part of msg.content) {
-				if (part.type === "text") return part.text;
+				if (part.type === "text" && part.text.trim()) return part.text;
 			}
 		}
 	}
 	return "";
 }
 
+/** Accumulated state folded from a subagent's NDJSON event stream. */
+export interface EventAccumulator {
+	messages: Message[];
+	usage: UsageStats;
+	model?: string;
+	stopReason?: string;
+	errorMessage?: string;
+	lastActivity: string;
+}
+
+export function newAccumulator(model?: string): EventAccumulator {
+	return { messages: [], usage: emptyUsage(), model, lastActivity: "" };
+}
+
+/**
+ * Fold one NDJSON line into the accumulator. Returns a LiveUpdate when an
+ * assistant message ended (for streaming), else null. Empty, malformed, and
+ * non-`message_end` lines are ignored — making the parser robust to partial
+ * buffers/noise and unit-testable without spawning a process.
+ */
+export function foldEventLine(acc: EventAccumulator, line: string): LiveUpdate | null {
+	if (!line.trim()) return null;
+	let event: any;
+	try {
+		event = JSON.parse(line);
+	} catch {
+		return null;
+	}
+	if (event.type !== "message_end" || !event.message) return null;
+	const msg = event.message as Message;
+	acc.messages.push(msg);
+	if (msg.role !== "assistant") return null;
+	acc.usage.turns++;
+	const u = (msg as any).usage;
+	if (u) {
+		acc.usage.input += u.input || 0;
+		acc.usage.output += u.output || 0;
+		acc.usage.cacheRead += u.cacheRead || 0;
+		acc.usage.cacheWrite += u.cacheWrite || 0;
+		acc.usage.cost += u.cost?.total || 0;
+		acc.usage.contextTokens = u.totalTokens || 0;
+	}
+	if (!acc.model && (msg as any).model) acc.model = (msg as any).model;
+	if ((msg as any).stopReason) acc.stopReason = (msg as any).stopReason;
+	if ((msg as any).errorMessage) acc.errorMessage = (msg as any).errorMessage;
+	const activity = describeActivity(msg);
+	if (activity) acc.lastActivity = activity;
+	return { text: acc.lastActivity, usage: { ...acc.usage }, model: acc.model };
+}
+
 /** One-line description of the most recent assistant activity (text or tool call). */
 function describeActivity(msg: Message): string {
 	if (msg.role !== "assistant") return "";
@@ -177,8 +271,7 @@ export async function runAgentTask(
 	let tmpPromptDir: string | null = null;
 	let tmpPromptPath: string | null = null;
 
-	const messages: Message[] = [];
-	let lastActivity = "";
+	const acc = newAccumulator(model);
 	const result: RunResult = {
 		agent: agentName,
 		task,
@@ -209,36 +302,8 @@ export async function runAgentTask(
 			let buffer = "";
 
 			const processLine = (line: string) => {
-				if (!line.trim()) return;
-				let event: any;
-				try {
-					event = JSON.parse(line);
-				} catch {
-					return;
-				}
-				if (event.type === "message_end" && event.message) {
-					const msg = event.message as Message;
-					messages.push(msg);
-					if (msg.role === "assistant") {
-						result.usage.turns++;
-						const u = (msg as any).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;
-							result.usage.contextTokens = u.totalTokens || 0;
-						}
-						if (!result.model && (msg as any).model) result.model = (msg as any).model;
-						if ((msg as any).stopReason) result.stopReason = (msg as any).stopReason;
-						if ((msg as any).errorMessage) result.errorMessage = (msg as any).errorMessage;
-						const activity = describeActivity(msg);
-						if (activity) lastActivity = activity;
-						if (opts.onLive)
-							opts.onLive({ text: lastActivity, usage: { ...result.usage }, model: result.model });
-					}
-				}
+				const live = foldEventLine(acc, line);
+				if (live && opts.onLive) opts.onLive(live);
 			};
 
 			proc.stdout.on("data", (data) => {
@@ -270,13 +335,26 @@ export async function runAgentTask(
 		});
 
 		result.exitCode = exitCode;
-		result.output = getFinalOutput(messages);
+		result.usage = acc.usage;
+		result.model = acc.model;
+		result.stopReason = acc.stopReason;
+		result.errorMessage = acc.errorMessage;
+		result.output = getFinalOutput(acc.messages);
 		if (wasAborted) {
 			result.stopReason = "aborted";
 			result.errorMessage = "Subagent was aborted";
 		}
+		// On failure, build a short, structured errorMessage + a placeholder
+		// output. We deliberately do NOT copy the raw errorMessage into
+		// `output`: upstream providers (e.g. a Cloudflare challenge page) can
+		// surface huge HTML/JSON in errorMessage, and that garbage would
+		// otherwise flow into downstream phase interpolations.
 		if (isFailed(result) && !result.output) {
-			result.output = result.errorMessage || result.stderr || "(no output)";
+			result.output = TRANSPORT_ERROR_PLACEHOLDER;
+			if (!result.errorMessage) {
+				result.errorMessage = result.stderr || `Subagent exited with code ${result.exitCode} (stopReason: ${result.stopReason ?? "unknown"})`;
+			}
+			result.errorMessage = sanitizeErrorMessage(result.errorMessage);
 		}
 		return result;
 	} finally {
@@ -317,34 +395,3 @@ export async function mapWithConcurrencyLimit<TIn, TOut>(
 	await Promise.all(workers);
 	return results;
 }
-
-export function formatTokens(count: number): string {
-	if (count < 1000) return count.toString();
-	if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
-	if (count < 1000000) return `${Math.round(count / 1000)}k`;
-	return `${(count / 1000000).toFixed(1)}M`;
-}
-
-export function formatUsage(usage: UsageStats, model?: string): string {
-	const parts: string[] = [];
-	if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
-	if (usage.input) parts.push(`↑${formatTokens(usage.input)}`);
-	if (usage.output) parts.push(`↓${formatTokens(usage.output)}`);
-	if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`);
-	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
-	if (model) parts.push(model);
-	return parts.join(" ");
-}
-
-export function aggregateUsage(usages: UsageStats[]): UsageStats {
-	const total = emptyUsage();
-	for (const u of usages) {
-		total.input += u.input;
-		total.output += u.output;
-		total.cacheRead += u.cacheRead;
-		total.cacheWrite += u.cacheWrite;
-		total.cost += u.cost;
-		total.turns += u.turns;
-	}
-	return total;
-}