@ian-pascoe/pi-minimal-subagents 0.15.0 → 0.16.0

package/README.md

@@ -276,10 +276,10 @@ creation; reloading does not silently broaden them. The default maximum depth
 is two levels beneath the interactive Root Agent.
 
 The extension registers six coordinator tools for the Root Agent and fanout
-children: `subagent`, `agent_message`, `subagent_wait`, `subagent_status`,
-`subagent_cancel`, and `subagent_delete`. Ordinary non-fanout children receive
-only the three adjacent-coordination tools: `agent_message`, `subagent_wait`,
-and `subagent_status`.
+children below the depth cap: `subagent`, `agent_message`, `subagent_wait`, `subagent_status`,
+`subagent_cancel`, and `subagent_delete`. Children that cannot spawn (delegation
+`none`, or fanout at the depth cap) have no children to wait on or inspect, so they
+receive only `agent_message`.
 
 A running child's `latest_activity_at` advances with the timestamps of its latest
 messages and tool results. Targeted `subagent_status` includes `recent_activity`, a bounded tail of message
@@ -288,7 +288,9 @@ assistant message but omits image data. Timeout Wait Events carry only a compact
 progress snapshot. Children target only direct children; the Root Agent
 may inspect any descendant. Model-facing status reports a `child_count` but no
 nested `children` summaries. Reported `usage` always includes `cacheWrite1h`
-and `reasoning`, as `0` when the provider reports none. `subagent_cancel`
+and `reasoning`, as `0` when the provider reports none. Tool-result text and
+`structuredContent` round every `usage.cost` field to six decimal places of USD;
+exact values stay in session data. `subagent_cancel`
 lists in `affected_agent_ids` only agents whose active turns it cancelled.
 
 `session_context` defaults to `omit`: the child starts with only its system

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ian-pascoe/pi-minimal-subagents",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "private": false,
   "description": "Persistent nested subagents with bounded delegation for Pi",
   "keywords": [

package/src/minimal-subagents-context.ts

@@ -353,7 +353,7 @@ export function buildSubagentSystemPrompt(
 ): string {
   const coordinatorBoundary = options.canSpawn
     ? "Coordinator tools support subagent, agent_message, subagent_wait, subagent_status, subagent_cancel, and subagent_delete. Wait, status, cancel, and delete target direct children only; recursive cancel and delete may affect a child's subtree."
-    : "Coordinator tools support agent_message, subagent_wait, and subagent_status; wait and status target direct children only.";
+    : "Coordinator tools support only agent_message; you have no children to wait on or inspect.";
   const delegationBoundary = options.canSpawn
     ? [
         "You have explicit fanout responsibility for this assigned task.",

package/src/minimal-subagents-render-contract.ts

@@ -272,7 +272,10 @@ const CoordinatorWaitSourceOutputSchema = {
   source_turn_id: Type.String(),
 };
 
-/** Final details schemas exposed to CodeMode for the six coordinator tools. */
+/**
+ * Final details schemas exposed to CodeMode for the six coordinator tools. `structuredContent`
+ * matches them with every `usage.cost` field rounded for presentation.
+ */
 export const CoordinatorToolOutputSchemas = {
   subagent: Type.Object({
     agent_id: Type.String(),

package/src/minimal-subagents-tools.ts

@@ -13,6 +13,7 @@ import type { TUI } from "@earendil-works/pi-tui";
 import type { MinimalSubagentsCoordinator } from "./minimal-subagents-coordinator.js";
 import { withTroubleshootingHint } from "./troubleshooting-skill.js";
 import type { MinimalSubagentsModelRole } from "./minimal-subagents-config.js";
+import { roundMinimalSubagentsUsageCosts } from "./minimal-subagents-usage.js";
 import {
   renderCoordinatorToolCall,
   renderCoordinatorToolResult,
@@ -42,11 +43,8 @@ import type {
   WaitResult,
 } from "./minimal-subagents-types.js";
 
-const ORDINARY_CHILD_COORDINATOR_TOOL_NAMES = new Set([
-  "agent_message",
-  "subagent_wait",
-  "subagent_status",
-]);
+/** A child that cannot spawn can never have children, so only adjacent messaging is useful. */
+const NON_SPAWNING_CHILD_COORDINATOR_TOOL_NAMES = new Set(["agent_message"]);
 
 /** Coordinator operations consumed by the six public coordinator tool definitions. */
 export type CoordinatorToolOperations = Pick<
@@ -183,10 +181,28 @@ function createCoordinatorToolRendering(
   };
 }
 
+/**
+ * Serialize a tool result with every nested `usage` cost rounded for presentation. Exact values
+ * stay in `details`, the Registry, and session data, which never pass through here.
+ */
+function stringifyWithRoundedUsageCosts(
+  result: CoordinatorToolResultDetails,
+  space?: number,
+): string {
+  // `JSON.stringify` types replacer values as `any`; a usage is recognized by key and `cost` object.
+  return JSON.stringify(
+    result,
+    (key, value) =>
+      key === "usage" && value?.cost ? roundMinimalSubagentsUsageCosts(value) : value,
+    space,
+  );
+}
+
 function structuredToolResult<TDetails extends CoordinatorToolResultDetails>(
   result: TDetails,
 ): AgentToolResult<TDetails> {
-  const json = JSON.stringify(result, null, 2);
+  // Presentation only: `details` keeps the exact values the session persists.
+  const json = stringifyWithRoundedUsageCosts(result, 2);
   const truncated = truncateHead(json, {
     maxBytes: DEFAULT_MAX_BYTES,
     maxLines: DEFAULT_MAX_LINES,
@@ -380,7 +396,7 @@ export function createCoordinatorToolDefinitions(
                 ? alreadyDeliveredContent(result)
                 : structuredToolResult(result).content,
             details,
-            structuredContent: JSON.parse(JSON.stringify(details)),
+            structuredContent: JSON.parse(stringifyWithRoundedUsageCosts(details)),
           };
         });
       } finally {
@@ -483,5 +499,5 @@ export function createCoordinatorToolDefinitions(
   const allowFanoutTools = options.allowFanoutTools ?? options.callerId === "root";
   return allowFanoutTools
     ? coordinatorTools
-    : coordinatorTools.filter((tool) => ORDINARY_CHILD_COORDINATOR_TOOL_NAMES.has(tool.name));
+    : coordinatorTools.filter((tool) => NON_SPAWNING_CHILD_COORDINATOR_TOOL_NAMES.has(tool.name));
 }

package/src/minimal-subagents-usage.ts

@@ -33,3 +33,33 @@ export function addMinimalSubagentsUsage(
     },
   };
 }
+
+/**
+ * USD decimal places kept in model-visible and structured usage costs. Six places is one
+ * millionth of a dollar: finer than any single turn's cost is worth reading, yet coarse enough to
+ * drop the binary-float tails that summing many per-message costs produces.
+ */
+export const MINIMAL_SUBAGENTS_COST_DECIMALS = 6;
+
+const COST_SCALE = 10 ** MINIMAL_SUBAGENTS_COST_DECIMALS;
+
+function roundCost(value: number): number {
+  return Number.isFinite(value) ? Math.round(value * COST_SCALE) / COST_SCALE : value;
+}
+
+/**
+ * Return a clone whose cost fields are rounded for presentation. Each field rounds independently
+ * from its exact value, so `total` stays within half a unit per summed field of the rounded sum.
+ */
+export function roundMinimalSubagentsUsageCosts(usage: Usage): Usage {
+  return {
+    ...usage,
+    cost: {
+      input: roundCost(usage.cost.input),
+      output: roundCost(usage.cost.output),
+      cacheRead: roundCost(usage.cost.cacheRead),
+      cacheWrite: roundCost(usage.cost.cacheWrite),
+      total: roundCost(usage.cost.total),
+    },
+  };
+}