@myagentroam/node 0.10.6 → 0.10.8

package/dist/connector.js

@@ -1,3 +1,6 @@
+import { normalizeMarAgentUsage } from './runner/mar-agent/conversation-normalizer.js';
+import { ModelUsageOutbox } from './service/model-usage-outbox.js';
+import { NodeModelUsageService } from './service/model-usage-service.js';
 import { dirname, resolve } from 'node:path';
 import { createEnvelope, composerVisibleText, directNodeCommandSchema } from '@myagentroam/protocol';
 import { hostedConversationStorePath, loadNodeConfig, computerUseRuntimeExecutable, directTransferUdpPortRange, nodeDataDirectory, nodeDatabasePath } from './config.js';
@@ -125,6 +128,7 @@ const HOSTED_CONVERSATION_OPERATIONS = [
     'conversation.hosted.config.update',
     'conversation.hosted.metadata.update',
     'conversation.hosted.image.read',
+    'conversation.hosted.tool-resource.read',
     'conversation.hosted.files.list',
     'conversation.hosted.file.read',
     'conversation.hosted.file.delete',
@@ -157,6 +161,8 @@ function upgradeMetadata(metadata, status) {
     return next;
 }
 export class NodeConnector {
+    usageOutbox;
+    modelUsage = new NodeModelUsageService(() => this.usageOutbox, () => this.config?.nodeId);
     nodeGeneration = crypto.randomUUID().replace(/-/g, '');
     controlChannel;
     controlMessages;
@@ -417,6 +423,7 @@ export class NodeConnector {
                     void this.enqueueGoalContinuation({
                         sessionId: retry.sessionId,
                         goal: pending.goal,
+                        ...(pending.usageGrant === undefined ? {} : { usageGrant: pending.usageGrant }),
                         secretEnvironment: pending.secretEnvironment,
                         ...(pending.personalInstructions === undefined
                             ? {}
@@ -442,6 +449,7 @@ export class NodeConnector {
             retry.timer.unref();
         },
         releaseExecution: (executionId) => {
+            this.modelUsage.release(executionId);
             this.goalExecutionProgress.delete(executionId);
             this.goalMcpServer.revoke(executionId);
             this.scheduledTaskMcpServer.revoke(executionId);
@@ -797,6 +805,7 @@ export class NodeConnector {
                     ...(run?.initiatedByUserId === undefined
                         ? {}
                         : { initiatedByUserId: run.initiatedByUserId }),
+                    ...(input.usageGrant === undefined ? {} : { usageGrant: input.usageGrant }),
                     secretEnvironment: input.secretEnvironment,
                     ...(input.personalInstructions === undefined
                         ? {}
@@ -986,7 +995,7 @@ export class NodeConnector {
             emitSession: (session) => this.emitSessionWorkbenchEvent({
                 session: this.sessionPresentationService.present(session)
             }),
-            execute: (operation, data) => this.executeNodeOperation(operation, data),
+            execute: (operation, data) => this.modelUsage.withGrant(isPlainRecord(data) ? data.__usageGrant : undefined, () => this.executeNodeOperation(operation, data)),
             interceptedSessionId: (clientMessageId) => this.fakeRunner === undefined ? undefined : `fake:${clientMessageId}`
         });
         this.externalSessionResumeService = new ExternalSessionResumeService({
@@ -1044,7 +1053,7 @@ export class NodeConnector {
                     goalAccessChanged: prepared.changed
                 };
             },
-            goal: async ({ session, objective, initiatedByUserId, secretEnvironment, personalInstructions, marAgentModel, marAgentModels, marAgentCompact, marAgentRuntimeScopeId }) => {
+            goal: async ({ session, objective, initiatedByUserId, secretEnvironment, personalInstructions, marAgentModel, marAgentModels, marAgentCompact, marAgentRuntimeScopeId, usageGrant }) => {
                 this.invalidateGoalContinuation(session.id);
                 const prepared = this.prepareGoalSession(session);
                 const goalSession = prepared.session;
@@ -1064,6 +1073,7 @@ export class NodeConnector {
                         objective: goal.objective,
                         deliveryIntent: replacing ? 'REPLACE_CURRENT' : 'SEND',
                         goal: goalRef,
+                        ...(usageGrant === undefined ? {} : { usageGrant }),
                         ...(initiatedByUserId === undefined ? {} : { initiatedByUserId }),
                         secretEnvironment,
                         ...(personalInstructions === undefined ? {} : { personalInstructions }),
@@ -1283,6 +1293,7 @@ export class NodeConnector {
             onReconnectScheduled: () => this.metrics.reconnectScheduled(),
             onMessage: (raw) => this.handleMessage(raw),
             onClose: (code, reason) => {
+                this.usageOutbox?.disconnected();
                 this.directTransferService?.close();
                 this.runtimeCredentials.disconnected();
                 this.chatgptLogins.close();
@@ -1300,8 +1311,24 @@ export class NodeConnector {
         });
         this.controlMessages = new NodeControlMessageService({
             config: () => this.config,
-            register: (nodeId, credential) => this.connectionLifecycle.register(nodeId, credential),
-            connected: () => this.connectionLifecycle.connected(),
+            register: async (nodeId, credential, payload) => {
+                await this.connectionLifecycle.register(nodeId, credential);
+                this.usageOutbox?.connected(payload);
+            },
+            usageAck: (payload) => this.usageOutbox?.handle(createEnvelope('usage.ack', payload)),
+            bindUsage: (payload) => {
+                if (!isPlainRecord(payload) ||
+                    typeof payload.runId !== 'string' ||
+                    typeof payload.sessionId !== 'string')
+                    return;
+                const runner = this.runtime.getAgentSession(payload.sessionId)?.runner;
+                if (runner)
+                    this.modelUsage.bind(payload.runId, payload.usageGrant, payload.sessionId, runner);
+            },
+            connected: (payload) => {
+                this.usageOutbox?.connected(payload);
+                this.connectionLifecycle.connected();
+            },
             close: (code, reason) => this.controlChannel.close(code, reason),
             inspectWorkspace: (envelope) => this.workspaceCoordinator.inspect(envelope),
             handleNodeRequest: (envelope) => this.nodeRequests.handle(envelope),
@@ -1323,7 +1350,7 @@ export class NodeConnector {
         this.nodeRequests = new NodeRequestService({
             nodeId: () => this.config?.nodeId,
             databaseAvailable: () => this.database !== undefined,
-            execute: (operation, data) => this.executeNodeOperation(operation, data),
+            execute: (operation, data) => this.modelUsage.withGrant(isPlainRecord(data) ? data.__usageGrant : undefined, () => this.executeNodeOperation(operation, data)),
             send: (type, payload, replyTo) => this.send(type, payload, replyTo)
         });
         this.workspaceCoordinator = new NodeWorkspaceCoordinator({
@@ -1336,6 +1363,13 @@ export class NodeConnector {
             send: (type, payload, replyTo) => this.send(type, payload, replyTo)
         });
         this.runEventBridge = new NodeRunEventBridge({
+            bindModelUsage: (runId) => {
+                const run = this.runtime.getRun(runId);
+                const session = run ? this.runtime.getAgentSession(run.sessionId) : undefined;
+                if (session)
+                    this.modelUsage.bindInherited(runId, session.id, session.runner);
+            },
+            modelUsage: (runId, payload) => this.modelUsage.record(runId, payload),
             runtime: this.runtime,
             state: this.runState,
             events: this.runEventService,
@@ -1414,6 +1448,7 @@ export class NodeConnector {
                     marAgentModel: context.marAgentModel,
                     marAgentModels: context.marAgentModels,
                     marAgentCompact: context.marAgentCompact,
+                    ...(context.usageGrant === undefined ? {} : { usageGrant: context.usageGrant }),
                     marAgentRuntimeScopeId: context.marAgentRuntimeScopeId
                 }));
                 return { runId: result.run.id };
@@ -1593,6 +1628,12 @@ export class NodeConnector {
                         })
                     });
                     hostedService = new HostedConversationNodeService({
+                        modelUsage: (grant, usage) => {
+                            const runId = usage.executionId ?? usage.requestId;
+                            this.modelUsage.bind(runId, grant, usage.sessionId, 'mar-agent');
+                            this.modelUsage.record(runId, normalizeMarAgentUsage(usage));
+                            this.modelUsage.release(runId);
+                        },
                         database: this.database,
                         store,
                         runtime,
@@ -1684,6 +1725,16 @@ export class NodeConnector {
         await this.upgradeCoordinator.loadResult(resolve(dirname(nodeDatabasePath(this.config, this.configPath)), 'upgrade-result.json'));
         await assertLocalSqlitePath(nodeDatabasePath(this.config, this.configPath));
         this.database ??= new NodeDatabase(nodeDatabasePath(this.config, this.configPath), () => this.config?.nodeId ?? 'unregistered');
+        this.usageOutbox?.disconnected();
+        this.usageOutbox = new ModelUsageOutbox({
+            database: () => this.database?.raw,
+            namespace: () => this.config?.nodeId
+                ? JSON.stringify([this.config.serverUrl, this.config.nodeId])
+                : undefined,
+            send: (type, payload) => this.send(type, payload),
+            diagnose: (code) => nodeLog('model.usage.diagnostic', { code })
+        });
+        this.usageOutbox.recoverInterrupted();
         this.database.closeRunningTerminalSessions();
         this.scheduledSessions.start();
         await this.initializeConversationHosting();
@@ -1872,6 +1923,7 @@ export class NodeConnector {
                 ...(input.initiatedByUserId === undefined
                     ? {}
                     : { initiatedByUserId: input.initiatedByUserId }),
+                ...(input.usageGrant === undefined ? {} : { usageGrant: input.usageGrant }),
                 secretEnvironment: input.secretEnvironment,
                 ...(input.personalInstructions === undefined
                     ? {}
@@ -2095,6 +2147,9 @@ export class NodeConnector {
                 await hostedConversationRuntime?.dispose().catch(() => undefined);
                 await drains;
                 await this.gitExecutionService?.close();
+                this.usageOutbox?.disconnected();
+                this.usageOutbox = undefined;
+                this.modelUsage.clear();
                 database?.close();
             }
         })();

package/dist/database.js

@@ -1,3 +1,4 @@
+import { NODE_SCHEMA_MIGRATION_V17 } from './migrations/v017.js';
 import { randomUUID } from 'node:crypto';
 import { closeSync, existsSync, mkdirSync, openSync, rmSync } from 'node:fs';
 import { dirname } from 'node:path';
@@ -14,7 +15,8 @@ import { assertNodeNoForeignKeys, assertNodeRelations } from './database-relatio
 export const NODE_SCHEMA_MIGRATIONS = [
     NODE_SCHEMA_MIGRATION_V14,
     NODE_SCHEMA_MIGRATION_V15,
-    NODE_SCHEMA_MIGRATION_V16
+    NODE_SCHEMA_MIGRATION_V16,
+    NODE_SCHEMA_MIGRATION_V17
 ];
 const LEGACY_NODE_SCHEMA_V12 = NODE_SCHEMA_VERSION_V13 - 1;
 const OBSOLETE_NODE_SCHEMA_V16 = 16;

package/dist/migrations/v017.js

@@ -0,0 +1,46 @@
+import { DatabaseSync } from 'node:sqlite';
+import { NODE_SCHEMA_V13 } from './v013.js';
+import { NODE_SCHEMA_MIGRATION_V14 } from './v014.js';
+import { NODE_SCHEMA_MIGRATION_V15 } from './v015.js';
+import { NODE_SCHEMA_MIGRATION_V16 } from './v016.js';
+const sql = `CREATE TABLE model_usage_outbox (
+  namespace TEXT NOT NULL,
+  record_id TEXT NOT NULL,
+  revision INTEGER NOT NULL,
+  payload TEXT NOT NULL,
+  bytes INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL,
+  ended_at INTEGER,
+  PRIMARY KEY(namespace, record_id)
+) STRICT;
+CREATE INDEX model_usage_outbox_updated ON model_usage_outbox(updated_at);`;
+export const NODE_SCHEMA_MIGRATION_V17 = {
+    version: 17,
+    sql,
+    preflight: (database) => NODE_SCHEMA_MIGRATION_V16.assert(database),
+    assert(database) {
+        const reference = new DatabaseSync(':memory:');
+        try {
+            reference.exec(NODE_SCHEMA_V13);
+            reference.exec(NODE_SCHEMA_MIGRATION_V14.sql);
+            reference.exec(NODE_SCHEMA_MIGRATION_V15.sql);
+            reference.exec(NODE_SCHEMA_MIGRATION_V16.sql);
+            reference.exec(sql);
+            const schema = (db) => db
+                .prepare("SELECT type,name,sql FROM sqlite_master WHERE sql IS NOT NULL AND name NOT LIKE 'sqlite_%' ORDER BY type,name")
+                .all()
+                .map((row) => [
+                row.type,
+                row.name,
+                row.name === 'node_schema_migrations'
+                    ? String(row.sql).replace(/\s+/g, '')
+                    : String(row.sql).replace(/\s+/g, ' ').trim()
+            ]);
+            if (JSON.stringify(schema(reference)) !== JSON.stringify(schema(database)))
+                throw new Error('NODE_DATABASE_SCHEMA_INVALID:model_usage');
+        }
+        finally {
+            reference.close();
+        }
+    }
+};

package/dist/native-session-history.js

@@ -7,6 +7,7 @@ import { nodeLog } from './operational.js';
 import { stripClaudePlanTag } from './runner-command-engine.js';
 import { stripGoalStartPrompt } from './service/goal-runtime.js';
 import { parseCodexComposerImageMarkers } from './runner/codex/composer-image-markers.js';
+import { extractClaudeToolResults } from './runner/claude/tool-normalizer.js';
 const DISCOVERY_READ_BYTES = 32 * 1024;
 const TRANSCRIPT_HEADER_READ_BYTES = 32 * 1024;
 const TRANSCRIPT_READ_MAX_BYTES = 16 * 1024 * 1024;
@@ -740,21 +741,11 @@ function toolUsesOf(record, createdAt) {
     });
 }
 function toolResultsOf(record, createdAt) {
-    return contentBlocks(record).flatMap((block) => {
-        if (block['type'] !== 'tool_result' || typeof block['tool_use_id'] !== 'string')
-            return [];
-        const output = compactValue(block['content'], 10_000);
-        return [
-            {
-                kind: 'tool_result',
-                toolUseId: block['tool_use_id'],
-                output: output.text,
-                failed: block['is_error'] === true,
-                truncated: output.truncated,
-                createdAt
-            }
-        ];
-    });
+    return extractClaudeToolResults(record).map((result) => ({
+        ...result,
+        kind: 'tool_result',
+        createdAt
+    }));
 }
 /**
  * Codex persists custom and standard function tools as paired `response_item`
@@ -973,6 +964,7 @@ function withToolResult(call, result) {
         ...call,
         outputSummary: result.output,
         outputTruncated: result.truncated,
+        ...(result.claudeResult === undefined ? {} : { claudeResult: result.claudeResult }),
         ...(imageAttachments === undefined ? {} : { imageAttachments }),
         failed: result.failed
     };

package/dist/runner/abstract-runner.js

@@ -126,6 +126,10 @@ export class AbstractRunner {
         void session;
         return undefined;
     }
+    async readToolResultResource(session, input) {
+        void [session, input];
+        throw new Error('TOOL_RESOURCE_UNSUPPORTED');
+    }
     acceptsTruncatedNativeHistory() {
         return true;
     }

package/dist/runner/claude/managed-run-controller.js

@@ -1,8 +1,9 @@
+import { ClaudeUsageNormalizer } from './tool-normalizer.js';
 import { createEnvelope } from '@myagentroam/protocol';
 import { ClaudeChannelGate } from '../../claude-channel.js';
 import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
-import { boundedConversationItemId, claudePlanText, compactRunnerText, extractClaudeText, extractClaudeThinkingSummaries, extractClaudeToolResults, extractClaudeToolUses } from '../codex/conversation-parser.js';
-import { normalizeClaudeTool } from './tool-normalizer.js';
+import { boundedConversationItemId, claudePlanText, compactRunnerText, extractClaudeText, extractClaudeThinkingSummaries, extractClaudeToolUses } from '../codex/conversation-parser.js';
+import { normalizeClaudeTool, extractClaudeToolResults } from './tool-normalizer.js';
 import { claudeContentBlocks } from '../../util/node-operation-parsers.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
@@ -134,6 +135,9 @@ export class ClaudeManagedRunController {
         let terminal = false;
         let handle;
         const toolKinds = new Map();
+        const toolInputs = new Map();
+        const knownSubagents = new Map();
+        const usage = new ClaudeUsageNormalizer(runId, (value) => this.host.emit(runId, 'run.usage', value));
         const finish = (status, eventType, eventPayload, failure, fallbackCode = 'CLAUDE_RUN_FAILED') => {
             if (terminal)
                 return;
@@ -157,6 +161,7 @@ export class ClaudeManagedRunController {
                     payload: { phase: 'COMPLETED', summary: null },
                     merge: true
                 });
+            usage.finish(status === 'SUCCEEDED' ? 'succeeded' : status === 'FAILED' ? 'failed' : 'cancelled');
             this.host.emit(runId, eventType, projected ?? eventPayload, status);
             this.runner.execution.runs.delete(runId);
             handle?.cancel();
@@ -233,6 +238,7 @@ export class ClaudeManagedRunController {
                 onMessage: (message) => {
                     if (terminal)
                         return;
+                    usage.observe(message);
                     const receiptAt = generationTiming.timestamp();
                     const record = message;
                     const nativeSessionId = typeof record.session_id === 'string' ? record.session_id : undefined;
@@ -373,7 +379,8 @@ export class ClaudeManagedRunController {
                                 continue;
                             }
                             const itemId = boundedConversationItemId('claude-tool', tool.id);
-                            const normalized = normalizeClaudeTool(tool.name, tool.input, null, false, tool.inputTruncated);
+                            toolInputs.set(tool.id, tool);
+                            const normalized = normalizeClaudeTool(tool.name, tool.input, null, false, tool.inputTruncated, knownSubagents);
                             const kind = normalized.kind;
                             toolKinds.set(tool.id, kind);
                             this.host.emitItem(runId, {
@@ -436,6 +443,10 @@ export class ClaudeManagedRunController {
                             const kind = toolKinds.get(result.toolUseId) ?? 'tool_call';
                             if (kind === 'user_input_request')
                                 continue;
+                            const tool = toolInputs.get(result.toolUseId);
+                            if (tool === undefined)
+                                continue;
+                            const normalized = normalizeClaudeTool(tool.name, tool.input, result.output, result.failed, tool.inputTruncated || result.truncated, knownSubagents, result.claudeResult);
                             this.host.emitItem(runId, {
                                 itemId: boundedConversationItemId('claude-tool', result.toolUseId),
                                 kind,
@@ -450,6 +461,7 @@ export class ClaudeManagedRunController {
                                     : kind === 'file_change'
                                         ? {}
                                         : {
+                                            ...normalized.payload,
                                             outputSummary: result.output,
                                             progressLabel: null,
                                             errorCode: result.failed ? 'TOOL_EXECUTION_FAILED' : null,

package/dist/runner/claude/tool-normalizer.js

@@ -1,10 +1,90 @@
-import { compactRunnerText, compactRunnerValue } from '../../util/node-operation-parsers.js';
-export function normalizeClaudeTool(toolName, input, output, failed, truncated) {
+import { claudeContentBlocks, compactRunnerText, compactRunnerValue } from '../../util/node-operation-parsers.js';
+import { RunnerUsageTracker, usageToken, usageTokenSum } from '../../service/runner-usage-tracker.js';
+export class ClaudeUsageNormalizer {
+    tracker;
+    messages = new Map();
+    constructor(identity, publish) {
+        this.tracker = new RunnerUsageTracker(identity, publish);
+    }
+    observe(value) {
+        const envelope = record(value);
+        if (!envelope)
+            return;
+        const parent = typeof envelope.parent_tool_use_id === 'string' ? envelope.parent_tool_use_id : '';
+        const event = envelope.type === 'stream_event' ? record(envelope.event) : undefined;
+        const message = record(envelope.type === 'assistant' ? envelope.message : event?.message);
+        const previous = this.messages.get(parent);
+        const id = typeof message?.id === 'string' ? message.id : previous?.id;
+        if (!id || message?.model === '<synthetic>')
+            return;
+        const usage = record(message?.usage ?? event?.usage);
+        let values = {
+            ...(previous?.id === id ? previous.values : {}),
+            purpose: 'conversation',
+            agentRole: parent ? 'subagent' : 'root',
+            ...(typeof message?.model === 'string' ? { actualModel: message.model } : {})
+        };
+        if (usage) {
+            const input = usageToken(usage.input_tokens), read = usageToken(usage.cache_read_input_tokens), write = usageToken(usage.cache_creation_input_tokens), output = usageToken(usage.output_tokens);
+            values = {
+                ...values,
+                ...(input === undefined
+                    ? {}
+                    : { inputTokens: usageTokenSum(input, read ?? '0', write ?? '0') }),
+                ...(output === undefined ? {} : { outputTokens: output }),
+                ...(read === undefined ? {} : { cacheReadTokens: read }),
+                ...(write === undefined ? {} : { cacheWriteTokens: write })
+            };
+        }
+        this.messages.set(parent, { id, values });
+        if (usage || event?.type === 'message_stop')
+            this.tracker.snapshot(id, values, event?.type === 'message_stop' ||
+                typeof record(event?.delta)?.stop_reason === 'string' ||
+                typeof message?.stop_reason === 'string', 'partial');
+    }
+    finish(state) {
+        this.tracker.finish(state);
+    }
+}
+export function restoreClaudeSubagentTitles(calls) {
+    const titles = new Map();
+    for (const call of calls)
+        claudeSubagentProjection(call.toolName, call.input, call.claudeResult ?? call.outputSummary, titles);
+    return titles;
+}
+export function extractClaudeToolResults(message) {
+    // This ID describes the owning subagent, not the tool call producing the result.
+    if (message.parent_tool_use_id !== undefined && message.parent_tool_use_id !== null)
+        return [];
+    const blocks = claudeContentBlocks(message).filter((block) => block.type === 'tool_result' && typeof block.tool_use_id === 'string');
+    return blocks.map((block) => {
+        const output = compactRunnerValue(block.content, 10_000);
+        // A message-level structured result cannot be assigned to multiple calls.
+        const structured = blocks.length === 1 ? structuredRecord(message.tool_use_result) : undefined;
+        const fields = structured ?? structuredRecord(block.content);
+        const agentId = boundedId(fields?.agentId);
+        const taskId = boundedId(fields?.task_id);
+        const taskType = boundedId(fields?.task_type);
+        const claudeResult = {
+            ...(agentId === undefined ? {} : { agentId }),
+            ...(taskId === undefined ? {} : { task_id: taskId }),
+            ...(taskType === undefined ? {} : { task_type: taskType })
+        };
+        return {
+            toolUseId: block.tool_use_id,
+            output: output.text,
+            failed: block.is_error === true,
+            truncated: output.truncated,
+            ...(Object.keys(claudeResult).length === 0 ? {} : { claudeResult })
+        };
+    });
+}
+export function normalizeClaudeTool(toolName, input, output, failed, truncated, knownSubagents = new Map(), resultMetadata) {
     const values = record(input);
     const normalizedToolName = compactRunnerText(toolName, 128) || 'unknown';
     const normalizedOutput = output === null ? null : compactRunnerText(output, 10_000);
     const outputTruncated = truncated || (output?.length ?? 0) > 10_000;
-    const subagent = claudeSubagentProjection(toolName, input, output);
+    const subagent = claudeSubagentProjection(toolName, input, resultMetadata ?? output, knownSubagents);
     if (isCommandTool(toolName))
         return {
             kind: 'command_execution',
@@ -70,7 +150,7 @@ function record(value) {
         ? value
         : undefined;
 }
-function claudeSubagentProjection(toolName, input, output) {
+function claudeSubagentProjection(toolName, input, output, knownSubagents) {
     const normalizedName = toolName.toLowerCase();
     const operation = normalizedName === 'agent'
         ? 'START'
@@ -90,12 +170,26 @@ function claudeSubagentProjection(toolName, input, output) {
         : normalizedName === 'sendmessage'
             ? boundedId(inputData?.to)
             : (boundedId(inputData?.task_id) ?? boundedId(outputData?.task_id));
+    if (normalizedName === 'taskoutput' || normalizedName === 'taskstop') {
+        const taskType = outputData?.task_type;
+        if (typeof taskType === 'string') {
+            if (taskType !== 'local_agent' && taskType !== 'remote_agent')
+                return undefined;
+        }
+        else if (subagentId === undefined || !knownSubagents.has(subagentId))
+            return undefined;
+    }
     const title = normalizedName === 'agent' && typeof inputData?.description === 'string'
         ? compactRunnerText(inputData.description, 500)
-        : '';
+        : subagentId === undefined
+            ? ''
+            : (knownSubagents.get(subagentId) ?? '');
+    if (subagentId !== undefined && normalizedName === 'agent')
+        knownSubagents.set(subagentId, title);
     return {
         subagentOperation: operation,
-        subagentId: subagentId ?? null,
+        subagentId: subagentId === '*' ? null : (subagentId ?? null),
+        ...(operation === 'STATUS' ? { subagentWait: inputData?.block === true } : {}),
         ...(title.length === 0 ? {} : { title })
     };
 }

package/dist/runner/codex/conversation-parser.js

@@ -1,3 +1,41 @@
+import { RunnerUsageTracker, usageToken } from '../../service/runner-usage-tracker.js';
+export class CodexUsageNormalizer {
+    requestedModel;
+    tracker;
+    constructor(identity, publish, requestedModel) {
+        this.requestedModel = requestedModel;
+        this.tracker = new RunnerUsageTracker(identity, publish);
+    }
+    observe(method, params, compact) {
+        // TokenCount.last can replay context/compaction snapshots without a request identity.
+        // Only raw response completions are independently additive request facts.
+        if (method !== 'rawResponse/completed' || typeof params.responseId !== 'string')
+            return;
+        const usage = isPlainRecord(params.usage) ? params.usage : {};
+        const inputTokens = usageToken(usage.inputTokens ?? usage.input_tokens);
+        const outputTokens = usageToken(usage.outputTokens ?? usage.output_tokens);
+        const cacheReadTokens = usageToken(usage.cachedInputTokens ??
+            (isPlainRecord(usage.input_tokens_details)
+                ? usage.input_tokens_details.cached_tokens
+                : undefined));
+        const reasoningTokens = usageToken(usage.reasoningOutputTokens ??
+            (isPlainRecord(usage.output_tokens_details)
+                ? usage.output_tokens_details.reasoning_tokens
+                : undefined));
+        const values = {
+            purpose: compact ? 'compact' : 'conversation',
+            agentRole: 'root',
+            ...(this.requestedModel ? { requestedModel: this.requestedModel } : {}),
+            ...(typeof params.model === 'string' ? { actualModel: params.model } : {}),
+            responseId: params.responseId,
+            ...(inputTokens === undefined ? {} : { inputTokens }),
+            ...(outputTokens === undefined ? {} : { outputTokens }),
+            ...(cacheReadTokens === undefined ? {} : { cacheReadTokens }),
+            ...(reasoningTokens === undefined ? {} : { reasoningTokens })
+        };
+        this.tracker.snapshot(params.responseId, values, true, 'partial');
+    }
+}
 import { basename, extname } from 'node:path';
 import { runnerErrorProjection } from '../../util/runner-error.js';
 import { conversationImageAttachmentSchema } from '@myagentroam/protocol';
@@ -503,7 +541,7 @@ export function codexPlanText(value) {
  * text with missing or unclosed tags remains a regular assistant message.
  */
 export function codexOfficialItem(session, nativeTurnId, value, turnSequence, itemSequence, startedAt, completedAt) {
-    if (!isPlainRecord(value) || typeof value.type !== 'string')
+    if (!isPlainRecord(value) || typeof value.type !== 'string' || value.type === 'subAgentActivity')
         return undefined;
     const id = (value.type === 'custom_tool_call' ||
         value.type === 'custom_tool_call_output' ||
@@ -686,11 +724,11 @@ export function codexOfficialItem(session, nativeTurnId, value, turnSequence, it
         : {
             ...base,
             ...special,
-            status: value.type === 'collabAgentToolCall' ? codexItemStatus(value.status, true) : base.status
+            status: base.status
         };
 }
 export function codexLiveConversationItem(value, completed, imageAttachments = []) {
-    if (typeof value.type !== 'string')
+    if (typeof value.type !== 'string' || value.type === 'subAgentActivity')
         return undefined;
     const nativeId = typeof value.call_id === 'string'
         ? value.call_id
@@ -936,33 +974,6 @@ function codexSpecialItem(value) {
                 inputSummary: typeof value.path === 'string' ? compactRunnerText(value.path, 4_096) : null
             }).payload
         };
-    if (value.type === 'subAgentActivity') {
-        const activity = typeof value.kind === 'string' ? value.kind : '';
-        const operation = activity === 'started'
-            ? 'START'
-            : activity === 'interrupted'
-                ? 'CANCEL'
-                : activity === 'interacted' || activity === 'completed'
-                    ? 'STATUS'
-                    : undefined;
-        if (operation === undefined)
-            return undefined;
-        const agentId = typeof value.agentThreadId === 'string' ? compactRunnerText(value.agentThreadId, 128) : '';
-        const agentPath = typeof value.agentPath === 'string' ? compactRunnerText(value.agentPath, 500) : '';
-        return {
-            kind: 'tool_call',
-            payload: {
-                ...normalizeCodexTool({
-                    name: 'subagent_activity',
-                    namespace: 'codex',
-                    outputSummary: activity
-                }).payload,
-                ...(agentPath ? { title: agentPath } : {}),
-                subagentOperation: operation,
-                subagentId: agentId || null
-            }
-        };
-    }
     if (value.type === 'collabAgentToolCall') {
         const names = {
             spawnAgent: 'spawn_agent',

package/dist/runner/codex/managed-run-controller.js

@@ -5,7 +5,7 @@ import { safeErrorCode } from '../../util/safe-error.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
 import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
 import { GenerationTimingTracker } from '../../service/generation-timing-tracker.js';
-import { boundedConversationItemId, codexImageAttachments, codexLiveConversationItem, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
+import { boundedConversationItemId, codexImageAttachments, codexLiveConversationItem, CodexUsageNormalizer, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
 export function resolveCodexNotificationRun(runs, input) {
     const entries = [...runs.entries()];
     if (input.turnId !== undefined) {
@@ -28,6 +28,7 @@ export function resolveCodexNotificationRun(runs, input) {
 export class CodexManagedRunController {
     runner;
     host;
+    usage = new Map();
     constructor(runner, host) {
         this.runner = runner;
         this.host = host;
@@ -113,6 +114,7 @@ export class CodexManagedRunController {
         catch (error) {
             this.emitError(runId, error, 'CODEX_COMPACT_FAILED');
             this.host.emit(runId, 'run.failed', runnerErrorProjection(error, 'CODEX_COMPACT_FAILED'), 'FAILED');
+            this.usage.delete(runId);
             this.runner.execution.runs.delete(runId);
             this.runner.releaseEnvironment(runId);
             this.host.removeActive(runId);
@@ -138,6 +140,12 @@ export class CodexManagedRunController {
         if (run === undefined)
             return;
         const [runId, activeRun] = run;
+        let usage = this.usage.get(runId);
+        if (!usage) {
+            usage = new CodexUsageNormalizer(runId, (value) => this.host.emit(runId, 'run.usage', value), this.host.session(activeRun.sessionId)?.model ?? undefined);
+            this.usage.set(runId, usage);
+        }
+        usage.observe(notification.method, params, activeRun.generationCompacting === true);
         const receiptAt = activeRun.generationTiming?.timestamp();
         if (notification.method === 'turn/started' && turnId !== undefined) {
             const active = this.runner.execution.runs.get(runId);
@@ -332,6 +340,7 @@ export class CodexManagedRunController {
                 this.host.session(active.sessionId)?.titleSource !== 'AUTO'
                 ? undefined
                 : this.host.syncTitle(active.sessionId, active.threadId, active.cwd);
+            this.usage.delete(runId);
             this.runner.execution.runs.delete(runId);
             if (titleRefresh === undefined)
                 this.runner.releaseEnvironment(runId);
@@ -624,6 +633,7 @@ export class CodexManagedRunController {
                     break;
                 }
                 catch (error) {
+                    this.usage.delete(runId);
                     this.runner.execution.runs.delete(runId);
                     if (attempt === 0 && (await this.runner.recoverMissingRollout(runId, error)))
                         continue;
@@ -663,6 +673,7 @@ export class CodexManagedRunController {
             }
             this.emitError(runId, error, 'CODEX_RUN_FAILED');
             this.host.emit(runId, 'run.failed', runnerErrorProjection(error, 'CODEX_RUN_FAILED'), 'FAILED');
+            this.usage.delete(runId);
             this.runner.execution.runs.delete(runId);
             this.runner.releaseEnvironment(runId);
             this.host.removeActive(runId);