@myagentroam/node 0.11.15 → 0.11.16

package/dist/native-transcript-adapters.js

@@ -0,0 +1,9 @@
+import { codexNativeTranscriptAdapter } from './runner/codex/native-transcript.js';
+import { claudeNativeTranscriptAdapter } from './runner/claude/native-transcript.js';
+const adapters = {
+    codex: codexNativeTranscriptAdapter,
+    'claude-code': claudeNativeTranscriptAdapter
+};
+export function nativeTranscriptAdapter(runner) {
+    return adapters[runner];
+}

package/dist/native-transcript-model.js

@@ -0,0 +1 @@
+export {};

package/dist/runner/abstract-runner.js

@@ -20,6 +20,13 @@ export class AbstractRunner {
         void [workspace, environment, waitForRefresh];
         return this.profile(capabilities);
     }
+    goalAccess(currentAccess) {
+        return { access: 'auto', accessChanged: currentAccess !== 'auto' };
+    }
+    /** Restore persisted values only; never normalize fresh configuration input. */
+    restoreStoredAccess(access, fallbackAccess) {
+        return access !== null && access.trim().length > 0 ? access : fallbackAccess;
+    }
     supportsConfiguration(configuration, workspace, environment) {
         void [workspace, environment];
         const profile = this.profileForValidation();
@@ -146,6 +153,11 @@ export class AbstractRunner {
         void nativeTurnId;
         return undefined;
     }
+    /** Synchronously migrate Runner-owned state without I/O or event publication. */
+    migrateSessionIdentity(previousId, nativeSessionId) {
+        void previousId;
+        void nativeSessionId;
+    }
     bindControl(control) {
         if (this.control !== undefined)
             throw new Error(`RUNNER_CONTROL_ALREADY_BOUND:${this.name}`);

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

@@ -1,4 +1,5 @@
-import { boundedConversationItemId, isPlainRecord, claudeContentBlocks, compactRunnerText } from '../../util/node-operation-parsers.js';
+import { boundedConversationItemId, isPlainRecord, compactRunnerText } from '../../util/node-operation-parsers.js';
+import { claudeContentBlocks } from './message-parsers.js';
 export function extractClaudeThinkingText(record) {
     return claudeContentBlocks(record).flatMap((block) => {
         // Completed public blocks only; signatures and redacted/encrypted data are never read.
@@ -40,3 +41,81 @@ export function claudeAssistantBlocks(record) {
         ];
     });
 }
+export function claudePlanText(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('<proposed_plan>') || !/<\/proposed_plan>\s*$/.test(trimmed))
+        return undefined;
+    const plan = trimmed
+        .slice('<proposed_plan>'.length)
+        .replace(/<\/proposed_plan>\s*$/, '')
+        .trim();
+    return plan.length > 0 ? plan : undefined;
+}
+export function claudeUserInputQuestions(value) {
+    if (!Array.isArray(value.questions) || value.questions.length === 0 || value.questions.length > 4)
+        return [];
+    const questions = value.questions.map((raw, index) => {
+        if (!isPlainRecord(raw) || typeof raw.question !== 'string')
+            return undefined;
+        const options = Array.isArray(raw.options)
+            ? raw.options.flatMap((option) => {
+                if (!isPlainRecord(option) || typeof option.label !== 'string')
+                    return [];
+                const label = compactRunnerText(option.label, 500);
+                return label.length === 0
+                    ? []
+                    : [
+                        {
+                            value: label,
+                            label,
+                            description: typeof option.description === 'string'
+                                ? compactRunnerText(option.description, 1_000)
+                                : null
+                        }
+                    ];
+            })
+            : [];
+        const multiSelect = raw.multiSelect === true;
+        return {
+            id: `claude-question-${index}`,
+            prompt: compactRunnerText(raw.question, 5_000),
+            input: options.length === 0 ? 'SHORT_TEXT' : multiSelect ? 'MULTI_SELECT' : 'SINGLE_SELECT',
+            options,
+            allowOther: true,
+            multiSelect
+        };
+    });
+    return questions.some((question) => question === undefined)
+        ? []
+        : questions;
+}
+export function claudeDiscoveredSession(value, fallbackCwd) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const record = value;
+    if (record.isSidechain === true)
+        return undefined;
+    const externalSessionId = typeof record.sessionId === 'string'
+        ? record.sessionId
+        : typeof record.id === 'string'
+            ? record.id
+            : undefined;
+    if (externalSessionId === undefined || externalSessionId.length === 0)
+        return undefined;
+    const officialTitle = [record.customTitle, record.firstPrompt, record.title].find((candidate) => typeof candidate === 'string' && candidate.trim().length > 0);
+    const previewTitle = typeof record.summary === 'string' && record.summary.trim().length > 0
+        ? record.summary
+        : undefined;
+    const title = officialTitle ?? previewTitle;
+    const cwd = typeof record.cwd === 'string' && record.cwd.length > 0 ? record.cwd : fallbackCwd;
+    return {
+        externalSessionId,
+        cwd,
+        ...(title === undefined
+            ? {}
+            : {
+                title: title.slice(0, 80),
+                titleOrigin: officialTitle === undefined ? 'PREVIEW' : 'OFFICIAL'
+            })
+    };
+}

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

@@ -3,9 +3,11 @@ 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, extractClaudeToolUses } from '../codex/conversation-parser.js';
+import { boundedConversationItemId, compactRunnerText } from '../../util/node-operation-parsers.js';
+import { extractClaudeText, extractClaudeToolUses } from './message-parsers.js';
+import { claudePlanText } from './conversation-parser.js';
 import { normalizeClaudeTool, extractClaudeToolResults } from './tool-normalizer.js';
-import { claudeContentBlocks } from '../../util/node-operation-parsers.js';
+import { claudeContentBlocks } from './message-parsers.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';

package/dist/runner/claude/message-parsers.js

@@ -0,0 +1,37 @@
+import { compactRunnerText, compactRunnerValue, isPlainRecord } from '../../util/node-operation-parsers.js';
+export function extractClaudeText(message) {
+    return claudeContentBlocks(message)
+        .flatMap((block) => block.type === 'text' && typeof block.text === 'string' ? [block.text] : [])
+        .join('');
+}
+export function extractClaudeToolUses(message) {
+    return claudeContentBlocks(message).flatMap((block) => {
+        if (block.type !== 'tool_use' || typeof block.id !== 'string' || typeof block.name !== 'string')
+            return [];
+        const input = block.input;
+        const command = isPlainRecord(input) && typeof input.command === 'string' ? input.command : undefined;
+        return [
+            {
+                id: block.id,
+                name: block.name,
+                input,
+                ...(command === undefined ? {} : { command }),
+                inputTruncated: compactRunnerValue(input, 10_000).truncated
+            }
+        ];
+    });
+}
+export function claudeContentBlocks(message) {
+    const content = message.message;
+    if (!isPlainRecord(content) || !Array.isArray(content.content))
+        return [];
+    return content.content.filter(isPlainRecord);
+}
+export function isClaudeCommandTool(name) {
+    return name === 'Bash' || name === 'bash' || name === 'Shell';
+}
+export function nativeClaudeCommand(entry) {
+    if (isPlainRecord(entry.input) && typeof entry.input.command === 'string')
+        return compactRunnerText(entry.input.command, 10_000);
+    return entry.inputSummary ?? entry.toolName;
+}

package/dist/runner/claude/native-context-usage.js

@@ -0,0 +1,90 @@
+import { forEachJsonlRecord, readJsonlWindow } from '../../native-jsonl-reader.js';
+import { locateNativeSessionPath } from '../../native-session-history.js';
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const CLAUDE_CONTEXT_USAGE_READ_BYTES = [256 * 1024, 1024 * 1024, 4 * 1024 * 1024];
+const DEFAULT_CLAUDE_CONTEXT_WINDOW_TOKENS = 200_000;
+const CLAUDE_CONTEXT_WINDOW_ENV = 'MAR_CLAUDE_CONTEXT_WINDOW_TOKENS';
+export async function readClaudeNativeContextUsage(workspacePath, externalSessionId, options = {}) {
+    const path = await locateNativeSessionPath('claude-code', workspacePath, externalSessionId);
+    if (path === undefined)
+        return undefined;
+    const latest = await readLatestClaudeContextUsage(path);
+    if (latest === undefined)
+        return undefined;
+    return {
+        ...latest,
+        maxTokens: await claudeContextWindowTokens(options)
+    };
+}
+async function readLatestClaudeContextUsage(path) {
+    for (const tailBytes of CLAUDE_CONTEXT_USAGE_READ_BYTES) {
+        const window = await readJsonlWindow(path, { tailBytes });
+        if (window === undefined)
+            return undefined;
+        let latest;
+        forEachJsonlRecord(window.content, (record) => {
+            const usage = claudeContextUsage(record);
+            if (usage !== undefined)
+                latest = usage;
+        });
+        if (latest !== undefined)
+            return latest;
+        if (!window.truncated)
+            return undefined;
+    }
+    return undefined;
+}
+export async function claudeContextWindowTokens(options = {}) {
+    const environment = options.environment ?? process.env;
+    const direct = positiveInteger(environment[CLAUDE_CONTEXT_WINDOW_ENV]);
+    if (direct !== undefined)
+        return direct;
+    try {
+        const settings = JSON.parse(await readFile(options.settingsPath ?? join(homedir(), '.claude', 'settings.json'), 'utf8'));
+        if (isRecord(settings) && isRecord(settings.env)) {
+            const configured = positiveInteger(settings.env[CLAUDE_CONTEXT_WINDOW_ENV]);
+            if (configured !== undefined)
+                return configured;
+        }
+    }
+    catch {
+        // Missing or malformed optional Claude settings use the stable default.
+    }
+    return DEFAULT_CLAUDE_CONTEXT_WINDOW_TOKENS;
+}
+function claudeContextUsage(value) {
+    if (value.type !== 'assistant' || !isRecord(value.message))
+        return undefined;
+    const model = value.message.model;
+    const usage = value.message.usage;
+    if (typeof model !== 'string' ||
+        model.length === 0 ||
+        model === '<synthetic>' ||
+        !isRecord(usage))
+        return undefined;
+    const inputTokens = nonNegativeInteger(usage.input_tokens);
+    const cacheCreationTokens = optionalNonNegativeInteger(usage.cache_creation_input_tokens);
+    const cacheReadTokens = optionalNonNegativeInteger(usage.cache_read_input_tokens);
+    if (inputTokens === undefined ||
+        cacheCreationTokens === undefined ||
+        cacheReadTokens === undefined)
+        return undefined;
+    return { model, usedTokens: inputTokens + cacheCreationTokens + cacheReadTokens };
+}
+function optionalNonNegativeInteger(value) {
+    return value === undefined ? 0 : nonNegativeInteger(value);
+}
+function nonNegativeInteger(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function positiveInteger(value) {
+    if (typeof value !== 'string' || !/^\d+$/.test(value.trim()))
+        return undefined;
+    const parsed = Number(value);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/runner/claude/native-transcript.js

@@ -0,0 +1,347 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { forEachJsonlRecord } from '../../native-jsonl-reader.js';
+import { compactRunnerValue as compactValue, isPlainRecord } from '../../util/node-operation-parsers.js';
+import { stripGoalStartPrompt, publicGoalHistoryText } from '../../service/goal-runtime.js';
+import { readdir } from 'node:fs/promises';
+import { stripClaudePlanTag } from '../../runner-command-engine.js';
+import { claudeAssistantBlocks, extractClaudeThinkingText, claudePlanText, claudeUserInputQuestions } from './conversation-parser.js';
+import { extractClaudeToolResults, claudeNativeToolResultMetadata, normalizeClaudeTool, restoreClaudeSubagentTitles } from './tool-normalizer.js';
+function parse(_path, window) {
+    const { content, truncated } = window;
+    let cwd;
+    let id;
+    let derivedSession = false;
+    const items = [];
+    const toolIndexes = new Map();
+    const metaRecordIds = new Set();
+    const claudeCompactCommandIds = new Set();
+    forEachJsonlRecord(content, (value) => {
+        if (derivedTranscriptRecord(value))
+            derivedSession = true;
+        cwd ??= workspacePath(value);
+        id ??= sessionId(value);
+        if (typeof value['uuid'] === 'string' && isClaudeCompactCommand(value))
+            claudeCompactCommandIds.add(value['uuid']);
+    });
+    forEachJsonlRecord(truncated ? window.pageContent : content, (value) => {
+        const recordId = typeof value['uuid'] === 'string' ? value['uuid'] : undefined;
+        const parentId = typeof value['parentUuid'] === 'string' ? value['parentUuid'] : undefined;
+        if (value['isMeta'] === true && recordId !== undefined)
+            metaRecordIds.add(recordId);
+        if (parentId !== undefined &&
+            claudeCompactCommandIds.has(parentId) &&
+            isClaudeCompactSuccess(value)) {
+            items.push({
+                kind: 'context_compaction',
+                phase: 'COMPLETED',
+                summary: null,
+                createdAt: timestampOf(value),
+                nativeId: parentId,
+                rewindAfter: parentId
+            });
+            return;
+        }
+        if (isHiddenTranscriptRecord(value) ||
+            (parentId !== undefined && metaRecordIds.has(parentId))) {
+            return;
+        }
+        for (const parsedItem of transcriptItems(value)) {
+            const item = {
+                ...parsedItem,
+                ...(recordId === undefined ? {} : { nativeId: recordId, rewindAfter: recordId })
+            };
+            if (item.kind === 'tool_result') {
+                const toolIndex = toolIndexes.get(item.toolUseId);
+                if (toolIndex !== undefined)
+                    items[toolIndex] = withToolResult(items[toolIndex], item);
+                continue;
+            }
+            if (item.kind === 'tool_call') {
+                toolIndexes.set(item.toolUseId, items.length);
+                items.push(item);
+                continue;
+            }
+            items.push(item);
+        }
+    });
+    if (derivedSession)
+        return undefined;
+    if (cwd === undefined)
+        return undefined;
+    const title = items.find((item) => item.kind === 'message' && item.role === 'USER')?.text;
+    // Tagged Plan Mode instruction labels do not form a session title.
+    const strippedTitle = title === undefined ? undefined : stripClaudePlanTag(stripGoalStartPrompt(title));
+    return {
+        ...(id === undefined ? {} : { externalSessionId: id }),
+        cwd,
+        ...(strippedTitle === undefined || strippedTitle.length === 0
+            ? {}
+            : { title: compact(strippedTitle) }),
+        items
+    };
+}
+function derivedTranscriptRecord(value) {
+    return value['isSidechain'] === true;
+}
+function transcriptItems(record) {
+    if (record.type === 'assistant') {
+        return claudeAssistantBlocks(record).flatMap(({ record: blockRecord, blockIndex, sourceItemId }) => {
+            const block = contentBlocks(blockRecord)[0];
+            if (block?.type === 'thinking') {
+                const text = extractClaudeThinkingText(blockRecord)[0] ?? '';
+                return text.length === 0
+                    ? []
+                    : [
+                        {
+                            kind: 'reasoning_summary',
+                            representation: 'visible_thinking',
+                            sections: [{ index: blockIndex, text }],
+                            createdAt: timestampOf(record),
+                            ...(sourceItemId === undefined ? {} : { sourceItemId })
+                        }
+                    ];
+            }
+            return transcriptRecordItems(blockRecord).map((item) => ({
+                ...item,
+                ...(sourceItemId === undefined ? {} : { sourceItemId })
+            }));
+        });
+    }
+    return transcriptRecordItems(record);
+}
+function transcriptRecordItems(record) {
+    const createdAt = timestampOf(record);
+    const results = toolResultsOf(record, createdAt);
+    if (results.length > 0)
+        return results;
+    const values = [
+        ...toolUsesOf(record, createdAt),
+        ...unsupportedTranscriptItems(record, createdAt)
+    ];
+    const role = roleOf(record);
+    if (role === undefined)
+        return values;
+    const rawText = messageText(textOf(record) ?? '');
+    if (rawText.length === 0)
+        return values;
+    values.unshift({ kind: 'message', role, text: rawText, createdAt });
+    return values;
+}
+function toolUsesOf(record, createdAt) {
+    return contentBlocks(record).flatMap((block) => {
+        if (block['type'] !== 'tool_use' ||
+            typeof block['id'] !== 'string' ||
+            typeof block['name'] !== 'string')
+            return [];
+        const input = block['input'];
+        const summary = compactValue(input, 10_000);
+        return [
+            {
+                kind: 'tool_call',
+                toolUseId: block['id'],
+                toolName: compact(block['name']).slice(0, 128),
+                input,
+                inputSummary: summary.text || null,
+                inputTruncated: summary.truncated,
+                outputSummary: null,
+                outputTruncated: false,
+                failed: false,
+                createdAt
+            }
+        ];
+    });
+}
+function toolResultsOf(record, createdAt) {
+    return extractClaudeToolResults(record).map((result) => ({
+        ...result,
+        kind: 'tool_result',
+        createdAt
+    }));
+}
+function isClaudeCompactCommand(record) {
+    return textOf(record)?.trim() === '<command-name>/compact</command-name>';
+}
+function isClaudeCompactSuccess(record) {
+    return textOf(record)?.trim() === '<local-command-stdout>Compacted</local-command-stdout>';
+}
+function withToolResult(call, result) {
+    return {
+        ...call,
+        outputSummary: result.output,
+        outputTruncated: result.truncated,
+        failed: result.failed,
+        ...(result.claudeResult === undefined
+            ? {}
+            : {
+                subagentResult: {
+                    ...(result.claudeResult.agentId === undefined
+                        ? {}
+                        : { agentId: result.claudeResult.agentId }),
+                    ...(result.claudeResult.task_id === undefined
+                        ? {}
+                        : { taskId: result.claudeResult.task_id }),
+                    ...(result.claudeResult.task_type === undefined
+                        ? {}
+                        : { taskType: result.claudeResult.task_type })
+                }
+            })
+    };
+}
+function workspacePath(record) {
+    return (firstString(record, ['cwd', 'working_directory', 'workspacePath']) ??
+        nestedString(record, ['payload', 'cwd']) ??
+        nestedString(record, ['message', 'cwd']));
+}
+function sessionId(record) {
+    return (firstString(record, ['sessionId', 'session_id', 'thread_id', 'conversationId']) ??
+        nestedString(record, ['payload', 'id']) ??
+        nestedString(record, ['payload', 'session_id']) ??
+        nestedString(record, ['payload', 'thread_id']));
+}
+function timestampOf(record) {
+    const raw = record['timestamp'] ?? record['created_at'] ?? record['createdAt'];
+    if (typeof raw === 'number' && Number.isFinite(raw))
+        return raw < 10_000_000_000 ? raw * 1_000 : raw;
+    if (typeof raw === 'string') {
+        const value = Date.parse(raw);
+        return Number.isNaN(value) ? null : value;
+    }
+    return null;
+}
+function firstString(value, keys) {
+    for (const key of keys)
+        if (typeof value[key] === 'string' && value[key].length > 0)
+            return value[key];
+    return undefined;
+}
+function nestedString(value, keys) {
+    let current = value;
+    for (const key of keys) {
+        if (!isRecord(current))
+            return undefined;
+        current = current[key];
+    }
+    return typeof current === 'string' && current.length > 0 ? current : undefined;
+}
+function compact(value) {
+    return value.replace(/\s+/g, ' ').trim().slice(0, 16_000);
+}
+function messageText(value) {
+    return value.trim().slice(0, 16_000);
+}
+function roleOf(record) {
+    const candidates = [
+        firstString(record, ['role']),
+        nestedString(record, ['message', 'role']),
+        nestedString(record, ['payload', 'role']),
+        firstString(record, ['type']),
+        nestedString(record, ['payload', 'type'])
+    ];
+    if (candidates.some((value) => value === 'user' || value === 'human' || value === 'input'))
+        return 'USER';
+    if (candidates.some((value) => value === 'assistant' || value === 'agent' || value === 'output'))
+        return 'ASSISTANT';
+    return undefined;
+}
+function textOf(record) {
+    return (firstString(record, ['content', 'text']) ??
+        nestedText(record['message']) ??
+        nestedText(record['payload']));
+}
+function nestedText(value) {
+    if (typeof value === 'string')
+        return value;
+    if (!isRecord(value))
+        return undefined;
+    const direct = firstString(value, ['content', 'text', 'message']);
+    if (direct !== undefined)
+        return direct;
+    if (Array.isArray(value['content'])) {
+        const parts = value['content'].flatMap((part) => {
+            if (typeof part === 'string')
+                return [part];
+            if (!isRecord(part))
+                return [];
+            return [firstString(part, ['text', 'content'])].filter((text) => text !== undefined);
+        });
+        return parts.join('\n');
+    }
+    return undefined;
+}
+function contentBlocks(record) {
+    const values = [record['message'], record['payload']];
+    for (const value of values)
+        if (isRecord(value) && Array.isArray(value['content']))
+            return value['content'].filter(isRecord);
+    return [];
+}
+function isHiddenTranscriptRecord(record) {
+    if (contentBlocks(record).some((block) => block['type'] === 'tool_result'))
+        return false;
+    if (record['interruptedByShutdown'] === true ||
+        record['isMeta'] === true ||
+        record['isVisibleInTranscriptOnly'] === true ||
+        record['isCompactSummary'] === true)
+        return true;
+    const text = textOf(record)?.trim() ?? '';
+    return (text.startsWith('<local-command-') ||
+        text.startsWith('<command-name>') ||
+        text.startsWith('<command-message>'));
+}
+function unsupportedTranscriptItems(record, createdAt) {
+    return contentBlocks(record).flatMap((block) => {
+        const type = typeof block.type === 'string' ? block.type : undefined;
+        if (type === undefined ||
+            type === 'text' ||
+            type === 'input_text' ||
+            type === 'output_text' ||
+            type === 'image' ||
+            type === 'input_image' ||
+            type === 'thinking' ||
+            type === 'redacted_thinking' ||
+            type === 'encrypted_thinking' ||
+            type === 'tool_use' ||
+            type === 'tool_result')
+            return [];
+        return [
+            {
+                kind: 'unknown',
+                sourceEventType: `transcript:${type}`,
+                label: `Agent ${compact(type).slice(0, 128)}`,
+                createdAt
+            }
+        ];
+    });
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export const claudeNativeTranscriptAdapter = {
+    runner: 'claude-code',
+    transcriptRoot: () => join(homedir(), '.claude', 'projects'),
+    includesPath: (path) => !path.split(/[\\/]/u).includes('subagents'),
+    async locateCandidates(externalSessionId) {
+        try {
+            const root = this.transcriptRoot();
+            return (await readdir(root, { withFileTypes: true }))
+                .filter((entry) => entry.isDirectory())
+                .map((entry) => join(root, entry.name, `${externalSessionId}.jsonl`));
+        }
+        catch {
+            return [];
+        }
+    },
+    parse,
+    createProjection(precedingItems) {
+        const titles = restoreClaudeSubagentTitles(precedingItems.filter((entry) => entry.kind === 'tool_call'));
+        return {
+            userText: (text) => publicGoalHistoryText(stripClaudePlanTag(text)),
+            planText: claudePlanText,
+            normalizeTool: (entry) => normalizeClaudeTool(entry.toolName, entry.input, entry.outputSummary, entry.failed, entry.inputTruncated || entry.outputTruncated, titles, claudeNativeToolResultMetadata(entry.subagentResult)),
+            userInputQuestions: (entry) => entry.toolName === 'AskUserQuestion' && isPlainRecord(entry.input)
+                ? claudeUserInputQuestions(entry.input)
+                : []
+        };
+    }
+};

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

@@ -1,4 +1,5 @@
-import { claudeContentBlocks, compactRunnerText, compactRunnerValue } from '../../util/node-operation-parsers.js';
+import { claudeContentBlocks } from './message-parsers.js';
+import { compactRunnerText, compactRunnerValue } from '../../util/node-operation-parsers.js';
 import { RunnerUsageTracker, usageToken, usageTokenSum } from '../../service/runner-usage-tracker.js';
 export class ClaudeUsageNormalizer {
     tracker;
@@ -46,10 +47,19 @@ export class ClaudeUsageNormalizer {
         this.tracker.finish(state);
     }
 }
+export function claudeNativeToolResultMetadata(result) {
+    if (result === undefined)
+        return undefined;
+    return {
+        ...(result.agentId === undefined ? {} : { agentId: result.agentId }),
+        ...(result.taskId === undefined ? {} : { task_id: result.taskId }),
+        ...(result.taskType === undefined ? {} : { task_type: result.taskType })
+    };
+}
 export function restoreClaudeSubagentTitles(calls) {
     const titles = new Map();
     for (const call of calls)
-        claudeSubagentProjection(call.toolName, call.input, call.claudeResult ?? call.outputSummary, titles);
+        claudeSubagentProjection(call.toolName, call.input, claudeNativeToolResultMetadata(call.subagentResult) ?? call.outputSummary, titles);
     return titles;
 }
 export function extractClaudeToolResults(message) {