pi-taskflow 0.0.6 → 0.0.8

package/README.md

@@ -22,9 +22,10 @@ saveable as a one-word `/tf:<name>` command.
 pi install npm:pi-taskflow
 ```
 
-Fan out one subagent per item, gate the results with an adversarial review, and
-get back only the final report — none of the intermediate transcripts ever touch
-your conversation.
+Fan out one subagent per item, route on results, retry the flaky ones, pause for
+human approval, cap the spend, and gate the output with an adversarial review —
+all from one declarative definition. Only the final report reaches your
+conversation; every intermediate transcript stays in the runtime.
 
 ## Why
 
@@ -45,6 +46,11 @@ only the final phase's output.
 | Scale | a few tasks | dynamic `map` fan-out |
 | Resumable | no | yes (cross-session, cached phases skip) |
 | Quality gates | no | `gate` phases with `VERDICT: BLOCK / PASS` |
+| Conditional routing | no | `when` guards + `join: any` OR-joins |
+| Fault tolerance | no | per-phase `retry` with backoff |
+| Human-in-the-loop | no | `approval` phases (approve / reject / edit) |
+| Cost control | no | run-wide `budget` (USD / token caps) |
+| Composition | no | `flow` phases run saved sub-flows |
 | Progress visibility | opaque while running | live DAG render with timing + cost |
 | Ergonomics | inline JSON each time | shorthand (`task`/`tasks`/`chain`) or DSL |
 
@@ -137,6 +143,36 @@ only the final report back.
 
 Save it once → `/tf:summarize-files` forever.
 
+### Route, gate, and guard
+
+Phases also **branch, retry, pause for a human, and respect a budget** — still
+declaratively, no scripting:
+
+```jsonc
+{
+  "name": "triage-and-fix",
+  "budget": { "maxUSD": 1.5 },
+  "phases": [
+    { "id": "triage", "type": "agent", "agent": "analyst", "output": "json",
+      "task": "Classify the bug. Output ONLY {\"severity\":\"high\"} or {\"severity\":\"low\"}." },
+    { "id": "deep",  "when": "{steps.triage.json.severity} == high", "dependsOn": ["triage"],
+      "agent": "executor_code", "task": "Root-cause and patch it.",
+      "retry": { "max": 2, "backoffMs": 500 } },
+    { "id": "quick", "when": "{steps.triage.json.severity} == low",  "dependsOn": ["triage"],
+      "agent": "executor_fast", "task": "Apply the quick fix." },
+    { "id": "approve", "type": "approval", "join": "any", "dependsOn": ["deep", "quick"],
+      "task": "Review the fix before it ships." },
+    { "id": "ship", "type": "agent", "dependsOn": ["approve"],
+      "task": "Open a PR with the change.", "final": true }
+  ]
+}
+```
+
+- **`when`** routes to `deep` *or* `quick` from the triage JSON; the other branch is skipped.
+- **`join: "any"`** lets `approve` run as soon as whichever branch fired completes.
+- **`retry`** re-runs a flaky patch with backoff; **`budget`** halts the whole run if it gets too expensive.
+- **`approval`** pauses for a human (approve / reject / edit) before the final `ship`.
+
 ## Watch it run
 
 This is the live progress render for a real run — the `self-improve` flow that
@@ -181,11 +217,28 @@ writes and verifies its own test suites, caught here mid-block by a quality gate
 | `approval` | **human-in-the-loop** pause — approve / reject / edit before continuing | — |
 | `flow` | run a **saved sub-flow** as one phase (composition/reuse) | `use` |
 
-Every phase needs `id`. Optional fields: `agent`, `dependsOn`, `output`,
-`model`, `thinking`, `tools`, `cwd`, `concurrency`, `final`, `optional`,
-`when` (conditional guard), `join` (`all`\|`any` dependency join), `retry`
-(`{max, backoffMs, factor}`), and `with` (args for a `flow` phase).
-Run-wide: `budget: {maxUSD, maxTokens}` halts the flow when exceeded.
+### Common phase fields
+
+Every phase needs a unique `id` and a `type` (defaults to `agent`). On top of the
+per-type fields above:
+
+| Field | Meaning |
+|---|---|
+| `agent` | Agent to run (defaults to the first discovered agent) |
+| `dependsOn` | Phase ids this phase waits for — builds the DAG |
+| `join` | `"all"` (default) waits for every dep; `"any"` is an OR-join |
+| `when` | Conditional guard — skip unless the expression is truthy |
+| `retry` | `{ max, backoffMs?, factor? }` — retry a failing subagent |
+| `output` | `"text"` (default) or `"json"` (exposes `{steps.ID.json}`) |
+| `model` / `thinking` / `tools` | Per-phase overrides for the subagent |
+| `cwd` | Working directory for the subagent |
+| `concurrency` | Fan-out cap for `map` / `parallel` (overrides the flow default) |
+| `final` | Marks the result-bearing phase (else the last phase wins) |
+| `optional` | A failure here does **not** abort the run |
+| `use` / `with` | (`flow`) saved sub-flow name + its args |
+
+Flow-level keys: `name`, `description`, `args`, `concurrency` (default 8),
+`agentScope`, and `budget: { maxUSD?, maxTokens? }`.
 
 ### Control flow & reliability
 
@@ -294,6 +347,20 @@ file). Phase-level overrides for `model`, `thinking`, and `tools` are passed as
 Settings from `~/.pi/agent/settings.json` (the `subagents.agentOverrides` map)
 are honored, letting you tweak model, thinking, or tools per agent across all flows.
 
+## Examples
+
+Ready-to-read definitions live in [`examples/`](./examples):
+
+| File | Demonstrates |
+|---|---|
+| [`summarize-files.json`](./examples/summarize-files.json) | discover → `map` fan-out → `reduce` |
+| [`conditional-research.json`](./examples/conditional-research.json) | `when` routing + `join: any` + `gate` + `budget` |
+| [`guarded-refactor.json`](./examples/guarded-refactor.json) | `approval` (human-in-the-loop) + `retry` + `gate` |
+
+To use one, copy it into `.pi/taskflows/<name>.json` (or
+`~/.pi/agent/taskflows/`) and it registers as `/tf:<name>` — or just point the
+model at the definition.
+
 ## Status & limits
 
 - **v0.0.6** — control flow & reliability: conditional `when` guards, `join: any`
@@ -327,13 +394,10 @@ are honored, letting you tweak model, thinking, or tools per agent across all fl
 ```bash
 npm install
 npm run typecheck
-node --experimental-strip-types --test test/interpolate.test.ts \
-  test/condition.test.ts test/schema.test.ts test/usage.test.ts \
-  test/runtime.test.ts test/features.test.ts test/runner.test.ts \
-  test/store.test.ts test/agents.test.ts test/render.test.ts test/desugar.test.ts
+npm test            # unit tests — no network, no process spawning
 
 # real end-to-end (spawns live subagents; needs model access)
-PI_TASKFLOW_PI_BIN=pi node --experimental-strip-types test/e2e.mts
+npm run test:e2e
 ```
 
 ## Contributing

package/examples/conditional-research.json

@@ -47,7 +47,7 @@
       "id": "report",
       "type": "reduce",
       "from": ["review"],
-      "dependsOn": ["review"],
+      "dependsOn": ["review", "deep", "quick"],
       "agent": "doc-writer",
       "task": "Write a clean markdown brief on \"{args.topic}\" from the validated research:\n\n{steps.deep.output}{steps.quick.output}",
       "final": true

package/examples/guarded-refactor.json

@@ -26,7 +26,7 @@
       "id": "implement",
       "type": "agent",
       "agent": "executor_code",
-      "dependsOn": ["approve"],
+      "dependsOn": ["approve", "plan"],
       "task": "Implement the approved plan for {args.target}.\nPlan:\n{steps.plan.output}\nExtra human guidance (if any):\n{steps.approve.output}",
       "retry": { "max": 1, "backoffMs": 1000 }
     },
@@ -41,7 +41,7 @@
       "id": "summary",
       "type": "reduce",
       "from": ["review"],
-      "dependsOn": ["review"],
+      "dependsOn": ["review", "implement"],
       "agent": "doc-writer",
       "task": "Write a short changelog entry summarizing what was done:\n\n{steps.implement.output}",
       "final": true

package/extensions/agents.ts

@@ -44,42 +44,56 @@ function loadAgentsFromDir(dir: string, source: "user" | "project"): AgentConfig
 	}
 
 	for (const entry of entries) {
-		if (!entry.name.endsWith(".md")) continue;
-		if (!entry.isFile() && !entry.isSymbolicLink()) continue;
-
-		const filePath = path.join(dir, entry.name);
-		let content: string;
 		try {
-			content = fs.readFileSync(filePath, "utf-8");
-		} catch {
-			continue;
-		}
+			if (!entry.name.endsWith(".md")) continue;
+			if (!entry.isFile() && !entry.isSymbolicLink()) continue;
 
-		const { frontmatter, body } = (() => {
+			const filePath = path.join(dir, entry.name);
+			let content: string;
 			try {
-				return parseFrontmatter<Record<string, string>>(content);
+				content = fs.readFileSync(filePath, "utf-8");
 			} catch {
-				// A single malformed agent file must not break discovery for every flow.
-				return { frontmatter: {} as Record<string, string>, body: "" };
+				continue;
 			}
-		})();
-		if (!frontmatter.name || !frontmatter.description) continue;
-
-		const tools = frontmatter.tools
-			?.split(",")
-			.map((t) => t.trim())
-			.filter(Boolean);
-
-		agents.push({
-			name: frontmatter.name,
-			description: frontmatter.description,
-			tools: tools && tools.length > 0 ? tools : undefined,
-			model: frontmatter.model,
-			thinking: frontmatter.thinking,
-			systemPrompt: body,
-			source,
-			filePath,
-		});
+
+			const { frontmatter, body } = (() => {
+				try {
+					return parseFrontmatter<Record<string, unknown>>(content);
+				} catch {
+					// A single malformed agent file must not break discovery for every flow.
+					return { frontmatter: {} as Record<string, unknown>, body: "" };
+				}
+			})();
+			if (!frontmatter.name || !frontmatter.description) continue;
+
+			// frontmatter is YAML-parsed: tools may be a comma-separated string ("a, b")
+			// OR a YAML sequence ([a, b]). Handle both forms.
+			const rawTools = frontmatter.tools;
+			const tools: string[] | undefined = Array.isArray(rawTools)
+				? rawTools.map((t) => String(t).trim()).filter(Boolean)
+				: rawTools !== undefined && rawTools !== null
+					? String(rawTools)
+							.split(",")
+							.map((t) => t.trim())
+							.filter(Boolean)
+					: undefined;
+
+			agents.push({
+				name: String(frontmatter.name),
+				description: String(frontmatter.description),
+				tools: tools && tools.length > 0 ? tools : undefined,
+				model: frontmatter.model === undefined ? undefined : String(frontmatter.model),
+				thinking: frontmatter.thinking === undefined ? undefined : String(frontmatter.thinking),
+				systemPrompt: body,
+				source,
+				filePath,
+			});
+		} catch {
+			// Defense-in-depth: a single bad agent file must not break discovery
+			// for the entire flow (e.g. exotic YAML shapes, runtime errors in
+			// field access, symlink races, etc.).
+			continue;
+		}
 	}
 	return agents;
 }
@@ -128,9 +142,15 @@ export function discoverAgents(
 		for (const [name, override] of Object.entries(overrides)) {
 			const agent = agentMap.get(name);
 			if (agent) {
-				if (override.model !== undefined) agent.model = override.model;
-				if (override.thinking !== undefined) agent.thinking = override.thinking;
-				if (override.tools !== undefined) agent.tools = override.tools;
+				// Clone before mutating: agentMap owns the original AgentConfig
+				// (loaded from disk in loadAgentsFromDir). Mutating it in place
+				// would cause cross-contamination for any caller that retains a
+				// reference and invokes discoverAgents again with different overrides.
+				const mutated: AgentConfig = { ...agent };
+				if (override.model !== undefined) mutated.model = override.model;
+				if (override.thinking !== undefined) mutated.thinking = override.thinking;
+				if (override.tools !== undefined) mutated.tools = override.tools;
+				agentMap.set(name, mutated);
 			}
 		}
 	}

package/extensions/index.ts

@@ -108,10 +108,6 @@ async function runFlow(
 	onUpdate: ((p: AgentToolResult<TaskflowDetails>) => void) | undefined,
 	existing?: RunState,
 ): Promise<RuntimeResult> {
-	const settings = readSubagentSettings();
-	const scope: AgentScope = def.agentScope ?? "user";
-	const { agents } = discoverAgents(ctx.cwd, scope, settings.agentOverrides);
-
 	const state = existing ?? makeRunState(def, args, ctx.cwd);
 
 	const emit = (s: RunState, finalOutput?: string) => {
@@ -166,6 +162,13 @@ async function runFlow(
 		: undefined;
 
 	try {
+		// Discover settings/agents inside try so a YAML/IO crash in
+		// discoverAgents or readSubagentSettings (F-001) is caught and
+		// the heartbeat timer is cleared by the finally block below.
+		const settings = readSubagentSettings();
+		const scope: AgentScope = def.agentScope ?? "user";
+		const { agents } = discoverAgents(ctx.cwd, scope, settings.agentOverrides);
+
 		const result = await executeTaskflow(state, {
 			cwd: ctx.cwd,
 			agents,
@@ -301,19 +304,28 @@ export default function (pi: ExtensionAPI) {
 							);
 					},
 				});
+				const warningText = v.warnings.length ? `\n\nWarnings:\n- ${v.warnings.join("\n- ")}` : "";
 				return {
 					content: [
-						{ type: "text", text: `Saved taskflow '${def.name}' → ${filePath}\nRun it with /tf:${def.name} or action=run.` },
+						{ type: "text", text: `Saved taskflow '${def.name}' → ${filePath}\nRun it with /tf:${def.name} or action=run.${warningText}` },
 					],
 					details: { action, message: filePath } satisfies TaskflowDetails,
 				};
 			}
 
 			// run
-			const v = validateTaskflow(def);
-			if (!v.ok) return errorResult(action, `Invalid taskflow:\n- ${v.errors.join("\n- ")}`);
 			const args = resolveArgs(def, params.args);
+			const v = validateTaskflow(def, { args, cwd: ctx.cwd });
+			if (!v.ok) return errorResult(action, `Invalid taskflow:\n- ${v.errors.join("\n- ")}`);
+			for (const w of v.warnings) {
+				console.warn(`[taskflow:${def.name}] ${w}`);
+			}
 			const result = await runFlow(def, args, ctx, signal, onUpdate as any);
+			// Surface the validation warnings in the tool result so the model
+			// can acknowledge or fix them, and the user sees them in the chat.
+			if (v.warnings.length) {
+				result.finalOutput = `${result.finalOutput}\n\nWarnings:\n- ${v.warnings.join("\n- ")}`;
+			}
 			return finalResult(action, result);
 		},
 

package/extensions/interpolate.ts

@@ -20,17 +20,20 @@ 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;
 	missing: string[];
 }
 
-export function interpolate(template: string, ctx: InterpolationContext): InterpolationResult {
+export function interpolate(
+	template: string | null | undefined,
+	ctx: InterpolationContext,
+): InterpolationResult {
 	const missing: string[] = [];
 
-	const text = template.replace(PLACEHOLDER, (whole, path: string) => {
+	const text = String(template ?? "").replace(PLACEHOLDER, (whole, path: string) => {
 		const value = resolvePath(path, ctx);
 		if (value === undefined) {
 			missing.push(path);
@@ -134,6 +137,24 @@ export function safeParse(text: string): unknown {
 			}
 		}
 	}
+	// Anti-pattern detection (v0.0.8.1): array followed by a stray top-level
+	// "key": value. A common LLM mistake — the model appends
+	// `"deferred": [...]` after a JSON array, producing a non-JSON hybrid that
+	// none of the above strategies can recover. We surface a diagnostic hint
+	// so flow authors can spot the bug fast.
+	//
+	// We check the original (trimmed) input rather than the slice tail,
+	// because `lastIndexOf(close)` lands on the *last* bracket — for the
+	// anti-pattern the stray key is between the array's `]` and the trailing
+	// `]`, not after the last one.
+	if (/]\s*[\},]?\s*"[^"\n]+"\s*:/.test(trimmed)) {
+		console.warn(
+			"[pi-taskflow safeParse] input looks like a JSON array followed by a stray top-level key " +
+				`(pattern: [{...}], "key": ...). This is not valid JSON. ` +
+				`Hint: put extra data as array members (e.g. {"id":"D-001","status":"deferred",...}) ` +
+				`or split into a separate phase.`,
+		);
+	}
 	return undefined;
 }
 
@@ -142,7 +163,7 @@ export function coerceArray(value: unknown): unknown[] | null {
 	if (Array.isArray(value)) return value;
 	if (value && typeof value === "object") {
 		// {items: [...]} or {results: [...]} convenience
-		for (const key of ["items", "results", "list", "data"]) {
+		for (const key of ["items", "results", "list", "data", "findings"]) {
 			const v = (value as Record<string, unknown>)[key];
 			if (Array.isArray(v)) return v;
 		}

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 "./usage.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,19 @@ 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 "";
+	const c = usage.cost;
+	return c >= 0.01
+		? theme.fg("muted", `$${c.toFixed(2)}`)
+		: theme.fg("muted", `$${c.toFixed(4)}`);
 }
 
 function aggregateCost(state: RunState): number {
@@ -118,7 +114,7 @@ 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" || type === "flow";
@@ -131,30 +127,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,20 +163,23 @@ 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(color as Parameters<typeof theme.fg>[0], theme.bold(d.toUpperCase()));
+		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 (cost) a += `  ${cost}`;
 		if (time) a += `  ${time}`;
+		if (ps.warnings?.length) a += theme.fg("warning", `  ⚠${ps.warnings.length}`);
 		return a;
 	}
 	if (ps.gate) {
@@ -187,16 +190,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. */
@@ -227,8 +232,8 @@ function headerLine(state: RunState, theme: Theme): string {
 	if (state.status === "blocked") line += theme.fg("error", " · blocked");
 	const cost = aggregateCost(state);
 	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)}`);
+	if (budget?.maxUSD !== undefined) line += theme.fg("muted", ` · $${cost >= 0.01 ? cost.toFixed(2) : cost.toFixed(4)}/$${budget.maxUSD}`);
+	else if (cost) line += theme.fg("muted", ` · $${cost >= 0.01 ? cost.toFixed(2) : cost.toFixed(4)}`);
 	const el = runElapsed(state);
 	if (el) line += theme.fg("dim", ` · ${elapsed(el)}`);
 	return line;