@narumitw/pi-subagents 2.0.2 → 2.0.4

package/dist/chunks/runtime-policy-5YELCOVC.ts

@@ -5,7 +5,7 @@ import {
   assertSubagentDepthAllowed,
   parsePositiveInteger,
   resolveDefaultSubagentTimeoutMs
-} from "./chunk-RRR66UWR.js";
+} from "./chunk-RRR66UWR.ts";
 export {
   FALLBACK_TIMEOUT_MS,
   assertSubagentDepthAllowed,

package/dist/chunks/semantic-snapshot-WPJ3UAFW.ts

@@ -7,7 +7,7 @@ import {
   captureSemanticSnapshot,
   evaluateSemanticCompatibility,
   isSemanticSnapshot
-} from "./chunk-BOAXY55Y.js";
+} from "./chunk-BOAXY55Y.ts";
 export {
   SEMANTIC_SNAPSHOT_VERSION,
   captureRepositoryGeneration,

package/dist/chunks/spawn-idempotency-QGHO2WKC.ts

@@ -4,7 +4,7 @@ import {
   MAX_SPAWN_IDEMPOTENCY_KEY_LENGTH,
   assertSpawnIdempotencyKey,
   hashSpawnRequest
-} from "./chunk-S2IWVK3J.js";
+} from "./chunk-S2IWVK3J.ts";
 export {
   MAX_SPAWN_IDEMPOTENCY_KEY_LENGTH,
   assertSpawnIdempotencyKey,

package/dist/chunks/stateful-lifecycle-JAR6K55H.ts

@@ -5,7 +5,7 @@ import {
   cleanupPersistedWorkspaces,
   disposeStatefulRuntime,
   waitForOwnedSpawn
-} from "./chunk-P7OH4XMF.js";
+} from "./chunk-P7OH4XMF.ts";
 export {
   assertCurrentSpawn,
   cleanupPersistedWorkspaces,

package/dist/chunks/subprocess-transport-C2XVR25R.ts

@@ -3,43 +3,43 @@
 import {
   buildStatefulTurnPrompt,
   resolveStatefulTurnTimeout
-} from "./chunk-SCZ33MYW.js";
+} from "./chunk-SCZ33MYW.ts";
 import {
   runSingleAgent
-} from "./chunk-DQMN4OYM.js";
-import "./chunk-IGAMVWFN.js";
-import "./chunk-47SK2QYC.js";
-import "./chunk-HKC4ES4B.js";
-import "./chunk-DSOOH73Y.js";
+} from "./chunk-DQMN4OYM.ts";
+import "./chunk-IGAMVWFN.ts";
+import "./chunk-47SK2QYC.ts";
+import "./chunk-HKC4ES4B.ts";
+import "./chunk-DSOOH73Y.ts";
 import {
   CHILD_PEER_TOOL_NAMES,
   childPeerBridgePath,
   peerBridgeEnvironment
-} from "./chunk-EWWXFU7N.js";
+} from "./chunk-EWWXFU7N.ts";
 import {
   resolvePiPromptResources
-} from "./chunk-G6VZTCFH.js";
-import "./chunk-G3RSMSXJ.js";
+} from "./chunk-G6VZTCFH.ts";
+import "./chunk-G3RSMSXJ.ts";
 import {
   getResultFinalOutput
-} from "./chunk-AEUYS7JC.js";
-import "./chunk-RTCVYIZA.js";
-import "./chunk-ONDTY4EL.js";
+} from "./chunk-AEUYS7JC.ts";
+import "./chunk-RTCVYIZA.ts";
+import "./chunk-ONDTY4EL.ts";
 import {
   discoverAgents
-} from "./chunk-PSK43Y6A.js";
-import "./chunk-RSUXZD6S.js";
+} from "./chunk-PSK43Y6A.ts";
+import "./chunk-RSUXZD6S.ts";
 import {
   resolveSubagentThinkingLevel
-} from "./chunk-7QPPBBXZ.js";
+} from "./chunk-7QPPBBXZ.ts";
 import {
   readSubagentSettings
-} from "./chunk-QBORTI4W.js";
-import "./chunk-7OBINKFM.js";
-import "./chunk-DPPVEQAM.js";
-import "./chunk-I2FAK44T.js";
-import "./chunk-H3FP6DLR.js";
-import "./chunk-RRR66UWR.js";
+} from "./chunk-QBORTI4W.ts";
+import "./chunk-7OBINKFM.ts";
+import "./chunk-DPPVEQAM.ts";
+import "./chunk-I2FAK44T.ts";
+import "./chunk-H3FP6DLR.ts";
+import "./chunk-RRR66UWR.ts";
 
 // src/subprocess-transport.ts
 function resolveStatefulSubprocessThinkingLevel(agents, record) {

package/dist/chunks/workspace-WDKLN72J.ts

@@ -3,7 +3,7 @@
 import {
   WorkspaceManager,
   assertWorkspaceIsolationReady
-} from "./chunk-6KJ34M6S.js";
+} from "./chunk-6KJ34M6S.ts";
 export {
   WorkspaceManager,
   assertWorkspaceIsolationReady

package/dist/index.ts

@@ -2,35 +2,35 @@
 // @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
 import {
   registerSubagentInspect
-} from "./chunks/chunk-F4L2UVSK.js";
+} from "./chunks/chunk-F4L2UVSK.ts";
 import {
   SubagentParams,
   hasUsableAggregator
-} from "./chunks/chunk-NIF42QMF.js";
+} from "./chunks/chunk-NIF42QMF.ts";
 import {
   registerStatefulSubagents
-} from "./chunks/chunk-F5YWVHQX.js";
+} from "./chunks/chunk-2OUVSORM.ts";
 import {
   discoverAgentCatalog,
   formatAgentCatalog,
   formatUsageStats,
   registerSubagentConsult
-} from "./chunks/chunk-RHRQMT7Q.js";
-import "./chunks/chunk-P7OH4XMF.js";
-import "./chunks/chunk-N7BLVXKK.js";
+} from "./chunks/chunk-RHRQMT7Q.ts";
+import "./chunks/chunk-P7OH4XMF.ts";
+import "./chunks/chunk-N7BLVXKK.ts";
 import {
   getResultFinalOutput,
   isResultError
-} from "./chunks/chunk-AEUYS7JC.js";
-import "./chunks/chunk-RTCVYIZA.js";
-import "./chunks/chunk-ONDTY4EL.js";
-import "./chunks/chunk-O4VO6JUJ.js";
+} from "./chunks/chunk-AEUYS7JC.ts";
+import "./chunks/chunk-RTCVYIZA.ts";
+import "./chunks/chunk-ONDTY4EL.ts";
+import "./chunks/chunk-O4VO6JUJ.ts";
 import {
   cachedModuleLoader,
   throwIfAborted
-} from "./chunks/chunk-HOP5FXDT.js";
-import "./chunks/chunk-PSK43Y6A.js";
-import "./chunks/chunk-RSUXZD6S.js";
+} from "./chunks/chunk-HOP5FXDT.ts";
+import "./chunks/chunk-PSK43Y6A.ts";
+import "./chunks/chunk-RSUXZD6S.ts";
 import {
   DEFAULT_CONSULTATION_CWD_POLICY,
   DEFAULT_CONSULT_RESOURCE_POLICY,
@@ -39,25 +39,25 @@ import {
   inspectSubagentSettings,
   readSubagentSettings,
   resolveBlockingMaxParallelTasks
-} from "./chunks/chunk-QBORTI4W.js";
-import "./chunks/chunk-7OBINKFM.js";
-import "./chunks/chunk-DPPVEQAM.js";
+} from "./chunks/chunk-QBORTI4W.ts";
+import "./chunks/chunk-7OBINKFM.ts";
+import "./chunks/chunk-DPPVEQAM.ts";
 import {
   SUBAGENT_COMPLETION_MESSAGE_TYPE,
   renderCompletionMessage
-} from "./chunks/chunk-QDVGH2X7.js";
+} from "./chunks/chunk-QDVGH2X7.ts";
 import {
   expansionHint,
   formatToolActivity,
   safeBlock,
   safeLine
-} from "./chunks/chunk-BFK2Z4ZF.js";
-import "./chunks/chunk-SWGQLFSD.js";
-import "./chunks/chunk-I2FAK44T.js";
+} from "./chunks/chunk-BFK2Z4ZF.ts";
+import "./chunks/chunk-SWGQLFSD.ts";
+import "./chunks/chunk-I2FAK44T.ts";
 import {
   MAX_BLOCKING_PARALLEL_CONCURRENCY
-} from "./chunks/chunk-H3FP6DLR.js";
-import "./chunks/chunk-S2IWVK3J.js";
+} from "./chunks/chunk-H3FP6DLR.ts";
+import "./chunks/chunk-S2IWVK3J.ts";
 
 // src/subagents-extension.ts
 import {
@@ -85,10 +85,10 @@ function registerSubagentConfigLifecycle(pi) {
 }
 function registerSubagentConfigCommand(pi, runtime, owner = registerSubagentConfigLifecycle(pi), dependencies = {}) {
   const loadConfigUi = cachedModuleLoader(
-    dependencies.loadConfigUi ?? (() => import("./chunks/config-ui-3IBMHTQB.js"))
+    dependencies.loadConfigUi ?? (() => import("./chunks/config-ui-7IMI3I4B.ts"))
   );
   const loadConfigStatus = cachedModuleLoader(
-    dependencies.loadConfigStatus ?? (() => import("./chunks/config-status-J4GPWP46.js"))
+    dependencies.loadConfigStatus ?? (() => import("./chunks/config-status-J4GPWP46.ts"))
   );
   pi.registerCommand("subagents", {
     description: "Manage current-session subagents and user settings",
@@ -832,7 +832,7 @@ ${expansionHint()}`;
 function subagents_extension_default(pi, dependencies = {}) {
   pi.registerMessageRenderer(SUBAGENT_COMPLETION_MESSAGE_TYPE, renderCompletionMessage);
   const loadBlockingExecution = cachedModuleLoader(
-    dependencies.loadBlockingExecution ?? (() => import("./chunks/execution-DS2DEIQZ.js"))
+    dependencies.loadBlockingExecution ?? (() => import("./chunks/execution-DS2DEIQZ.ts"))
   );
   const configOwner = registerSubagentConfigLifecycle(pi);
   const settings = readSubagentSettings();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-subagents",
-	"version": "2.0.2",
+	"version": "2.0.4",
 	"description": "Pi extension for delegating work to specialized isolated subagents.",
 	"type": "module",
 	"license": "MIT",
@@ -42,17 +42,17 @@
 		"typebox": "*"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "2.5.8",
+		"@biomejs/biome": "2.5.9",
 		"@earendil-works/pi-agent-core": "0.84.2",
 		"@earendil-works/pi-ai": "0.84.2",
 		"@earendil-works/pi-coding-agent": "0.84.2",
 		"@earendil-works/pi-tui": "0.84.2",
-		"esbuild": "0.28.1",
-		"typebox": "1.3.14",
+		"esbuild": "0.28.2",
+		"typebox": "1.3.16",
 		"typescript": "7.0.2"
 	},
 	"dependencies": {
-		"@narumitw/pi-tui-kit": "^0.56.0",
+		"@narumitw/pi-tui-kit": "^0.56.1",
 		"proper-lockfile": "^4.1.2"
 	},
 	"repository": {

package/src/rpc-transport.ts

@@ -37,8 +37,10 @@ import {
 } from "./rpc-transport-metadata.js";
 import {
 	captureRpcEvent,
+	commitRpcInFlightUsage,
 	createRpcTurnCapture,
 	observeRpcBudgetEvent,
+	snapshotRpcUsage,
 } from "./rpc-turn-capture.js";
 import { terminateProcess } from "./runner.js";
 import { safeTerminalText } from "./safe-text.js";
@@ -501,11 +503,17 @@ export class RpcTransport implements SubagentTransport {
 		});
 		void settled.catch(() => undefined);
 		const unsubscribeEvent = child.client.onEvent((event) => {
-			captureRpcEvent(event, capture);
+			const usageChanged = captureRpcEvent(event, capture);
 			observeRpcBudgetEvent(event, budgetMonitor);
 			if (!capture.firstActivityAt && isActivityEvent(event)) {
 				capture.firstActivityAt = Date.now();
-				publish({ phase: "running", timing: { firstActivityAt: capture.firstActivityAt } });
+				publish({
+					phase: "running",
+					timing: { firstActivityAt: capture.firstActivityAt },
+					...(usageChanged ? { usage: snapshotRpcUsage(capture) } : {}),
+				});
+			} else if (usageChanged) {
+				publish({ usage: snapshotRpcUsage(capture) });
 			}
 			const type = eventType(event);
 			if (type === "auto_retry_start") publish({ phase: "retrying" });
@@ -572,7 +580,7 @@ export class RpcTransport implements SubagentTransport {
 						phase: explicitAbort ? "interrupted" : "failed",
 						failurePhase: "running",
 						timing: { settledAt: Date.now() },
-						usage: capture.usage,
+						usage: snapshotRpcUsage(capture),
 					});
 					const checkpointOutput = termination
 						? formatTimeoutCheckpoint(termination.checkpoint)
@@ -591,7 +599,11 @@ export class RpcTransport implements SubagentTransport {
 					};
 				}
 
-				publish({ phase: "finalizing", failurePhase: "running" });
+				publish({
+					phase: "finalizing",
+					failurePhase: "running",
+					usage: snapshotRpcUsage(capture),
+				});
 				const finalizationStartedAt = Date.now();
 				const summary = await finalizeTimedOutRpcTurn({
 					client: child.client,
@@ -605,6 +617,7 @@ export class RpcTransport implements SubagentTransport {
 					finalizationTimeoutMs: this.options.timeoutFinalizationMs,
 					abortGraceMs: this.options.abortGraceMs ?? ABORT_GRACE_MS,
 					resetCapture() {
+						commitRpcInFlightUsage(capture);
 						capture.output = "";
 						capture.partial = "";
 						capture.stopReason = undefined;
@@ -625,7 +638,7 @@ export class RpcTransport implements SubagentTransport {
 					phase: "failed",
 					failurePhase: "running",
 					timing: { settledAt: Date.now() },
-					usage: capture.usage,
+					usage: snapshotRpcUsage(capture),
 				});
 				const checkpointOutput = termination ? formatTimeoutCheckpoint(termination.checkpoint) : "";
 				return {
@@ -651,7 +664,7 @@ export class RpcTransport implements SubagentTransport {
 				timing: { settledAt: Date.now() },
 				provider: capture.provider ?? telemetry.provider,
 				model: capture.model ?? telemetry.model,
-				usage: capture.usage,
+				usage: snapshotRpcUsage(capture),
 			});
 			return {
 				output: output.text,
@@ -686,6 +699,7 @@ export class RpcTransport implements SubagentTransport {
 				phase: signal.aborted ? "interrupted" : "failed",
 				failurePhase: accepted ? "running" : "ready",
 				timing: { settledAt: Date.now() },
+				usage: snapshotRpcUsage(capture),
 			});
 			return {
 				output:

package/src/rpc-turn-capture.ts

@@ -12,6 +12,7 @@ export interface RpcTurnCapture {
 	provider?: string;
 	model?: string;
 	usage: TransportUsage;
+	inFlightUsage?: TransportUsage;
 	firstActivityAt?: number;
 	journal: TimeoutProgressJournal;
 }
@@ -25,8 +26,9 @@ export function createRpcTurnCapture(): RpcTurnCapture {
 	};
 }
 
-export function captureRpcEvent(event: unknown, capture: RpcTurnCapture): void {
-	if (!isRecord(event)) return;
+export function captureRpcEvent(event: unknown, capture: RpcTurnCapture): boolean {
+	if (!isRecord(event)) return false;
+	const previousUsage = snapshotRpcUsage(capture);
 	if (event.type === "tool_execution_start") {
 		capture.journal.recordToolCall(
 			typeof event.toolCallId === "string" ? event.toolCallId : "",
@@ -42,7 +44,12 @@ export function captureRpcEvent(event: unknown, capture: RpcTurnCapture): void {
 			{ content: result.content, isError: event.isError },
 		);
 	}
+	if (event.type === "message_start" && isRecord(event.message)) {
+		if (event.message.role === "assistant") commitRpcInFlightUsage(capture);
+	}
 	if (event.type === "message_update") {
+		const usage = normalizeUsage(event.usage);
+		if (usage) capture.inFlightUsage = usage;
 		const delta = event.assistantMessageEvent;
 		if (isRecord(delta) && delta.type === "text_delta" && typeof delta.delta === "string") {
 			capture.partial = truncateUtf8(
@@ -51,10 +58,28 @@ export function captureRpcEvent(event: unknown, capture: RpcTurnCapture): void {
 			).text;
 		}
 	}
-	if (event.type !== "message_end" || !isRecord(event.message)) return;
-	const candidate = event.message;
-	if (candidate.role !== "toolResult") journalMessages(capture.journal, [candidate]);
-	if (candidate.role !== "assistant") return;
+	if (event.type === "message_end" && isRecord(event.message)) {
+		const candidate = event.message;
+		if (candidate.role !== "toolResult") journalMessages(capture.journal, [candidate]);
+		if (candidate.role === "assistant") captureAssistantEnd(candidate, capture);
+	}
+	return !sameUsage(previousUsage, snapshotRpcUsage(capture));
+}
+
+export function snapshotRpcUsage(capture: RpcTurnCapture): TransportUsage {
+	const usage = { ...capture.usage };
+	if (capture.inFlightUsage) addUsage(usage, capture.inFlightUsage);
+	return usage;
+}
+
+export function commitRpcInFlightUsage(capture: RpcTurnCapture): boolean {
+	if (!capture.inFlightUsage) return false;
+	addUsage(capture.usage, capture.inFlightUsage);
+	capture.inFlightUsage = undefined;
+	return true;
+}
+
+function captureAssistantEnd(candidate: Record<string, unknown>, capture: RpcTurnCapture): void {
 	capture.output = truncateUtf8(
 		assistantText(candidate.content) || capture.partial,
 		DEFAULT_MAX_OUTPUT_BYTES,
@@ -76,8 +101,11 @@ export function captureRpcEvent(event: unknown, capture: RpcTurnCapture): void {
 				? candidate.model
 				: undefined;
 	capture.model = responseModel ? boundedPrivateText(responseModel, 256) : undefined;
-	capture.usage.turns++;
-	addUsage(capture.usage, candidate.usage);
+	const finalUsage = normalizeUsage(candidate.usage);
+	const completedUsage = finalUsage ?? capture.inFlightUsage;
+	if (completedUsage) addUsage(capture.usage, completedUsage);
+	capture.inFlightUsage = undefined;
+	capture.usage.turns = addUsageValue(capture.usage.turns, 1);
 }
 
 export function observeRpcBudgetEvent(event: unknown, monitor: TurnBudgetMonitor): void {
@@ -101,29 +129,76 @@ function assistantToolCallCount(content: unknown): number {
 	return content.filter((part) => isRecord(part) && part.type === "toolCall").length;
 }
 
-function addUsage(target: TransportUsage, value: unknown): void {
-	if (!isRecord(value)) return;
-	target.input += safeNonNegative(value.input);
-	target.output += safeNonNegative(value.output);
-	target.cacheRead += safeNonNegative(value.cacheRead);
-	target.cacheWrite += safeNonNegative(value.cacheWrite);
+function normalizeUsage(value: unknown): TransportUsage | undefined {
+	if (!isRecord(value)) return undefined;
+	const input = safeNonNegative(value.input);
+	const output = safeNonNegative(value.output);
+	const cacheRead = safeNonNegative(value.cacheRead);
+	const cacheWrite = safeNonNegative(value.cacheWrite);
 	const reportedTotal = safeNonNegative(value.totalTokens);
-	target.totalTokens +=
-		reportedTotal ||
-		safeNonNegative(value.input) +
-			safeNonNegative(value.output) +
-			safeNonNegative(value.cacheRead) +
-			safeNonNegative(value.cacheWrite);
-	if (isRecord(value.cost)) target.cost += safeNonNegative(value.cost.total);
+	const cost = isRecord(value.cost) ? safeNonNegative(value.cost.total) : undefined;
+	if (
+		input === undefined &&
+		output === undefined &&
+		cacheRead === undefined &&
+		cacheWrite === undefined &&
+		reportedTotal === undefined &&
+		cost === undefined
+	) {
+		return undefined;
+	}
+	const components = [input, output, cacheRead, cacheWrite].reduce<number>(
+		(total, current) => addUsageValue(total, current ?? 0),
+		0,
+	);
+	return {
+		input: input ?? 0,
+		output: output ?? 0,
+		cacheRead: cacheRead ?? 0,
+		cacheWrite: cacheWrite ?? 0,
+		totalTokens: reportedTotal ?? components,
+		cost: cost ?? 0,
+		turns: 0,
+	};
+}
+
+function addUsage(target: TransportUsage, value: TransportUsage): void {
+	for (const key of [
+		"input",
+		"output",
+		"cacheRead",
+		"cacheWrite",
+		"totalTokens",
+		"cost",
+		"turns",
+	] as const) {
+		target[key] = addUsageValue(target[key], value[key]);
+	}
 }
 
-function safeNonNegative(value: unknown): number {
+function addUsageValue(current: number, addition: number): number {
+	return Math.min(Number.MAX_SAFE_INTEGER, current + addition);
+}
+
+function safeNonNegative(value: unknown): number | undefined {
 	return typeof value === "number" &&
 		Number.isFinite(value) &&
 		value >= 0 &&
 		value <= Number.MAX_SAFE_INTEGER
 		? value
-		: 0;
+		: undefined;
+}
+
+function sameUsage(left: TransportUsage, right: TransportUsage): boolean {
+	return (
+		left.input === right.input &&
+		left.output === right.output &&
+		left.cacheRead === right.cacheRead &&
+		left.cacheWrite === right.cacheWrite &&
+		left.totalTokens === right.totalTokens &&
+		left.cost === right.cost &&
+		left.turns === right.turns
+	);
 }
 
 function assistantText(value: unknown): string {