@murphai/murph 1.3.0 → 1.3.1

package/node_modules/@murphai/assistant-engine/dist/assistant/providers/helpers.js

@@ -1,10 +1,15 @@
+import { Buffer } from 'node:buffer';
 import { createHash } from 'node:crypto';
 import { getAssistantBindingContextLines } from '../bindings.js';
+import { readCodexNonEmptyString, readCodexRecord, readCodexServerNotification, readCodexThreadTokenUsage, } from '../../assistant-codex/app-server-protocol.js';
 import { normalizeNullableString, } from '../shared.js';
-import { supportsAssistantNativeResume, } from '@murphai/operator-config/assistant/provider-config';
-import { isCodexReservedModelProviderId, resolveAssistantCodexModelProviderConfig, } from '@murphai/operator-config/assistant/target-runtime';
+import {} from '@murphai/operator-config/assistant/provider-config';
+import { isCodexReservedModelProviderId, resolveAssistantCodexUsageProviderName, resolveAssistantCodexModelProviderConfig, } from '@murphai/operator-config/assistant/target-runtime';
 import { VaultCliError } from '@murphai/operator-config/vault-cli-errors';
-import { ASSISTANT_TURN_PROFILE_MAX_REQUESTS, ASSISTANT_TURN_PROFILE_MAX_TOOL_LABEL_LENGTH, ASSISTANT_TURN_PROFILE_MAX_TOOLS, ASSISTANT_TURN_PROFILE_SCHEMA, } from '@murphai/hosted-execution/assistant-usage';
+import { VAULT_CLI_BATCH_MAX_COMMANDS, VAULT_CLI_BATCH_RESULT_SCHEMA, } from '@murphai/operator-config/vault-cli-contracts';
+import { resolveCodexCommandFamily, } from '../../assistant-codex/command-family.js';
+import { isCodexActionStructurallyFailed, } from '../../assistant-codex/action-outcome.js';
+import { buildAssistantTurnProfileToolIdentityLabel, ASSISTANT_TURN_PROFILE_MAX_REQUESTS, ASSISTANT_TURN_PROFILE_MAX_TOOLS, ASSISTANT_TURN_PROFILE_SCHEMA, } from '@murphai/hosted-execution/assistant-usage';
 import { resolveHostedAiUsageTokenPricingBasis, } from '@murphai/hosted-execution/runtime-control';
 const CODEX_USAGE_EXTRACTION_VERSION = 'codex-usage-v1';
 function requireAssistantProviderUserPrompt(input) {
@@ -15,15 +20,7 @@ function requireAssistantProviderUserPrompt(input) {
     throw new Error('Assistant provider turns require either prompt or userPrompt.');
 }
 function hasAssistantProviderUsableNativeResume(input) {
-    const resumeCodexThreadId = normalizeNullableString(input.resume?.codexThreadId);
-    if (!resumeCodexThreadId) {
-        return false;
-    }
-    if (!supportsAssistantNativeResume(input.providerConfig)) {
-        return false;
-    }
-    void resumeCodexThreadId;
-    return true;
+    return normalizeNullableString(input.resume?.codexThreadId) !== null;
 }
 export function resolveAssistantProviderHistoryMode(input) {
     if (hasAssistantProviderUsableNativeResume(input)) {
@@ -166,110 +163,88 @@ function upsertCodexConfigOverride(overrides, key, value) {
     overrides.push(`${key}=${value}`);
 }
 export function extractCodexAssistantProviderUsage(input) {
-    const completionEvent = findAssistantCodexCompletionEvent(input.rawEvents);
-    const completionRecord = completionEvent ? readAssistantProviderRecord(completionEvent) : null;
-    const completionParams = readAssistantProviderRecord(completionRecord?.params);
-    const completionTurn = readAssistantProviderRecord(completionParams?.turn) ??
-        readAssistantProviderRecord(completionRecord?.turn);
-    const completionMetrics = readAssistantProviderRecord(completionParams?.metrics) ??
-        readAssistantProviderRecord(completionRecord?.metrics);
-    const turnId = readAssistantCodexTurnIdFromCompletion({
-        completionParams,
-        completionRecord,
-        completionTurn,
-    });
-    const usageSource = resolveAssistantProviderUsageSource({
-        completionMetrics,
-        completionParams,
-        completionRecord,
-        completionTurn,
+    const completion = findAssistantCodexCompletionEvent(input.rawEvents);
+    const completionTurn = completion
+        ? readCodexRecord(completion.params.turn)
+        : null;
+    const turnId = readCodexNonEmptyString(completionTurn?.id);
+    const usageSource = findAssistantCodexThreadTokenUsageSource({
         rawEvents: input.rawEvents,
         turnId,
     });
-    const usageRecord = usageSource?.record ?? null;
-    const sanitizedRawUsageJson = sanitizeAssistantProviderRawUsageJson(usageRecord ?? completionRecord);
+    const usage = usageSource?.record ?? null;
+    const sanitizedRawUsageJson = usage ? sanitizeCodexUsage(usage) : null;
     const turnProfileJson = buildAssistantCodexTurnProfileJson({
         rawEvents: input.rawEvents,
         turnId,
     });
-    const inputTokens = readAssistantProviderInteger(usageRecord ?? completionRecord, 'inputTokens', 'input_tokens', 'prompt_tokens', 'promptTokens');
-    const outputTokens = readAssistantProviderInteger(usageRecord ?? completionRecord, 'outputTokens', 'output_tokens', 'completion_tokens', 'completionTokens');
-    const providerName = input.providerConfig.target.kind === 'codex-cli'
-        ? input.providerConfig.target.modelProvider
-        : null;
+    const providerName = resolveAssistantCodexUsageProviderName(input.providerConfig.target.modelProvider);
     const requestedModel = input.providerConfig.target.model;
-    const servedModel = readAssistantProviderString(completionTurn?.model, completionRecord?.model, completionRecord?.model_id, completionRecord?.modelId) ?? requestedModel;
+    const servedModel = findAssistantCodexCurrentTurnReroutedModel({
+        rawEvents: input.rawEvents,
+        turnId,
+    }) ?? requestedModel;
     return {
         apiKeyEnv: null,
         baseUrl: null,
-        cacheWriteTokens: readAssistantProviderInteger(usageRecord ?? completionRecord, 'cacheWriteTokens', 'cache_write_tokens'),
-        cachedInputTokens: readAssistantProviderInteger(usageRecord ?? completionRecord, 'cachedInputTokens', 'cached_input_tokens') ?? readAssistantProviderNestedInteger(usageRecord ?? completionRecord, 'input_tokens_details', 'cached_tokens') ?? readAssistantProviderNestedInteger(usageRecord ?? completionRecord, 'prompt_tokens_details', 'cached_tokens'),
-        inputTokens,
-        outputTokens,
-        providerMetadataJson: completionRecord ?? null,
+        cacheWriteTokens: usage?.cacheWriteInputTokens ?? null,
+        cachedInputTokens: usage?.cachedInputTokens ?? null,
+        inputTokens: usage?.inputTokens ?? null,
+        outputTokens: usage?.outputTokens ?? null,
+        providerMetadataJson: completion ?? null,
         providerName,
-        providerRequestId: readAssistantProviderString(completionRecord?.request_id, completionRecord?.requestId, completionTurn?.id, completionRecord?.id),
+        providerRequestId: turnId,
         rawUsageJson: sanitizedRawUsageJson,
         rawUsageJsonHash: sanitizedRawUsageJson
             ? hashAssistantProviderStableJson(sanitizedRawUsageJson)
             : null,
-        reasoningTokens: readAssistantProviderInteger(usageRecord ?? completionRecord, 'reasoningTokens', 'reasoning_tokens', 'reasoningOutputTokens') ?? readAssistantProviderNestedInteger(usageRecord ?? completionRecord, 'output_tokens_details', 'reasoning_tokens'),
+        reasoningTokens: usage?.reasoningOutputTokens ?? null,
         requestedModel,
         servedModel,
         tokenPricingBasis: resolveCodexAssistantProviderTokenPricingBasis({
-            model: requestedModel,
+            model: servedModel,
             modelProvider: providerName,
             serviceTier: input.serviceTier ?? null,
         }),
-        totalTokens: readAssistantProviderInteger(usageRecord ?? completionRecord, 'totalTokens', 'total_tokens')
-            ?? resolveAssistantProviderTotalTokens({
-                inputTokens,
-                outputTokens,
-            }),
+        totalTokens: usage?.totalTokens ?? null,
         turnProfileJson,
-        usageExtractionSourcePath: usageSource?.sourcePath ?? (completionRecord ? 'completion' : null),
+        usageExtractionSourcePath: usageSource?.sourcePath ?? null,
         usageExtractionVersion: CODEX_USAGE_EXTRACTION_VERSION,
     };
 }
-function resolveAssistantProviderUsageSource(input) {
-    const candidates = [
-        {
-            record: readAssistantProviderRecord(input.completionParams?.usage),
-            sourcePath: 'params.usage',
-        },
-        {
-            record: readAssistantProviderRecord(input.completionTurn?.usage),
-            sourcePath: input.completionParams?.turn ? 'params.turn.usage' : 'turn.usage',
-        },
-        {
-            record: readAssistantProviderRecord(input.completionMetrics?.usage),
-            sourcePath: input.completionParams?.metrics ? 'params.metrics.usage' : 'metrics.usage',
-        },
-        {
-            record: readAssistantProviderRecord(input.completionRecord?.usage),
-            sourcePath: 'usage',
-        },
-    ];
-    for (const candidate of candidates) {
-        if (hasAssistantProviderUsageTokenFields(candidate.record)) {
-            return {
-                record: candidate.record,
-                sourcePath: candidate.sourcePath,
-            };
+function findAssistantCodexCurrentTurnReroutedModel(input) {
+    let currentTurnId = input.turnId;
+    let currentTurnStarted = false;
+    let servedModel = null;
+    for (const rawEvent of input.rawEvents) {
+        const notification = readCodexServerNotification(rawEvent);
+        if (!notification) {
+            continue;
+        }
+        if (notification.method === 'turn/started') {
+            const startedTurnId = readCodexNonEmptyString(readCodexRecord(notification.params.turn)?.id);
+            if (startedTurnId) {
+                currentTurnId ??= startedTurnId;
+                currentTurnStarted = startedTurnId === currentTurnId;
+            }
+            continue;
+        }
+        if (!currentTurnStarted) {
+            continue;
+        }
+        if (notification.method === 'model/rerouted') {
+            servedModel = readCodexNonEmptyString(notification.params.toModel)
+                ?? servedModel;
+            continue;
+        }
+        if (notification.method === 'turn/completed') {
+            const completedTurnId = readCodexNonEmptyString(readCodexRecord(notification.params.turn)?.id);
+            if (completedTurnId === currentTurnId) {
+                break;
+            }
         }
     }
-    return findAssistantCodexThreadTokenUsageSource({
-        rawEvents: input.rawEvents,
-        turnId: input.turnId,
-    });
-}
-function hasAssistantProviderUsageTokenFields(record) {
-    if (!record) {
-        return false;
-    }
-    return (readAssistantProviderInteger(record, 'cacheWriteTokens', 'cache_write_tokens', 'cachedInputTokens', 'cached_input_tokens', 'inputTokens', 'input_tokens', 'prompt_tokens', 'promptTokens', 'outputTokens', 'output_tokens', 'completion_tokens', 'completionTokens', 'reasoningTokens', 'reasoning_tokens', 'reasoningOutputTokens', 'totalTokens', 'total_tokens') !== null ||
-        readAssistantProviderNestedInteger(record, 'input_tokens_details', 'cached_tokens') !== null ||
-        readAssistantProviderNestedInteger(record, 'output_tokens_details', 'reasoning_tokens') !== null);
+    return servedModel;
 }
 function findAssistantCodexThreadTokenUsageSource(input) {
     const tokenUsageEvents = readAssistantCodexThreadTokenUsageEvents(input);
@@ -280,83 +255,45 @@ function findAssistantCodexThreadTokenUsageSource(input) {
             sourcePath: 'thread.tokenUsage.total.delta',
         };
     }
-    for (let index = tokenUsageEvents.length - 1; index >= 0; index -= 1) {
-        const event = tokenUsageEvents[index];
-        if (hasAssistantProviderUsageTokenFields(event.last)) {
-            return {
-                record: event.last,
-                sourcePath: 'thread.tokenUsage.last',
-            };
+    const last = tokenUsageEvents.at(-1)?.last ?? null;
+    return last
+        ? {
+            record: last,
+            sourcePath: 'thread.tokenUsage.last',
         }
-    }
-    return null;
+        : null;
 }
 function readAssistantCodexThreadTokenUsageEvents(input) {
     const turnStartedEventIndex = findAssistantCodexTurnStartedEventIndex(input);
     const currentTurnOutputEventIndex = findAssistantCodexCurrentTurnOutputEventIndex({
-        rawEvents: input.rawEvents,
-        turnId: input.turnId,
+        ...input,
         turnStartedEventIndex,
     });
     const events = input.rawEvents.flatMap((rawEvent, index) => {
         const pair = readAssistantCodexTokenUsagePairFromEvent(rawEvent);
         if (!pair ||
+            (input.turnId !== null && pair.turnId !== input.turnId) ||
             (turnStartedEventIndex !== null && index < turnStartedEventIndex)) {
             return [];
         }
-        const record = readAssistantProviderRecord(rawEvent);
-        if (!isAssistantCodexTokenUsageEventForTurn(record, input.turnId)) {
-            return [];
-        }
-        return [
-            {
-                index,
-                ...pair,
-            },
-        ];
+        return [{ index, ...pair }];
     });
     if (currentTurnOutputEventIndex === null) {
-        return events.map(({ last, tokenUsage, total }) => ({
-            last,
-            tokenUsage,
-            total,
-        }));
+        return events;
     }
     const postOutputEvents = events.filter((event) => event.index >= currentTurnOutputEventIndex);
-    const selectedEvents = postOutputEvents.length > 0 ? postOutputEvents : events;
-    return selectedEvents.map(({ last, tokenUsage, total }) => ({
-        last,
-        tokenUsage,
-        total,
-    }));
+    return postOutputEvents.length > 0 ? postOutputEvents : events;
+}
+function sanitizeCodexUsage(usage) {
+    return {
+        cacheWriteInputTokens: usage.cacheWriteInputTokens,
+        cachedInputTokens: usage.cachedInputTokens,
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        reasoningOutputTokens: usage.reasoningOutputTokens,
+        totalTokens: usage.totalTokens,
+    };
 }
-const ASSISTANT_TURN_PROFILE_SAFE_TOKEN_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/u;
-const ASSISTANT_TURN_PROFILE_SUBCOMMAND_TOKEN_PATTERN = /^[a-z][a-z0-9-]{0,24}$/u;
-const ASSISTANT_TURN_PROFILE_SHELL_TOKEN_PATTERN = /^(?:.*\/)?(?:ba|z|da)?sh$/u;
-// Codex shlex-joins shell executions into `bash -lc <script>` (multi-word
-// scripts arrive double-quoted), so strip one wrapper prefix before labeling.
-const ASSISTANT_TURN_PROFILE_SHELL_WRAPPER_PREFIX_PATTERN = /^\s*(?:\S*\/)?(?:ba|z|da)?sh\s+-[a-z]*c[a-z]*\s+/u;
-// Only these head binaries get subcommand tokens in persisted labels. For any
-// other command the first positional token can be member content (search
-// terms, vault paths), so the label stops at the binary name.
-const ASSISTANT_TURN_PROFILE_SUBCOMMAND_HEAD_BINARIES = new Set(['vault-cli', 'murph']);
-// Codex also emits a best-effort parsed commandActions array. Use only these
-// fixed executable names to retain an ordered compound-command chain or when
-// shell-wrapper quoting makes the raw command fail closed; never persist an
-// action argument, path, query, or arbitrary head.
-const ASSISTANT_TURN_PROFILE_STRUCTURED_COMMAND_HEAD_BINARIES = new Set([
-    'cat',
-    'grep',
-    'head',
-    'jq',
-    'murph',
-    'node',
-    'printf',
-    'rg',
-    'sed',
-    'tail',
-    'vault-cli',
-]);
 // Compact per-turn profile derived entirely from notifications Codex already
 // emits (thread/tokenUsage/updated per provider request, item/completed per
 // tool call). This is what lets prod answer "which tool calls and which
@@ -365,58 +302,55 @@ const ASSISTANT_TURN_PROFILE_STRUCTURED_COMMAND_HEAD_BINARIES = new Set([
 // totals so the profile always reconciles with the row's token deltas.
 export function buildAssistantCodexTurnProfileJson(input) {
     const tokenUsageEvents = readAssistantCodexThreadTokenUsageEvents(input);
-    const requests = [];
-    let modelContextWindow = null;
-    for (const event of tokenUsageEvents) {
-        modelContextWindow =
-            readAssistantProviderInteger(event.tokenUsage, 'modelContextWindow', 'model_context_window') ?? modelContextWindow;
-        if (event.last) {
-            requests.push({
-                cachedInput: readAssistantProviderInteger(event.last, 'cachedInputTokens', 'cached_input_tokens')
-                    ?? 0,
-                input: readAssistantProviderInteger(event.last, 'inputTokens', 'input_tokens') ?? 0,
-                output: readAssistantProviderInteger(event.last, 'outputTokens', 'output_tokens') ?? 0,
-            });
-        }
-    }
-    const toolsByLabel = new Map();
+    const requests = tokenUsageEvents.map((event) => ({
+        cachedInput: event.last.cachedInputTokens,
+        input: event.last.inputTokens,
+        output: event.last.outputTokens,
+    }));
+    const modelContextWindow = tokenUsageEvents.at(-1)?.tokenUsage.modelContextWindow
+        ?? null;
+    const toolsByKindAndLabel = new Map();
+    let toolAttributionTruncated = false;
     const startIndex = findAssistantCodexTurnStartedEventIndex(input) ?? 0;
     for (let index = startIndex; index < input.rawEvents.length; index += 1) {
-        const record = readAssistantProviderRecord(input.rawEvents[index]);
-        const eventType = readAssistantProviderString(record?.method, record?.type, record?.event);
-        if (eventType !== 'item/completed' && eventType !== 'item.completed') {
+        const notification = readCodexServerNotification(input.rawEvents[index]);
+        if (notification?.method !== 'item/completed') {
             continue;
         }
-        // Replayed foreign-turn items must not inflate this turn's aggregates;
-        // stay lenient when the event predates turn-id stamping.
-        const itemTurnId = readAssistantCodexTurnIdFromRecord(record);
-        if (input.turnId && itemTurnId && itemTurnId !== input.turnId) {
+        if (input.turnId !== null &&
+            readCodexNonEmptyString(notification.params.turnId) !== input.turnId) {
             continue;
         }
-        const params = readAssistantProviderRecord(record?.params);
-        const item = readAssistantProviderRecord(params?.item);
-        const aggregate = readAssistantTurnProfileToolAggregate(item);
-        if (!aggregate) {
+        const item = readCodexRecord(notification.params.item);
+        const toolRead = readAssistantTurnProfileToolAggregates(item);
+        if (!toolRead) {
             continue;
         }
-        const existing = toolsByLabel.get(aggregate.label);
-        if (existing) {
-            existing.calls += aggregate.calls;
-            existing.durationMs += aggregate.durationMs;
-            existing.outputChars += aggregate.outputChars;
-        }
-        else {
-            toolsByLabel.set(aggregate.label, aggregate);
+        toolAttributionTruncated ||= toolRead.attributionTruncated;
+        for (const aggregate of toolRead.aggregates) {
+            const aggregateKey = JSON.stringify([aggregate.kind, aggregate.label]);
+            const existing = toolsByKindAndLabel.get(aggregateKey);
+            if (existing) {
+                if (!mergeAssistantTurnProfileToolAggregate(existing, aggregate)) {
+                    return null;
+                }
+            }
+            else {
+                toolsByKindAndLabel.set(aggregateKey, aggregate);
+            }
         }
     }
-    if (requests.length === 0 && toolsByLabel.size === 0) {
+    if (requests.length === 0 && toolsByKindAndLabel.size === 0) {
         return null;
     }
-    const tools = [...toolsByLabel.values()].sort((left, right) => {
-        const durationDelta = right.durationMs - left.durationMs;
-        return durationDelta !== 0
-            ? durationDelta
-            : right.outputChars - left.outputChars;
+    const tools = [...toolsByKindAndLabel.values()].sort((left, right) => {
+        if (right.durationMs !== left.durationMs) {
+            return right.durationMs > left.durationMs ? 1 : -1;
+        }
+        if (right.outputBytesTotal !== left.outputBytesTotal) {
+            return right.outputBytesTotal > left.outputBytesTotal ? 1 : -1;
+        }
+        return 0;
     });
     return {
         modelContextWindow,
@@ -424,367 +358,373 @@ export function buildAssistantCodexTurnProfileJson(input) {
         requests: requests.slice(-ASSISTANT_TURN_PROFILE_MAX_REQUESTS),
         requestsTruncated: requests.length > ASSISTANT_TURN_PROFILE_MAX_REQUESTS,
         schema: ASSISTANT_TURN_PROFILE_SCHEMA,
-        tools: tools.slice(0, ASSISTANT_TURN_PROFILE_MAX_TOOLS),
-        toolsTruncated: tools.length > ASSISTANT_TURN_PROFILE_MAX_TOOLS,
+        tools: tools.slice(0, ASSISTANT_TURN_PROFILE_MAX_TOOLS).map((tool) => ({
+            calls: tool.calls,
+            durationKnownCalls: tool.durationKnownCalls,
+            durationMs: tool.durationMs,
+            failedCalls: tool.failedCalls,
+            kind: tool.kind,
+            label: tool.label,
+            outputBytesMax: tool.outputBytesMax,
+            outputBytesTotal: tool.outputBytesTotal,
+        })),
+        toolsTruncated: toolAttributionTruncated
+            || tools.length > ASSISTANT_TURN_PROFILE_MAX_TOOLS,
     };
 }
-function readAssistantTurnProfileToolAggregate(item) {
+function readAssistantTurnProfileToolAggregates(item) {
     const itemType = readAssistantProviderString(item?.type);
     if (!item || !itemType) {
         return null;
     }
     if (itemType === 'commandExecution') {
+        const aggregatedOutput = item.aggregatedOutput;
+        const label = resolveCodexCommandFamily({
+            allowKnownShellWrapper: true,
+            commandLabel: readAssistantProviderString(item.command),
+            source: 'display',
+        });
+        if (label === 'vault-cli batch') {
+            const batchRead = readAssistantTurnProfileBatchToolAggregates(aggregatedOutput);
+            if (batchRead !== null) {
+                return {
+                    aggregates: batchRead,
+                    attributionTruncated: false,
+                };
+            }
+        }
+        const durationMs = readAssistantProviderInteger(item, 'durationMs');
+        const outputBytes = readAssistantTurnProfileUtf8Bytes(aggregatedOutput);
         return {
-            calls: 1,
-            durationMs: readAssistantProviderInteger(item, 'durationMs', 'duration_ms') ?? 0,
-            label: buildAssistantTurnProfileCommandLabel(readAssistantProviderString(item.command), item.commandActions ?? item.command_actions),
-            outputChars: readAssistantTurnProfileTextLength(item.aggregatedOutput ?? item.aggregated_output),
+            aggregates: [{
+                    calls: 1,
+                    durationKnownCalls: durationMs === null ? 0 : 1,
+                    durationMs: durationMs ?? 0,
+                    failedCalls: isCodexActionStructurallyFailed({ item }) ? 1 : 0,
+                    kind: 'command',
+                    label,
+                    outputBytesMax: outputBytes,
+                    outputBytesTotal: outputBytes,
+                }],
+            attributionTruncated: label === 'vault-cli batch',
         };
     }
     if (itemType === 'mcpToolCall' || itemType === 'dynamicToolCall') {
-        const server = readAssistantProviderString(item.server);
-        const tool = readAssistantProviderString(item.tool, item.name);
-        const label = [server, tool]
-            .filter((part) => part !== null && ASSISTANT_TURN_PROFILE_SAFE_TOKEN_PATTERN.test(part))
-            .join('.');
+        const tool = readAssistantProviderString(item.tool);
+        const kind = itemType === 'mcpToolCall' ? 'mcp_tool' : 'dynamic_tool';
+        const label = buildAssistantTurnProfileToolIdentityLabel({
+            kind,
+            tool,
+        });
+        const durationMs = readAssistantProviderInteger(item, 'durationMs');
+        const outputBytes = readAssistantTurnProfileUtf8Bytes(itemType === 'mcpToolCall' ? item.result : item.contentItems);
         return {
-            calls: 1,
-            durationMs: readAssistantProviderInteger(item, 'durationMs', 'duration_ms') ?? 0,
-            label: truncateAssistantTurnProfileLabel(label.length > 0 ? label : itemType),
-            outputChars: readAssistantTurnProfileTextLength(item.result),
+            aggregates: [{
+                    calls: 1,
+                    durationKnownCalls: durationMs === null ? 0 : 1,
+                    durationMs: durationMs ?? 0,
+                    failedCalls: isCodexActionStructurallyFailed({ item }) ? 1 : 0,
+                    kind,
+                    label,
+                    outputBytesMax: outputBytes,
+                    outputBytesTotal: outputBytes,
+                }],
+            attributionTruncated: false,
         };
     }
     return null;
 }
-// Tool labels must stay secret-safe: persist only the binary name unless the
-// head binary is a known subcommand-style CLI, because the first positional
-// argument of arbitrary commands (grep patterns, file paths) can carry member
-// health content even when it matches a benign-looking token charset.
-function buildAssistantTurnProfileCommandLabel(command, commandActions) {
-    const tokens = unwrapAssistantTurnProfileShellWrapper(command ?? '')
-        .split(/\s+/u)
-        .filter((token) => token.length > 0);
-    const labelTokens = [];
-    for (const token of tokens) {
-        if (labelTokens.length === 0) {
-            // A shell or flag head surviving wrapper stripping is not a labelable
-            // binary (`bash member-script.sh` would put the script filename in the
-            // head slot): fail closed instead of skipping into positional content.
-            if (ASSISTANT_TURN_PROFILE_SHELL_TOKEN_PATTERN.test(token) || token.startsWith('-')) {
-                break;
-            }
-            // Path-invoked binaries (`scripts/check-x.sh`) can carry member-named
-            // files; only bare binary names may persist.
-            if (!ASSISTANT_TURN_PROFILE_SAFE_TOKEN_PATTERN.test(token) || token.includes('/')) {
-                break;
-            }
-            labelTokens.push(token);
-            if (!ASSISTANT_TURN_PROFILE_SUBCOMMAND_HEAD_BINARIES.has(token)) {
-                break;
-            }
-            continue;
-        }
-        if (!ASSISTANT_TURN_PROFILE_SUBCOMMAND_TOKEN_PATTERN.test(token)) {
-            break;
-        }
-        labelTokens.push(token);
-        if (labelTokens.length >= 3) {
-            break;
-        }
+function readAssistantTurnProfileBatchToolAggregates(value) {
+    if (typeof value !== 'string' || value.length === 0) {
+        return null;
     }
-    if (labelTokens.length > 0) {
-        const rawLabel = labelTokens.join(' ');
-        const structuredHeads = readAssistantTurnProfileStructuredCommandHeads(commandActions);
-        if (structuredHeads.length > 1
-            && structuredHeads[0] === labelTokens[0]) {
-            return truncateAssistantTurnProfileLabel([rawLabel, ...structuredHeads.slice(1)].join(' '));
-        }
-        return truncateAssistantTurnProfileLabel(rawLabel);
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
     }
-    const structuredHeads = readAssistantTurnProfileStructuredCommandHeads(commandActions);
-    return structuredHeads.length > 0
-        ? truncateAssistantTurnProfileLabel(structuredHeads.join(' '))
-        : 'command';
-}
-function readAssistantTurnProfileStructuredCommandHeads(value) {
-    if (!Array.isArray(value) || value.length === 0) {
-        return [];
+    catch {
+        return null;
     }
-    const heads = [];
-    for (const action of value) {
-        const command = readAssistantProviderString(readAssistantProviderRecord(action)?.command);
-        const head = command?.split(/\s/u, 1)[0] ?? null;
-        if (!head
-            || head.includes('/')
-            || !ASSISTANT_TURN_PROFILE_SAFE_TOKEN_PATTERN.test(head)
-            || !ASSISTANT_TURN_PROFILE_STRUCTURED_COMMAND_HEAD_BINARIES.has(head)) {
-            return [];
-        }
-        heads.push(head);
+    const result = readAssistantProviderRecord(parsed);
+    if (result?.schema !== VAULT_CLI_BATCH_RESULT_SCHEMA) {
+        return null;
     }
-    return heads;
-}
-// Strip one `bash -lc <script>` wrapper layer so the inner head binary can be
-// labeled. The quoted form unwraps only when the whole remainder is a single
-// quoted region with no unescaped inner quote of the same type; any other
-// shape keeps the original string, whose quote/shell head then fails closed in
-// the token sanitizer. This keeps the fail-closed guarantee independent of how
-// the provider quotes commands.
-function unwrapAssistantTurnProfileShellWrapper(command) {
-    const wrapper = ASSISTANT_TURN_PROFILE_SHELL_WRAPPER_PREFIX_PATTERN.exec(command);
-    if (!wrapper) {
-        return command;
+    const commands = result?.commands;
+    const count = result?.count;
+    const failed = result?.failed;
+    if (!Array.isArray(commands)
+        || commands.length === 0
+        || commands.length > VAULT_CLI_BATCH_MAX_COMMANDS
+        || typeof count !== 'number'
+        || !Number.isSafeInteger(count)
+        || count !== commands.length
+        || typeof failed !== 'number'
+        || !Number.isSafeInteger(failed)
+        || failed < 0) {
+        return null;
     }
-    const script = command.slice(wrapper[0].length);
-    const quote = script[0];
-    if (quote !== '"' && quote !== "'") {
-        return script;
+    const aggregates = [];
+    let failedCommands = 0;
+    for (const value of commands) {
+        const command = readAssistantProviderRecord(value);
+        const argv = command?.argv;
+        const durationMs = command?.durationMs;
+        const ok = command?.ok;
+        // The v1 batch envelope counts UTF-16 code units, not bytes. Validate it
+        // only as part of the envelope; byte metrics come from source-owned bytes.
+        const legacyOutputChars = command?.outputChars;
+        const outputBytes = command?.outputBytes;
+        const stdout = command?.stdout;
+        if (!command
+            || !Array.isArray(argv)
+            || argv.some((token) => typeof token !== 'string')
+            || typeof durationMs !== 'number'
+            || !Number.isSafeInteger(durationMs)
+            || durationMs < 0
+            || typeof ok !== 'boolean'
+            || typeof legacyOutputChars !== 'number'
+            || !Number.isSafeInteger(legacyOutputChars)
+            || legacyOutputChars < 0
+            || typeof outputBytes !== 'number'
+            || !Number.isSafeInteger(outputBytes)
+            || outputBytes < 0
+            || typeof stdout !== 'string'
+            || (stdout.length > 0 && Buffer.byteLength(stdout, 'utf8') !== outputBytes)) {
+            return null;
+        }
+        if (!ok) {
+            const nextFailedCommands = safeAssistantTurnProfileIntegerSum(failedCommands, 1);
+            if (nextFailedCommands === null) {
+                return null;
+            }
+            failedCommands = nextFailedCommands;
+        }
+        aggregates.push({
+            calls: 1,
+            durationKnownCalls: 1,
+            durationMs,
+            failedCalls: ok ? 0 : 1,
+            kind: 'command',
+            label: resolveCodexCommandFamily({
+                argv,
+                source: 'batch_argv',
+            }),
+            outputBytesMax: outputBytes,
+            outputBytesTotal: outputBytes,
+        });
     }
-    if (script.length < 2 || !script.endsWith(quote)) {
-        return command;
+    if (failedCommands !== failed) {
+        return null;
     }
-    const inner = script.slice(1, -1);
-    return hasAssistantTurnProfileUnescapedQuote(inner, quote) ? command : inner;
-}
-function hasAssistantTurnProfileUnescapedQuote(inner, quote) {
-    let backslashes = 0;
-    for (const char of inner) {
-        if (char === '\\') {
-            backslashes += 1;
-            continue;
-        }
-        if (char === quote && backslashes % 2 === 0) {
-            return true;
-        }
-        backslashes = 0;
+    return aggregates;
+}
+function mergeAssistantTurnProfileToolAggregate(target, source) {
+    const calls = safeAssistantTurnProfileIntegerSum(target.calls, source.calls);
+    const durationKnownCalls = safeAssistantTurnProfileIntegerSum(target.durationKnownCalls, source.durationKnownCalls);
+    const durationMs = safeAssistantTurnProfileIntegerSum(target.durationMs, source.durationMs);
+    const failedCalls = safeAssistantTurnProfileIntegerSum(target.failedCalls, source.failedCalls);
+    const outputBytesTotal = safeAssistantTurnProfileIntegerSum(target.outputBytesTotal, source.outputBytesTotal);
+    if (calls === null
+        || durationKnownCalls === null
+        || durationMs === null
+        || failedCalls === null
+        || outputBytesTotal === null) {
+        return false;
     }
-    return false;
+    target.calls = calls;
+    target.durationKnownCalls = durationKnownCalls;
+    target.durationMs = durationMs;
+    target.failedCalls = failedCalls;
+    target.outputBytesMax = Math.max(target.outputBytesMax, source.outputBytesMax);
+    target.outputBytesTotal = outputBytesTotal;
+    return true;
 }
-function truncateAssistantTurnProfileLabel(label) {
-    return label.length > ASSISTANT_TURN_PROFILE_MAX_TOOL_LABEL_LENGTH
-        ? label.slice(0, ASSISTANT_TURN_PROFILE_MAX_TOOL_LABEL_LENGTH)
-        : label;
+function safeAssistantTurnProfileIntegerSum(left, right) {
+    const result = left + right;
+    return Number.isSafeInteger(result) ? result : null;
 }
-function readAssistantTurnProfileTextLength(value) {
+function readAssistantTurnProfileUtf8Bytes(value) {
+    let serialized;
     if (typeof value === 'string') {
-        return value.length;
+        serialized = value;
     }
-    if (value === null || value === undefined) {
-        return 0;
+    else if (value === null || value === undefined) {
+        serialized = '';
     }
-    try {
-        return JSON.stringify(value)?.length ?? 0;
-    }
-    catch {
-        return 0;
+    else {
+        try {
+            serialized = JSON.stringify(value) ?? '';
+        }
+        catch {
+            serialized = '';
+        }
     }
+    return Buffer.byteLength(serialized, 'utf8');
 }
 function findAssistantCodexTurnStartedEventIndex(input) {
     let fallbackIndex = null;
     for (let index = 0; index < input.rawEvents.length; index += 1) {
-        const record = readAssistantProviderRecord(input.rawEvents[index]);
-        const eventType = readAssistantProviderString(record?.method, record?.type, record?.event);
-        if (eventType !== 'turn/started' && eventType !== 'turn.started') {
+        const notification = readCodexServerNotification(input.rawEvents[index]);
+        if (notification?.method !== 'turn/started') {
             continue;
         }
         fallbackIndex ??= index;
-        if (!isAssistantCodexTurnEventForTurn(record, input.turnId)) {
-            continue;
+        if (input.turnId === null) {
+            return index;
+        }
+        const eventTurnId = readCodexNonEmptyString(readCodexRecord(notification.params.turn)?.id);
+        if (eventTurnId === input.turnId) {
+            return index;
         }
-        return index;
     }
     return fallbackIndex;
 }
 function findAssistantCodexCurrentTurnOutputEventIndex(input) {
     const startIndex = input.turnStartedEventIndex ?? 0;
     for (let index = startIndex; index < input.rawEvents.length; index += 1) {
-        const record = readAssistantProviderRecord(input.rawEvents[index]);
-        if (!isAssistantCodexTurnEventForTurn(record, input.turnId)) {
+        const notification = readCodexServerNotification(input.rawEvents[index]);
+        if (!notification ||
+            (input.turnId !== null &&
+                readCodexNotificationTurnId(notification) !== input.turnId)) {
             continue;
         }
-        if (isAssistantCodexCurrentTurnOutputEvent(record)) {
+        if (isAssistantCodexCurrentTurnOutputNotification(notification)) {
             return index;
         }
     }
     return null;
 }
-function isAssistantCodexCurrentTurnOutputEvent(record) {
-    const eventType = readAssistantProviderString(record?.method, record?.type, record?.event);
-    if (eventType === 'assistant.message.delta'
-        || eventType === 'agent.message.delta'
-        || eventType === 'item/agentMessage/delta'
-        || eventType === 'item/plan/delta'
-        || eventType === 'item/reasoning/summaryPartAdded'
-        || eventType === 'item/reasoning/summaryTextDelta'
-        || eventType === 'item/reasoning/textDelta'
-        || eventType === 'rawResponseItem/completed') {
+function readCodexNotificationTurnId(notification) {
+    return readCodexNonEmptyString(notification.params.turnId) ??
+        readCodexNonEmptyString(readCodexRecord(notification.params.turn)?.id);
+}
+function isAssistantCodexCurrentTurnOutputNotification(notification) {
+    if (notification.method === 'item/agentMessage/delta' ||
+        notification.method === 'item/plan/delta' ||
+        notification.method === 'item/reasoning/summaryPartAdded' ||
+        notification.method === 'item/reasoning/summaryTextDelta' ||
+        notification.method === 'item/reasoning/textDelta' ||
+        notification.method === 'rawResponseItem/completed') {
         return true;
     }
-    if (eventType !== 'item/started' && eventType !== 'item/completed') {
+    if (notification.method !== 'item/started' &&
+        notification.method !== 'item/completed') {
         return false;
     }
-    const params = readAssistantProviderRecord(record?.params);
-    const item = readAssistantProviderRecord(params?.item);
-    const itemType = readAssistantProviderString(item?.type);
-    return (itemType === 'agentMessage'
-        || itemType === 'plan'
-        || itemType === 'reasoning'
-        || itemType === 'commandExecution'
-        || itemType === 'fileChange'
-        || itemType === 'mcpToolCall'
-        || itemType === 'dynamicToolCall'
-        || itemType === 'webSearch');
-}
-function isAssistantCodexTokenUsageEventForTurn(record, turnId) {
-    if (!turnId) {
-        return true;
-    }
-    return readAssistantCodexTurnIdFromRecord(record) === turnId;
-}
-function isAssistantCodexTurnEventForTurn(record, turnId) {
-    if (!turnId) {
-        return true;
-    }
-    return readAssistantCodexTurnIdFromRecord(record) === turnId;
-}
-function readAssistantCodexTurnIdFromCompletion(input) {
-    return (readAssistantProviderString(input.completionTurn?.id) ??
-        readAssistantCodexTurnIdFromRecord(input.completionParams) ??
-        readAssistantCodexTurnIdFromRecord(input.completionRecord));
+    const itemType = readCodexNonEmptyString(readCodexRecord(notification.params.item)?.type);
+    return itemType === 'agentMessage' ||
+        itemType === 'plan' ||
+        itemType === 'reasoning' ||
+        itemType === 'commandExecution' ||
+        itemType === 'fileChange' ||
+        itemType === 'mcpToolCall' ||
+        itemType === 'dynamicToolCall' ||
+        itemType === 'webSearch';
 }
 export function isAssistantCodexTokenUsageEventType(eventType) {
-    return (eventType === 'thread/tokenUsage/updated' ||
-        eventType === 'thread/token_usage/updated' ||
-        eventType === 'thread.tokenUsage.updated' ||
-        eventType === 'thread.token.usage.updated' ||
-        eventType === 'thread.token_usage.updated');
-}
-function readAssistantCodexTokenUsageRecord(record) {
-    const params = readAssistantProviderRecord(record?.params);
-    const data = readAssistantProviderRecord(record?.data);
-    return (readAssistantProviderRecord(params?.tokenUsage) ??
-        readAssistantProviderRecord(params?.token_usage) ??
-        readAssistantProviderRecord(data?.tokenUsage) ??
-        readAssistantProviderRecord(data?.token_usage) ??
-        readAssistantProviderRecord(record?.tokenUsage) ??
-        readAssistantProviderRecord(record?.token_usage));
+    return eventType === 'thread/tokenUsage/updated';
 }
 function readAssistantCodexTokenUsagePairFromEvent(rawEvent) {
-    const record = readAssistantProviderRecord(rawEvent);
-    const eventType = readAssistantProviderString(record?.method, record?.type, record?.event);
-    if (!isAssistantCodexTokenUsageEventType(eventType)) {
+    const notification = readCodexServerNotification(rawEvent);
+    if (notification?.method !== 'thread/tokenUsage/updated') {
+        return null;
+    }
+    const threadId = readCodexNonEmptyString(notification.params.threadId);
+    const turnId = readCodexNonEmptyString(notification.params.turnId);
+    const tokenUsage = readCodexThreadTokenUsage(notification.params.tokenUsage);
+    if (!threadId || !turnId || !tokenUsage) {
         return null;
     }
-    const tokenUsage = readAssistantCodexTokenUsageRecord(record);
     return {
-        last: readAssistantProviderRecord(tokenUsage?.last),
+        last: tokenUsage.last,
+        threadId,
         tokenUsage,
-        total: readAssistantProviderRecord(tokenUsage?.total),
+        total: tokenUsage.total,
+        turnId,
     };
 }
-function readAssistantCodexTurnIdFromRecord(record) {
-    const params = readAssistantProviderRecord(record?.params);
-    const data = readAssistantProviderRecord(record?.data);
-    const turn = readAssistantProviderRecord(params?.turn) ??
-        readAssistantProviderRecord(data?.turn) ??
-        readAssistantProviderRecord(record?.turn);
-    return readAssistantProviderString(turn?.id, params?.turnId, params?.turn_id, data?.turnId, data?.turn_id, record?.turnId, record?.turn_id);
-}
 function resolveAssistantCodexThreadTokenUsageTotalDelta(events) {
-    const first = events.find((event) => hasAssistantProviderUsageTokenFields(event.last)
-        && hasAssistantProviderUsageTokenFields(event.total));
-    const final = [...events].reverse().find((event) => hasAssistantProviderUsageTokenFields(event.last)
-        && hasAssistantProviderUsageTokenFields(event.total));
-    if (!first?.last || !first.total || !final?.total) {
+    const first = events[0];
+    const final = events.at(-1);
+    if (!first || !final) {
         return null;
     }
-    const priorThreadBaseline = subtractAssistantProviderUsageRecords(first.total, first.last);
-    const currentTurnUsage = subtractAssistantProviderUsageRecords(final.total, priorThreadBaseline);
-    if (readAssistantProviderInteger(currentTurnUsage, 'totalTokens') === null) {
-        const totalTokens = resolveAssistantProviderTotalTokens({
-            inputTokens: readAssistantProviderInteger(currentTurnUsage, 'inputTokens'),
-            outputTokens: readAssistantProviderInteger(currentTurnUsage, 'outputTokens'),
-        });
-        if (totalTokens !== null) {
-            currentTurnUsage.totalTokens = totalTokens;
-        }
-    }
-    return hasAssistantProviderUsageTokenFields(currentTurnUsage)
-        ? currentTurnUsage
-        : null;
+    const priorThreadBaseline = subtractCodexTokenUsage(first.total, first.last);
+    return subtractCodexTokenUsage(final.total, priorThreadBaseline);
 }
-function subtractAssistantProviderUsageRecords(minuend, subtrahend) {
-    const result = {};
-    copyAssistantProviderUsageDifference(result, 'cacheWriteTokens', minuend, subtrahend, ['cacheWriteTokens', 'cache_write_tokens']);
-    copyAssistantProviderUsageDifference(result, 'cachedInputTokens', minuend, subtrahend, ['cachedInputTokens', 'cached_input_tokens'], {
-        nested: [
-            ['input_tokens_details', 'cached_tokens'],
-            ['prompt_tokens_details', 'cached_tokens'],
-        ],
-    });
-    copyAssistantProviderUsageDifference(result, 'inputTokens', minuend, subtrahend, ['inputTokens', 'input_tokens', 'prompt_tokens', 'promptTokens']);
-    copyAssistantProviderUsageDifference(result, 'outputTokens', minuend, subtrahend, ['outputTokens', 'output_tokens', 'completion_tokens', 'completionTokens']);
-    copyAssistantProviderUsageDifference(result, 'reasoningOutputTokens', minuend, subtrahend, ['reasoningTokens', 'reasoning_tokens', 'reasoningOutputTokens'], {
-        nested: [['output_tokens_details', 'reasoning_tokens']],
-    });
-    copyAssistantProviderUsageDifference(result, 'totalTokens', minuend, subtrahend, ['totalTokens', 'total_tokens']);
-    return result;
+function subtractCodexTokenUsage(minuend, subtrahend) {
+    return {
+        cacheWriteInputTokens: Math.max(0, minuend.cacheWriteInputTokens - subtrahend.cacheWriteInputTokens),
+        cachedInputTokens: Math.max(0, minuend.cachedInputTokens - subtrahend.cachedInputTokens),
+        inputTokens: Math.max(0, minuend.inputTokens - subtrahend.inputTokens),
+        outputTokens: Math.max(0, minuend.outputTokens - subtrahend.outputTokens),
+        reasoningOutputTokens: Math.max(0, minuend.reasoningOutputTokens - subtrahend.reasoningOutputTokens),
+        totalTokens: Math.max(0, minuend.totalTokens - subtrahend.totalTokens),
+    };
 }
 // Codex ships no aggregate usage primitive for spawned subagent threads (no
 // usage RPC, no usage on the protocol Turn, no parent-side aggregation), so
 // the canonical pattern is consuming each child thread's tokenUsage
 // notifications. This converts the buffered first/final tokenUsage samples
-// per child thread into additional usage drafts on the parent turn, using
-// the same total-delta arithmetic as the parent's billed usage. Billing is
+// per child turn into additional usage drafts on the parent turn, using the
+// same total-delta arithmetic as the parent's billed usage. Billing is
 // gated on spawn evidence: only threads named by a parent-thread
 // collabAgentToolCall item's receiverThreadIds (multi-agent V1: spawnAgent,
 // sendInput, wait, resume — covering freshly spawned and reused children) or
 // by a subAgentActivity item's agentThreadId (multi-agent V2, which emits
 // activity items instead of collab tool calls) become drafts. The model is
-// attributed from V1 spawn items, the only ones that carry it; V2 children
-// inherit the parent model by default, so evidence without a model falls
-// back to parentModel. Warm processes are reused across threads, so a
-// foreign thread id alone is not proof of a subagent — a stale flush from a
-// previous thread must never mint a usage row.
+// attributed directly from V1 spawn items or optional V2 activity evidence;
+// same-model children without explicit evidence inherit parentModel. Warm
+// processes are reused across threads, so a foreign thread id alone is not
+// proof of a subagent — a stale flush from a previous thread must never mint a
+// usage row.
 export function extractCodexSubagentUsageDrafts(input) {
-    if (input.subagentTokenUsageByThread.size === 0) {
+    if (input.subagentTokenUsageByTurn.size === 0) {
         return [];
     }
     const spawnModelByThreadId = readCodexCollabSpawnModelsByThread(input.parentRawEvents);
-    const attributedThreads = [...input.subagentTokenUsageByThread].filter(([threadId]) => spawnModelByThreadId.has(threadId));
     const drafts = [];
     let ordinal = input.ordinalStart;
-    for (const [threadId, sample] of attributedThreads) {
+    for (const sample of input.subagentTokenUsageByTurn.values()) {
+        if (!spawnModelByThreadId.has(sample.threadId)) {
+            continue;
+        }
         const pairs = (sample.firstEvent === sample.lastEvent
             ? [sample.firstEvent]
             : [sample.firstEvent, sample.lastEvent]).flatMap((event) => {
             const pair = readAssistantCodexTokenUsagePairFromEvent(event);
-            return pair ? [pair] : [];
+            return pair &&
+                pair.threadId === sample.threadId &&
+                pair.turnId === sample.turnId
+                ? [pair]
+                : [];
         });
         const delta = resolveAssistantCodexThreadTokenUsageTotalDelta(pairs);
         if (!delta) {
             continue;
         }
-        const model = spawnModelByThreadId.get(threadId) ?? input.parentModel ?? null;
-        const inputTokens = readAssistantProviderInteger(delta, 'inputTokens', 'input_tokens');
-        const outputTokens = readAssistantProviderInteger(delta, 'outputTokens', 'output_tokens');
+        const model = spawnModelByThreadId.get(sample.threadId)
+            ?? input.parentModel
+            ?? null;
+        const rawUsageJson = sanitizeCodexUsage(delta);
         drafts.push({
+            occurredAt: sample.occurredAt,
             provider: 'codex-cli',
             providerRequestOrdinal: ordinal++,
             providerRequestOutcome: 'succeeded',
             usage: {
                 apiKeyEnv: null,
                 baseUrl: null,
-                cacheWriteTokens: readAssistantProviderInteger(delta, 'cacheWriteTokens', 'cache_write_tokens'),
-                cachedInputTokens: readAssistantProviderInteger(delta, 'cachedInputTokens', 'cached_input_tokens'),
-                inputTokens,
-                outputTokens,
+                cacheWriteTokens: delta.cacheWriteInputTokens,
+                cachedInputTokens: delta.cachedInputTokens,
+                inputTokens: delta.inputTokens,
+                outputTokens: delta.outputTokens,
                 providerMetadataJson: null,
-                providerName: input.modelProvider,
+                providerName: resolveAssistantCodexUsageProviderName(input.modelProvider),
                 providerRequestId: null,
-                rawUsageJson: delta,
-                rawUsageJsonHash: hashAssistantProviderStableJson(delta),
-                reasoningTokens: readAssistantProviderInteger(delta, 'reasoningTokens', 'reasoning_tokens', 'reasoningOutputTokens', 'reasoning_output_tokens'),
+                rawUsageJson,
+                rawUsageJsonHash: hashAssistantProviderStableJson(rawUsageJson),
+                reasoningTokens: delta.reasoningOutputTokens,
                 requestedModel: model,
                 servedModel: model,
                 tokenPricingBasis: resolveCodexAssistantProviderTokenPricingBasis({
@@ -792,12 +732,8 @@ export function extractCodexSubagentUsageDrafts(input) {
                     modelProvider: input.modelProvider,
                     serviceTier: input.serviceTier ?? null,
                 }),
-                totalTokens: readAssistantProviderInteger(delta, 'totalTokens', 'total_tokens') ??
-                    resolveAssistantProviderTotalTokens({
-                        inputTokens,
-                        outputTokens,
-                    }),
-                usageExtractionSourcePath: 'subagent.thread.tokenUsage.total.delta',
+                totalTokens: delta.totalTokens,
+                usageExtractionSourcePath: 'subagent.turn.tokenUsage.total.delta',
                 usageExtractionVersion: CODEX_USAGE_EXTRACTION_VERSION,
             },
         });
@@ -807,16 +743,14 @@ export function extractCodexSubagentUsageDrafts(input) {
 export function resolveCodexAssistantProviderTokenPricingBasis(input) {
     return resolveHostedAiUsageTokenPricingBasis({
         model: input.model,
-        providerName: input.modelProvider,
+        providerName: resolveAssistantCodexUsageProviderName(input.modelProvider),
         serviceTier: input.serviceTier ?? null,
     });
 }
-// Spawn evidence map: every thread id named by a parent-thread collab tool
-// call item (V1: spawnAgent, sendInput, wait, resumeAgent, ...) or
-// subAgentActivity item (V2) is a key — that membership is what authorizes
-// billing a foreign thread's usage, covering both freshly spawned children
-// and reused existing children. The effective model is only known from V1
-// spawn items and may be null otherwise.
+// Spawn evidence map: every thread id named by a canonical collab tool call
+// or subAgentActivity item is a key. That membership authorizes billing a
+// foreign thread's usage. Only spawnAgent carries an explicit model in the
+// pinned protocol; activity-only evidence inherits the parent model.
 function readCodexCollabSpawnModelsByThread(rawEvents) {
     const modelByThreadId = new Map();
     for (const rawEvent of rawEvents) {
@@ -838,77 +772,44 @@ export function readCodexCollabReceiverThreadIds(rawEvent) {
     return readCodexCollabToolCallFromEvent(rawEvent)?.receiverThreadIds ?? [];
 }
 function readCodexCollabToolCallFromEvent(rawEvent) {
-    const record = readAssistantProviderRecord(rawEvent);
-    const params = readAssistantProviderRecord(record?.params);
-    const data = readAssistantProviderRecord(record?.data);
-    const item = readAssistantProviderRecord(params?.item) ??
-        readAssistantProviderRecord(data?.item) ??
-        readAssistantProviderRecord(record?.item);
-    if (!item) {
+    const notification = readCodexServerNotification(rawEvent);
+    if (notification?.method !== 'item/started' &&
+        notification?.method !== 'item/completed') {
         return null;
     }
-    const itemType = readAssistantProviderString(item.type, item.itemType, item.item_type);
-    // Multi-agent V2 emits subAgentActivity items (started/interacted/
-    // interrupted) instead of collab tool calls; any of them names the child
-    // thread this parent turn engaged, which is exactly the spawn evidence the
-    // billing gate needs. V2 activity items carry no model.
-    if (itemType === 'subAgentActivity' || itemType === 'sub_agent_activity') {
-        const agentThreadId = readAssistantProviderString(item.agentThreadId, item.agent_thread_id);
+    const item = readCodexRecord(notification.params.item);
+    const itemType = readCodexNonEmptyString(item?.type);
+    if (itemType === 'subAgentActivity') {
+        const agentThreadId = readCodexNonEmptyString(item?.agentThreadId);
         return agentThreadId
-            ? { receiverThreadIds: [agentThreadId], spawnModel: null }
+            ? {
+                receiverThreadIds: [agentThreadId],
+                spawnModel: null,
+            }
             : null;
     }
-    if (itemType !== 'collabAgentToolCall') {
-        return null;
-    }
-    const rawReceiverThreadIds = item.receiverThreadIds ?? item.receiver_thread_ids;
-    if (!Array.isArray(rawReceiverThreadIds)) {
+    if (itemType !== 'collabAgentToolCall' || !Array.isArray(item?.receiverThreadIds)) {
         return null;
     }
-    const receiverThreadIds = rawReceiverThreadIds.flatMap((receiverThreadId) => {
-        const normalized = readAssistantProviderString(receiverThreadId);
+    const receiverThreadIds = item.receiverThreadIds.flatMap((receiverThreadId) => {
+        const normalized = readCodexNonEmptyString(receiverThreadId);
         return normalized ? [normalized] : [];
     });
     if (receiverThreadIds.length === 0) {
         return null;
     }
-    const tool = readAssistantProviderString(item.tool);
-    const isSpawnTool = tool === 'spawnAgent' || tool === 'spawn_agent';
     return {
         receiverThreadIds,
-        spawnModel: isSpawnTool
-            ? readAssistantProviderString(item.model) ?? null
+        spawnModel: item.tool === 'spawnAgent'
+            ? readCodexNonEmptyString(item.model)
             : null,
     };
 }
-function copyAssistantProviderUsageDifference(target, targetKey, minuend, subtrahend, sourceKeys, options = {}) {
-    const minuendValue = readAssistantProviderUsageInteger(minuend, sourceKeys, options);
-    if (minuendValue === null) {
-        return;
-    }
-    const subtrahendValue = readAssistantProviderUsageInteger(subtrahend, sourceKeys, options) ?? 0;
-    target[targetKey] = Math.max(0, minuendValue - subtrahendValue);
-}
-function readAssistantProviderUsageInteger(source, sourceKeys, options = {}) {
-    const directValue = readAssistantProviderInteger(source, ...sourceKeys);
-    if (directValue !== null) {
-        return directValue;
-    }
-    for (const nested of options.nested ?? []) {
-        const nestedValue = readAssistantProviderNestedInteger(source, nested[0], nested[1]);
-        if (nestedValue !== null) {
-            return nestedValue;
-        }
-    }
-    return null;
-}
 function findAssistantCodexCompletionEvent(rawEvents) {
     for (let index = rawEvents.length - 1; index >= 0; index -= 1) {
-        const record = readAssistantProviderRecord(rawEvents[index]);
-        const eventType = readAssistantProviderString(record?.type, record?.event, record?.method);
-        if (eventType === 'turn.completed' ||
-            eventType === 'turn/completed') {
-            return record ?? null;
+        const notification = readCodexServerNotification(rawEvents[index]);
+        if (notification?.method === 'turn/completed') {
+            return notification;
         }
     }
     return null;
@@ -937,63 +838,12 @@ function readAssistantProviderInteger(record, ...keys) {
     }
     for (const key of keys) {
         const value = record[key];
-        if (typeof value === 'number' && Number.isInteger(value) && value >= 0) {
+        if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0) {
             return value;
         }
     }
     return null;
 }
-function readAssistantProviderNestedInteger(record, objectKey, valueKey) {
-    return readAssistantProviderInteger(readAssistantProviderRecord(record?.[objectKey]), valueKey);
-}
-function sanitizeAssistantProviderRawUsageJson(record) {
-    if (!record) {
-        return null;
-    }
-    const sanitized = {};
-    copyAssistantProviderIntegerFields(sanitized, record, [
-        'cacheWriteTokens',
-        'cache_write_tokens',
-        'cachedInputTokens',
-        'cached_input_tokens',
-        'completionTokens',
-        'completion_tokens',
-        'inputTokens',
-        'input_tokens',
-        'outputTokens',
-        'output_tokens',
-        'promptTokens',
-        'prompt_tokens',
-        'reasoningTokens',
-        'reasoning_tokens',
-        'reasoningOutputTokens',
-        'totalTokens',
-        'total_tokens',
-    ]);
-    copyAssistantProviderTokenDetails(sanitized, record, 'input_tokens_details', ['cached_tokens']);
-    copyAssistantProviderTokenDetails(sanitized, record, 'prompt_tokens_details', ['cached_tokens']);
-    copyAssistantProviderTokenDetails(sanitized, record, 'output_tokens_details', ['reasoning_tokens']);
-    return Object.keys(sanitized).length > 0 ? sanitized : null;
-}
-function copyAssistantProviderIntegerFields(target, source, keys) {
-    for (const key of keys) {
-        const value = source[key];
-        if (typeof value === 'number' && Number.isInteger(value) && value >= 0) {
-            target[key] = value;
-        }
-    }
-}
-function copyAssistantProviderTokenDetails(target, source, objectKey, valueKeys) {
-    const sourceDetails = readAssistantProviderRecord(source[objectKey]);
-    if (!sourceDetails) {
-        return;
-    }
-    const sanitizedDetails = {};
-    copyAssistantProviderIntegerFields(sanitizedDetails, sourceDetails, valueKeys);
-    if (Object.keys(sanitizedDetails).length > 0) {
-        target[objectKey] = sanitizedDetails;
-    }
-}
 export function hashAssistantProviderStableJson(value) {
     return `sha256:${createHash('sha256')
         .update(stableStringifyAssistantProviderJson(value))
@@ -1017,10 +867,4 @@ function sortAssistantProviderJson(value) {
     }
     return value;
 }
-function resolveAssistantProviderTotalTokens(input) {
-    if (input.inputTokens === null && input.outputTokens === null) {
-        return null;
-    }
-    return (input.inputTokens ?? 0) + (input.outputTokens ?? 0);
-}
 //# sourceMappingURL=helpers.js.map