@selesai/code 0.13.31 → 0.13.33

package/dist/extensions/pi-subagents/src/runs/foreground/execution.ts

@@ -71,7 +71,7 @@ import { deriveChildSessionName } from "../../shared/child-session-name.ts";
 import { assertAgentAllowedByCapabilityCeiling, intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling } from "../shared/capability-ceiling.ts";
 import { resolveEffectiveThinking } from "../../shared/model-info.ts";
 import { assertThinkingWithinCeiling, intersectThinkingCeilings } from "../../shared/thinking-ceiling.ts";
-import { MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR, MISSING_STRUCTURED_OUTPUT_CALL_ERROR } from "../shared/structured-output.ts";
+import { formatStructuredOutputRejectionError, MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR, MISSING_STRUCTURED_OUTPUT_CALL_ERROR } from "../shared/structured-output.ts";
 import { formatMidToolExitError, isOrdinaryToolForMidToolExit } from "../shared/process-signal.ts";
 import { formatChildToolDiagnostic } from "../shared/tool-availability.ts";
 import { buildTimeoutRecoverySummary, collectTrackedMutationEvidence, snapshotTrackedMutations } from "../shared/mutation-evidence.ts";
@@ -1431,10 +1431,14 @@ async function runSingleAttempt(
 		result.structuredOutputSchemaPath = options.structuredOutput.schemaPath;
 		result.structuredOutputPath = options.structuredOutput.outputPath;
 		const structured = capture.structuredOutput();
-		if (!structuredOutputToolInvoked || !structured.called) {
+		if (!structuredOutputToolInvoked) {
 			result.exitCode = 1;
 			result.error = MISSING_STRUCTURED_OUTPUT_CALL_ERROR;
 			result.structuredOutputFailed = true;
+		} else if (!structured.called) {
+			result.exitCode = 1;
+			result.error = formatStructuredOutputRejectionError(result.messages ?? []);
+			result.structuredOutputFailed = true;
 		} else {
 			result.structuredOutput = structured.value;
 			const acceptanceMode = options.structuredOutput.acceptanceReportPath

package/dist/extensions/pi-subagents/src/runs/shared/child-tool-plan.ts

@@ -30,6 +30,17 @@ import {
 } from "./capability-ceiling.ts";
 
 const MAX_LAUNCH_RESOLVED_EXTENSION_IDS = 32;
+export const CAPABILITY_GATEWAY_EXTENSION_PATH = path.join(
+	path.dirname(fileURLToPath(import.meta.url)),
+	"..",
+	"..",
+	"..",
+	"..",
+	"capability-gateway",
+	"index.ts",
+);
+const CAPABILITY_GATEWAY_TOOL_NAMES = ["capability_catalog", "capability_discover", "capability_skill_show"] as const;
+const CAPABILITY_GATEWAY_ENABLED_ENV = "SELESAI_CAPABILITY_GATEWAY";
 const PROMPT_RUNTIME_EXTENSION_PATH = path.join(
 	path.dirname(fileURLToPath(import.meta.url)),
 	"subagent-prompt-runtime.ts",
@@ -172,6 +183,8 @@ export interface PiLaunchToolPlan {
 	extensionArgs: string[];
 	disableAmbientExtensions: boolean;
 	capabilityAudit?: SubagentCapabilityAudit;
+	/** Whether the capability gateway is loaded for this child's permitted extension/tool policy. */
+	capabilityGatewayEnabled: boolean;
 	/** Non-fatal launch warnings; they do not change behavior. */
 	warnings: string[];
 }
@@ -195,6 +208,14 @@ function hasPermissionRules(rules: PermissionRules | undefined): boolean {
 	return rules !== undefined && Object.keys(rules).length > 0;
 }
 
+function isCapabilityGatewayExtensionPath(value: string, cwd?: string): boolean {
+	const resolved = path.normalize(path.resolve(cwd ?? process.cwd(), value));
+	return (
+		resolved === path.normalize(CAPABILITY_GATEWAY_EXTENSION_PATH) ||
+		resolved === path.normalize(path.dirname(CAPABILITY_GATEWAY_EXTENSION_PATH))
+	);
+}
+
 /**
  * Children are pi sessions inside the parent or the runner process; a spawned
  * `pi` received extra MCP server definitions as a CLI argument, but a session
@@ -330,6 +351,9 @@ export function resolvePiLaunchToolPlan(
 		!excludedToolSet.has("subagent") &&
 		(!allowedToolSet || allowedToolSet.has("subagent"))
 	);
+	if (effectiveDeclaredBuiltinTools.includes("subagent_supervisor") && !fanoutAuthorized) {
+		throw new Error("Tool 'subagent_supervisor' requires fanout authorization: include 'subagent' in the effective tools allowlist or enable allowNestedSubagents.");
+	}
 	const toolExtensionPaths: string[] = capabilityCeiling?.denyExtensions
 		? []
 		: (input.tools ?? []).filter(
@@ -363,13 +387,41 @@ export function resolvePiLaunchToolPlan(
 		(input.mcpDirectTools?.length ?? 0) > 0 ||
 		allowedToolSet !== undefined;
 	const internalTools = (input.structuredOutput ? ["structured_output"] : []).filter((tool) => !excludedToolSet.has(tool));
-	const effectiveToolAllowlist = [
+	const baseEffectiveToolAllowlist = [
 		...new Set([
 			...effectiveDeclaredBuiltinTools,
 			...effectiveMcpTools,
 			...internalTools,
 		]),
 	];
+	const explicitlyNoTools =
+		explicitToolAllowlist &&
+		effectiveDeclaredBuiltinTools.length === 0 &&
+		effectiveMcpTools.length === 0;
+	const gatewayExplicitlyConfigured = [
+		...toolExtensionPaths,
+		...(input.extensions ?? []),
+		...(input.subagentOnlyExtensions ?? []),
+	].some((extensionPath) => isCapabilityGatewayExtensionPath(extensionPath, input.cwd));
+	const gatewayExtensionPolicyAllows =
+		capabilityCeiling?.denyExtensions !== true &&
+		fs.existsSync(CAPABILITY_GATEWAY_EXTENSION_PATH) &&
+		(input.extensions === undefined || gatewayExplicitlyConfigured);
+	const permittedGatewayTools = CAPABILITY_GATEWAY_TOOL_NAMES.filter(
+		(name) => (!allowedToolSet || allowedToolSet.has(name)) && !excludedToolSet.has(name),
+	);
+	const capabilityGatewayEnabled =
+		gatewayExtensionPolicyAllows &&
+		!explicitlyNoTools &&
+		permittedGatewayTools.length > 0 &&
+		process.env[CAPABILITY_GATEWAY_ENABLED_ENV] !== "0";
+	const gatewayTools = capabilityGatewayEnabled ? permittedGatewayTools : [];
+	const effectiveToolAllowlist = [
+		...new Set([
+			...baseEffectiveToolAllowlist,
+			...(explicitToolAllowlist ? gatewayTools : []),
+		]),
+	];
 	// Supervisor-coordination names stay in the --tools allowlist but are never
 	// strict requirements: children register contact_supervisor at runtime through
 	// the native supervisor channel (or pi-intercom). The pre-0.50 bridge always
@@ -383,6 +435,7 @@ export function resolvePiLaunchToolPlan(
 					...(input.tools !== undefined ? effectiveDeclaredBuiltinTools : []),
 					...(input.mcpDirectTools?.length ? effectiveMcpTools : []),
 					...internalTools,
+					...gatewayTools,
 				].filter((tool) => tool !== "contact_supervisor" && (!legacySupervisorPairing || tool !== "intercom"))),
 			]
 		: [];
@@ -395,6 +448,9 @@ export function resolvePiLaunchToolPlan(
 	const fastModeExtensions = resolveFastModeExtension({ fast: input.fast, model: input.model, modelCandidates: input.modelCandidates, agentName: input.agentName });
 	const runtimeExtensions = [
 		PROMPT_RUNTIME_EXTENSION_PATH,
+		...(capabilityGatewayEnabled && !gatewayExplicitlyConfigured
+			? [CAPABILITY_GATEWAY_EXTENSION_PATH]
+			: []),
 		...fastModeExtensions,
 		...(fanoutAuthorized ? [FANOUT_CHILD_EXTENSION_PATH] : []),
 		...(permSystemExt ? [permSystemExt] : []),
@@ -412,20 +468,25 @@ export function resolvePiLaunchToolPlan(
 				+ "List the extensions this child actually needs instead of an empty array.",
 		);
 	}
+	const gatewayFilteredExtensions = (extensions: string[]) =>
+		extensions.filter(
+			(extensionPath) =>
+				!isCapabilityGatewayExtensionPath(extensionPath, input.cwd) || capabilityGatewayEnabled,
+		);
 	const configuredExtensions = capabilityCeiling?.denyExtensions
 		? []
-		: [
+		: gatewayFilteredExtensions([
 				...toolExtensionPaths,
 				...(input.extensions ?? []),
 				...(input.subagentOnlyExtensions ?? []),
-			];
+			]);
 	const extensionArgs = disableAmbientExtensions
 		? [...new Set([...runtimeExtensions, ...configuredExtensions])]
 		: [
 				...new Set([
 					...runtimeExtensions,
-					...toolExtensionPaths,
-					...(input.subagentOnlyExtensions ?? []),
+					...gatewayFilteredExtensions(toolExtensionPaths),
+					...gatewayFilteredExtensions(input.subagentOnlyExtensions ?? []),
 				]),
 			];
 	const requestedToolNames =
@@ -494,6 +555,7 @@ export function resolvePiLaunchToolPlan(
 		configuredExtensions,
 		extensionArgs,
 		disableAmbientExtensions,
+		capabilityGatewayEnabled,
 		warnings,
 		...(capabilityAudit ? { capabilityAudit } : {}),
 	};

package/dist/extensions/pi-subagents/src/runs/shared/completion-guard.ts

@@ -17,6 +17,12 @@ const READ_ONLY_BUILTIN_TOOLS = new Set([
 	"intercom",
 	"contact_supervisor",
 	"structured_output",
+	// Gateway controls only search, activate, or load capabilities; activation stays
+	// filtered by the child's own tool policy, so they are not mutation-capable.
+	// Kept literal: child-tool-plan transitively imports this module (via single-output).
+	"capability_catalog",
+	"capability_discover",
+	"capability_skill_show",
 ]);
 
 // Cursor native edit/write often land as thinking traces (inactive_trace /

package/dist/extensions/pi-subagents/src/runs/shared/external-cli-runner.ts

@@ -6,6 +6,7 @@ import { finished } from "node:stream/promises";
 import type { ExternalProcessStatus } from "../../shared/types.ts";
 import { createOwnedProcessTreeController, type OwnedProcessTreeController } from "../background/owned-process-tree.ts";
 import { omitExtensionBindingsEnv } from "./extension-bindings.ts";
+import { omitGitRoutingEnv } from "./git-environment.ts";
 import {
 	invalidateExternalCliPreflight,
 	preflightExternalCli,
@@ -86,7 +87,7 @@ function narrowLimit(value: number | undefined, ceiling: number, label: string):
 }
 
 function externalEnvironment(allowlist: readonly string[] | undefined, values: Readonly<Record<string, string>> | undefined): NodeJS.ProcessEnv {
-	if (!allowlist) return omitExtensionBindingsEnv(process.env);
+	if (!allowlist) return omitGitRoutingEnv(omitExtensionBindingsEnv(process.env));
 	const allowed = new Set(allowlist);
 	const env: NodeJS.ProcessEnv = {};
 	for (const key of allowed) {

package/dist/extensions/pi-subagents/src/runs/shared/git-environment.ts

@@ -0,0 +1,29 @@
+// ponytail: this static list can lag Git additions; refresh from `git rev-parse --local-env-vars` and indexed config keys when Git changes.
+const GIT_ROUTING_VARIABLES = new Set([
+	"GIT_ALTERNATE_OBJECT_DIRECTORIES",
+	"GIT_COMMON_DIR",
+	"GIT_CONFIG",
+	"GIT_CONFIG_COUNT",
+	"GIT_CONFIG_PARAMETERS",
+	"GIT_DIR",
+	"GIT_GRAFT_FILE",
+	"GIT_IMPLICIT_WORK_TREE",
+	"GIT_INDEX_FILE",
+	"GIT_NAMESPACE",
+	"GIT_NO_REPLACE_OBJECTS",
+	"GIT_OBJECT_DIRECTORY",
+	"GIT_PREFIX",
+	"GIT_REPLACE_REF_BASE",
+	"GIT_SHALLOW_FILE",
+	"GIT_WORK_TREE",
+]);
+
+function isGitRoutingVariable(name: string): boolean {
+	const upper = name.toUpperCase();
+	return GIT_ROUTING_VARIABLES.has(upper) || /^GIT_CONFIG_(?:KEY|VALUE)_\d+$/.test(upper);
+}
+
+/** Remove inherited values that can route Git commands away from the child cwd. */
+export function omitGitRoutingEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
+	return Object.fromEntries(Object.entries(env).filter(([name]) => !isGitRoutingVariable(name)));
+}

package/dist/extensions/pi-subagents/src/runs/shared/structured-output.ts

@@ -3,12 +3,81 @@ import { createRequire } from "node:module";
 import * as os from "node:os";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
+import type { Message } from "@earendil-works/pi-ai";
 import { SELESAI_CODING_AGENT_PACKAGE_ROOT_ENV } from "../../shared/utils.ts";
 import type { JsonSchemaObject } from "../../shared/types.ts";
 import type { ResolvedAcceptanceReportMode } from "./acceptance.ts";
 
 export const MISSING_STRUCTURED_OUTPUT_CALL_ERROR = "Missing structured_output call; this step has outputSchema and must finish by calling structured_output.";
 export const MISSING_STRUCTURED_ACCEPTANCE_REPORT_ERROR = "Missing acceptanceReport in structured_output call; acceptance.report is \"on\".";
+export const STRUCTURED_OUTPUT_REJECTION_ERROR = "structured_output was invoked but no valid output was captured.";
+export const INVALID_STRUCTURED_OUTPUT_SCHEMA_ERROR = "Structured output invocation was rejected: invalid outputSchema.";
+export const STRUCTURED_OUTPUT_VALIDATOR_UNAVAILABLE_ERROR = "Structured output invocation was rejected: validator unavailable.";
+export const MAX_STRUCTURED_OUTPUT_REJECTION_ERROR_BYTES = 4096;
+
+function utf8Prefix(value: string, maxBytes: number): string {
+	if (Buffer.byteLength(value, "utf8") <= maxBytes) return value;
+	const suffix = "...";
+	const contentLimit = maxBytes - Buffer.byteLength(suffix, "utf8");
+	let bytes = 0;
+	let result = "";
+	for (const character of value) {
+		const characterBytes = Buffer.byteLength(character, "utf8");
+		if (bytes + characterBytes > contentLimit) break;
+		result += character;
+		bytes += characterBytes;
+	}
+	return result + suffix;
+}
+
+function messageText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	return content
+		.filter((part): part is { type: "text"; text: string } => Boolean(part) && typeof part === "object" && (part as { type?: unknown }).type === "text" && typeof (part as { text?: unknown }).text === "string")
+		.map((part) => part.text)
+		.join("\n");
+}
+
+function sanitizeStructuredOutputRejection(text: string): string {
+	const withoutControls = text.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "");
+	if (/invalid outputSchema(?:\s*:|$)/i.test(withoutControls)) return INVALID_STRUCTURED_OUTPUT_SCHEMA_ERROR;
+	if (/failed to validate structured output:|cannot load typebox\/compile/i.test(withoutControls)) return STRUCTURED_OUTPUT_VALIDATOR_UNAVAILABLE_ERROR;
+	const validationMarker = "Structured output validation failed:";
+	const markerIndex = withoutControls.indexOf(validationMarker);
+	const diagnostic = markerIndex >= 0 ? withoutControls.slice(markerIndex) : withoutControls;
+	const lines = diagnostic.split(/\r?\n/).filter((line) => {
+		const trimmed = line.trim();
+		return trimmed.length > 0
+			&& !/^at\s/.test(trimmed)
+			&& !/^(?:arguments?|parameters?|submitted value|input|outputSchema|schema|stack)\s*:/i.test(trimmed);
+	});
+	const sanitized = lines.join("\n")
+		.replace(/\b(received|actual|got)(?:\s+value)?\s*[:=]\s*(?:\"(?:[^\"\\\\]|\\\\.)*\"|'(?:[^'\\\\]|\\\\.)*'|\{[^\n]*\}|\[[^\n]*\]|\S+)/gi, "$1: [redacted]")
+		.trim();
+	return sanitized || STRUCTURED_OUTPUT_REJECTION_ERROR;
+}
+
+/** Returns bounded evidence from the latest failed structured_output result in a terminal transcript. */
+export function formatStructuredOutputRejectionError(messages: readonly Message[]): string {
+	const toolCallIds = new Set<string>();
+	for (const message of messages) {
+		if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
+		for (const part of message.content) {
+			const call = part as { type?: unknown; id?: unknown; name?: unknown };
+			if (call.type === "toolCall" && call.name === "structured_output" && typeof call.id === "string") toolCallIds.add(call.id);
+		}
+	}
+	for (let index = messages.length - 1; index >= 0; index--) {
+		const message = messages[index] as Message & { toolCallId?: unknown; toolName?: unknown; isError?: unknown };
+		if (message.role !== "toolResult" || message.isError !== true) continue;
+		const matchingName = message.toolName === "structured_output";
+		const matchingId = typeof message.toolCallId === "string" && toolCallIds.has(message.toolCallId);
+		if (!matchingName && !matchingId) continue;
+		return utf8Prefix(sanitizeStructuredOutputRejection(messageText(message.content)), MAX_STRUCTURED_OUTPUT_REJECTION_ERROR_BYTES);
+	}
+	return STRUCTURED_OUTPUT_REJECTION_ERROR;
+}
 
 export interface StructuredOutputRuntime {
 	schema: JsonSchemaObject;

package/dist/extensions/pi-subagents/src/shared/types.ts

@@ -704,6 +704,25 @@ export type ProcessTerminal =
 		diagnostic?: string;
 	});
 
+export type WorkflowTerminalProof =
+	| {
+		version: 1;
+		kind: "workflow";
+		runId: string;
+		state: "observed";
+		dispatchClosed: true;
+		observedAt: number;
+		children: ProcessTerminal[];
+	}
+	| {
+		version: 1;
+		kind: "workflow";
+		runId: string;
+		state: "pending" | "unknown";
+		dispatchClosed: boolean;
+		reason: string;
+	};
+
 /** Identifies the durable schedule that launched a run, so its completion is attributable. */
 export interface ScheduleOrigin {
 	id: string;
@@ -1398,6 +1417,7 @@ export interface Details {
 	context?: "fresh" | "fork" | "mixed";
 	results: SingleResult[];
 	workflowChildren?: WorkflowChildSummary;
+	workflowTerminalProof?: WorkflowTerminalProof;
 	/**
 	 * Terminal completion payloads for runs this bg_wait call observed
 	 * finishing. Async completions travel as result files that are consumed and

package/dist/extensions/pi-subagents/src/slash/slash-commands.ts

@@ -17,17 +17,17 @@ import {
 } from "../profiles/profiles.ts";
 import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
 import { findModelInfo, toModelInfo } from "../shared/model-info.ts";
-import { formatTokens, shortenPath } from "../shared/formatters.ts";
+import { shortenPath } from "../shared/formatters.ts";
 import { listAsyncRuns, formatAsyncRunProgressLabel, type AsyncRunSummary } from "../runs/background/async-status.ts";
 import { encodeInspectReply, handleInspectRpcArgs, INSPECT_WIDGET_KEY } from "../runs/background/inspect-rpc.ts";
 import { listScheduledRunSummaries } from "../runs/background/scheduled-runs.ts";
 import { resolveAsyncStatusChild } from "../runs/shared/child-identity.ts";
 import { readStatus } from "../shared/utils.ts";
-import { getArtifactPaths, getArtifactsDir } from "../shared/artifacts.ts";
-import { readWorkflowReceipt } from "../workflows/workflow-receipt.ts";
+
 import { FLEET_OPEN_SHORTCUT } from "../shared/shortcuts.ts";
 import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
 import { registerPromptWorkflowCommands } from "./prompt-workflows.ts";
+import { collectSubagentCost, formatSubagentCostReport } from "./subagent-cost.ts";
 import { openSubagentsAdmin } from "./subagents-admin.ts";
 import { SUBAGENT_GUIDE_TOPICS } from "../extension/subagent-guide.ts";
 import { openSubagentFleet } from "../tui/fleet.ts";
@@ -36,7 +36,6 @@ import {
 	buildSlashInitialResult,
 	failSlashResult,
 	finalizeSlashResult,
-	resolveSlashMessageDetails,
 } from "./slash-live-state.ts";
 import {
 	SLASH_RESULT_TYPE,
@@ -47,11 +46,9 @@ import {
 	SLASH_SUBAGENT_STARTED_EVENT,
 	SLASH_SUBAGENT_UPDATE_EVENT,
 	DIRS,
-	type Details,
 	type FleetKeybindingsConfig,
 	type SingleResult,
 	type SubagentState,
-	type Usage,
 } from "../shared/types.ts";
 
 interface InlineConfig {
@@ -328,237 +325,6 @@ class SubagentsStopSelector implements Component {
 	}
 }
 
-function emptyUsage(): Usage {
-	return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
-}
-
-function addUsage(target: Usage, source: Usage): void {
-	target.input += source.input;
-	target.output += source.output;
-	target.cacheRead += source.cacheRead;
-	target.cacheWrite += source.cacheWrite;
-	target.cost += source.cost;
-	target.turns += source.turns;
-}
-
-function usageHasValue(usage: Usage): boolean {
-	return usage.input !== 0 || usage.output !== 0 || usage.cacheRead !== 0 || usage.cacheWrite !== 0 || usage.cost !== 0 || usage.turns !== 0;
-}
-
-function nonNegativeNumber(value: unknown): number | undefined {
-	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
-}
-
-function usageFromValue(value: unknown, turnsOverride?: number): Usage | undefined {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
-	const record = value as Record<string, unknown>;
-	const costValue = typeof record.cost === "object" && record.cost !== null && !Array.isArray(record.cost)
-		? (record.cost as Record<string, unknown>).total
-		: record.cost;
-	const turnsValue = turnsOverride ?? record.turns;
-	const usage = {
-		input: nonNegativeNumber(record.input) ?? 0,
-		output: nonNegativeNumber(record.output) ?? 0,
-		cacheRead: nonNegativeNumber(record.cacheRead) ?? 0,
-		cacheWrite: nonNegativeNumber(record.cacheWrite) ?? 0,
-		cost: nonNegativeNumber(costValue) ?? 0,
-		turns: nonNegativeNumber(turnsValue) ?? 0,
-	};
-	return Number.isSafeInteger(usage.turns) ? usage : undefined;
-}
-
-function assistantUsageFromMessage(message: unknown): Usage | undefined {
-	if (!message || typeof message !== "object") return undefined;
-	const msg = message as { role?: unknown; usage?: unknown };
-	return msg.role === "assistant" ? usageFromValue(msg.usage, 1) : undefined;
-}
-
-function compactionUsageFromEntry(entry: unknown): Usage | undefined {
-	if (!entry || typeof entry !== "object") return undefined;
-	const record = entry as { type?: unknown; usage?: unknown };
-	return record.type === "compaction" ? usageFromValue(record.usage, 0) : undefined;
-}
-
-const MAX_USAGE_METADATA_BYTES = 2 * 1024 * 1024;
-
-function readUsageMetadata(metadataPath: string): Record<string, unknown> | undefined {
-	let fd: number | undefined;
-	try {
-		fd = fs.openSync(metadataPath, "r");
-		const stat = fs.fstatSync(fd);
-		if (!stat.isFile() || stat.size > MAX_USAGE_METADATA_BYTES) return undefined;
-		const buffer = Buffer.allocUnsafe(stat.size);
-		let offset = 0;
-		while (offset < buffer.length) {
-			const bytesRead = fs.readSync(fd, buffer, offset, buffer.length - offset, null);
-			if (bytesRead <= 0) return undefined;
-			offset += bytesRead;
-		}
-		const value: unknown = JSON.parse(buffer.toString("utf-8"));
-		return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
-	} finally {
-		if (fd !== undefined) fs.closeSync(fd);
-	}
-}
-
-function isSubagentDetails(value: unknown): value is Details {
-	if (!value || typeof value !== "object") return false;
-	const details = value as { mode?: unknown; results?: unknown };
-	return typeof details.mode === "string" && Array.isArray(details.results);
-}
-
-function detailsFromSessionEntry(entry: unknown): Details | undefined {
-	if (!entry || typeof entry !== "object") return undefined;
-	const record = entry as { type?: unknown; customType?: unknown; details?: unknown; message?: unknown };
-	if (record.type === "custom_message" && record.customType === SLASH_RESULT_TYPE) {
-		const details = resolveSlashMessageDetails(record.details)?.result.details;
-		return isSubagentDetails(details) ? details : undefined;
-	}
-	if (record.type !== "message" || !record.message || typeof record.message !== "object") return undefined;
-	const message = record.message as { role?: unknown; toolName?: unknown; details?: unknown };
-	if (message.role !== "toolResult" || (message.toolName !== "subagent" && message.toolName !== "bg_wait")) return undefined;
-	return isSubagentDetails(message.details) ? message.details : undefined;
-}
-
-function metadataUsage(
-	artifactsDirs: string[],
-	input: { runId: string; agent: string },
-): Usage | undefined {
-	if (!/^[A-Za-z0-9._-]+$/.test(input.runId)) return undefined;
-	for (const artifactsDir of artifactsDirs) {
-		for (const index of [0, undefined] as const) {
-			const metadataPath = getArtifactPaths(artifactsDir, input.runId, input.agent, index).metadataPath;
-			try {
-				const metadata = readUsageMetadata(metadataPath);
-				if (!metadata) continue;
-				if (metadata.runId !== input.runId || metadata.agent !== input.agent) continue;
-				const usage = usageFromValue(metadata.usage);
-				if (usage && usageHasValue(usage)) return usage;
-			} catch (error) {
-				if ((error as NodeJS.ErrnoException).code !== "ENOENT") console.error(`Failed to read subagent usage metadata '${metadataPath}':`, error);
-			}
-		}
-	}
-	return undefined;
-}
-
-function formatCostUsage(label: string, usage: Usage): string {
-	const extras = [
-		usage.cacheRead ? `cache read ${formatTokens(usage.cacheRead)}` : "",
-		usage.cacheWrite ? `cache write ${formatTokens(usage.cacheWrite)}` : "",
-		usage.turns ? `${usage.turns} turn${usage.turns === 1 ? "" : "s"}` : "",
-	].filter(Boolean);
-	return `${label}: ↑${formatTokens(usage.input)} ↓${formatTokens(usage.output)} $${usage.cost.toFixed(4)}${extras.length ? ` (${extras.join(", ")})` : ""}`;
-}
-
-function buildSubagentCostReport(ctx: ExtensionContext, state: SubagentState): string {
-	const parent = emptyUsage();
-	const childTotal = emptyUsage();
-	const total = emptyUsage();
-	const children: Array<{ label: string; usage: Usage; sessionFile?: string }> = [];
-	const seenChildren = new Set<string>();
-	const workflowRunIds = new Set<string>();
-	let unresolvedAsyncChildren = 0;
-
-	const addChild = (input: { agent?: string; runId?: string; usage?: Usage; sessionFile?: string }): boolean => {
-		if (!input.usage || !usageHasValue(input.usage)) return false;
-		const identity = input.runId ? `run:${input.runId}` : input.sessionFile ? `session:${input.sessionFile}` : undefined;
-		if (identity && seenChildren.has(identity)) return true;
-		if (identity) seenChildren.add(identity);
-		const usage = { ...input.usage };
-		children.push({
-			label: `Child ${children.length + 1} (${input.agent ?? "unknown"})`,
-			usage,
-			...(input.sessionFile ? { sessionFile: input.sessionFile } : {}),
-		});
-		addUsage(childTotal, usage);
-		return true;
-	};
-
-	for (const entry of ctx.sessionManager.getBranch()) {
-		const message = entry.type === "message" ? (entry as { message?: unknown }).message : undefined;
-		const parentUsage = assistantUsageFromMessage(message) ?? compactionUsageFromEntry(entry);
-		if (parentUsage) addUsage(parent, parentUsage);
-		const details = detailsFromSessionEntry(entry);
-		if (!details) continue;
-		if (details.mode === "workflow" && details.runId) workflowRunIds.add(details.runId);
-		for (const result of details.results) {
-			const resultRunId = (result as SingleResult & { runId?: unknown }).runId;
-			addChild({ agent: result.agent, runId: typeof resultRunId === "string" ? resultRunId : undefined, usage: usageFromValue(result.usage), sessionFile: result.sessionFile });
-		}
-		for (const completion of details.completions ?? []) {
-			if (completion.mode === "workflow") workflowRunIds.add(completion.runId);
-			for (const result of completion.results ?? []) {
-				addChild({ agent: result.agent, runId: result.runId, usage: usageFromValue(result.usage), sessionFile: result.sessionFile });
-			}
-		}
-	}
-
-	let sessionFile: string | null = null;
-	try {
-		sessionFile = ctx.sessionManager.getSessionFile() ?? null;
-	} catch { /* an unpersisted session can still report direct child usage */ }
-	const artifactsDirs = new Set<string>();
-	const addArtifactsDir = (cwd: string | undefined): void => {
-		try {
-			artifactsDirs.add(getArtifactsDir(sessionFile, cwd, state.artifactDirPreference));
-		} catch { /* invalid or unavailable project roots are ignored */ }
-	};
-	addArtifactsDir(ctx.cwd);
-	addArtifactsDir(state.baseCwd);
-
-	for (const workflowRunId of workflowRunIds) {
-		try {
-			const status = readStatus(path.join(DIRS.async, workflowRunId));
-			addArtifactsDir(status?.cwd);
-			const receipt = readWorkflowReceipt(DIRS.async, workflowRunId);
-			const summaryChildren = new Map((receipt.workflowChildren?.children ?? []).map((child) => [child.childId, child]));
-			const refsByRunId = new Map<string, { runId: string; agent: string }>();
-			const addRef = (runId: string | undefined, agent: string | undefined): void => {
-				if (!runId || !agent || refsByRunId.has(runId)) return;
-				refsByRunId.set(runId, { runId, agent });
-			};
-			for (const [key, entry] of Object.entries(receipt.entries)) {
-				const summaryChild = summaryChildren.get(key);
-				const runIds = entry.continuation?.runIds?.length
-					? entry.continuation.runIds
-					: entry.latestRunId ? [entry.latestRunId] : summaryChild?.runId ? [summaryChild.runId] : [];
-				for (const runId of runIds) addRef(runId, entry.agent ?? summaryChild?.agent);
-			}
-			for (const child of receipt.workflowChildren?.children ?? []) {
-				if (!Object.hasOwn(receipt.entries, child.childId)) addRef(child.runId, child.agent);
-			}
-			const refs = [...refsByRunId.values()];
-			for (const ref of refs) {
-				if (seenChildren.has(`run:${ref.runId}`)) continue;
-				const usage = metadataUsage([...artifactsDirs], ref);
-				if (!usage || !addChild({ ...ref, usage })) unresolvedAsyncChildren += 1;
-			}
-		} catch (error) {
-			if ((error as NodeJS.ErrnoException).code !== "ENOENT") console.error(`Failed to resolve async subagent usage for '${workflowRunId}':`, error);
-		}
-	}
-
-	addUsage(total, parent);
-	addUsage(total, childTotal);
-	const lines = [
-		"Subagent cost",
-		"",
-		formatCostUsage("Parent", parent),
-	];
-	if (children.length === 0) {
-		lines.push("No subagent child usage found in this session.");
-	} else {
-		for (const child of children) {
-			lines.push(formatCostUsage(child.label, child.usage));
-			if (child.sessionFile) lines.push(`  Session: ${child.sessionFile}`);
-		}
-	}
-	if (unresolvedAsyncChildren > 0) lines.push(`Async child usage unavailable: ${unresolvedAsyncChildren}.`);
-	lines.push("────────────────────────────", formatCostUsage("Children", childTotal), formatCostUsage("Total", total));
-	return lines.join("\n");
-}
-
 function parseSingleRequiredArg(args: string, usage: string): { ok: true; value: string } | { ok: false; message: string } {
 	const parts = args.trim().split(/\s+/).filter(Boolean);
 	if (parts.length !== 1) return { ok: false, message: usage };
@@ -923,7 +689,7 @@ export function registerSlashCommands(
 	pi.registerCommand("subagent-cost", {
 		description: "Show parent and subagent child usage cost for this session",
 		handler: async (_args, ctx) => {
-			sendSlashText(pi, buildSubagentCostReport(ctx, state));
+			sendSlashText(pi, formatSubagentCostReport(collectSubagentCost(ctx, state)));
 		},
 	});