pi-dev-team 0.2.0

package/extensions/dev-team/lib/agents.ts

@@ -0,0 +1,272 @@
+/**
+ * Agent discovery and Claude Code -> pi mapping.
+ *
+ * Agent files keep their upstream Claude Code frontmatter unchanged:
+ *   name, description, tools ("Read, Grep, Glob, ..."), model (opus|sonnet|haiku|fable|inherit|provider/id),
+ *   effort (low|medium|high|...), skills (list), color, memory.
+ * They are mapped to pi at dispatch time.
+ *
+ * Lookup order (first wins):
+ *   <project>/.pi/agents, <project>/.claude/agents   (project overrides, e.g. /setup's activated templates)
+ *   <package>/agents                                  (upstream dev-team agents + port-provided Explore/general-purpose)
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parseFrontmatter } from "@earendil-works/pi-coding-agent";
+import { readSmallFile } from "./safe-read.ts";
+import type { AgentSource } from "./subagent-types.ts";
+
+export const DEV_TEAM_SUBAGENT_TOOL = "dev_team_subagent";
+
+export interface AgentDef {
+	name: string;
+	description: string;
+	/** Raw Claude tool list from frontmatter (undefined = all default tools). */
+	claudeTools?: string[];
+	/** Tier name or explicit provider/model id. */
+	model?: string;
+	effort?: string;
+	skills: string[];
+	body: string;
+	filePath: string;
+	source: AgentSource;
+}
+
+type AgentFrontmatter = {
+	name?: unknown;
+	description?: unknown;
+	tools?: unknown;
+	model?: unknown;
+	effort?: unknown;
+	skills?: unknown;
+};
+
+/** Split a Claude tools string on top-level commas: "Read, Bash(npx playwright *), Grep". */
+export function splitToolList(value: unknown): string[] | undefined {
+	if (Array.isArray(value)) return value.filter((v): v is string => typeof v === "string").map((v) => v.trim());
+	if (typeof value !== "string") return undefined;
+	const out: string[] = [];
+	let depth = 0;
+	let cur = "";
+	for (const ch of value) {
+		if (ch === "(") depth++;
+		if (ch === ")") depth = Math.max(0, depth - 1);
+		if (ch === "," && depth === 0) {
+			if (cur.trim()) out.push(cur.trim());
+			cur = "";
+		} else cur += ch;
+	}
+	if (cur.trim()) out.push(cur.trim());
+	return out.length ? out : undefined;
+}
+
+function toStringList(value: unknown): string[] {
+	if (Array.isArray(value)) return value.filter((v): v is string => typeof v === "string").map((v) => v.trim());
+	if (typeof value === "string") return value.split(",").map((v) => v.trim()).filter(Boolean);
+	return [];
+}
+
+export function parseAgentFile(filePath: string, source: AgentSource): AgentDef | undefined {
+	let content = readSmallFile(filePath);
+	if (content === undefined) return undefined;
+	// Upstream files sometimes have a blank line right after the opening '---'.
+	content = content.replace(/^---\r?\n\s*\r?\n/, "---\n");
+	let frontmatter: AgentFrontmatter;
+	let body: string;
+	try {
+		({ frontmatter, body } = parseFrontmatter<AgentFrontmatter>(content));
+	} catch {
+		return undefined;
+	}
+	if (typeof frontmatter.name !== "string" || typeof frontmatter.description !== "string") return undefined;
+	return {
+		name: frontmatter.name,
+		description: frontmatter.description,
+		claudeTools: splitToolList(frontmatter.tools),
+		model: typeof frontmatter.model === "string" ? frontmatter.model.trim() : undefined,
+		effort: typeof frontmatter.effort === "string" ? frontmatter.effort.trim() : undefined,
+		skills: toStringList(frontmatter.skills),
+		body,
+		filePath,
+		source,
+	};
+}
+
+function loadDir(dir: string, source: AgentSource): AgentDef[] {
+	let entries: fs.Dirent[];
+	try {
+		entries = fs.readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+	const out: AgentDef[] = [];
+	for (const e of entries) {
+		if (!e.name.endsWith(".md") || !(e.isFile() || e.isSymbolicLink())) continue;
+		const def = parseAgentFile(path.join(dir, e.name), source);
+		if (def) out.push(def);
+	}
+	return out;
+}
+
+/** Project agents (.pi/agents, .claude/agents) first, then the package's. Pass `includeProject: ctx.isProjectTrusted()`. */
+export function discoverAgents(cwd: string, packageRoot: string, opts: { includeProject: boolean }): Map<string, AgentDef> {
+	return byName([...(opts.includeProject ? loadProjectAgents(cwd) : []), ...loadDir(path.join(packageRoot, "agents"), "package")]);
+}
+
+function loadProjectAgents(cwd: string): AgentDef[] {
+	return [...loadDir(path.join(cwd, ".pi", "agents"), "project"), ...loadDir(path.join(cwd, ".claude", "agents"), "project")];
+}
+
+/** First definition of each name wins. */
+function byName(defs: AgentDef[]): Map<string, AgentDef> {
+	const map = new Map<string, AgentDef>();
+	for (const d of defs) if (!map.has(d.name)) map.set(d.name, d);
+	return map;
+}
+
+/** Requested agents that resolve to a project agent (.pi/agents, .claude/agents). */
+export function projectAgentsRequested(agents: Map<string, AgentDef>, requested: string[]): AgentDef[] {
+	const out = new Map<string, AgentDef>();
+	for (const name of requested) {
+		const def = resolveAgentName(agents, name);
+		if (def?.source === "project") out.set(def.filePath, def);
+	}
+	return [...out.values()];
+}
+
+/**
+ * Agents a dispatch may use. When pi reports the project untrusted (the user declined pi's trust
+ * prompt or ran with --no-approve), project agents are dropped and `skippedProjectAgents` names the
+ * requested ones, so the caller can say why they did not run. Each directory is read once.
+ */
+export function discoverDispatchAgents(
+	cwd: string,
+	packageRoot: string,
+	projectTrusted: boolean,
+	requested: string[],
+): { agents: Map<string, AgentDef>; skippedProjectAgents: string[] } {
+	const project = loadProjectAgents(cwd);
+	const packaged = loadDir(path.join(packageRoot, "agents"), "package");
+	const all = byName([...project, ...packaged]);
+	if (projectTrusted) return { agents: all, skippedProjectAgents: [] };
+	return { agents: byName(packaged), skippedProjectAgents: projectAgentsRequested(all, requested.filter(Boolean)).map((d) => d.name) };
+}
+
+/** Accept Claude-style qualified names ("dev-team:security-review") and case differences. */
+export function resolveAgentName(agents: Map<string, AgentDef>, requested: string): AgentDef | undefined {
+	const bare = requested.trim().replace(/^[\w-]+:/, "");
+	if (agents.has(bare)) return agents.get(bare);
+	const lower = bare.toLowerCase();
+	for (const [name, def] of agents) if (name.toLowerCase() === lower) return def;
+	return undefined;
+}
+
+const CLAUDE_TO_PI_TOOL: Record<string, string[]> = {
+	read: ["read"],
+	grep: ["grep"],
+	glob: ["find", "ls"],
+	ls: ["ls"],
+	bash: ["bash"],
+	edit: ["edit"],
+	multiedit: ["edit"],
+	write: ["write"],
+	notebookedit: ["edit"],
+	skill: ["skill"],
+	agent: [DEV_TEAM_SUBAGENT_TOOL],
+	task: [DEV_TEAM_SUBAGENT_TOOL],
+	askuserquestion: ["ask_user"],
+	webfetch: ["web_fetch"],
+	todowrite: [],
+	websearch: [],
+};
+
+export interface ToolMapping {
+	tools: string[];
+	/** Claude entries with no pi equivalent (reported, not fatal). */
+	unmapped: string[];
+	/** Scoped Bash grants like "Bash(npx playwright *)" — pi cannot scope bash; recorded for the prompt. */
+	scopedBash: string[];
+}
+
+/** Rewrite a Claude-plugin MCP tool name to pi's `mcp__<server>__<tool>` naming. */
+function normaliseMcpName(name: string): string {
+	// Claude plugin-provided servers are named mcp__plugin_<plugin>_<server>__tool.
+	const m = name.match(/^mcp__plugin_[^_]+(?:_[^_]+)*?_([^_]+)__(.+)$/);
+	if (m) return `mcp__${m[1]}__${m[2]}`;
+	return name;
+}
+
+function globToRegex(glob: string): RegExp {
+	return new RegExp(`^${glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`);
+}
+
+/**
+ * Map a Claude tool list to pi tool names.
+ * @param available names of tools registered in the parent pi session (for MCP pattern expansion)
+ */
+export function mapTools(claudeTools: string[] | undefined, available: string[]): ToolMapping | undefined {
+	if (!claudeTools) return undefined;
+	const tools = new Set<string>();
+	const unmapped: string[] = [];
+	const scopedBash: string[] = [];
+	for (const raw of claudeTools) {
+		const entry = raw.trim();
+		if (!entry) continue;
+		if (entry.startsWith("mcp__")) {
+			const re = globToRegex(normaliseMcpName(entry));
+			const hits = available.filter((t) => re.test(t));
+			for (const h of hits) tools.add(h);
+			if (hits.length && available.includes("codemode")) tools.add("codemode");
+			continue;
+		}
+		const scoped = entry.match(/^(\w+)\((.*)\)$/s);
+		const base = (scoped ? scoped[1] : entry).toLowerCase();
+		if (scoped && base === "bash") scopedBash.push(scoped[2]);
+		const mapped = CLAUDE_TO_PI_TOOL[base];
+		if (mapped === undefined) {
+			// Already a pi tool name?
+			if (available.includes(entry)) tools.add(entry);
+			else unmapped.push(entry);
+			continue;
+		}
+		for (const t of mapped) tools.add(t);
+	}
+	return { tools: [...tools], unmapped, scopedBash };
+}
+
+export interface ModelChoice {
+	/** provider/id to pass to --model, or undefined to inherit. */
+	model?: string;
+	/** Tier label for reporting (opus/sonnet/haiku/...). */
+	tier?: string;
+}
+
+/**
+ * Resolve an agent's model. `override` (per call) beats frontmatter.
+ * Tier names go through the config table; "inherit" or an unmapped tier inherits the parent's model.
+ */
+export function resolveModel(
+	frontmatterModel: string | undefined,
+	override: string | undefined,
+	tiers: Record<string, string>,
+	parentModel: string | undefined,
+): ModelChoice {
+	const wanted = (override || frontmatterModel || "inherit").trim();
+	if (wanted.includes("/")) return { model: wanted };
+	const tier = wanted.toLowerCase();
+	if (tier === "inherit") return { model: parentModel, tier: "inherit" };
+	const mapped = tiers[tier];
+	if (!mapped || mapped === "inherit") return { model: parentModel, tier };
+	return { model: mapped, tier };
+}
+
+export function resolveThinking(
+	effort: string | undefined,
+	override: string | undefined,
+	table: Record<string, string>,
+	parentThinking: string | undefined,
+): string | undefined {
+	const wanted = (override || effort || "").trim().toLowerCase();
+	if (!wanted) return parentThinking;
+	return table[wanted] ?? parentThinking;
+}

package/extensions/dev-team/lib/ai-credits.ts

@@ -0,0 +1,92 @@
+/**
+ * GitHub Copilot AI credits: what Copilot bills for model use, shown next to pi's USD cost.
+ *
+ * Copilot prices models per token and converts the total at 1 AI credit = $0.01 USD
+ * (docs.github.com/en/copilot/reference/copilot-billing/models-and-pricing). pi's catalog prices the
+ * `github-copilot` provider at those same per-token rates (checked against pi-ai's catalog for 11
+ * models, long-context tiers included, in October 2026), so a Copilot run's credits are its USD cost
+ * x 100: exact by formula (tokens x GitHub's per-token rates / $0.01). The figures are gross usage:
+ * they do not subtract a plan's monthly allowance.
+ */
+import { costUsd, type PiUsage, positiveFiniteOrZero, providerOf, sessionSpend } from "./session-spend.ts";
+
+export const COPILOT_PROVIDER = "github-copilot";
+export const CREDITS_PER_USD = 100;
+/** The finest precision shown; a session below it shows no status line. */
+const FINEST_DIGITS = 2;
+
+/** True for a "provider/model" id served by GitHub Copilot. */
+export function isCopilotModel(model: string | undefined): boolean {
+	return !!model && providerOf(model) === COPILOT_PROVIDER;
+}
+
+/** The AI credits of `usd` spent on `model`: x 100 when Copilot served it, else 0. The one place the conversion lives. */
+export function creditsFor(model: string | undefined, usd: number): number {
+	return isCopilotModel(model) ? usd * CREDITS_PER_USD : 0;
+}
+
+/** One run's AI credits, from its cost; a cost that is not a positive number counts as none. */
+export function runAiCredits(run: { model?: string; usage: PiUsage }): number {
+	return creditsFor(run.model, positiveFiniteOrZero(costUsd(run.usage)));
+}
+
+/**
+ * Where "this month" starts for /dev-team usage, for every provider: the 1st at 00:00 UTC, the
+ * calendar month in UTC. It is the same instant GitHub starts a Copilot billing period, so the
+ * month's AI credits line up with GitHub's.
+ */
+export const usageMonthStart = (now: Date): Date => copilotBillingPeriodStart(now);
+
+/** The AI credits of the runs served by Copilot; every other run counts 0. */
+export function runsAiCredits(runs: Iterable<{ model?: string; usage: PiUsage }>): number {
+	return Array.from(runs).reduce((credits, run) => credits + runAiCredits(run), 0);
+}
+
+/** Decimal places for a credits value: 2 below 10, 1 below 1000, else 0, judged after rounding. */
+function creditDigits(credits: number): number {
+	if (Number(credits.toFixed(FINEST_DIGITS)) < 10) return FINEST_DIGITS;
+	return Number(credits.toFixed(1)) < 1000 ? 1 : 0;
+}
+
+/** "0.12", "12.3", "1,234": a credits value without its unit, fewer decimals as the number grows. */
+export function formatCredits(credits: number): string {
+	const digits = creditDigits(credits);
+	// Print the value the tier was judged on: Intl rounds some halves the other way than toFixed.
+	const shown = Number(credits.toFixed(digits));
+	return shown.toLocaleString("en-US", { minimumFractionDigits: digits, maximumFractionDigits: digits });
+}
+
+/** "0.12 AI credits", "12.3 AI credits", "1,234 AI credits": fewer decimals as the number grows. */
+export function formatAiCredits(credits: number): string {
+	return `${formatCredits(credits)} AI credits`;
+}
+
+/**
+ * The session's Copilot AI credits (every branch, like pi's footer): the main thread's turns, every
+ * dispatched agent (nested ones included) and pi's other usage entries such as cache warming, each
+ * counted when a Copilot model served it.
+ */
+export function sessionAiCredits(entries: readonly Record<string, unknown>[]): number {
+	return runsAiCredits(sessionSpend(entries));
+}
+
+/**
+ * The first instant of the Copilot billing period `now` falls in, in UTC. GitHub's docs
+ * (https://docs.github.com/en/copilot/concepts/billing/copilot-requests, checked 2026-10-04) state
+ * "Premium request counters reset on the 1st of each month at 00:00:00 UTC"; we assume AI credit
+ * allowances follow the same period. Local time would put the boundary hours off for anyone not on UTC.
+ */
+export function copilotBillingPeriodStart(now: Date): Date {
+	return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
+}
+
+/** False while `credits` round to 0.00: the one test of "no Copilot spend" the status line, overlay and summary share. */
+export function hasVisibleCredits(credits: number): boolean {
+	return Number(credits.toFixed(FINEST_DIGITS)) > 0;
+}
+
+/** The status line text, or undefined (hidden) while the session's credits round to 0.00. */
+export function aiCreditsStatus(entries: readonly Record<string, unknown>[]): string | undefined {
+	const credits = sessionAiCredits(entries);
+	return hasVisibleCredits(credits) ? `GitHub Copilot: ${formatAiCredits(credits)}` : undefined;
+}

package/extensions/dev-team/lib/autocompact.ts

@@ -0,0 +1,81 @@
+/**
+ * Autocompact: dev-team v14 replaced its context ceiling guard with the harness's own compaction at
+ * CLAUDE_AUTOCOMPACT_PCT_OVERRIDE percent (written by /setup via scripts/set_autocompact_env.py).
+ * pi only compacts at `contextWindow - reserveTokens`, so the extension lowers that to the configured
+ * percentage, measured with ctx.getContextUsage(), which knows every model's window.
+ */
+import * as os from "node:os";
+import * as path from "node:path";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { readSmallFile } from "./safe-read.ts";
+
+export const AUTOCOMPACT_KEY = "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE";
+/** Plain integer 1-100: no sign, no whitespace, no decimal point, no leading zero (as upstream). */
+const PCT_RE = /^(?:100|[1-9][0-9]?)$/;
+
+export interface AutocompactSetting {
+	/** Valid threshold 1-100, or undefined when absent or invalid. */
+	thresholdPct?: number;
+	/** Where the first definition was found, as upstream labels it (shown in diagnostics and tests). */
+	origin?: string;
+}
+
+function envBlock(file: string): Record<string, unknown> | undefined {
+	const text = readSmallFile(file);
+	if (text === undefined) return undefined;
+	try {
+		const data = JSON.parse(text);
+		return data && typeof data === "object" && data.env && typeof data.env === "object" && !Array.isArray(data.env) ? data.env : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/**
+ * Same precedence as upstream hooks/lib/autocompact_config.py `detect`: process env,
+ * `.claude/settings.local.json`, `.claude/settings.json`, then user settings. The first source that
+ * defines the key decides. Project files are skipped when the project is not trusted in pi.
+ */
+export function autocompactSetting(
+	projectDir: string,
+	opts: { env?: NodeJS.ProcessEnv; projectTrusted: boolean },
+): AutocompactSetting {
+	const env = opts.env ?? process.env;
+	const settingFrom = (raw: unknown, origin: string): AutocompactSetting => ({
+		thresholdPct: typeof raw === "string" && PCT_RE.test(raw) ? Number(raw) : undefined,
+		origin,
+	});
+	if (env[AUTOCOMPACT_KEY] !== undefined) return settingFrom(env[AUTOCOMPACT_KEY], "process env");
+	const userSettings = env.CLAUDE_CONFIG_DIR
+		? path.join(env.CLAUDE_CONFIG_DIR, "settings.json")
+		: path.join(env.HOME || os.homedir(), ".claude", "settings.json");
+	const candidates: [string, string][] = [
+		...(!opts.projectTrusted
+			? []
+			: ([
+					["settings.local.json", path.join(projectDir, ".claude", "settings.local.json")],
+					["settings.json", path.join(projectDir, ".claude", "settings.json")],
+				] as [string, string][])),
+		["user settings.json", userSettings],
+	];
+	for (const [label, file] of candidates) {
+		const block = envBlock(file);
+		if (block && AUTOCOMPACT_KEY in block) return settingFrom(block[AUTOCOMPACT_KEY], label);
+	}
+	return {};
+}
+
+/**
+ * The threshold and current usage when the session should compact now, else undefined. Unconfigured
+ * repos keep pi's default (and get the autocompact_setup_nudge advisory at session start).
+ */
+export function autocompactDue(
+	ctx: Pick<ExtensionContext, "cwd" | "getContextUsage" | "isProjectTrusted">,
+	env: NodeJS.ProcessEnv = process.env,
+): { thresholdPct: number; usedPct: number } | undefined {
+	const { thresholdPct } = autocompactSetting(ctx.cwd, { env, projectTrusted: ctx.isProjectTrusted() });
+	if (thresholdPct === undefined) return undefined;
+	const usage = ctx.getContextUsage();
+	if (!usage || usage.percent == null) return undefined;
+	return usage.percent >= thresholdPct ? { thresholdPct, usedPct: usage.percent } : undefined;
+}

package/extensions/dev-team/lib/child-run.ts

@@ -0,0 +1,102 @@
+/**
+ * Folds a child pi's `--mode json` event stream into what the dispatch tool reports: messages for the
+ * synthetic transcript, the child's own usage, the spend of agents it dispatched itself (credited to
+ * those agents), and the progress fields the TUI shows. Pure apart from mutating the state it is given.
+ */
+import type { Usage } from "@earendil-works/pi-ai";
+import { DEV_TEAM_SUBAGENT_TOOL } from "./agents.ts";
+import {
+	addPiUsage,
+	creditedRuns,
+	emptyPiUsage,
+	type NestedUsage,
+	type ProgressPatch,
+	type SubagentDetails,
+	type SubagentTaskView,
+	type ToolCallSummary,
+	toUsageTotals,
+} from "./subagent-types.ts";
+import type { PiMessageLike } from "./transcript.ts";
+
+const RECENT_CALLS_KEPT = 8;
+/** Arguments the progress view shows, by name; anything else in a call is not kept. */
+const SHOWN_ARGS = ["command", "pattern", "path", "file_path", "url", "name", "agent", "subagent_type"] as const;
+const SHOWN_ARG_CHARS = 200;
+
+/** The parts of a tool call the progress view needs, each argument one line and bounded. */
+export function summarizeToolCall(name: string, args: unknown): ToolCallSummary {
+	const record = (args && typeof args === "object" ? args : {}) as Record<string, unknown>;
+	const shown: Record<string, string> = {};
+	for (const key of SHOWN_ARGS) {
+		const value = record[key];
+		if (typeof value === "string" && value.trim()) shown[key] = value.replace(/\s+/g, " ").trim().slice(0, SHOWN_ARG_CHARS);
+	}
+	if (Array.isArray(record.tasks)) shown.tasks = String(record.tasks.length);
+	return Object.keys(shown).length ? { name, args: shown } : { name };
+}
+
+export interface ChildEvent {
+	type?: string;
+	message?: PiMessageLike & { errorMessage?: string; provider?: string; toolName?: string; details?: unknown };
+}
+
+export interface ChildRunState {
+	messages: PiMessageLike[];
+	/** Usage of the child's own assistant turns (and of tool results other than dev-team dispatch). */
+	own: Usage;
+	/** Everything, including nested dev-team dispatches: what pi should add to session totals. */
+	total: Usage;
+	nested: NestedUsage[];
+	turns: number;
+	recentCalls: ToolCallSummary[];
+	model?: string;
+	stopReason?: string;
+	errorMessage?: string;
+}
+
+export function newChildRunState(model?: string): ChildRunState {
+	return { messages: [], own: emptyPiUsage(), total: emptyPiUsage(), nested: [], turns: 0, recentCalls: [], model };
+}
+
+/** Usage of the agents a nested dev_team_subagent result ran, each with its own nested runs. */
+function nestedUsageOf(details: unknown): NestedUsage[] {
+	const results = (details as SubagentDetails | undefined)?.results;
+	if (!Array.isArray(results)) return [];
+	return results.flatMap((v: SubagentTaskView) => creditedRuns({ ...v, nested: Array.isArray(v.nested) ? v.nested : undefined }));
+}
+
+/**
+ * Apply one event. Returns the progress patch to show when the event changed it. pi's json mode
+ * reports every finished message, tool results included, as `message_end`; other events carry nothing
+ * this needs.
+ */
+export function applyChildEvent(state: ChildRunState, ev: ChildEvent): ProgressPatch | undefined {
+	const m = ev.message;
+	if (ev.type !== "message_end" || !m) return undefined;
+	if (m.role === "assistant") {
+		state.messages.push(m);
+		state.turns++;
+		addPiUsage(state.own, m.usage as Partial<Usage> | undefined);
+		addPiUsage(state.total, m.usage as Partial<Usage> | undefined);
+		if (m.model) state.model = m.provider ? `${m.provider}/${m.model}` : m.model;
+		if (m.stopReason) state.stopReason = m.stopReason;
+		if (m.errorMessage) state.errorMessage = m.errorMessage;
+		const calls = Array.isArray(m.content)
+			? (m.content as { type: string; name?: string; arguments?: unknown }[])
+					.filter((c) => c.type === "toolCall" && !!c.name)
+					.map((c) => summarizeToolCall(c.name as string, c.arguments))
+			: [];
+		state.recentCalls = [...state.recentCalls, ...calls].slice(-RECENT_CALLS_KEPT);
+		return { turns: state.turns, recentCalls: state.recentCalls, model: state.model, usage: toUsageTotals(state.own, state.turns) };
+	}
+	if (m.role === "toolResult") {
+		state.messages.push(m);
+		const usage = m.usage as Partial<Usage> | undefined;
+		addPiUsage(state.total, usage);
+		// A nested dev-team dispatch reports its agents' spend; credit those agents, not this child.
+		const runs = m.toolName === DEV_TEAM_SUBAGENT_TOOL ? nestedUsageOf(m.details) : [];
+		if (runs.length) state.nested = [...state.nested, ...runs];
+		else addPiUsage(state.own, usage);
+	}
+	return undefined;
+}