@myagentroam/node 0.9.140 → 0.9.142

package/dist/claude-agent-sdk.js

@@ -49,6 +49,7 @@ export class ClaudeAgentSdkAdapter {
             prompt,
             options: {
                 cwd: input.cwd,
+                ...(channelEnabled ? { includePartialMessages: true } : {}),
                 // Claude SDK defaults CLAUDE_CODE_ENTRYPOINT to sdk-ts. Keep the
                 // transcript discoverable by the same VS Code session filters used by
                 // the external Claude Code extension.

package/dist/connector.js

@@ -306,15 +306,10 @@ export class NodeConnector {
     workspaceState = new WorkspaceDomainState();
     workspaceWatchService = new WorkspaceWatchService(this.workspaceState, (workspaceId) => this.workspaceSessionService.ensureWatch(workspaceId), (workspaceId) => this.workspaceSessionService.stopWatch(workspaceId), (workspaceId) => this.workspaceWorkbenchService?.releaseWorkspace(workspaceId));
     workspaceSessionService = new WorkspaceSessionService(this.workspaceState, {
-        discover: (workspaceId) => this.discoverWorkspaceSessions(workspaceId),
+        discover: (workspaceId, onRunnerDiscovered) => this.discoverWorkspaceSessions(workspaceId, onRunnerDiscovered),
         listPage: (workspaceId) => this.executeNodeOperation('session.list', { workspaceId, limit: 20 }),
         active: (workspaceId) => this.workspaceWatchService.topicActive(workspaceId, 'sessions'),
-        invalidate: (workspaceId) => void this.workspaceWorkbenchService?.invalidateTopic(workspaceId, 'sessions'),
-        onPending: (workspaceId, waitMs) => nodeLog('native.session.discovery.pending', {
-            nodeId: this.config?.nodeId,
-            workspaceId,
-            waitMs
-        })
+        invalidate: (workspaceId) => void this.workspaceWorkbenchService?.invalidateTopic(workspaceId, 'sessions')
     });
     workspaceFileService = new WorkspaceFileService(this.workspaceState, (workspaceId) => {
         this.workspaceWorkbenchService?.invalidateWorkspaceFiles(workspaceId);
@@ -1131,6 +1126,7 @@ export class NodeConnector {
             projection: this.nativeSessionProjectionService,
             cachedNative: () => [...this.sessionState.directNative.values()],
             cachedWorkspace: (workspaceId) => this.workspaceCoordinator.cachedSessions(workspaceId),
+            discoveryPending: (workspaceId) => this.workspaceSessionService.discoveryPending(workspaceId),
             discoverWorkspace: (workspaceId) => this.nativeSessionProjectionService.discoverWorkspace(workspaceId),
             present: (session) => this.sessionPresentationService.present(session),
             projectionForNative: (session) => this.nativeSessionProjectionService.projectionForNative(session),
@@ -2185,7 +2181,7 @@ export class NodeConnector {
             return;
         this.workbenchEventService.publish(event);
     };
-    discoverWorkspaceSessions = (workspaceId) => this.nativeSessionProjectionService.discoverWorkspace(workspaceId);
+    discoverWorkspaceSessions = (workspaceId, onRunnerDiscovered) => this.nativeSessionProjectionService.discoverWorkspace(workspaceId, onRunnerDiscovered);
     invalidateWorkspaceWatchTopics = (workspaceId) => this.workspaceCoordinator.invalidate(workspaceId);
     reconcilePersistedRuns = () => undefined;
     startCapabilityRefresh = () => this.connectionLifecycle.startCapabilityRefresh();

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

@@ -7,6 +7,7 @@ import { claudeContentBlocks } from '../../util/node-operation-parsers.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
+import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
 export class ClaudeManagedRunController {
     runner;
     host;
@@ -162,6 +163,13 @@ export class ClaudeManagedRunController {
         };
         try {
             const gate = new ClaudeChannelGate(sessionId);
+            const responseLatency = new ResponseLatencyTracker();
+            let responseMessageId;
+            const observeResponse = (id, incremental = false) => {
+                const latencyMs = responseLatency.response(id, incremental);
+                if (latencyMs !== undefined)
+                    this.host.emit(runId, 'run.performance', { latencyMs });
+            };
             handle = this.runner.startChannel({
                 prompt: payload.input,
                 cwd,
@@ -191,12 +199,19 @@ export class ClaudeManagedRunController {
                             dataBase64: attachment.dataBase64
                         }))
                     }),
-                onPermission: (toolName, toolInput, options) => toolName === 'AskUserQuestion'
-                    ? (toolKinds.set(options.toolUseID, 'user_input_request'),
-                        this.host.requestUserInput(runId, toolInput, options.toolUseID))
-                    : this.host.requestApproval(runId, toolName, toolInput),
+                onPermission: (toolName, toolInput, options) => {
+                    const latencyMs = responseLatency.toolStarted(options.toolUseID);
+                    if (latencyMs !== undefined)
+                        this.host.emit(runId, 'run.performance', { latencyMs });
+                    return toolName === 'AskUserQuestion'
+                        ? (toolKinds.set(options.toolUseID, 'user_input_request'),
+                            this.host.requestUserInput(runId, toolInput, options.toolUseID))
+                        : this.host.requestApproval(runId, toolName, toolInput);
+                },
                 onChannelReply: (content) => this.host.emit(runId, 'channel.reply', { content }),
                 onMessage: (message) => {
+                    if (terminal)
+                        return;
                     const record = message;
                     const nativeSessionId = typeof record.session_id === 'string' ? record.session_id : undefined;
                     const current = this.runner.execution.runs.get(runId);
@@ -221,8 +236,43 @@ export class ClaudeManagedRunController {
                                 });
                         }
                     }
+                    if (record.type === 'stream_event') {
+                        // Observe semantic timing without forwarding raw thinking or input fragments.
+                        const event = record.event;
+                        const block = event?.content_block;
+                        const delta = event?.delta;
+                        if (event?.type === 'message_start') {
+                            const message = event.message;
+                            responseMessageId = typeof message?.id === 'string' ? message.id : undefined;
+                        }
+                        if (event?.type === 'content_block_start' &&
+                            block?.type === 'tool_use' &&
+                            typeof block.id === 'string') {
+                            const latencyMs = responseLatency.toolStarted(block.id);
+                            if (latencyMs !== undefined)
+                                this.host.emit(runId, 'run.performance', { latencyMs });
+                            // A later full snapshot of this streamed message is not a new response.
+                            responseLatency.response(responseMessageId);
+                        }
+                        if ((event?.type === 'content_block_start' && block?.type === 'thinking') ||
+                            (event?.type === 'content_block_delta' &&
+                                ((delta?.type === 'text_delta' &&
+                                    typeof delta.text === 'string' &&
+                                    delta.text.length > 0) ||
+                                    (delta?.type === 'thinking_delta' &&
+                                        typeof delta.thinking === 'string' &&
+                                        delta.thinking.length > 0) ||
+                                    (delta?.type === 'input_json_delta' &&
+                                        typeof delta.partial_json === 'string' &&
+                                        delta.partial_json.length > 0))))
+                            observeResponse(responseMessageId, event?.type === 'content_block_delta');
+                    }
                     if (record.type === 'assistant') {
                         const text = extractClaudeText(record);
+                        if (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, {
@@ -242,6 +292,9 @@ export class ClaudeManagedRunController {
                             });
                         }
                         for (const tool of extractClaudeToolUses(record)) {
+                            const latencyMs = responseLatency.toolStarted(tool.id);
+                            if (latencyMs !== undefined)
+                                this.host.emit(runId, 'run.performance', { latencyMs });
                             if (tool.name === 'AskUserQuestion') {
                                 toolKinds.set(tool.id, 'user_input_request');
                                 continue;
@@ -305,6 +358,7 @@ export class ClaudeManagedRunController {
                     }
                     if (record.type === 'user') {
                         for (const result of extractClaudeToolResults(record)) {
+                            responseLatency.toolCompleted(result.toolUseId);
                             const kind = toolKinds.get(result.toolUseId) ?? 'tool_call';
                             if (kind === 'user_input_request')
                                 continue;
@@ -336,7 +390,7 @@ export class ClaudeManagedRunController {
                             Number.isFinite(value) &&
                             value >= 0 &&
                             Number.isSafeInteger(Math.round(value)));
-                        if (nativeTtft !== undefined)
+                        if (nativeTtft !== undefined && !responseLatency.hasObservedResponse)
                             this.host.emit(runId, 'run.performance', { latencyMs: Math.round(nativeTtft) });
                         const subtype = typeof record.subtype === 'string' ? record.subtype : 'unknown';
                         const completedNativeSessionId = this.runner.execution.runs.get(runId)?.nativeSessionId ?? nativeSessionId;

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

@@ -3,6 +3,7 @@ import { extractId } from '../../util/runner-native-session-parsers.js';
 import { parseSecretEnvironment } from '../../util/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
 import { runnerErrorProjection } from '../../util/runner-error.js';
+import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
 import { boundedConversationItemId, codexImageAttachments, codexLiveConversationItem, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
 export function resolveCodexNotificationRun(runs, input) {
     const entries = [...runs.entries()];
@@ -199,6 +200,15 @@ export class CodexManagedRunController {
                 text: params.delta,
                 ...(itemId === undefined ? {} : { itemId })
             });
+            if (params.delta.length > 0)
+                this.observeResponse(runId, itemId, true);
+            return;
+        }
+        if (notification.method === 'item/reasoning/textDelta' && typeof params.delta === 'string') {
+            if (params.delta.length > 0)
+                this.observeResponse(runId, typeof params.itemId === 'string'
+                    ? boundedConversationItemId('codex', params.itemId)
+                    : undefined, true);
             return;
         }
         if (notification.method === 'item/reasoning/summaryTextDelta' &&
@@ -215,6 +225,8 @@ export class CodexManagedRunController {
                 merge: true,
                 append: 'sections'
             });
+            if (params.delta.length > 0)
+                this.observeResponse(runId, boundedConversationItemId('codex', params.itemId), true);
             return;
         }
         if (notification.method === 'item/commandExecution/outputDelta' &&
@@ -246,8 +258,24 @@ export class CodexManagedRunController {
             isPlainRecord(params.item)) {
             const attachments = this.host.appendImages(runId, codexImageAttachments(params.item));
             const item = codexLiveConversationItem(params.item, notification.method === 'item/completed', attachments);
-            if (item !== undefined)
+            if (item !== undefined) {
                 this.host.emitItem(runId, item);
+                const tracker = activeRun.responseLatency;
+                const tool = ['tool_call', 'command_execution', 'file_change'].includes(item.kind);
+                if (tool) {
+                    if (notification.method === 'item/completed')
+                        tracker?.toolCompleted(item.itemId);
+                    else {
+                        const latencyMs = tracker?.toolStarted(item.itemId);
+                        if (latencyMs !== undefined)
+                            this.host.emit(runId, 'run.performance', { latencyMs });
+                    }
+                }
+                else if (['assistant_message', 'reasoning_summary', 'plan'].includes(item.kind)) {
+                    // A started reasoning item is itself a semantic response, even before its summary.
+                    this.observeResponse(runId, item.itemId);
+                }
+            }
             return;
         }
         if (notification.method === 'turn/completed') {
@@ -273,6 +301,13 @@ export class CodexManagedRunController {
             this.host.removeActive(runId);
         }
     }
+    observeResponse(runId, itemId, incremental = false) {
+        const latencyMs = this.runner.execution.runs
+            .get(runId)
+            ?.responseLatency?.response(itemId, incremental);
+        if (latencyMs !== undefined)
+            this.host.emit(runId, 'run.performance', { latencyMs });
+    }
     requestApproval(runId, notification) {
         const approvalId = `codex:${runId}:${notification.requestId}`;
         const expiresAt = Date.now() + 10 * 60_000;
@@ -458,7 +493,8 @@ export class CodexManagedRunController {
                         threadId,
                         cwd,
                         goalMcp: hasGoalMcp(payload.mcpServers),
-                        scheduleMcp: hasScheduleMcp(payload.mcpServers)
+                        scheduleMcp: hasScheduleMcp(payload.mcpServers),
+                        responseLatency: new ResponseLatencyTracker()
                     });
                     turnResult = await this.runner.startTurn(threadId, input, cwd, turnConfiguration, materializedAttachments, runId);
                     break;
@@ -480,6 +516,7 @@ export class CodexManagedRunController {
             }
             const turnId = extractId(turnResult, 'turn');
             this.runner.execution.runs.set(runId, {
+                ...this.runner.execution.runs.get(runId),
                 sessionId: publicSessionId,
                 threadId,
                 turnId,

package/dist/runner/mar-agent/mcp-client-pool.js

@@ -188,17 +188,49 @@ export class MarAgentMcpClientPool {
                 : this.#controller.signal
         });
         const items = Array.isArray(result.content) ? result.content : [];
+        const images = [];
+        const remaining = [];
         const content = items
             .map((item) => {
-            if (item === null || typeof item !== 'object')
+            if (item === null || typeof item !== 'object') {
+                remaining.push(item);
                 return '[unknown]';
+            }
             const value = item;
-            return value.type === 'text' && typeof value.text === 'string'
-                ? value.text
-                : `[${String(value.type ?? 'unknown')}]`;
+            if (value.type === 'text' && typeof value.text === 'string') {
+                const { text, ...metadata } = value;
+                if (Object.keys(metadata).some((key) => key !== 'type'))
+                    remaining.push(metadata);
+                return text;
+            }
+            if (value.type === 'image' &&
+                typeof value.mimeType === 'string' &&
+                typeof value.data === 'string') {
+                // Native MCP pixels belong only in the SDK image channel, not duplicated JSON text.
+                images.push({ mimeType: value.mimeType, dataBase64: value.data });
+                const { data: _pixels, ...metadata } = value;
+                if (Object.keys(metadata).some((key) => key !== 'type' && key !== 'mimeType'))
+                    remaining.push(metadata);
+            }
+            else {
+                remaining.push(item);
+            }
+            return `[${String(value.type ?? 'unknown')}]`;
         })
             .join('\n');
-        return { content, data: result.structuredContent ?? items };
+        const structured = result.structuredContent;
+        const data = structured !== undefined && structured !== null
+            ? remaining.length
+                ? { structuredContent: structured, content: remaining }
+                : structured
+            : remaining.length
+                ? remaining
+                : undefined;
+        return {
+            content,
+            ...(data === undefined ? {} : { data }),
+            ...(images.length ? { images } : {})
+        };
     }
     async close() {
         if (this.#closed)

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

@@ -4,6 +4,7 @@ import { runnerErrorProjection } from '../../util/runner-error.js';
 import { boundedConversationItemId, compactRunnerText } from '../codex/conversation-parser.js';
 import { openCodePatchToolPayload, openCodeQuestions } from './conversation-parser.js';
 import { normalizeOpenCodeTool } from './tool-normalizer.js';
+import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
 export class OpenCodeManagedRunController {
     runner;
     host;
@@ -265,6 +266,13 @@ export class OpenCodeManagedRunController {
             const attachmentPaths = input.attachments.length === 0
                 ? []
                 : await this.host.persistAttachments(input.cwd, input.runId, input.attachments);
+            const execution = this.runner.execution.get(input.runId);
+            if (execution !== undefined) {
+                execution.responseLatency = new ResponseLatencyTracker();
+                execution.responsePartKinds = new Map();
+                execution.responseStartedAt = Date.now();
+                execution.responseMessages = new Set();
+            }
             await client.prompt({
                 directory: input.cwd,
                 sessionID: nativeSessionId,
@@ -312,6 +320,13 @@ export class OpenCodeManagedRunController {
                 const roles = this.messageRoles.get(runId) ?? new Map();
                 roles.set(info.id, info.role);
                 this.messageRoles.set(runId, roles);
+                const execution = this.runner.execution.get(runId);
+                const created = record(info.time)?.created;
+                if (info.role === 'assistant' &&
+                    execution?.responseStartedAt !== undefined &&
+                    typeof created === 'number' &&
+                    created >= execution.responseStartedAt)
+                    execution.responseMessages?.add(info.id);
             }
             if (info?.role === 'assistant' &&
                 typeof info.id === 'string' &&
@@ -334,6 +349,19 @@ export class OpenCodeManagedRunController {
             }
             return;
         }
+        if (event?.type === 'message.part.delta') {
+            const kind = typeof properties?.partID === 'string'
+                ? this.runner.execution.get(runId)?.responsePartKinds?.get(properties.partID)
+                : undefined;
+            if ((kind === 'text' || kind === 'reasoning') &&
+                properties?.field === 'text' &&
+                typeof properties.delta === 'string' &&
+                properties.delta.length > 0 &&
+                typeof properties.messageID === 'string' &&
+                this.currentResponseMessage(runId, properties.messageID))
+                this.observeResponse(runId, boundedConversationItemId('opencode', properties.partID), true);
+            return;
+        }
         if (event?.type === 'message.part.updated') {
             const part = record(properties?.part);
             if (part?.type === 'compaction' &&
@@ -356,9 +384,32 @@ export class OpenCodeManagedRunController {
             const parentId = this.messageParents.get(runId)?.get(part.messageID);
             if (parentId !== undefined && this.compactionPartIds.get(runId)?.has(parentId))
                 return;
+            if (typeof part.id === 'string' && typeof part.type === 'string')
+                this.runner.execution.get(runId)?.responsePartKinds?.set(part.id, part.type);
             const item = openCodePart(part, this.runner.execution.get(runId)?.agent === 'plan');
             if (item !== undefined)
                 this.host.emitItem(runId, item);
+            if (typeof part.id === 'string') {
+                const itemId = boundedConversationItemId('opencode', part.id);
+                const tracker = this.currentResponseMessage(runId, part.messageID)
+                    ? this.runner.execution.get(runId)?.responseLatency
+                    : undefined;
+                if (part.type === 'tool') {
+                    const state = record(part.state);
+                    if (state?.status === 'completed' || state?.status === 'error')
+                        tracker?.toolCompleted(itemId);
+                    else if (state?.status === 'pending' || state?.status === 'running') {
+                        const latencyMs = tracker?.toolStarted(itemId);
+                        if (latencyMs !== undefined)
+                            this.host.emit(runId, 'run.performance', { latencyMs });
+                    }
+                }
+                else if (tracker !== undefined &&
+                    (part.type === 'text' || part.type === 'reasoning') &&
+                    typeof part.text === 'string' &&
+                    part.text.length > 0)
+                    this.observeResponse(runId, itemId);
+            }
             return;
         }
         if (event?.type === 'permission.asked')
@@ -366,6 +417,19 @@ export class OpenCodeManagedRunController {
         if (event?.type === 'question.asked')
             this.requestQuestion(runId, properties);
     }
+    currentResponseMessage(runId, messageId) {
+        const parent = this.messageParents.get(runId)?.get(messageId);
+        return (this.runner.execution.get(runId)?.responseMessages?.has(messageId) === true &&
+            this.messageRoles.get(runId)?.get(messageId) === 'assistant' &&
+            (parent === undefined || !this.compactionPartIds.get(runId)?.has(parent)));
+    }
+    observeResponse(runId, itemId, incremental = false) {
+        const latencyMs = this.runner.execution
+            .get(runId)
+            ?.responseLatency?.response(itemId, incremental);
+        if (latencyMs !== undefined)
+            this.host.emit(runId, 'run.performance', { latencyMs });
+    }
     requestPermission(runId, properties) {
         const execution = this.runner.execution.get(runId);
         const requestId = typeof properties?.id === 'string' ? properties.id : undefined;

package/dist/runtime-state.js

@@ -561,7 +561,14 @@ export class NodeRuntimeState {
             return false;
         if (id !== run.id && this.currentExecutionId(run.id) !== id)
             return false;
-        this.runPerformance.set(run.id, { ...performance });
+        this.runPerformance.set(run.id, {
+            ...this.runPerformance.get(run.id),
+            runId: performance.runId,
+            ...(performance.latencyMs === undefined ? {} : { latencyMs: performance.latencyMs }),
+            ...(performance.tokensPerSecond === undefined
+                ? {}
+                : { tokensPerSecond: performance.tokensPerSecond })
+        });
         return true;
     }
     sessionPerformance(sessionId) {

package/dist/service/continuous-run-coordinator.js

@@ -283,14 +283,11 @@ export class ContinuousRunCoordinator {
         }
         this.dispatchedExecutions.add(executionId);
         try {
-            const goalMcp = pending.goal === undefined
-                ? undefined
-                : await this.options.goalMcp?.(pending);
-            const scheduledMcp = await this.options.scheduledMcp?.(pending);
-            const mailMcp = await this.options.mailMcp?.({
-                ...pending,
-                runId: executionId
-            });
+            // Capabilities belong to this Execution, never the Run or a claimed QueueItem.
+            const executionInput = { ...pending, runId: executionId };
+            const goalMcp = pending.goal === undefined ? undefined : await this.options.goalMcp?.(executionInput);
+            const scheduledMcp = await this.options.scheduledMcp?.(executionInput);
+            const mailMcp = await this.options.mailMcp?.(executionInput);
             if (!this.goalCurrent(pending)) {
                 this.dispatchedExecutions.delete(executionId);
                 this.rejectStaleGoal(executionId);

package/dist/service/native-session-projection-service.js

@@ -33,12 +33,20 @@ export class NativeSessionProjectionService {
         this.remember(sessions);
         return sessions.map(this.options.present);
     }
-    async discoverWorkspace(workspaceId) {
-        const discovered = await Promise.all(this.options.runners
+    async discoverWorkspace(workspaceId, onRunnerDiscovered) {
+        const discovered = await Promise.allSettled(this.options.runners
             .advertised()
             .filter((runner) => runner.available(this.options.capabilities()))
-            .map((runner) => this.discover(runner.name, workspaceId)));
-        const sessions = deduplicateDirectSessions(discovered.flat());
+            .map(async (runner) => {
+            const name = runner.name;
+            const sessions = await this.discover(name, workspaceId);
+            onRunnerDiscovered?.(name, sessions);
+            return sessions;
+        }));
+        const failed = discovered.find((result) => result.status === 'rejected');
+        if (failed?.status === 'rejected')
+            throw failed.reason;
+        const sessions = deduplicateDirectSessions(discovered.flatMap((result) => (result.status === 'fulfilled' ? result.value : [])));
         this.remember(sessions);
         return sessions;
     }

package/dist/service/response-latency-tracker.js

@@ -0,0 +1,47 @@
+/** Monotonic, observation-only timing; native event semantics belong to each Runner. */
+export class ResponseLatencyTracker {
+    now;
+    waitingAt;
+    pendingTools = new Set();
+    completedTools = new Set();
+    observedResponses = new Set();
+    hasObservedResponse = false;
+    constructor(now = () => performance.now()) {
+        this.now = now;
+        this.waitingAt = now();
+    }
+    response(id, incremental = false) {
+        if (id !== undefined) {
+            // A new delta is semantic output even when the Runner reuses a response item.
+            if (!incremental && this.observedResponses.has(id))
+                return undefined;
+            this.observedResponses.add(id);
+            if (this.observedResponses.size > 1_024)
+                this.observedResponses.delete(this.observedResponses.values().next().value);
+        }
+        if (this.waitingAt === undefined || this.pendingTools.size > 0)
+            return undefined;
+        const latencyMs = Math.max(0, Math.round(this.now() - this.waitingAt));
+        this.waitingAt = undefined;
+        this.hasObservedResponse = true;
+        return latencyMs;
+    }
+    toolStarted(id) {
+        if (this.completedTools.has(id) || this.pendingTools.has(id))
+            return undefined;
+        const latencyMs = this.response(id);
+        this.pendingTools.add(id);
+        this.waitingAt = undefined;
+        return latencyMs;
+    }
+    toolCompleted(id) {
+        if (this.completedTools.has(id))
+            return;
+        this.completedTools.add(id);
+        if (this.completedTools.size > 1_024)
+            this.completedTools.delete(this.completedTools.values().next().value);
+        this.pendingTools.delete(id);
+        if (this.pendingTools.size === 0)
+            this.waitingAt = this.now();
+    }
+}

package/dist/service/session-catalog-service.js

@@ -57,7 +57,7 @@ export class SessionCatalogService {
                 this.options.projectionForNative(candidate) === undefined)
         ].map((session) => [session.id, session]));
         if (workspaceId !== undefined)
-            this.mergePersisted(merged, workspaceId);
+            this.mergePersisted(merged, workspaceId, query === undefined && this.options.discoveryPending(workspaceId));
         const sessions = [...merged.values()].filter((session) => {
             if (query === undefined)
                 return true;
@@ -70,7 +70,7 @@ export class SessionCatalogService {
             ? sessions
             : sessions.filter((session) => session.workspaceId === workspaceId), input);
     }
-    mergePersisted(merged, workspaceId) {
+    mergePersisted(merged, workspaceId, discoveryPending) {
         const database = this.options.database();
         const workspace = database.getWorkspace(workspaceId);
         if (workspace === undefined)
@@ -78,6 +78,9 @@ export class SessionCatalogService {
         for (const persisted of database.listSessionRecords(workspaceId)) {
             if (merged.has(persisted.id))
                 continue;
+            // A metadata record alone does not establish a discovered native Session.
+            if (discoveryPending)
+                continue;
             merged.set(persisted.id, this.options.present({
                 id: persisted.id,
                 nodeId: this.options.nodeId(),

package/dist/service/workspace-session-service.js

@@ -1,10 +1,12 @@
+import { nodeLog } from '../operational.js';
 const WATCH_INTERVAL_MS = 30_000;
 const CACHE_TTL_MS = 15_000;
-const INITIAL_WAIT_MS = 500;
 export class WorkspaceSessionService {
     state;
     options;
     cacheGenerations = new Map();
+    initialReads = new Map();
+    incompleteDiscoveries = new Set();
     constructor(state, options) {
         this.state = state;
         this.options = options;
@@ -22,32 +24,90 @@ export class WorkspaceSessionService {
         this.state.sessionWatchTimers.delete(workspaceId);
         this.state.sessionWatchSignatures.delete(workspaceId);
     }
+    discoveryPending(workspaceId) {
+        // Partial cold batches still await native identity confirmation for the remaining Runners.
+        return this.incompleteDiscoveries.has(workspaceId);
+    }
     async cached(workspaceId) {
         const cached = this.state.sessionCache.get(workspaceId);
         if (cached !== undefined && cached.expiresAt > Date.now())
             return cached.sessions;
-        let initialDiscoveryTimedOut = false;
         let discovery = this.state.sessionCacheReads.get(workspaceId);
         if (discovery === undefined) {
             const generation = this.cacheGenerations.get(workspaceId) ?? 0;
-            const read = this.options
-                .discover(workspaceId)
-                .then((sessions) => {
+            let resolveInitial;
+            let rejectInitial;
+            const initial = new Promise((resolve, reject) => {
+                resolveInitial = resolve;
+                rejectInitial = reject;
+            });
+            if (cached === undefined) {
+                this.initialReads.set(workspaceId, initial);
+                this.incompleteDiscoveries.add(workspaceId);
+            }
+            // A cached caller does not await this promise, but failures still belong to the read.
+            void initial.catch(() => undefined);
+            let acceptingBatches = true;
+            let batchPublished = false;
+            let notifyCompletion = false;
+            const publish = (sessions, notify = true) => {
                 if ((this.cacheGenerations.get(workspaceId) ?? 0) !== generation)
-                    return sessions;
+                    return;
                 const previous = this.state.sessionCache.get(workspaceId)?.sessions;
                 this.state.sessionCache.set(workspaceId, {
                     sessions,
                     expiresAt: Date.now() + CACHE_TTL_MS
                 });
-                if (initialDiscoveryTimedOut ||
-                    (previous !== undefined && sessionSignature(previous) !== sessionSignature(sessions)))
+                if (notify &&
+                    previous !== undefined &&
+                    sessionSignature(previous) !== sessionSignature(sessions))
                     this.options.invalidate(workspaceId);
+            };
+            const read = this.options
+                .discover(workspaceId, (runner, sessions) => {
+                if (!acceptingBatches || (this.cacheGenerations.get(workspaceId) ?? 0) !== generation)
+                    return;
+                const previous = this.state.sessionCache.get(workspaceId)?.sessions;
+                const merged = [
+                    ...(previous ?? []).filter((session) => session.runner !== runner),
+                    ...sessions
+                ];
+                // An empty early Runner must not turn an undiscovered Workspace into an empty list.
+                if (previous === undefined && merged.length === 0)
+                    return;
+                publish(merged);
+                batchPublished = true;
+                resolveInitial(merged);
+            })
+                .then((sessions) => {
+                if ((this.cacheGenerations.get(workspaceId) ?? 0) === generation)
+                    this.incompleteDiscoveries.delete(workspaceId);
+                const previous = this.state.sessionCache.get(workspaceId)?.sessions;
+                notifyCompletion =
+                    batchPublished ||
+                        (previous !== undefined && sessionSignature(previous) !== sessionSignature(sessions));
+                publish(sessions, false);
+                resolveInitial(sessions);
                 return sessions;
+            })
+                .catch((error) => {
+                rejectInitial(error);
+                if ((this.cacheGenerations.get(workspaceId) ?? 0) === generation) {
+                    nodeLog('native.session.discovery.failed', { workspaceId });
+                    const partial = this.state.sessionCache.get(workspaceId);
+                    if (partial !== undefined)
+                        this.state.sessionCache.set(workspaceId, { ...partial, expiresAt: 0 });
+                }
+                throw error;
             })
                 .finally(() => {
+                acceptingBatches = false;
                 if (this.state.sessionCacheReads.get(workspaceId) === read)
                     this.state.sessionCacheReads.delete(workspaceId);
+                if (this.initialReads.get(workspaceId) === initial)
+                    this.initialReads.delete(workspaceId);
+                if (notifyCompletion && (this.cacheGenerations.get(workspaceId) ?? 0) === generation)
+                    this.options.invalidate(workspaceId);
                 if (!this.state.sessionCacheReads.has(workspaceId) &&
                     !this.state.sessionCache.has(workspaceId) &&
                     (this.cacheGenerations.get(workspaceId) ?? 0) !== generation)
@@ -55,15 +115,12 @@ export class WorkspaceSessionService {
             });
             discovery = read;
             this.state.sessionCacheReads.set(workspaceId, discovery);
+            // Later Runner failures cannot become unhandled after the first batch was returned.
+            void discovery.catch(() => undefined);
         }
         if (cached !== undefined)
             return cached.sessions;
-        const discovered = await within(discovery, INITIAL_WAIT_MS);
-        if (discovered !== undefined)
-            return discovered;
-        initialDiscoveryTimedOut = true;
-        this.options.onPending?.(workspaceId, INITIAL_WAIT_MS);
-        return [];
+        return this.initialReads.get(workspaceId) ?? discovery;
     }
     clear() {
         for (const timer of this.state.sessionWatchTimers.values())
@@ -78,6 +135,8 @@ export class WorkspaceSessionService {
             this.bumpCacheGeneration(workspaceId);
         this.state.sessionCache.clear();
         this.state.sessionCacheReads.clear();
+        this.initialReads.clear();
+        this.incompleteDiscoveries.clear();
     }
     invalidate(workspaceId) {
         this.invalidateCache(workspaceId);
@@ -87,6 +146,8 @@ export class WorkspaceSessionService {
         this.bumpCacheGeneration(workspaceId);
         this.state.sessionCache.delete(workspaceId);
         this.state.sessionCacheReads.delete(workspaceId);
+        this.initialReads.delete(workspaceId);
+        this.incompleteDiscoveries.delete(workspaceId);
     }
     bumpCacheGeneration(workspaceId) {
         this.cacheGenerations.set(workspaceId, (this.cacheGenerations.get(workspaceId) ?? 0) + 1);
@@ -146,9 +207,3 @@ function sessionSignature(sessions) {
         session.externalDiscovered
     ]));
 }
-async function within(promise, timeoutMs) {
-    return Promise.race([
-        promise,
-        new Promise((resolve) => setTimeout(resolve, timeoutMs))
-    ]);
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.140",
+  "version": "0.9.142",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -35,9 +35,9 @@
     "ws": "^8.21.3",
     "zod": "4.4.3",
     "@myagentroam/marctl": "0.9.120",
-    "@myagentroam/protocol": "0.9.140",
-    "@myagentroam/code-navigation": "0.9.129",
-    "@myagentroam/agent": "0.9.140"
+    "@myagentroam/agent": "0.9.142",
+    "@myagentroam/protocol": "0.9.142",
+    "@myagentroam/code-navigation": "0.9.129"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"