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

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

@@ -15,6 +15,8 @@ import { observeReplaySubagents, parseClaudeSubagentMeta, } from "./subagents/re
 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";
@@ -1534,6 +1536,8 @@ 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.sidechainTracker = new ClaudeSidechainTracker({
             getToolInput: (toolUseId) => this.toolUseCache.get(toolUseId)?.input ?? null,
             // Releases that predate the task protocol announce nothing, so the tracker keeps deriving
@@ -2130,6 +2134,7 @@ class ClaudeAgentSession {
         this.turnState = "idle";
         this.sidechainTracker.clear();
         this.taskProtocolSource.reset();
+        this.subagentCosts.clear();
         this.input?.end();
         this.query?.close?.();
         await this.awaitWithTimeout(this.query?.interrupt?.(), "close query interrupt");
@@ -3325,6 +3330,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;
@@ -3851,6 +3857,53 @@ 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();
+            const costUsd = prices ? await transcript.read(prices) : undefined;
+            if (costUsd === undefined)
+                return;
+            for (const event of foldSubagentObservations(this.taskProtocolSource.observeCost(taskId, costUsd))) {
+                this.notifySubscribers({ type: "provider_subagent", provider: "claude", event });
+            }
+        }
+        catch (error) {
+            this.logger.debug({ err: error, taskId }, "Failed to estimate Claude subagent cost");
+        }
+    }
+    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.
      *
@@ -4698,9 +4751,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

@@ -126,6 +126,8 @@ 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[];
     /**
      * Effort as reported by a hook firing inside a subagent.
      *

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

@@ -335,6 +335,13 @@ export class ClaudeTaskProtocolSource {
             return [];
         return this.updatePresentation(id, { usage });
     }
+    /** Cost estimated from the subagent's transcript, which the session reads as usage grows. */
+    observeCost(taskId, costUsd) {
+        const id = this.subagentIdByTaskId.get(taskId);
+        if (!id)
+            return [];
+        return this.updatePresentation(id, { costUsd });
+    }
     /**
      * Effort as reported by a hook firing inside a subagent.
      *

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/claude/subagents/presentation.d.ts

@@ -6,6 +6,8 @@ export interface ClaudeSubagentPresentationFacts {
     model?: string;
     effort?: string;
     usage?: ClaudeSubagentUsage;
+    /** Estimated from list prices; Claude reports no cost per subagent. */
+    costUsd?: number;
 }
 /** Build the complete compact subtitle Claude exposes to provider-neutral clients. */
 export declare function buildClaudeSubagentSubtitle(facts: ClaudeSubagentPresentationFacts): string | undefined;

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

@@ -1,3 +1,4 @@
+import { formatSubagentCost, formatSubagentTokens, } from "../../../provider-subagents/subtitle-format.js";
 import { findClaudeModel } from "../models.js";
 /** Build the complete compact subtitle Claude exposes to provider-neutral clients. */
 export function buildClaudeSubagentSubtitle(facts) {
@@ -5,7 +6,8 @@ export function buildClaudeSubagentSubtitle(facts) {
         readPart(facts.title),
         formatModel(facts.model),
         formatEffort(facts.effort),
-        formatTokens(facts.usage?.totalTokens),
+        formatSubagentTokens(facts.usage?.totalTokens),
+        formatSubagentCost(facts.costUsd),
     ].filter((part) => part !== undefined);
     return parts.length > 0 ? parts.join(" · ") : undefined;
 }
@@ -31,11 +33,4 @@ function formatEffort(effort) {
         .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
         .join(" ");
 }
-function formatTokens(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`;
-}
 //# sourceMappingURL=presentation.js.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/claude/subagents/transcript-cost.d.ts

@@ -0,0 +1,18 @@
+import type { CodexPrices } from "../../codex/pricing.js";
+/**
+ * Sums the estimated cost of every model request recorded in a Claude subagent transcript.
+ *
+ * Claude Code reports only a token count per subagent, but its transcript records each request's
+ * model and usage split into input, cache writes, cache reads, and output, which is what a price
+ * needs. One request can span several entries that share a message id, so each id is priced once,
+ * from its latest entry.
+ */
+export declare class ClaudeTranscriptCost {
+    private readonly lines;
+    private readonly costByMessageId;
+    constructor(filePath: string);
+    /** Returns the cost so far, or undefined when no request used a priced model. */
+    read(prices: CodexPrices): Promise<number | undefined>;
+    private applyLine;
+}
+//# sourceMappingURL=transcript-cost.d.ts.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/claude/subagents/transcript-cost.js

@@ -0,0 +1,50 @@
+import { AppendedLinesReader, parseRecordLine, readCount, toRecord, } from "../../appended-lines-reader.js";
+/**
+ * Sums the estimated cost of every model request recorded in a Claude subagent transcript.
+ *
+ * Claude Code reports only a token count per subagent, but its transcript records each request's
+ * model and usage split into input, cache writes, cache reads, and output, which is what a price
+ * needs. One request can span several entries that share a message id, so each id is priced once,
+ * from its latest entry.
+ */
+export class ClaudeTranscriptCost {
+    constructor(filePath) {
+        this.costByMessageId = new Map();
+        this.lines = new AppendedLinesReader(filePath);
+    }
+    /** Returns the cost so far, or undefined when no request used a priced model. */
+    async read(prices) {
+        await this.lines.read((line) => this.applyLine(line, prices));
+        if (this.costByMessageId.size === 0)
+            return undefined;
+        let total = 0;
+        for (const cost of this.costByMessageId.values())
+            total += cost;
+        return total;
+    }
+    applyLine(line, prices) {
+        // Skip user entries and tool results without parsing them.
+        if (!line.includes('"assistant"') || !line.includes('"usage"'))
+            return;
+        const entry = parseRecordLine(line);
+        if (entry?.type !== "assistant")
+            return;
+        const message = toRecord(entry.message);
+        const usage = toRecord(message?.usage);
+        if (typeof message?.id !== "string" || !usage)
+            return;
+        const cacheWrite = readCount(usage.cache_creation_input_tokens);
+        const cacheWrite1h = readCount(toRecord(usage.cache_creation)?.ephemeral_1h_input_tokens);
+        const cost = prices.claudeRequestCostUsd({
+            model: typeof message.model === "string" ? message.model : undefined,
+            inputTokens: readCount(usage.input_tokens),
+            cacheWrite5mTokens: Math.max(0, cacheWrite - cacheWrite1h),
+            cacheWrite1hTokens: cacheWrite1h,
+            cacheReadTokens: readCount(usage.cache_read_input_tokens),
+            outputTokens: readCount(usage.output_tokens),
+        });
+        if (cost !== undefined)
+            this.costByMessageId.set(message.id, cost);
+    }
+}
+//# sourceMappingURL=transcript-cost.js.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/codex/pricing.d.ts

@@ -6,12 +6,25 @@ export interface CodexRequestUsage {
     cachedInputTokens: number;
     outputTokens: number;
 }
-/** OpenAI list prices for one model request, keyed by Codex model slug. */
+export interface ClaudeRequestUsage {
+    model: string | undefined;
+    inputTokens: number;
+    cacheWrite5mTokens: number;
+    cacheWrite1hTokens: number;
+    cacheReadTokens: number;
+    outputTokens: number;
+}
+/** List prices for one model request, keyed by Codex model slug or Claude model id. */
 export declare class CodexPrices {
     private readonly entries;
     constructor(entries: Record<string, unknown>);
     /** Returns undefined for a model missing from the price list. */
     requestCostUsd({ model, serviceTier, inputTokens, cachedInputTokens, outputTokens, }: CodexRequestUsage): number | undefined;
+    /**
+     * Returns undefined for a model missing from the price list.
+     * ponytail: ignores Anthropic's long-context rate, which LiteLLM lists only for some models.
+     */
+    claudeRequestCostUsd({ model, inputTokens, cacheWrite5mTokens, cacheWrite1hTokens, cacheReadTokens, outputTokens, }: ClaudeRequestUsage): number | undefined;
 }
 export interface CodexPriceListOptions {
     logger: Logger;
@@ -39,4 +52,5 @@ export declare class CodexPriceList {
     private load;
     private readSavedCopy;
 }
+export declare function getSharedCodexPriceList(logger: Logger): CodexPriceList;
 //# sourceMappingURL=pricing.d.ts.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/codex/pricing.js

@@ -13,7 +13,7 @@ const FETCH_TIMEOUT_MS = 15000;
 const LONG_CONTEXT_THRESHOLD_TOKENS = 272000;
 const LONG_CONTEXT_SUFFIX = "_above_272k_tokens";
 const PRIORITY_SUFFIX = "_priority";
-/** OpenAI list prices for one model request, keyed by Codex model slug. */
+/** List prices for one model request, keyed by Codex model slug or Claude model id. */
 export class CodexPrices {
     constructor(entries) {
         this.entries = entries;
@@ -38,6 +38,31 @@ export class CodexPrices {
             cachedInputTokens * cachedInputRate +
             outputTokens * outputRate);
     }
+    /**
+     * Returns undefined for a model missing from the price list.
+     * ponytail: ignores Anthropic's long-context rate, which LiteLLM lists only for some models.
+     */
+    claudeRequestCostUsd({ model, inputTokens, cacheWrite5mTokens, cacheWrite1hTokens, cacheReadTokens, outputTokens, }) {
+        const entry = model ? toRecord(this.entries[model]) : undefined;
+        if (!entry)
+            return undefined;
+        const inputRate = readNumber(entry.input_cost_per_token);
+        const outputRate = readNumber(entry.output_cost_per_token);
+        if (inputRate === undefined || outputRate === undefined)
+            return undefined;
+        const cacheWrite5mRate = readNumber(entry.cache_creation_input_token_cost) ?? inputRate;
+        const cacheWrite1hRate = readNumber(entry.cache_creation_input_token_cost_above_1hr) ?? cacheWrite5mRate;
+        const cacheReadRate = readNumber(entry.cache_read_input_token_cost) ?? inputRate;
+        // Anthropic counts cache reads and writes apart from input tokens.
+        return (inputTokens * inputRate +
+            cacheWrite5mTokens * cacheWrite5mRate +
+            cacheWrite1hTokens * cacheWrite1hRate +
+            cacheReadTokens * cacheReadRate +
+            outputTokens * outputRate);
+    }
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
 // Prefer the most specific rate LiteLLM lists: a model without a long-context or priority variant
 // bills that request at its plain rate.
@@ -123,6 +148,12 @@ export class CodexPriceList {
         }
     }
 }
+let sharedCodexPriceList;
+// One price list per daemon, so every session that estimates cost shares one fetch.
+export function getSharedCodexPriceList(logger) {
+    sharedCodexPriceList ?? (sharedCodexPriceList = new CodexPriceList({ logger }));
+    return sharedCodexPriceList;
+}
 function parsePriceList(text) {
     const entries = toRecord(JSON.parse(text));
     if (!entries) {

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/codex/rollout-cost.d.ts

@@ -5,19 +5,16 @@ import type { CodexPrices } from "./pricing.js";
  * Codex writes each request's token counts and the model of each turn to the rollout, and the file
  * survives compaction, resume, and daemon restarts. Pricing request by request applies the
  * long-context rate and mid-session model switches, which pricing the thread total cannot.
- * Each read parses only the bytes appended since the previous read.
  */
 export declare class CodexRolloutCost {
-    private readonly filePath;
-    private offset;
-    private readonly decoder;
-    private pendingLine;
-    private model;
+    private readonly lines;
+    private currentModel;
     private highestTotalTokens;
     private costUsd;
     private pricedRequests;
-    private queue;
     constructor(filePath: string);
+    /** The model of the latest turn read so far. */
+    get model(): string | undefined;
     /**
      * Returns the session cost so far, or undefined when no request used a priced model.
      * ponytail: prices every request at the current service tier; the rollout does not record it.
@@ -26,7 +23,6 @@ export declare class CodexRolloutCost {
         prices: CodexPrices;
         serviceTier: string | null;
     }): Promise<number | undefined>;
-    private readAppended;
     private applyLine;
 }
 //# sourceMappingURL=rollout-cost.d.ts.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/codex/rollout-cost.js

@@ -1,62 +1,39 @@
-import fs from "node:fs/promises";
-import { StringDecoder } from "node:string_decoder";
+import { AppendedLinesReader, parseRecordLine, readCount, toRecord, } from "../appended-lines-reader.js";
 /**
  * Sums the estimated cost of every model request recorded in a Codex rollout file.
  *
  * Codex writes each request's token counts and the model of each turn to the rollout, and the file
  * survives compaction, resume, and daemon restarts. Pricing request by request applies the
  * long-context rate and mid-session model switches, which pricing the thread total cannot.
- * Each read parses only the bytes appended since the previous read.
  */
 export class CodexRolloutCost {
     constructor(filePath) {
-        this.filePath = filePath;
-        this.offset = 0;
-        this.decoder = new StringDecoder("utf8");
-        this.pendingLine = "";
         this.highestTotalTokens = -1;
         this.costUsd = 0;
         this.pricedRequests = 0;
-        this.queue = Promise.resolve();
+        this.lines = new AppendedLinesReader(filePath);
+    }
+    /** The model of the latest turn read so far. */
+    get model() {
+        return this.currentModel;
     }
     /**
      * Returns the session cost so far, or undefined when no request used a priced model.
      * ponytail: prices every request at the current service tier; the rollout does not record it.
      */
-    read({ prices, serviceTier, }) {
-        const result = this.queue.then(() => this.readAppended(prices, serviceTier));
-        this.queue = result.catch(() => undefined);
-        return result;
-    }
-    async readAppended(prices, serviceTier) {
-        const handle = await fs.open(this.filePath, "r");
-        try {
-            const { size } = await handle.stat();
-            if (size > this.offset) {
-                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) {
-                    this.applyLine(line, prices, serviceTier);
-                }
-            }
-        }
-        finally {
-            await handle.close();
-        }
+    async read({ prices, serviceTier, }) {
+        await this.lines.read((line) => this.applyLine(line, prices, serviceTier));
         return this.pricedRequests > 0 ? this.costUsd : undefined;
     }
     applyLine(line, prices, serviceTier) {
         // Skip the bulk of the rollout (messages, tool output) without parsing it.
         if (!line.includes('"turn_context"') && !line.includes('"token_count"'))
             return;
-        const entry = parseRecord(line);
+        const entry = parseRecordLine(line);
         const payload = toRecord(entry?.payload);
         if (entry?.type === "turn_context") {
             if (typeof payload?.model === "string")
-                this.model = payload.model;
+                this.currentModel = payload.model;
             return;
         }
         if (payload?.type !== "token_count")
@@ -71,7 +48,7 @@ export class CodexRolloutCost {
             return;
         this.highestTotalTokens = totalTokens;
         const cost = prices.requestCostUsd({
-            model: this.model,
+            model: this.currentModel,
             serviceTier,
             inputTokens: readCount(last.input_tokens),
             cachedInputTokens: readCount(last.cached_input_tokens),
@@ -83,21 +60,4 @@ export class CodexRolloutCost {
         this.pricedRequests += 1;
     }
 }
-function parseRecord(line) {
-    try {
-        return toRecord(JSON.parse(line));
-    }
-    catch {
-        // A torn or foreign line only drops that line from an estimate.
-        return undefined;
-    }
-}
-function toRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function readCount(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
-}
 //# sourceMappingURL=rollout-cost.js.map

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/codex-app-server-agent.d.ts

@@ -2,7 +2,7 @@ import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOpt
 import type { Logger } from "pino";
 import type { ChildProcessWithoutNullStreams } from "node:child_process";
 import { Dirent } from "node:fs";
-import { CodexPriceList } from "./codex/pricing.js";
+import { type CodexPriceList } from "./codex/pricing.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
 import { type CodexThreadForkParams, type CodexThreadForkResponse, type CodexThreadRollbackParams, type CodexThreadRollbackResponse, type CodexAppServerTraceContext } from "./codex/app-server-transport.js";
 import type { WorkspaceGitService } from "../../workspace-git-service.js";
@@ -173,6 +173,7 @@ export declare class CodexAppServerAgentSession implements AgentSession {
     private emittedProviderSubagentUserMessageKeys;
     private subAgentCallsByCallId;
     private subAgentCallIdByChildThreadId;
+    private subAgentUsageByThreadId;
     private pendingSubAgentNotificationsByThreadId;
     private warnedUnknownNotificationMethods;
     private warnedInvalidNotificationPayloads;
@@ -336,6 +337,9 @@ export declare class CodexAppServerAgentSession implements AgentSession {
     private resetTurnTrackingState;
     private handlePlanUpdatedNotification;
     private handleTokenUsageUpdatedNotification;
+    private handleSubAgentTokenUsage;
+    private refreshSubAgentCost;
+    private emitSubAgentSubtitle;
     private refreshRolloutCost;
     private applyCostEstimate;
     private openRolloutCost;

package/node_modules/@getpaseo/server/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -11,8 +11,9 @@ import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { composeSystemPromptParts } from "../system-prompt.js";
 import { curateAgentActivity } from "../activity-curator.js";
 import { CodexAsyncQuestions, codexAsyncQuestionToTimeline } from "./codex/async-questions.js";
-import { CodexPriceList } from "./codex/pricing.js";
+import { getSharedCodexPriceList } from "./codex/pricing.js";
 import { CodexRolloutCost } from "./codex/rollout-cost.js";
+import { formatSubagentCost, formatSubagentTokens } from "../provider-subagents/subtitle-format.js";
 import { mapCodexToolCallEnvelope, mapCodexToolCallFromThreadItem, normalizeCommandExecutionCommand, splitCodexMcpToolResultImages, } from "./codex/tool-call-mapper.js";
 import { checkProviderLaunchAvailable, createProviderEnv, createProviderEnvSpec, resolveProviderLaunch, } from "../provider-launch-config.js";
 import { findExecutable, probeExecutable, } from "../../../executable-resolution/executable-resolution.js";
@@ -723,12 +724,6 @@ function filterCodexThreadsByCwd(threads, cwd) {
     const belongsToWorkspace = createPathEquivalenceMatcher(cwd);
     return threads.filter((thread) => typeof thread.cwd === "string" && belongsToWorkspace(thread.cwd));
 }
-let sharedCodexPriceList;
-// One price list per daemon, so every Codex session and custom Codex provider shares one fetch.
-function getSharedCodexPriceList(logger) {
-    sharedCodexPriceList ?? (sharedCodexPriceList = new CodexPriceList({ logger }));
-    return sharedCodexPriceList;
-}
 var CodexCostStatus;
 (function (CodexCostStatus) {
     /** No priced request yet, an unpriced model, or no rollout file. */
@@ -750,16 +745,31 @@ function isSameCostEstimate(left, right) {
     }
     return left.status === right.status;
 }
-// Both cost fields are always written, undefined included, so the agent manager's usage merge on
+// All cost fields are always written, undefined included, so the agent manager's usage merge on
 // turn completion cannot keep a stale value from the previous state.
 function withCostEstimate(usage, estimate) {
     switch (estimate.status) {
         case CodexCostStatus.Estimated:
-            return { ...usage, totalCostUsd: estimate.costUsd, totalCostUnavailable: false };
+            return {
+                ...usage,
+                totalCostUsd: estimate.costUsd,
+                totalCostUnavailable: false,
+                totalCostEstimated: true,
+            };
         case CodexCostStatus.Unavailable:
-            return { ...usage, totalCostUsd: undefined, totalCostUnavailable: true };
+            return {
+                ...usage,
+                totalCostUsd: undefined,
+                totalCostUnavailable: true,
+                totalCostEstimated: undefined,
+            };
         case CodexCostStatus.Pending:
-            return { ...usage, totalCostUsd: undefined, totalCostUnavailable: undefined };
+            return {
+                ...usage,
+                totalCostUsd: undefined,
+                totalCostUnavailable: undefined,
+                totalCostEstimated: undefined,
+            };
     }
 }
 export function toAgentUsage(tokenUsage) {
@@ -2598,6 +2608,7 @@ export class CodexAppServerAgentSession {
         this.emittedProviderSubagentUserMessageKeys = new Set();
         this.subAgentCallsByCallId = new Map();
         this.subAgentCallIdByChildThreadId = new Map();
+        this.subAgentUsageByThreadId = new Map();
         this.pendingSubAgentNotificationsByThreadId = new Map();
         this.warnedUnknownNotificationMethods = new Set();
         this.warnedInvalidNotificationPayloads = new Set();
@@ -3000,6 +3011,7 @@ export class CodexAppServerAgentSession {
         const { timeline, subAgentRoutes } = history;
         this.subAgentCallsByCallId.clear();
         this.subAgentCallIdByChildThreadId.clear();
+        this.subAgentUsageByThreadId.clear();
         this.pendingSubAgentNotificationsByThreadId.clear();
         this.persistedProviderSubagentEvents = [];
         this.loadingPersistedHistory = true;
@@ -4271,6 +4283,9 @@ export class CodexAppServerAgentSession {
     }
     dispatchSubAgentNotification(parsed, callId) {
         switch (parsed.kind) {
+            case "token_usage_updated":
+                this.handleSubAgentTokenUsage(parsed);
+                return;
             case "thread_started":
                 this.emitSubAgentActivityUpdate(callId, "running", { reopen: true });
                 return;
@@ -4947,6 +4962,62 @@ export class CodexAppServerAgentSession {
         }
         void this.refreshRolloutCost();
     }
+    handleSubAgentTokenUsage(parsed) {
+        const threadId = parsed.threadId;
+        if (!threadId)
+            return;
+        let usage = this.subAgentUsageByThreadId.get(threadId);
+        if (!usage) {
+            usage = {};
+            this.subAgentUsageByThreadId.set(threadId, usage);
+        }
+        // The last request's context, which is what the Claude subagent rows report as tokens too.
+        usage.tokens = toAgentUsage(parsed.tokenUsage)?.contextWindowUsedTokens;
+        this.emitSubAgentSubtitle(threadId, usage);
+        void this.refreshSubAgentCost(threadId, usage);
+    }
+    async refreshSubAgentCost(threadId, usage) {
+        const priceList = this.deps.codexPriceList;
+        if (!priceList)
+            return;
+        try {
+            usage.rolloutCost ?? (usage.rolloutCost = this.openRolloutCost(threadId));
+            const rolloutCost = await usage.rolloutCost;
+            const prices = await priceList.get();
+            if (!rolloutCost || !prices)
+                return;
+            usage.costUsd = await rolloutCost.read({ prices, serviceTier: this.serviceTier });
+            usage.model = rolloutCost.model;
+            if (this.subAgentUsageByThreadId.get(threadId) !== usage)
+                return;
+            this.emitSubAgentSubtitle(threadId, usage);
+        }
+        catch (error) {
+            usage.rolloutCost = undefined;
+            this.logger.warn({ error, threadId }, "Failed to read a Codex subagent rollout for its cost");
+        }
+    }
+    emitSubAgentSubtitle(threadId, usage) {
+        // A provider subtitle replaces the row's agent type, so it leads with it.
+        const callId = this.subAgentCallIdByChildThreadId.get(threadId);
+        const detail = callId ? this.subAgentCallsByCallId.get(callId)?.toolCall.detail : undefined;
+        const subtitle = [
+            detail?.type === "sub_agent" ? (detail.subAgentType ?? "Codex subagent") : undefined,
+            usage.model,
+            formatSubagentTokens(usage.tokens),
+            formatSubagentCost(usage.costUsd),
+        ]
+            .filter((part) => part !== undefined)
+            .join(" · ");
+        if (!subtitle || subtitle === usage.subtitle)
+            return;
+        usage.subtitle = subtitle;
+        this.emitEvent({
+            type: "provider_subagent",
+            provider: CODEX_PROVIDER,
+            event: { type: "upsert", id: threadId, subtitle },
+        });
+    }
     async refreshRolloutCost() {
         const threadId = this.currentThreadId;
         const priceList = this.deps.codexPriceList;

package/node_modules/@getpaseo/server/dist/server/server/agent/turn-diffs/snapshot.d.ts

@@ -3,12 +3,26 @@ export interface WorkingTreeSnapshot {
     repoRoot: string;
     tree: string;
 }
+export type TurnStartSnapshot = WorkingTreeSnapshot & {
+    head?: string;
+    headLogPath: string;
+    headLogSize: number;
+};
 /**
  * Writes the whole working tree (tracked changes plus untracked, non-ignored files up to 1 MiB)
  * as a git tree object. Staging goes through a copy of the index, so the user's index, HEAD and
  * branches are untouched; only git objects are written.
  */
 export declare function snapshotWorkingTree(cwd: string): Promise<WorkingTreeSnapshot | null>;
+/** A working tree snapshot plus where HEAD and its reflog stood, to separate out branch moves. */
+export declare function snapshotTurnStart(cwd: string): Promise<TurnStartSnapshot | null>;
+/**
+ * The tree to diff a turn from. When the turn moved HEAD to another commit, the start snapshot's
+ * uncommitted changes are replayed onto where HEAD landed, so the diff holds the agent's edits and
+ * commits and none of the content the move brought in. Undefined when that can't be worked out
+ * (no reflog, unborn branch, replay conflict); the turn then gets no diff.
+ */
+export declare function resolveTurnFromTree(start: TurnStartSnapshot): Promise<string | undefined>;
 export declare function diffTreeStats(params: {
     repoRoot: string;
     fromTree: string;