@mduan/paseo-cli 0.11.0-fork.1 → 0.11.0-fork.3

package/node_modules/@getpaseo/protocol/dist/messages.js

@@ -253,8 +253,10 @@ const AgentUsageSchema = z.object({
     inputTokens: z.number().optional(),
     cachedInputTokens: z.number().optional(),
     outputTokens: z.number().optional(),
+    subagentCostUsd: z.number().optional(),
     totalCostUsd: z.number().optional(),
     totalCostUnavailable: z.boolean().optional(),
+    totalCostEstimated: z.boolean().optional(),
     contextWindowMaxTokens: z.number().optional(),
     contextWindowUsedTokens: z.number().optional(),
 });
@@ -1570,6 +1572,8 @@ export const AgentTurnDiffsListRequestMessageSchema = z.object({
 export const AgentTurnDiffTargetSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("turn"), turnId: z.string() }),
     z.object({ kind: z.literal("last_turn") }),
+    // COMPAT(turnDiffSession): added in v0.11.0-beta.3, remove after 2027-01-04. The daemon no longer
+    // serves Chat Session diffs; older clients still send this target.
     z.object({ kind: z.literal("session") }),
 ]);
 export const AgentTurnDiffsGetDiffRequestMessageSchema = z.object({

package/node_modules/@getpaseo/protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/protocol",
-  "version": "0.11.0-fork.1",
+  "version": "0.11.0-fork.3",
   "description": "Paseo shared protocol schemas and wire types",
   "files": [
     "dist",

package/node_modules/@getpaseo/relay/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/relay",
-  "version": "0.11.0-fork.1",
+  "version": "0.11.0-fork.3",
   "description": "Paseo relay for bridging daemon and client connections",
   "files": [
     "dist",

package/node_modules/@getpaseo/server/dist/server/builtin-plugins/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/builtin-plugins",
-  "version": "0.11.0-fork.1",
+  "version": "0.11.0-fork.3",
   "private": true,
   "type": "module",
   "scripts": {

package/node_modules/@getpaseo/server/dist/server/server/agent/agent-manager.d.ts

@@ -12,7 +12,7 @@ import { type ForegroundTurnWaiter } from "./agent-run-state.js";
 import { type RewindMode } from "./rewind/rewind.js";
 import type { PaseoToolCatalogFactory } from "./tools/types.js";
 import { type ProviderSubagentDescriptor, type ProviderSubagentStoreEvent } from "./provider-subagents/store.js";
-import type { WorkingTreeSnapshot } from "./turn-diffs/snapshot.js";
+import type { TurnStartSnapshot } from "./turn-diffs/snapshot.js";
 import type { TurnDiffStore } from "./turn-diffs/store.js";
 export declare class AgentManagerShuttingDownError extends Error {
     constructor();
@@ -160,7 +160,7 @@ export type AttentionState = {
 };
 interface PendingTurnDiff {
     turnId: string;
-    start: WorkingTreeSnapshot;
+    start: TurnStartSnapshot;
     clientMessageId?: string;
 }
 interface ManagedAgentBase {

package/node_modules/@getpaseo/server/dist/server/server/agent/agent-manager.js

@@ -229,6 +229,9 @@ function buildExplicitTimelineSeedForRegister(now, options) {
 function totalCostOf(usage) {
     return usage?.totalCostUsd;
 }
+function subagentCostOf(usage) {
+    return usage?.subagentCostUsd;
+}
 function buildImportedTimelineRows(entries) {
     const rows = [];
     for (const entry of entries) {
@@ -780,6 +783,7 @@ export class AgentManager {
             workspaceId: options?.workspaceId ?? null,
         });
         launchContext.priorTotalCostUsd = totalCostOf(record?.lastUsage);
+        launchContext.priorSubagentCostUsd = subagentCostOf(record?.lastUsage);
         const providerLaunchConfig = this.resolveProviderLaunchConfig(launchConfig, launchContext);
         const session = await client.resumeSession(handle, providerLaunchConfig, launchContext, currentResumeOptions);
         await this.requireExternalMcpSupport(session, storedConfig);
@@ -931,6 +935,7 @@ export class AgentManager {
         const previousPaseoToolPolicy = this.paseoToolPolicies.get(agentId);
         const launchContext = await this.buildLaunchContext(agentId, client, storedConfig.cwd, paseoToolPolicy, undefined, { reason: "refresh", purpose: "interactive", workspaceId: existing.workspaceId });
         launchContext.priorTotalCostUsd = totalCostOf(preservedLastUsage);
+        launchContext.priorSubagentCostUsd = subagentCostOf(preservedLastUsage);
         const providerLaunchConfig = this.resolveProviderLaunchConfig(launchConfig, launchContext);
         if (Object.keys(storedConfig.mcpServers ?? {}).length > 0 &&
             existing.session.capabilities.supportsMcpServers !== true) {

package/node_modules/@getpaseo/server/dist/server/server/agent/agent-projections.js

@@ -371,6 +371,7 @@ function sanitizeUsage(value) {
         "inputTokens",
         "cachedInputTokens",
         "outputTokens",
+        "subagentCostUsd",
         "totalCostUsd",
         "contextWindowMaxTokens",
         "contextWindowUsedTokens",
@@ -383,6 +384,9 @@ function sanitizeUsage(value) {
     if (typeof sanitized.totalCostUnavailable === "boolean") {
         result.totalCostUnavailable = sanitized.totalCostUnavailable;
     }
+    if (typeof sanitized.totalCostEstimated === "boolean") {
+        result.totalCostEstimated = sanitized.totalCostEstimated;
+    }
     return Object.keys(result).length ? result : undefined;
 }
 function sanitizeRuntimeInfo(runtimeInfo) {

package/node_modules/@getpaseo/server/dist/server/server/agent/agent-sdk-types.d.ts

@@ -173,13 +173,18 @@ export interface AgentUsage {
     inputTokens?: number;
     cachedInputTokens?: number;
     outputTokens?: number;
+    /** Cost attributed to provider-native descendants. Paseo-managed agents are excluded. */
+    subagentCostUsd?: number;
+    /** Total cost for this provider session, including provider-native descendants. */
     totalCostUsd?: number;
     /** The provider can estimate cost, but its price list could not be loaded. */
     totalCostUnavailable?: boolean;
+    /** Paseo priced the provider's token counts itself; the provider reports no cost. */
+    totalCostEstimated?: boolean;
     contextWindowMaxTokens?: number;
     contextWindowUsedTokens?: number;
 }
-export type AgentUsageNumericField = Exclude<keyof AgentUsage, "totalCostUnavailable">;
+export type AgentUsageNumericField = Exclude<keyof AgentUsage, "totalCostUnavailable" | "totalCostEstimated">;
 export declare const TOOL_CALL_ICON_NAMES: readonly ["wrench", "square_terminal", "eye", "pencil", "search", "bot", "sparkles", "brain", "mic_vocal"];
 export type ToolCallIconName = (typeof TOOL_CALL_ICON_NAMES)[number];
 export type ToolCallDetail = {
@@ -548,6 +553,8 @@ export interface AgentLaunchContext {
      * total restarts with their process add it, so a resume or reload keeps the session total.
      */
     priorTotalCostUsd?: number;
+    /** Provider-native descendant cost reported before this session object existed. */
+    priorSubagentCostUsd?: number;
 }
 export interface AgentCreateSessionOptions {
     /**

package/node_modules/@getpaseo/server/dist/server/server/agent/agent-storage.d.ts

@@ -86,8 +86,10 @@ declare const STORED_AGENT_SCHEMA: z.ZodObject<{
         inputTokens: z.ZodOptional<z.ZodNumber>;
         cachedInputTokens: z.ZodOptional<z.ZodNumber>;
         outputTokens: z.ZodOptional<z.ZodNumber>;
+        subagentCostUsd: z.ZodOptional<z.ZodNumber>;
         totalCostUsd: z.ZodOptional<z.ZodNumber>;
         totalCostUnavailable: z.ZodOptional<z.ZodBoolean>;
+        totalCostEstimated: z.ZodOptional<z.ZodBoolean>;
         contextWindowMaxTokens: z.ZodOptional<z.ZodNumber>;
         contextWindowUsedTokens: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;

package/node_modules/@getpaseo/server/dist/server/server/agent/agent-storage.js

@@ -37,8 +37,10 @@ const STORED_USAGE_SCHEMA = z.object({
     inputTokens: z.number().optional(),
     cachedInputTokens: z.number().optional(),
     outputTokens: z.number().optional(),
+    subagentCostUsd: z.number().optional(),
     totalCostUsd: z.number().optional(),
     totalCostUnavailable: z.boolean().optional(),
+    totalCostEstimated: z.boolean().optional(),
     contextWindowMaxTokens: z.number().optional(),
     contextWindowUsedTokens: z.number().optional(),
 });

package/node_modules/@getpaseo/server/dist/server/server/agent/provider-subagents/cost.d.ts

@@ -0,0 +1,17 @@
+export interface ProviderSubagentCostNode {
+    id: string;
+    parentSubagentId: string | null;
+    ownCostUsd: number;
+}
+export interface ProviderSubagentCost {
+    ownCostUsd: number;
+    subagentCostUsd: number;
+    totalCostUsd: number;
+}
+export interface ProviderSubagentCostRollup {
+    byId: Map<string, ProviderSubagentCost>;
+    totalCostUsd: number;
+}
+/** Roll each direct cost into every native ancestor. Missing parents remain attributed to root. */
+export declare function rollupProviderSubagentCosts(nodes: readonly ProviderSubagentCostNode[]): ProviderSubagentCostRollup;
+//# sourceMappingURL=cost.d.ts.map

package/node_modules/@getpaseo/server/dist/server/server/agent/provider-subagents/cost.js

@@ -0,0 +1,25 @@
+/** Roll each direct cost into every native ancestor. Missing parents remain attributed to root. */
+export function rollupProviderSubagentCosts(nodes) {
+    const nodesById = new Map(nodes.map((node) => [node.id, node]));
+    const byId = new Map(nodes.map((node) => [
+        node.id,
+        { ownCostUsd: node.ownCostUsd, subagentCostUsd: 0, totalCostUsd: node.ownCostUsd },
+    ]));
+    let totalCostUsd = 0;
+    for (const node of nodes) {
+        totalCostUsd += node.ownCostUsd;
+        const visited = new Set([node.id]);
+        let parentId = node.parentSubagentId;
+        while (parentId && !visited.has(parentId)) {
+            visited.add(parentId);
+            const parentCost = byId.get(parentId);
+            if (!parentCost)
+                break;
+            parentCost.subagentCostUsd += node.ownCostUsd;
+            parentCost.totalCostUsd += node.ownCostUsd;
+            parentId = nodesById.get(parentId)?.parentSubagentId ?? null;
+        }
+    }
+    return { byId, totalCostUsd };
+}
+//# sourceMappingURL=cost.js.map

package/node_modules/@getpaseo/server/dist/server/server/agent/provider-subagents/subtitle-format.d.ts

@@ -0,0 +1,8 @@
+/** Subtitle parts that every provider formats the same way. */
+export declare function formatSubagentTokens(totalTokens: number | undefined): string | undefined;
+/** Subagent rows show the estimated cost of the subagent and all its native descendants. */
+export declare function formatSubagentCosts({ ownCostUsd, subagentCostUsd, }: {
+    ownCostUsd: number | undefined;
+    subagentCostUsd: number | undefined;
+}): string[];
+//# sourceMappingURL=subtitle-format.d.ts.map

package/node_modules/@getpaseo/server/dist/server/server/agent/provider-subagents/subtitle-format.js

@@ -0,0 +1,22 @@
+/** Subtitle parts that every provider formats the same way. */
+export function formatSubagentTokens(totalTokens) {
+    if (typeof totalTokens !== "number" || totalTokens <= 0)
+        return undefined;
+    if (totalTokens < 1000)
+        return `${Math.round(totalTokens)} tokens`;
+    return `${Math.round(totalTokens / 100) / 10}k tokens`;
+}
+function formatSubagentCost(costUsd) {
+    if (typeof costUsd !== "number" || !Number.isFinite(costUsd) || costUsd < 0)
+        return undefined;
+    const amount = costUsd < 0.01 && costUsd > 0 ? costUsd.toFixed(4) : costUsd.toFixed(2);
+    return `$${amount}`;
+}
+/** Subagent rows show the estimated cost of the subagent and all its native descendants. */
+export function formatSubagentCosts({ ownCostUsd, subagentCostUsd, }) {
+    if (typeof ownCostUsd !== "number")
+        return [];
+    const total = formatSubagentCost(ownCostUsd + Math.max(0, subagentCostUsd ?? 0));
+    return total ? [`~${total}`] : [];
+}
+//# sourceMappingURL=subtitle-format.js.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/appended-lines-reader.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Reads a file that a provider keeps appending to, one complete line at a time.
+ * Each read parses only the bytes appended since the previous read, and reads run one at a time so
+ * a line is never handed out twice.
+ */
+export declare class AppendedLinesReader {
+    private readonly filePath;
+    private offset;
+    private readonly decoder;
+    private pendingLine;
+    private queue;
+    constructor(filePath: string);
+    /** Passes each line completed since the previous read to `onLine`. */
+    read(onLine: (line: string) => void): Promise<void>;
+    private readAppended;
+}
+export declare function parseRecordLine(line: string): Record<string, unknown> | undefined;
+export declare function toRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function readCount(value: unknown): number;
+//# sourceMappingURL=appended-lines-reader.d.ts.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/appended-lines-reader.js

@@ -0,0 +1,59 @@
+import fs from "node:fs/promises";
+import { StringDecoder } from "node:string_decoder";
+/**
+ * Reads a file that a provider keeps appending to, one complete line at a time.
+ * Each read parses only the bytes appended since the previous read, and reads run one at a time so
+ * a line is never handed out twice.
+ */
+export class AppendedLinesReader {
+    constructor(filePath) {
+        this.filePath = filePath;
+        this.offset = 0;
+        this.decoder = new StringDecoder("utf8");
+        this.pendingLine = "";
+        this.queue = Promise.resolve();
+    }
+    /** Passes each line completed since the previous read to `onLine`. */
+    read(onLine) {
+        const result = this.queue.then(() => this.readAppended(onLine));
+        this.queue = result.catch(() => undefined);
+        return result;
+    }
+    async readAppended(onLine) {
+        const handle = await fs.open(this.filePath, "r");
+        try {
+            const { size } = await handle.stat();
+            if (size <= this.offset)
+                return;
+            const buffer = Buffer.alloc(size - this.offset);
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, this.offset);
+            this.offset += bytesRead;
+            const lines = (this.pendingLine + this.decoder.write(buffer.subarray(0, bytesRead))).split("\n");
+            this.pendingLine = lines.pop() ?? "";
+            for (const line of lines) {
+                onLine(line);
+            }
+        }
+        finally {
+            await handle.close();
+        }
+    }
+}
+export function parseRecordLine(line) {
+    try {
+        return toRecord(JSON.parse(line));
+    }
+    catch {
+        // A torn or foreign line only drops that line from an estimate.
+        return undefined;
+    }
+}
+export function toRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+export function readCount(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+//# sourceMappingURL=appended-lines-reader.js.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/claude/agent.js

@@ -11,10 +11,12 @@ import { parsePartialJsonObject } from "./partial-json.js";
 import { ClaudeSidechainTracker } from "./sidechain-tracker.js";
 import { ClaudeTaskState } from "./task-state.js";
 import { ClaudeTaskProtocolSource, } from "./subagents/live-source.js";
-import { observeReplaySubagents, parseClaudeSubagentMeta, } from "./subagents/replay-source.js";
+import { observeReplaySubagentCosts, observeReplaySubagents, parseClaudeSubagentMeta, } from "./subagents/replay-source.js";
 import { foldSubagentObservations } from "./subagents/observation.js";
 import { observeReplayWorkflows, parseClaudeWorkflowRun, } from "./subagents/workflow-replay-source.js";
 import { readClaudeWorkflowResultFile } from "./subagents/workflow-output.js";
+import { ClaudeTranscriptCost } from "./subagents/transcript-cost.js";
+import { getSharedCodexPriceList } from "../codex/pricing.js";
 import { buildClaudeFeatures, claudeModelSupportsFastMode } from "./feature-definitions.js";
 import { buildBinaryDiagnosticRows, buildCommandResolutionDiagnosticRows, formatProviderDiagnostic, formatProviderDiagnosticError, } from "../diagnostic-utils.js";
 import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "../provider-runner.js";
@@ -1075,6 +1077,7 @@ export class ClaudeAgentClient {
             agentId: launchContext?.agentId,
             launchEnv: launchContext?.env,
             priorTotalCostUsd: launchContext?.priorTotalCostUsd,
+            priorSubagentCostUsd: launchContext?.priorSubagentCostUsd,
             persistSession: options?.persistSession,
             logger: this.logger,
             queryFactory: this.queryFactory,
@@ -1101,6 +1104,7 @@ export class ClaudeAgentClient {
             agentId: launchContext?.agentId,
             launchEnv: launchContext?.env,
             priorTotalCostUsd: launchContext?.priorTotalCostUsd,
+            priorSubagentCostUsd: launchContext?.priorSubagentCostUsd,
             logger: this.logger,
             queryFactory: this.queryFactory,
             resolveBinary: this.resolveBinary,
@@ -1534,6 +1538,9 @@ class ClaudeAgentSession {
             getToolInput: (toolUseId) => this.toolUseCache.get(toolUseId)?.input ?? null,
             readWorkflowResult: readClaudeWorkflowResultFile,
         });
+        /** Task id -> cost reader over that subagent's transcript. */
+        this.subagentCosts = new Map();
+        this.replaySubagentTaskIds = new Set();
         this.sidechainTracker = new ClaudeSidechainTracker({
             getToolInput: (toolUseId) => this.toolUseCache.get(toolUseId)?.input ?? null,
             // Releases that predate the task protocol announce nothing, so the tracker keeps deriving
@@ -1545,6 +1552,7 @@ class ClaudeAgentSession {
         this.persistedHistory = [];
         this.persistedProviderSubagentEvents = [];
         this.historyPending = false;
+        this.replaySubagentCostTargets = [];
         this.turnState = "idle";
         this.nextTurnOrdinal = 1;
         this.cancelCurrentTurn = null;
@@ -1652,6 +1660,7 @@ class ClaudeAgentSession {
         assertClaudeThinkingOptionSupported(config.model, config.thinkingOptionId);
         this.launchEnv = options.launchEnv;
         this.costBeforeQueryUsd = options.priorTotalCostUsd ?? 0;
+        this.subagentCostUsd = options.priorSubagentCostUsd ?? 0;
         this.agentId = options.agentId;
         this.defaults = options.defaults;
         this.runtimeSettings = options.runtimeSettings;
@@ -1874,8 +1883,10 @@ class ClaudeAgentSession {
         }
         const history = this.persistedHistory;
         const providerSubagentEvents = this.persistedProviderSubagentEvents;
+        const costTargets = this.replaySubagentCostTargets;
         this.persistedHistory = [];
         this.persistedProviderSubagentEvents = [];
+        this.replaySubagentCostTargets = [];
         this.historyPending = false;
         for (const entry of history) {
             yield {
@@ -1886,6 +1897,28 @@ class ClaudeAgentSession {
             };
         }
         yield* providerSubagentEvents;
+        yield* await this.replaySubagentCostEvents(costTargets);
+    }
+    /** Replay has no task frames to trigger pricing, so restored subagents are priced here. */
+    async replaySubagentCostEvents(targets) {
+        if (targets.length === 0)
+            return [];
+        try {
+            const prices = await getSharedCodexPriceList(this.logger).get();
+            if (!prices)
+                return [];
+            const costUsdByTaskId = new Map();
+            for (const target of targets) {
+                const costUsd = await this.subagentTranscriptCost(target.taskId)?.read(prices);
+                if (costUsd !== undefined)
+                    costUsdByTaskId.set(target.taskId, costUsd);
+            }
+            return foldSubagentObservations(observeReplaySubagentCosts(targets, costUsdByTaskId)).map((event) => ({ type: "provider_subagent", provider: "claude", event }));
+        }
+        catch (error) {
+            this.logger.warn({ err: error }, "Failed to estimate restored Claude subagent costs");
+            return [];
+        }
     }
     async getAvailableModes() {
         return this.availableModes;
@@ -2130,6 +2163,8 @@ class ClaudeAgentSession {
         this.turnState = "idle";
         this.sidechainTracker.clear();
         this.taskProtocolSource.reset();
+        this.subagentCosts.clear();
+        this.replaySubagentTaskIds.clear();
         this.input?.end();
         this.query?.close?.();
         await this.awaitWithTimeout(this.query?.interrupt?.(), "close query interrupt");
@@ -2383,6 +2418,7 @@ class ClaudeAgentSession {
         this.persistedHistory = [];
         this.persistedProviderSubagentEvents = [];
         this.historyPending = false;
+        this.replaySubagentCostTargets = [];
         this.userMessageIds = [];
         this.emittedUserMessageIds.clear();
         this.rewindTurnAnchors.length = 0;
@@ -2413,6 +2449,7 @@ class ClaudeAgentSession {
         this.persistedHistory = [];
         this.persistedProviderSubagentEvents = [];
         this.historyPending = false;
+        this.replaySubagentCostTargets = [];
         this.userMessageIds = [];
         this.emittedUserMessageIds.clear();
         this.rewindTurnAnchors.length = 0;
@@ -3258,6 +3295,7 @@ class ClaudeAgentSession {
         this.persistedHistory = [];
         this.persistedProviderSubagentEvents = [];
         this.historyPending = false;
+        this.replaySubagentCostTargets = [];
         this.cachedRuntimeInfo = null;
         this.queryRestartNeeded = false;
         this.autonomousTurn = null;
@@ -3325,6 +3363,7 @@ class ClaudeAgentSession {
         for (const event of foldSubagentObservations(subagentObservations)) {
             events.push({ type: "provider_subagent", provider: "claude", event });
         }
+        this.refreshSubagentCost(message);
         for (const observation of subagentObservations) {
             if (observation.kind !== "declared")
                 continue;
@@ -3812,7 +3851,13 @@ class ClaudeAgentSession {
         }
         // A crash or startup-error result can carry a zeroed total; keep the running one.
         this.queryCostUsd = Math.max(this.queryCostUsd, usage.totalCostUsd);
-        return { ...usage, totalCostUsd: this.costBeforeQueryUsd + this.queryCostUsd };
+        const totalCostUsd = this.costBeforeQueryUsd + this.queryCostUsd;
+        const subagentCostUsd = Math.min(this.subagentCostUsd, totalCostUsd);
+        return {
+            ...usage,
+            totalCostUsd,
+            ...(subagentCostUsd > 0 ? { subagentCostUsd } : {}),
+        };
     }
     enqueueTimeline(item) {
         this.pushEvent({ type: "timeline", item, provider: "claude" });
@@ -3851,6 +3896,95 @@ class ClaudeAgentSession {
     pushEvent(event) {
         this.notifySubscribers(event);
     }
+    /**
+     * Claude reports only a token count per subagent, so each usage report re-prices the
+     * subagent's transcript from the point the previous report reached.
+     */
+    refreshSubagentCost(message) {
+        if (message.type !== "system")
+            return;
+        if (message.subtype !== "task_progress" && message.subtype !== "task_notification")
+            return;
+        const taskId = message.task_id;
+        if (typeof taskId !== "string" || !this.taskProtocolSource.isDeclaredTask(taskId))
+            return;
+        void this.readSubagentCost(taskId);
+    }
+    async readSubagentCost(taskId) {
+        try {
+            const transcript = this.subagentTranscriptCost(taskId);
+            if (!transcript)
+                return;
+            const prices = await getSharedCodexPriceList(this.logger).get();
+            if (!prices)
+                return;
+            const costUsd = await transcript.read(prices);
+            if (costUsd === undefined)
+                return;
+            for (const event of foldSubagentObservations(this.taskProtocolSource.observeCost(taskId, costUsd))) {
+                this.notifySubscribers({ type: "provider_subagent", provider: "claude", event });
+            }
+            await this.refreshSubagentCostTotal(prices);
+        }
+        catch (error) {
+            this.logger.debug({ err: error, taskId }, "Failed to estimate Claude subagent cost");
+        }
+    }
+    async refreshSubagentCostTotal(prices) {
+        const historyPath = this.claudeSessionId ? this.resolveHistoryPath(this.claudeSessionId) : null;
+        if (!historyPath)
+            return;
+        const directory = claudeSubagentsDirectory(historyPath);
+        let entries;
+        try {
+            entries = await promises.readdir(directory);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return;
+            throw error;
+        }
+        const admittedTaskIds = new Set([
+            ...this.replaySubagentTaskIds,
+            ...this.taskProtocolSource.costTaskIds,
+        ]);
+        const costs = await Promise.all(entries
+            .filter((entry) => entry.startsWith("agent-") && entry.endsWith(".jsonl"))
+            .map(async (entry) => {
+            const taskId = entry.slice("agent-".length, -".jsonl".length);
+            if (!admittedTaskIds.has(taskId))
+                return undefined;
+            return this.subagentTranscriptCost(taskId)?.read(prices);
+        }));
+        let subagentCostUsd = 0;
+        for (const cost of costs)
+            subagentCostUsd += cost ?? 0;
+        this.subagentCostUsd = subagentCostUsd;
+        const totalCostUsd = this.costBeforeQueryUsd + this.queryCostUsd;
+        if (totalCostUsd <= 0 || this.subagentCostUsd <= 0)
+            return;
+        this.notifySubscribers({
+            type: "usage_updated",
+            provider: "claude",
+            usage: { subagentCostUsd: Math.min(this.subagentCostUsd, totalCostUsd) },
+        });
+    }
+    subagentTranscriptCost(taskId) {
+        const existing = this.subagentCosts.get(taskId);
+        if (existing)
+            return existing;
+        const historyPath = this.claudeSessionId ? this.resolveHistoryPath(this.claudeSessionId) : null;
+        if (!historyPath)
+            return undefined;
+        // Claude Code names a subagent's transcript after the same id the task protocol calls task_id.
+        const transcriptPath = path.join(claudeSubagentsDirectory(historyPath), `agent-${taskId}.jsonl`);
+        // Workflows and transcript-less tasks never get one; don't fetch prices for them.
+        if (!fs.existsSync(transcriptPath))
+            return undefined;
+        const transcript = new ClaudeTranscriptCost(transcriptPath);
+        this.subagentCosts.set(taskId, transcript);
+        return transcript;
+    }
     /**
      * Effort is reachable only through hooks.
      *
@@ -3968,6 +4102,9 @@ class ClaudeAgentSession {
             parent: readClaudeReplayParentFacts(parentEntries),
             convertEntry: (entry) => this.convertHistoryEntry(entry),
         });
+        for (const taskId of subagentReplay.taskIds)
+            this.replaySubagentTaskIds.add(taskId);
+        this.replaySubagentCostTargets = subagentReplay.costTargets;
         const observations = [
             ...subagentReplay.observations,
             ...observeReplayWorkflows({
@@ -4698,9 +4835,15 @@ function readClaudeReplayParentFacts(parentEntries) {
     };
 }
 const CLAUDE_SUBAGENT_META_FILE = /^agent-(.+)\.meta\.json$/;
+function claudeSessionDirectory(historyPath) {
+    return path.join(path.dirname(historyPath), path.basename(historyPath, ".jsonl"));
+}
+function claudeSubagentsDirectory(historyPath) {
+    return path.join(claudeSessionDirectory(historyPath), "subagents");
+}
 function readClaudeSidechainHistory(historyPath) {
-    const sessionDirectory = path.join(path.dirname(historyPath), path.basename(historyPath, ".jsonl"));
-    const sidechainDirectory = path.join(sessionDirectory, "subagents");
+    const sessionDirectory = claudeSessionDirectory(historyPath);
+    const sidechainDirectory = claudeSubagentsDirectory(historyPath);
     const history = {
         contents: [],
         workflowContents: [],

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/claude/subagents/live-source.d.ts

@@ -55,6 +55,8 @@ export declare class ClaudeTaskProtocolSource {
     private readonly lastStatusById;
     /** Claude facts stay inside the provider boundary; clients receive one compact subtitle. */
     private readonly presentationById;
+    private readonly parentSubagentIdById;
+    private readonly directCostUsdById;
     private readonly lastSubtitleById;
     private sawTaskStarted;
     private sawAnyTask;
@@ -77,6 +79,7 @@ export declare class ClaudeTaskProtocolSource {
      * this source has yet to hear about.
      */
     get announcesTasks(): boolean;
+    get costTaskIds(): ReadonlySet<string>;
     /**
      * Whether this source declared the given subagent. Callers route frames through this before
      * attributing anything to an id: a frame for a task that was never declared belongs to work
@@ -126,6 +129,9 @@ export declare class ClaudeTaskProtocolSource {
      */
     private observeTaskProgress;
     private observeUsage;
+    /** Cost estimated from the subagent's transcript, which the session reads as usage grows. */
+    observeCost(taskId: string, costUsd: number): SubagentObservation[];
+    private costRollup;
     /**
      * Effort as reported by a hook firing inside a subagent.
      *