@myagentroam/node 0.11.2 → 0.11.3

package/dist/native-session-history.js

@@ -7,6 +7,8 @@ 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 { codexTranscriptSourceItemId } from './runner/codex/conversation-parser.js';
+import { claudeAssistantBlocks, extractClaudeThinkingText } from './runner/claude/conversation-parser.js';
 import { extractClaudeToolResults } from './runner/claude/tool-normalizer.js';
 const DISCOVERY_READ_BYTES = 32 * 1024;
 const TRANSCRIPT_HEADER_READ_BYTES = 32 * 1024;
@@ -477,9 +479,11 @@ async function readTranscript(path, runner, byteLimit, page, targetLines = Numbe
         const generatedImage = codexGeneratedImageEvent(value);
         if (generatedImage !== undefined)
             items.push(generatedImage);
+        const sourceItemId = runner === 'codex' ? codexTranscriptSourceItemId(value, codexTurnId) : undefined;
         for (const parsedItem of transcriptItems(runner, value)) {
             const item = {
                 ...parsedItem,
+                ...(sourceItemId === undefined ? {} : { sourceItemId }),
                 ...(recordId === undefined ? {} : { nativeId: recordId }),
                 ...(runner === 'codex' &&
                     parsedItem.kind === 'message' &&
@@ -615,6 +619,32 @@ function positiveInteger(value) {
     return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
 }
 function transcriptItems(runner, record) {
+    if (runner === 'claude-code' && 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(runner, blockRecord).map((item) => ({
+                ...item,
+                ...(sourceItemId === undefined ? {} : { sourceItemId })
+            }));
+        });
+    }
+    return transcriptRecordItems(runner, record);
+}
+function transcriptRecordItems(runner, record) {
     const createdAt = timestampOf(record);
     const results = [...toolResultsOf(record, createdAt), ...codexToolResultsOf(record, createdAt)];
     if (results.length > 0)
@@ -689,7 +719,7 @@ function codexReasoningSummariesOf(record, createdAt) {
             return text.length === 0 ? [] : [{ index, text }];
         })
         : [];
-    return [{ kind: 'reasoning_summary', sections, createdAt }];
+    return [{ kind: 'reasoning_summary', representation: 'summary', sections, createdAt }];
 }
 function unsupportedTranscriptItems(record, createdAt) {
     return contentBlocks(record).flatMap((block) => {

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

@@ -0,0 +1,42 @@
+import { boundedConversationItemId, isPlainRecord, claudeContentBlocks, compactRunnerText } from '../../util/node-operation-parsers.js';
+export function extractClaudeThinkingText(record) {
+    return claudeContentBlocks(record).flatMap((block) => {
+        // Completed public blocks only; signatures and redacted/encrypted data are never read.
+        if (block.type !== 'thinking' || typeof block.thinking !== 'string')
+            return [];
+        const text = compactRunnerText(block.thinking.trim(), 10_000);
+        return text.length === 0 ? [] : [text];
+    });
+}
+/** Preserve native block order and identity across SDK callbacks and transcript reads. */
+export function claudeAssistantBlocks(record) {
+    const message = isPlainRecord(record.message) ? record.message : undefined;
+    if (message === undefined)
+        return [];
+    const content = typeof message.content === 'string'
+        ? [{ type: 'text', text: message.content }]
+        : Array.isArray(message.content)
+            ? message.content
+            : [];
+    const messageId = typeof record.uuid === 'string'
+        ? record.uuid
+        : typeof message.id === 'string'
+            ? message.id
+            : undefined;
+    return content.flatMap((block, blockIndex) => {
+        if (!isPlainRecord(block))
+            return [];
+        const sourceItemId = block.type === 'tool_use' && typeof block.id === 'string'
+            ? boundedConversationItemId('claude-tool', block.id)
+            : messageId === undefined
+                ? undefined
+                : JSON.stringify(['claude', messageId, blockIndex]);
+        return [
+            {
+                record: { ...record, message: { ...message, content: [block] } },
+                blockIndex,
+                ...(sourceItemId === undefined ? {} : { sourceItemId })
+            }
+        ];
+    });
+}

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

@@ -1,8 +1,9 @@
+import { claudeAssistantBlocks, extractClaudeThinkingText } from './conversation-parser.js';
 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, extractClaudeToolUses } from '../codex/conversation-parser.js';
+import { boundedConversationItemId, claudePlanText, compactRunnerText, extractClaudeText, 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';
@@ -344,67 +345,84 @@ export class ClaudeManagedRunController {
                             finalOutputTokens.set(snapshotId, snapshotUsage.output_tokens);
                             settleGeneration(snapshotId, receiptAt);
                         }
-                        const text = extractClaudeText(record);
-                        if (mainTask && (text.length > 0 || extractClaudeThinkingSummaries(record).length > 0))
-                            observeResponse(typeof record.message?.id === 'string'
-                                ? record.message.id
-                                : undefined);
-                        const planText = claudePlanText(text);
-                        if (planText !== undefined)
-                            this.host.emitItem(runId, {
-                                itemId: boundedConversationItemId('claude-plan', typeof record.uuid === 'string' ? record.uuid : `${runId}:plan`),
-                                kind: 'plan',
-                                status: 'COMPLETED',
-                                payload: { explanation: compactRunnerText(planText, 20_000), steps: [] }
-                            });
-                        else if (text.length > 0)
-                            this.host.emit(runId, 'text.delta', { text });
-                        for (const [index, text] of extractClaudeThinkingSummaries(record).entries()) {
-                            this.host.emitItem(runId, {
-                                itemId: boundedConversationItemId('claude-reasoning', `${typeof record.uuid === 'string' ? record.uuid : runId}:${index}`),
-                                kind: 'reasoning_summary',
-                                status: 'COMPLETED',
-                                payload: { sections: [{ index, text }] }
-                            });
-                        }
-                        for (const tool of extractClaudeToolUses(record)) {
-                            const latencyMs = mainTask ? responseLatency.toolStarted(tool.id) : undefined;
-                            if (latencyMs !== undefined)
-                                this.host.emit(runId, 'run.performance', { latencyMs });
-                            if (tool.name === 'AskUserQuestion') {
-                                toolKinds.set(tool.id, 'user_input_request');
-                                continue;
+                        const fallbackMessageId = crypto.randomUUID();
+                        for (const { record: blockRecord, blockIndex, sourceItemId } of claudeAssistantBlocks(record)) {
+                            const text = extractClaudeText(blockRecord);
+                            if (mainTask &&
+                                (text.length > 0 || extractClaudeThinkingText(blockRecord).length > 0))
+                                observeResponse(typeof record.message?.id === 'string'
+                                    ? record.message.id
+                                    : undefined);
+                            const planText = claudePlanText(text);
+                            if (planText !== undefined)
+                                this.host.emitItem(runId, {
+                                    itemId: boundedConversationItemId('claude-plan', sourceItemId ?? `${fallbackMessageId}:${blockIndex}`),
+                                    ...(sourceItemId === undefined ? {} : { sourceItemId }),
+                                    kind: 'plan',
+                                    status: 'COMPLETED',
+                                    payload: { explanation: compactRunnerText(planText, 20_000), steps: [] }
+                                });
+                            else if (text.length > 0)
+                                this.host.emitItem(runId, {
+                                    itemId: boundedConversationItemId('claude-text', sourceItemId ?? `${fallbackMessageId}:${blockIndex}`),
+                                    ...(sourceItemId === undefined ? {} : { sourceItemId }),
+                                    kind: 'assistant_message',
+                                    status: 'COMPLETED',
+                                    payload: { text, format: 'markdown', model: null }
+                                });
+                            for (const text of extractClaudeThinkingText(blockRecord)) {
+                                this.host.emitItem(runId, {
+                                    itemId: boundedConversationItemId('claude-reasoning', sourceItemId ?? `${fallbackMessageId}:${blockIndex}`),
+                                    ...(sourceItemId === undefined ? {} : { sourceItemId }),
+                                    kind: 'reasoning',
+                                    status: 'COMPLETED',
+                                    payload: {
+                                        representation: 'visible_thinking',
+                                        sections: [{ index: blockIndex, text }]
+                                    }
+                                });
                             }
-                            const itemId = boundedConversationItemId('claude-tool', tool.id);
-                            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, {
-                                itemId,
-                                kind,
-                                status: 'IN_PROGRESS',
-                                payload: normalized.payload
-                            });
-                        }
-                        for (const [index, block] of claudeContentBlocks(record).entries()) {
-                            const type = typeof block.type === 'string' ? block.type : 'unknown';
-                            if (type === 'text' ||
-                                type === 'thinking' ||
-                                type === 'redacted_thinking' ||
-                                type === 'encrypted_thinking' ||
-                                type === 'tool_use' ||
-                                type === 'tool_result')
-                                continue;
-                            this.host.emitItem(runId, {
-                                itemId: boundedConversationItemId('claude-item', `${typeof record.uuid === 'string' ? record.uuid : runId}:${index}`),
-                                kind: 'unknown',
-                                status: 'COMPLETED',
-                                payload: {
-                                    sourceEventType: `claude-code:${type}`,
-                                    label: `Claude Code ${compactRunnerText(type, 128)}`
+                            for (const tool of extractClaudeToolUses(blockRecord)) {
+                                const latencyMs = mainTask ? responseLatency.toolStarted(tool.id) : undefined;
+                                if (latencyMs !== undefined)
+                                    this.host.emit(runId, 'run.performance', { latencyMs });
+                                if (tool.name === 'AskUserQuestion') {
+                                    toolKinds.set(tool.id, 'user_input_request');
+                                    continue;
                                 }
-                            });
+                                const itemId = boundedConversationItemId('claude-tool', tool.id);
+                                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, {
+                                    itemId,
+                                    sourceItemId: itemId,
+                                    kind,
+                                    status: 'IN_PROGRESS',
+                                    payload: normalized.payload
+                                });
+                            }
+                            for (const block of claudeContentBlocks(blockRecord)) {
+                                const type = typeof block.type === 'string' ? block.type : 'unknown';
+                                if (type === 'text' ||
+                                    type === 'thinking' ||
+                                    type === 'redacted_thinking' ||
+                                    type === 'encrypted_thinking' ||
+                                    type === 'tool_use' ||
+                                    type === 'tool_result')
+                                    continue;
+                                this.host.emitItem(runId, {
+                                    itemId: boundedConversationItemId('claude-item', sourceItemId ?? `${fallbackMessageId}:${blockIndex}`),
+                                    ...(sourceItemId === undefined ? {} : { sourceItemId }),
+                                    kind: 'unknown',
+                                    status: 'COMPLETED',
+                                    payload: {
+                                        sourceEventType: `claude-code:${type}`,
+                                        label: `Claude Code ${compactRunnerText(type, 128)}`
+                                    }
+                                });
+                            }
                         }
                     }
                     if (record.type === 'tool_progress' && typeof record.tool_use_id === 'string') {

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

@@ -135,6 +135,16 @@ export function normalizeClaudeTool(toolName, input, output, failed, truncated,
             progressLabel: null,
             errorCode: failed ? 'TOOL_EXECUTION_FAILED' : null,
             truncated: outputTruncated,
+            ...(toolName === 'Read'
+                ? {
+                    toolPresentation: {
+                        kind: 'READ',
+                        paths: typeof values?.file_path === 'string' && values.file_path.length > 0
+                            ? [compactRunnerText(values.file_path, 4096)]
+                            : []
+                    }
+                }
+                : {}),
             ...subagent
         }
     };

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

@@ -629,6 +629,20 @@ export function codexPlanText(value) {
  * A final Claude tagged Plan Mode plan is fully wrapped in `<proposed_plan>` tags;
  * text with missing or unclosed tags remains a regular assistant message.
  */
+export function codexSourceItemId(nativeTurnId, itemId) {
+    return JSON.stringify([nativeTurnId, itemId]);
+}
+export function codexTranscriptSourceItemId(record, nativeTurnId) {
+    if (nativeTurnId === undefined ||
+        record.type !== 'response_item' ||
+        !isPlainRecord(record.payload))
+        return undefined;
+    const payload = record.payload;
+    const id = typeof payload.call_id === 'string' ? payload.call_id : payload.id;
+    return typeof id === 'string'
+        ? codexSourceItemId(nativeTurnId, boundedConversationItemId('codex', id))
+        : undefined;
+}
 export function codexOfficialItem(session, nativeTurnId, value, turnSequence, itemSequence, startedAt, completedAt) {
     if (!isPlainRecord(value) || typeof value.type !== 'string' || value.type === 'subAgentActivity')
         return undefined;
@@ -645,6 +659,7 @@ export function codexOfficialItem(session, nativeTurnId, value, turnSequence, it
                 : `${nativeTurnId}:${itemSequence}`;
     const base = {
         id: `${session.id}:official:${nativeTurnId}:${id}`,
+        sourceItemId: codexSourceItemId(nativeTurnId, boundedConversationItemId('codex', id)),
         sessionId: session.id,
         turnId: `${session.id}:official:${nativeTurnId}`,
         runId: null,
@@ -689,7 +704,7 @@ export function codexOfficialItem(session, nativeTurnId, value, turnSequence, it
                 ? [{ index, text: compactRunnerText(text, 10_000) }]
                 : [])
             : [];
-        return { ...base, kind: 'reasoning_summary', payload: { sections } };
+        return { ...base, kind: 'reasoning', payload: { representation: 'summary', sections } };
     }
     if (value.type === 'commandExecution') {
         const output = typeof value.aggregatedOutput === 'string' ? value.aggregatedOutput : '';
@@ -835,9 +850,9 @@ export function codexLiveConversationItem(value, completed, imageAttachments = [
             : [];
         return {
             itemId,
-            kind: 'reasoning_summary',
+            kind: 'reasoning',
             status: completed ? 'COMPLETED' : 'IN_PROGRESS',
-            payload: { sections }
+            payload: { representation: 'summary', sections }
         };
     }
     const planText = codexPlanText(value);

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

@@ -6,7 +6,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, CodexUsageNormalizer, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
+import { boundedConversationItemId, codexImageAttachments, codexLiveConversationItem, codexSourceItemId, CodexUsageNormalizer, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
 export function resolveCodexNotificationRun(runs, input) {
     const entries = [...runs.entries()];
     if (input.turnId !== undefined) {
@@ -35,6 +35,15 @@ export class CodexManagedRunController {
         this.runner = runner;
         this.host = host;
     }
+    emitItem(runId, item) {
+        const nativeTurnId = this.runner.execution.runs.get(runId)?.turnId;
+        this.host.emitItem(runId, nativeTurnId === undefined
+            ? item
+            : {
+                ...item,
+                sourceItemId: codexSourceItemId(nativeTurnId, item.itemId)
+            });
+    }
     async executeCommand(session, command, input, context) {
         if (command.id === 'plan') {
             const environmentLeaseId = crypto.randomUUID();
@@ -222,6 +231,9 @@ export class CodexManagedRunController {
                 : undefined;
             this.host.emit(runId, 'text.delta', {
                 text: params.delta,
+                ...(itemId === undefined || turnId === undefined
+                    ? {}
+                    : { sourceItemId: codexSourceItemId(turnId, itemId) }),
                 ...(itemId === undefined ? {} : { itemId })
             });
             if (params.delta.length > 0)
@@ -245,11 +257,14 @@ export class CodexManagedRunController {
             const index = typeof params.summaryIndex === 'number' && Number.isInteger(params.summaryIndex)
                 ? params.summaryIndex
                 : 0;
-            this.host.emitItem(runId, {
+            this.emitItem(runId, {
                 itemId: boundedConversationItemId('codex', params.itemId),
-                kind: 'reasoning_summary',
+                kind: 'reasoning',
                 status: 'IN_PROGRESS',
-                payload: { sections: [{ index, text: compactRunnerText(params.delta, 10_000) }] },
+                payload: {
+                    representation: 'summary',
+                    sections: [{ index, text: compactRunnerText(params.delta, 10_000) }]
+                },
                 merge: true,
                 append: 'sections'
             });
@@ -262,7 +277,7 @@ export class CodexManagedRunController {
         if (notification.method === 'item/commandExecution/outputDelta' &&
             typeof params.itemId === 'string' &&
             typeof params.delta === 'string') {
-            this.host.emitItem(runId, {
+            this.emitItem(runId, {
                 itemId: boundedConversationItemId('codex', params.itemId),
                 kind: 'command_execution',
                 status: 'IN_PROGRESS',
@@ -275,7 +290,7 @@ export class CodexManagedRunController {
         if (notification.method === 'item/mcpToolCall/progress' &&
             typeof params.itemId === 'string' &&
             typeof params.message === 'string') {
-            this.host.emitItem(runId, {
+            this.emitItem(runId, {
                 itemId: boundedConversationItemId('codex', params.itemId),
                 kind: 'tool_call',
                 status: 'IN_PROGRESS',
@@ -289,7 +304,7 @@ export class CodexManagedRunController {
             const attachments = this.host.appendImages(runId, codexImageAttachments(params.item));
             const item = codexLiveConversationItem(params.item, notification.method === 'item/completed', attachments);
             if (item !== undefined) {
-                this.host.emitItem(runId, item);
+                this.emitItem(runId, item);
                 if (item.kind === 'context_compaction') {
                     activeRun.generationCompacting = notification.method === 'item/started';
                     if (activeRun.generationCompacting) {
@@ -317,7 +332,7 @@ export class CodexManagedRunController {
                             this.host.emit(runId, 'run.performance', { latencyMs });
                     }
                 }
-                else if (['assistant_message', 'reasoning_summary', 'plan'].includes(item.kind)) {
+                else if (['assistant_message', 'reasoning', 'plan'].includes(item.kind)) {
                     // A started reasoning item is itself a semantic response, even before its summary.
                     if (notification.method === 'item/started')
                         this.beginGeneration(runId, receiptAt);
@@ -527,7 +542,7 @@ export class CodexManagedRunController {
                 allowOther: question.allowOther
             }))
         });
-        this.host.emitItem(runId, {
+        this.emitItem(runId, {
             itemId: boundedConversationItemId('codex-input', requestId),
             kind: 'user_input_request',
             status: 'PENDING',
@@ -722,7 +737,7 @@ export class CodexManagedRunController {
     }
     emitError(runId, error, fallbackCode) {
         const projected = runnerErrorProjection(error, fallbackCode);
-        this.host.emitItem(runId, {
+        this.emitItem(runId, {
             itemId: boundedConversationItemId('runner-error', runId),
             kind: 'error',
             status: 'FAILED',

package/dist/runner/mar-agent/conversation-normalizer.js

@@ -52,11 +52,11 @@ export class MarAgentConversationNormalizer {
                 }
             ];
         }
-        if (event.type === 'message.completed') {
+        if (event.type === 'message.started' || event.type === 'message.completed') {
             const modelName = record(event)?.modelName;
             const itemId = this.messageItemId(event.itemId);
             const payload = {
-                text: event.text,
+                text: event.type === 'message.completed' ? event.text : '',
                 format: 'markdown',
                 model: typeof modelName === 'string' ? modelName : null
             };
@@ -64,7 +64,7 @@ export class MarAgentConversationNormalizer {
                 {
                     itemId,
                     kind: 'assistant_message',
-                    status: 'COMPLETED',
+                    status: event.type === 'message.completed' ? 'COMPLETED' : 'IN_PROGRESS',
                     payload
                 }
             ];
@@ -78,20 +78,24 @@ export class MarAgentConversationNormalizer {
                     payload: { explanation: event.text, steps: [] }
                 }
             ];
-        if (event.type === 'reasoning.summary')
+        if (event.type === 'reasoning.completed')
             return [
                 {
-                    itemId: itemId('reasoning', event.eventId),
-                    kind: 'reasoning_summary',
+                    itemId: itemId('reasoning', event.itemId),
+                    kind: 'reasoning',
                     status: 'COMPLETED',
-                    payload: { sections: [{ index: 0, text: compactRunnerText(event.text, 10_000) }] }
+                    payload: {
+                        representation: event.representation,
+                        sections: [{ index: 0, text: compactRunnerText(event.text, 10_000) }]
+                    }
                 }
             ];
         if (event.type === 'tool.started' ||
             event.type === 'tool.completed' ||
             event.type === 'tool.failed') {
-            // Native web calls and generated artifacts stay visible independently of cell observations.
+            // Read/web calls and generated artifacts stay visible independently of cell observations.
             if (event.parentCallId !== undefined &&
+                event.toolName !== 'read' &&
                 event.toolName !== 'web_search' &&
                 event.toolName !== 'web_fetch' &&
                 !isImageGenerationTool(event.toolName))
@@ -352,7 +356,7 @@ export class MarAgentConversationNormalizer {
             if (observation.id !== undefined)
                 this.#codeModeObservationIds.add(observation.id);
             this.#codeModeSourceCallIds.add(observation.source.callId);
-            items.push(...projected);
+            items.push(...projected.map((item) => 'callId' in event ? { ...item, parentItemId: itemId('tool', event.callId) } : item));
         }
         return items;
     }
@@ -665,6 +669,16 @@ function genericToolItem(id, toolName, status, input, outputSummary = null, erro
     };
 }
 function projectToolPresentation(toolName, input, output, startedAt) {
+    if (toolName === 'read') {
+        const reads = record(input)?.reads;
+        const paths = (Array.isArray(reads) ? reads : [])
+            .flatMap((entry) => {
+            const path = record(entry)?.path;
+            return typeof path === 'string' && path.length > 0 ? [compactRunnerText(path, 4096)] : [];
+        })
+            .slice(0, 16);
+        return { kind: 'READ', paths };
+    }
     const category = toolName === 'web_search'
         ? 'WEB_SEARCH'
         : toolName === 'web_fetch'

package/dist/runner/mar-agent/history-projection.js

@@ -102,7 +102,7 @@ export function projectMarAgentHistory(session, entries, options = {}) {
             const attachments = projected.generatedImages === undefined
                 ? []
                 : (options.registerGeneratedImages?.(event.sessionId, projected.generatedImages) ?? []);
-            replace(projectionTurn, historyItem(session, projectionTurn, projected.itemId, projected.kind, projected.status, attachments.length === 0 ? projected.payload : { ...projected.payload, attachments }, at, projected.permissionStop));
+            replace(projectionTurn, historyItem(session, projectionTurn, projected.itemId, projected.kind, projected.status, attachments.length === 0 ? projected.payload : { ...projected.payload, attachments }, at, projected.permissionStop, projected.parentItemId));
         }
     }
     return [...turns.values()];
@@ -129,13 +129,13 @@ function record(value) {
         ? value
         : undefined;
 }
-function historyItem(session, turn, id, kind, status, payload, at, permissionStop) {
+function historyItem(session, turn, id, kind, status, payload, at, permissionStop, parentItemId) {
     return {
         id,
         sessionId: session.id,
         turnId: turn.id,
         runId: turn.runId,
-        parentItemId: null,
+        parentItemId: parentItemId ?? null,
         sourceSequence: null,
         revision: 0,
         kind,

package/dist/runner/mar-agent/managed-run-controller.js

@@ -709,6 +709,7 @@ export class MarAgentManagedRunController {
                         []);
                 this.host.emitItem(runId, {
                     itemId: item.itemId,
+                    ...(item.parentItemId === undefined ? {} : { parentItemId: item.parentItemId }),
                     kind: item.kind,
                     status: item.status,
                     payload: attachments.length === 0 ? item.payload : { ...item.payload, attachments },

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

@@ -139,7 +139,12 @@ function openCodeTurn(session, user, userParts, assistants, sequence, managed) {
         for (const part of assistant.parts) {
             const projected = partItem(session, nativeTurnId, part, assistant.info.mode === 'plan', startedAt, completedAt, sequence);
             if (projected !== undefined)
-                items.push(projected);
+                items.push({
+                    ...projected,
+                    ...(typeof assistant.info.id === 'string' && typeof record(part)?.id === 'string'
+                        ? { sourceItemId: openCodeSourceItemId(assistant.info.id, record(part).id) }
+                        : {})
+                });
         }
     }
     if (items.length === 0)
@@ -173,12 +178,17 @@ function partItem(session, turnId, raw, planMode, startedAt, completedAt, sequen
     const part = record(raw);
     if (typeof part?.id !== 'string' || typeof part.type !== 'string')
         return undefined;
+    if (part.type === 'reasoning' && (typeof part.text !== 'string' || !part.text.trim()))
+        return undefined;
     if ((part.type === 'text' || part.type === 'reasoning') && typeof part.text === 'string')
-        return item(session, turnId, part.id, part.type === 'text' ? (planMode ? 'plan' : 'assistant_message') : 'reasoning_summary', completedAt === null ? 'IN_PROGRESS' : 'COMPLETED', part.type === 'text'
+        return item(session, turnId, part.id, part.type === 'text' ? (planMode ? 'plan' : 'assistant_message') : 'reasoning', completedAt === null ? 'IN_PROGRESS' : 'COMPLETED', part.type === 'text'
             ? planMode
                 ? { explanation: compactRunnerText(part.text, 20_000), steps: [] }
                 : { text: compactRunnerText(part.text, 20_000), format: 'markdown', model: null }
-            : { sections: [{ index: 0, text: compactRunnerText(part.text, 10_000) }] }, startedAt, completedAt, sequence);
+            : {
+                representation: 'unspecified',
+                sections: [{ index: 0, text: compactRunnerText(part.text, 10_000) }]
+            }, startedAt, completedAt, sequence);
     if (part.type === 'tool' && typeof part.tool === 'string') {
         const state = record(part.state);
         if (part.tool === 'question' && typeof part.callID === 'string') {
@@ -258,6 +268,9 @@ export function openCodePatchToolPayload() {
         truncated: false
     };
 }
+export function openCodeSourceItemId(messageId, partId) {
+    return JSON.stringify(['opencode', messageId, partId]);
+}
 function item(session, turnId, nativeId, kind, status, payload, startedAt, completedAt, sequence) {
     return {
         id: boundedConversationItemId(`${session.id}:official:${turnId}`, nativeId),

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

@@ -1,4 +1,4 @@
-import { OpenCodeUsageNormalizer } from './conversation-parser.js';
+import { OpenCodeUsageNormalizer, openCodeSourceItemId } from './conversation-parser.js';
 import { parseComposerTags } from '@myagentroam/protocol';
 import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
@@ -440,7 +440,10 @@ export class OpenCodeManagedRunController {
             }
             const item = openCodePart(part, this.runner.execution.get(runId)?.agent === 'plan');
             if (item !== undefined)
-                this.host.emitItem(runId, item);
+                this.host.emitItem(runId, {
+                    ...item,
+                    sourceItemId: openCodeSourceItemId(part.messageID, part.id)
+                });
             if (typeof part.id === 'string') {
                 const itemId = boundedConversationItemId('opencode', part.id);
                 const responseLatency = this.currentResponseMessage(runId, part.messageID)
@@ -688,6 +691,8 @@ function openCodePart(part, planMode = false) {
     const id = typeof part?.id === 'string' ? part.id : undefined;
     if (id === undefined || typeof part?.type !== 'string')
         return undefined;
+    if (part.type === 'reasoning' && (typeof part.text !== 'string' || !part.text.trim()))
+        return undefined;
     const itemId = boundedConversationItemId('opencode', id);
     if (part.type === 'text' && typeof part.text === 'string')
         return {
@@ -702,9 +707,9 @@ function openCodePart(part, planMode = false) {
     if (part.type === 'reasoning' && typeof part.text === 'string')
         return {
             itemId,
-            kind: 'reasoning_summary',
+            kind: 'reasoning',
             status: record(part.time)?.end === undefined ? 'IN_PROGRESS' : 'COMPLETED',
-            payload: { sections: [{ index: 0, text: part.text }] },
+            payload: { representation: 'unspecified', sections: [{ index: 0, text: part.text }] },
             merge: true
         };
     if (part.type === 'tool' && typeof part.tool === 'string') {

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

@@ -38,6 +38,16 @@ export function normalizeOpenCodeTool(toolName, state) {
             progressLabel: null,
             errorCode: status === 'FAILED' ? 'OPENCODE_TOOL_FAILED' : null,
             truncated: false,
+            ...(normalizedName === 'read'
+                ? {
+                    toolPresentation: {
+                        kind: 'READ',
+                        paths: typeof input?.filePath === 'string' && input.filePath.length > 0
+                            ? [compactRunnerText(input.filePath, 4096)]
+                            : []
+                    }
+                }
+                : {}),
             ...subagent
         }
     };

package/dist/runtime-state.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { projectConversationWorkProcesses } from './service/conversation-work-process.js';
 import { nodeLog } from './operational.js';
 import { safeErrorCode } from './util/safe-error.js';
 import { permissionStopSchema } from '@myagentroam/protocol';
@@ -1383,6 +1384,7 @@ export class NodeRuntimeState {
             this.currentTurnForRun(event.runId) === undefined &&
             conversationItemFromEvent(event) !== undefined)
             this.createItemOnlyTurn(run, event.createdAt);
+        let needsProcessProjection = false;
         const update = (turn) => {
             if (event.eventType === 'text.delta' &&
                 isRecord(event.payload) &&
@@ -1398,8 +1400,14 @@ export class NodeRuntimeState {
                         : undefined
                     : turn.items.find((item) => item.id === stableItemId && item.kind === 'assistant_message');
                 const text = `${existing === undefined ? '' : readableText(existing.payload)}${event.payload.text}`;
+                const sourceItemId = conversationSourceItemId(event.payload) ?? existing?.sourceItemId;
+                needsProcessProjection =
+                    existing === undefined ||
+                        existing.sourceItemId !== sourceItemId ||
+                        (!readableText(existing.payload).trim() && !!text.trim());
                 const item = {
                     id: existing?.id ?? stableItemId ?? `${event.runId}:assistant:${event.sequence}`,
+                    ...(sourceItemId === undefined ? {} : { sourceItemId }),
                     sessionId: run.sessionId,
                     turnId: turn.id,
                     runId: event.runId,
@@ -1407,6 +1415,7 @@ export class NodeRuntimeState {
                     sourceSequence: existing?.sourceSequence ?? event.sequence,
                     revision: event.sequence,
                     kind: 'assistant_message',
+                    ...(existing?.processGroup === undefined ? {} : { processGroup: existing.processGroup }),
                     updatedAt: event.createdAt,
                     status: 'IN_PROGRESS',
                     payload: { text, format: 'markdown', model: null },
@@ -1447,15 +1456,30 @@ export class NodeRuntimeState {
                         ? trailingItem
                         : undefined);
                 const status = projected.status;
+                const sourceItemId = projected.sourceItemId ?? existing?.sourceItemId;
+                const parentItemId = projected.parentItemId === undefined
+                    ? (existing?.parentItemId ?? null)
+                    : runConversationItemId(event.runId, projected.parentItemId);
+                needsProcessProjection =
+                    existing === undefined ||
+                        existing.kind !== projected.kind ||
+                        projected.kind === 'context_compaction' ||
+                        existing.parentItemId !== parentItemId ||
+                        existing.sourceItemId !== sourceItemId ||
+                        (projected.kind === 'assistant_message' &&
+                            !!readableText(existing.payload).trim() !== !!readableText(projected.payload).trim()) ||
+                        (projected.kind === 'reasoning' && existing.processGroup === undefined);
                 const item = {
                     id: itemId,
                     sessionId: run.sessionId,
                     turnId: turn.id,
                     runId: event.runId,
-                    parentItemId: null,
+                    parentItemId,
+                    ...(sourceItemId === undefined ? {} : { sourceItemId }),
                     sourceSequence: existing?.sourceSequence ?? event.sequence,
                     revision: (existing?.revision ?? -1) + 1,
                     kind: projected.kind,
+                    ...(existing?.processGroup === undefined ? {} : { processGroup: existing.processGroup }),
                     updatedAt: event.createdAt,
                     status,
                     payload: mergeConversationItemPayload(existing?.payload, projected),
@@ -1495,11 +1519,16 @@ export class NodeRuntimeState {
             }
             return turn;
         };
+        const project = (turn) => {
+            const next = update(turn);
+            // Ordinary token/output updates retain membership; only structural input needs a scan.
+            return needsProcessProjection ? projectConversationWorkProcesses(next) : next;
+        };
         if (turnId === undefined)
-            this.updateCurrentTurnForRun(event.runId, update);
+            this.updateCurrentTurnForRun(event.runId, project);
         else {
             const current = this.turns.get(run.sessionId) ?? [];
-            this.turns.set(run.sessionId, current.map((turn) => (turn.id === turnId ? update(turn) : turn)));
+            this.turns.set(run.sessionId, current.map((turn) => (turn.id === turnId ? project(turn) : turn)));
         }
     }
 }
@@ -1575,12 +1604,19 @@ function conversationItemFromEvent(event) {
         !isRecord(payload))
         return undefined;
     const append = event.payload.append;
+    const sourceItemId = conversationSourceItemId(event.payload);
     const permissionStop = permissionStopSchema.safeParse(event.payload.permissionStop);
     return {
         itemId,
         kind,
         status,
         payload,
+        ...(sourceItemId === undefined ? {} : { sourceItemId }),
+        ...(typeof event.payload.parentItemId === 'string' &&
+            event.payload.parentItemId.length > 0 &&
+            event.payload.parentItemId.length <= 88
+            ? { parentItemId: event.payload.parentItemId }
+            : {}),
         ...(permissionStop.success ? { permissionStop: permissionStop.data } : {}),
         merge: event.payload.merge === true,
         ...(append === 'sections' || append === 'outputPreview' || append === 'outputSummary'
@@ -1588,10 +1624,17 @@ function conversationItemFromEvent(event) {
             : {})
     };
 }
+function conversationSourceItemId(payload) {
+    return typeof payload.sourceItemId === 'string' &&
+        payload.sourceItemId.length > 0 &&
+        payload.sourceItemId.length <= 1024
+        ? payload.sourceItemId
+        : undefined;
+}
 function projectableConversationKind(value) {
     return (value === 'user_message' ||
         value === 'assistant_message' ||
-        value === 'reasoning_summary' ||
+        value === 'reasoning' ||
         value === 'tool_call' ||
         value === 'command_execution' ||
         value === 'approval_request' ||

package/dist/service/conversation-history-service.js

@@ -1,3 +1,4 @@
+import { projectConversationWorkProcesses } from './conversation-work-process.js';
 import { discoverNativeSessions, readNativeSession } from '../native-session-history.js';
 import { nativeConversationPage } from '../util/runner-native-session-parsers.js';
 import { isPlainRecord } from '../util/node-operation-parsers.js';
@@ -552,7 +553,7 @@ export class ConversationHistoryService {
     page(nextCursor, turns, metadata) {
         return {
             ...metadata,
-            turns,
+            turns: turns.map(projectConversationWorkProcesses),
             nextCursor,
             latestVisibleAt: Math.max(0, ...turns.map((turn) => Math.max(turn.startedAt ?? 0, turn.completedAt ?? 0)))
         };

package/dist/service/conversation-segment-service.js

@@ -1,3 +1,4 @@
+import { projectConversationWorkProcesses } from './conversation-work-process.js';
 const MAX_INITIAL_TURN_PAGE_SIZE = 30;
 function conversationSegmentPrefix(turn) {
     const user = turn.items.find((item) => item.kind === 'user_message');
@@ -10,6 +11,7 @@ function conversationSegmentPrefix(turn) {
         : turn.id;
 }
 export function conversationSegments(turn) {
+    turn = projectConversationWorkProcesses(turn);
     const prefix = conversationSegmentPrefix(turn);
     const groups = [];
     let current = [];
@@ -25,7 +27,7 @@ export function conversationSegments(turn) {
     return groups.map((items, index) => {
         const id = `${prefix}:segment:${index}`;
         const latest = index === groups.length - 1;
-        const projectedItems = items.map((item) => ({
+        const projectedItems = items.map(({ sourceItemId: _sourceItemId, ...item }) => ({
             ...item,
             runId: turn.runId,
             segmentId: id,

package/dist/service/conversation-work-process.js

@@ -0,0 +1,102 @@
+import { createHash } from 'node:crypto';
+const members = new Set([
+    'reasoning',
+    'tool_call',
+    'command_execution',
+    'file_change',
+    'todo_list'
+]);
+const boundaries = new Set([
+    'user_message',
+    'assistant_message',
+    'approval_request',
+    'user_input_request',
+    'plan',
+    'turn_summary'
+]);
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function visible(item) {
+    const payload = record(item.payload);
+    if (item.kind === 'assistant_message')
+        return typeof payload.text === 'string' && !!payload.text.trim();
+    if (item.kind === 'reasoning')
+        return (Array.isArray(payload.sections) &&
+            payload.sections.some((part) => {
+                const text = record(part).text;
+                return typeof text === 'string' && !!text.trim();
+            }));
+    return true;
+}
+/** Runtime owns this exact prefix; native history already carries the unprefixed identity. */
+function sourceIdentity(item) {
+    if (item.sourceItemId !== undefined)
+        return item.sourceItemId;
+    const prefix = item.runId === null ? undefined : `${item.runId}:`;
+    return prefix !== undefined && item.id.startsWith(prefix)
+        ? item.id.slice(prefix.length)
+        : item.id;
+}
+/** Project complete public input before transport segmentation, without clocks or stored groups. */
+export function projectConversationWorkProcesses(turn) {
+    const positions = new Map(turn.items.map((item, index) => [item.id, index]));
+    const anchored = new Map();
+    const relocated = new Set();
+    for (const item of turn.items) {
+        const payload = record(item.payload);
+        if (item.kind !== 'context_compaction' ||
+            !['BACKGROUND', 'BLOCKING'].includes(String(payload.mode)) ||
+            typeof payload.anchorItemId !== 'string' ||
+            !positions.has(payload.anchorItemId) ||
+            payload.anchorItemId === item.id ||
+            turn.items[positions.get(payload.anchorItemId)]?.kind === 'context_compaction')
+            continue;
+        const list = anchored.get(payload.anchorItemId) ?? [];
+        list.push(item);
+        anchored.set(payload.anchorItemId, list);
+        relocated.add(item.id);
+    }
+    const ordered = turn.items.flatMap((item) => relocated.has(item.id) ? [] : [item, ...(anchored.get(item.id) ?? [])]);
+    let knownBoundary = turn.runId !== null || turn.items.some((item) => item.id === turn.userItemId);
+    let current;
+    const assigned = new Map();
+    const items = ordered.map((item) => {
+        const payload = record(item.payload);
+        let group;
+        let isStart = false;
+        const independent = boundaries.has(item.kind) ||
+            (item.kind === 'context_compaction' && payload.mode !== 'BACKGROUND') ||
+            (item.kind === 'error' && item.parentItemId === null);
+        if (visible(item)) {
+            if (independent) {
+                current = undefined;
+                knownBoundary = true;
+            }
+            else if (members.has(item.kind) || ['warning', 'error', 'unknown'].includes(item.kind)) {
+                group = item.parentItemId === null ? undefined : assigned.get(item.parentItemId);
+                if (group === undefined) {
+                    group = current;
+                    if (group === undefined && knownBoundary && members.has(item.kind)) {
+                        group = `process:${createHash('sha256')
+                            .update(`${turn.sessionId}\0${sourceIdentity(item)}`)
+                            .digest('hex')}`;
+                        current = group;
+                        isStart = true;
+                    }
+                }
+                if (group !== undefined)
+                    assigned.set(item.id, group);
+            }
+        }
+        if (item.processGroup?.id === group && (item.processGroup?.isStart === true) === isStart)
+            return item;
+        const { processGroup: _previous, ...rest } = item;
+        return group === undefined
+            ? rest
+            : { ...rest, processGroup: { id: group, ...(isStart ? { isStart: true } : {}) } };
+    });
+    return items.every((item, index) => item === turn.items[index]) ? turn : { ...turn, items };
+}

package/dist/service/run-event-service.js

@@ -159,8 +159,15 @@ export class RunEventService {
         const createdTurn = targetsCurrentTurn && targetTurn === undefined && currentTurn === undefined
             ? this.options.runtime.conversationTurnForRun(runId)
             : undefined;
+        const projectedTurn = this.options.runtime.conversationTurnForExecution(executionId) ??
+            this.options.runtime.conversationTurnForRun(runId);
+        const previousGroups = new Map(targetTurn?.items.map((item) => [item.id, item.processGroup]));
+        const correctedGroups = projectedTurn !== undefined &&
+            projectedTurn.items.some((item) => previousGroups.has(item.id) &&
+                (previousGroups.get(item.id)?.id !== item.processGroup?.id ||
+                    previousGroups.get(item.id)?.isStart !== item.processGroup?.isStart));
         if (targetsCurrentTurn)
-            this.options.emitWorkbench('conversation', createdTurn === undefined
+            this.options.emitWorkbench('conversation', createdTurn === undefined && !correctedGroups
                 ? {
                     event: {
                         ...event,
@@ -168,7 +175,7 @@ export class RunEventService {
                         createdAt: recorded?.createdAt ?? Date.now()
                     }
                 }
-                : { turn: createdTurn });
+                : { turn: createdTurn ?? projectedTurn });
         else {
             const projectedTurn = this.options.runtime.conversationTurnForExecution(executionId);
             if (projectedTurn !== undefined)

package/dist/service/workbench-event-projection.js

@@ -90,6 +90,8 @@ export function projectWorkbenchPayload(queries, category, payload) {
                     payload: item.payload,
                     startedAt: item.startedAt,
                     completedAt: item.completedAt,
+                    parentItemId: item.parentItemId,
+                    ...(item.processGroup === undefined ? {} : { processGroup: item.processGroup }),
                     segmentId: segment.id,
                     segmentIndex: segment.index
                 }

package/dist/service/workbench-manifest-service.js

@@ -29,7 +29,7 @@ export class WorkbenchManifestService {
             conversation: {
                 available: true,
                 reasonCode: null,
-                itemVersions: [1],
+                itemVersions: [2],
                 supportsSessionCursor: true,
                 supportsHistoryPaging: true,
                 supportsItemFinalSnapshots: true,

package/dist/util/node-operation-parsers.js

@@ -133,16 +133,6 @@ export function extractClaudeText(message) {
         .flatMap((block) => block.type === 'text' && typeof block.text === 'string' ? [block.text] : [])
         .join('');
 }
-export function extractClaudeThinkingSummaries(message) {
-    return claudeContentBlocks(message).flatMap((block) => {
-        // `showThinkingSummaries` asks the SDK/API for exactly these public
-        // summaries. Partial raw thinking events are intentionally not read.
-        if (block.type !== 'thinking' || typeof block.thinking !== 'string')
-            return [];
-        const text = compactRunnerText(block.thinking.trim(), 10_000);
-        return text.length === 0 ? [] : [text];
-    });
-}
 export function extractClaudeToolUses(message) {
     return claudeContentBlocks(message).flatMap((block) => {
         if (block.type !== 'tool_use' || typeof block.id !== 'string' || typeof block.name !== 'string')

package/dist/util/runner-native-session-parsers.js

@@ -263,7 +263,9 @@ function nativeTranscriptTurnIds(sessionId, turns) {
     return turns.map((entries) => {
         const user = entries.find(({ entry }) => entry.kind === 'message' && entry.role === 'USER')?.entry;
         const first = user ?? entries[0]?.entry;
-        const base = first?.nativeId ?? nativeTranscriptItemFingerprint(first);
+        const base = first?.nativeId ??
+            nativeTranscriptSourceIdentity(first) ??
+            nativeTranscriptItemFingerprint(first);
         const occurrence = occurrences.get(base) ?? 0;
         occurrences.set(base, occurrence + 1);
         return `${sessionId}:native:${base}${occurrence === 0 ? '' : `:${occurrence}`}`;
@@ -276,14 +278,20 @@ function nativeTranscriptItemIdentities(entries) {
             nativeIdCounts.set(entry.nativeId, (nativeIdCounts.get(entry.nativeId) ?? 0) + 1);
     const occurrences = new Map();
     return entries.map(({ entry }) => {
-        const base = entry.nativeId !== undefined && nativeIdCounts.get(entry.nativeId) === 1
-            ? entry.nativeId
-            : `${entry.nativeId === undefined ? '' : `${entry.nativeId}:`}${nativeTranscriptItemFingerprint(entry)}`;
+        const base = nativeTranscriptSourceIdentity(entry) ??
+            (entry.nativeId !== undefined && nativeIdCounts.get(entry.nativeId) === 1
+                ? entry.nativeId
+                : `${entry.nativeId === undefined ? '' : `${entry.nativeId}:`}${nativeTranscriptItemFingerprint(entry)}`);
         const occurrence = occurrences.get(base) ?? 0;
         occurrences.set(base, occurrence + 1);
         return occurrence === 0 ? base : `${base}:${occurrence}`;
     });
 }
+function nativeTranscriptSourceIdentity(entry) {
+    return entry?.sourceItemId === undefined
+        ? undefined
+        : `source:${createHash('sha256').update(entry.sourceItemId).digest('base64url').slice(0, 24)}`;
+}
 function nativeTranscriptItemFingerprint(entry) {
     return createHash('sha256')
         .update(JSON.stringify(entry ?? null))
@@ -350,6 +358,7 @@ function nativeTranscriptConversationItem(session, entry, index, itemIdentity, t
     const planText = entry.kind === 'message' && entry.role !== 'USER' ? claudePlanText(entryText) : undefined;
     const item = {
         id: `${turnId}:item:${itemIdentity}`,
+        ...(entry.sourceItemId === undefined ? {} : { sourceItemId: entry.sourceItemId }),
         sessionId: session.id,
         turnId,
         runId: null,
@@ -359,7 +368,7 @@ function nativeTranscriptConversationItem(session, entry, index, itemIdentity, t
         kind: isUserInputRequest
             ? 'user_input_request'
             : isReasoning
-                ? 'reasoning_summary'
+                ? 'reasoning'
                 : isContextCompaction
                     ? 'context_compaction'
                     : isToolCall
@@ -378,7 +387,7 @@ function nativeTranscriptConversationItem(session, entry, index, itemIdentity, t
                 questions: userInputQuestions
             }
             : isReasoning
-                ? { sections: entry.sections }
+                ? { representation: entry.representation ?? 'unspecified', sections: entry.sections }
                 : isContextCompaction
                     ? { phase: entry.phase, summary: entry.summary }
                     : isToolCall

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.11.2",
+  "version": "0.11.3",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -37,10 +37,10 @@
     "playwright": "1.62.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.11.2",
-    "@myagentroam/protocol": "0.11.2",
-    "@myagentroam/marctl": "0.11.0",
-    "@myagentroam/code-navigation": "0.11.0"
+    "@myagentroam/agent": "0.11.3",
+    "@myagentroam/code-navigation": "0.11.0",
+    "@myagentroam/protocol": "0.11.3",
+    "@myagentroam/marctl": "0.11.0"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"