@myagentroam/node 0.9.139 → 0.9.141

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,17 +306,12 @@ 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, () => this.config?.allowedRoots ?? [], (workspaceId) => {
+    workspaceFileService = new WorkspaceFileService(this.workspaceState, (workspaceId) => {
         this.workspaceWorkbenchService?.invalidateWorkspaceFiles(workspaceId);
         this.workspaceCoordinator.invalidate(workspaceId);
     });
@@ -462,6 +457,7 @@ export class NodeConnector {
                 sequence: this.workbenchEventService.snapshotSequence(),
                 session: this.sessionPresentationService.present(session),
                 runs: this.runtime.listRunsForSession(session.id),
+                performance: this.runtime.sessionPerformance(session.id),
                 queue: this.workspaceQueueWorkbenchService.snapshot(session.id),
                 context,
                 conversation: this.conversationSegmentService.projectInitial(session, page, limit)
@@ -1130,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),
@@ -2184,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/{marmgr.js → marctl.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
 // Keep the CLI implementation in its own package; the Node install exposes the same entrypoint.
-const entrypoint = '@myagentroam/marmgr/bin/marmgr.mjs';
+const entrypoint = '@myagentroam/marctl/bin/marctl.mjs';
 await import(entrypoint);
 export {};

package/dist/marnodes.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-const entrypoint = '@myagentroam/marmgr/bin/marnodes.mjs';
+const entrypoint = '@myagentroam/marctl/bin/marnodes.mjs';
 await import(entrypoint);
 export {};

package/dist/marscp.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-const entrypoint = '@myagentroam/marmgr/bin/marscp.mjs';
+const entrypoint = '@myagentroam/marctl/bin/marscp.mjs';
 await import(entrypoint);
 export {};

package/dist/marssh.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-const entrypoint = '@myagentroam/marmgr/bin/marssh.mjs';
+const entrypoint = '@myagentroam/marctl/bin/marssh.mjs';
 await import(entrypoint);
 export {};

package/dist/runner/abstract-runner.js

@@ -172,17 +172,17 @@ export class AbstractRunner {
 function resolvedMcpServers(raw, secrets) {
     if (!Array.isArray(raw))
         return [];
-    const marmgrEnvironment = {
+    const marctlEnvironment = {
         MAR_USERNAME: secrets['MAR_USERNAME'] ?? '',
-        ...(secrets['MAR_MGR_SERVER_URL'] === undefined
+        ...(secrets['MAR_CTL_SERVER_URL'] === undefined
             ? {}
-            : { MAR_MGR_SERVER_URL: secrets['MAR_MGR_SERVER_URL'] }),
-        ...(secrets['MAR_MGR_USER_TOKEN'] === undefined
+            : { MAR_CTL_SERVER_URL: secrets['MAR_CTL_SERVER_URL'] }),
+        ...(secrets['MAR_CTL_USER_TOKEN'] === undefined
             ? {}
-            : { MAR_MGR_USER_TOKEN: secrets['MAR_MGR_USER_TOKEN'] }),
-        MAR_MGR_CONTEXT_REQUIRED: '1'
+            : { MAR_CTL_USER_TOKEN: secrets['MAR_CTL_USER_TOKEN'] }),
+        MAR_CTL_CONTEXT_REQUIRED: '1'
     };
-    const mcpEnvironment = (provided) => nodeExecutionEnvironment({ ...provided, ...marmgrEnvironment }, { PATH: process.env['PATH'], Path: process.env['Path'] });
+    const mcpEnvironment = (provided) => nodeExecutionEnvironment({ ...provided, ...marctlEnvironment }, { PATH: process.env['PATH'], Path: process.env['Path'] });
     const result = [];
     for (const value of raw) {
         if (value === null || typeof value !== 'object' || Array.isArray(value))

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,
@@ -173,7 +181,7 @@ export class ClaudeManagedRunController {
                 ...(typeof payload.access === 'string' ? { access: payload.access } : {}),
                 environment: nodeExecutionEnvironment({
                     ...secretEnvironment,
-                    MAR_MGR_CONTEXT_REQUIRED: '1'
+                    MAR_CTL_CONTEXT_REQUIRED: '1'
                 }, { PATH: process.env['PATH'], Path: process.env['Path'] }),
                 ...(typeof payload.personalInstructions === 'string'
                     ? { personalInstructions: payload.personalInstructions }
@@ -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()];
@@ -66,7 +67,7 @@ export class CodexManagedRunController {
             throw new Error('RUNNER_COMMAND_UNAVAILABLE');
         if (command.id === 'compact') {
             const runId = crypto.randomUUID();
-            this.runner.prepareEnvironment(nodeExecutionEnvironment({ ...context.secretEnvironment, MAR_MGR_CONTEXT_REQUIRED: '1' }, { PATH: process.env['PATH'], Path: process.env['Path'] }), runId);
+            this.runner.prepareEnvironment(nodeExecutionEnvironment({ ...context.secretEnvironment, MAR_CTL_CONTEXT_REQUIRED: '1' }, { PATH: process.env['PATH'], Path: process.env['Path'] }), runId);
             try {
                 await this.runner.start(runId);
                 return await this.compact(session, threadId, runId, context.initiatedByUserId);
@@ -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;
@@ -386,7 +421,7 @@ export class CodexManagedRunController {
             return;
         }
         try {
-            this.runner.prepareEnvironment(nodeExecutionEnvironment({ ...secretEnvironment, MAR_MGR_CONTEXT_REQUIRED: '1' }, { PATH: process.env['PATH'], Path: process.env['Path'] }), runId);
+            this.runner.prepareEnvironment(nodeExecutionEnvironment({ ...secretEnvironment, MAR_CTL_CONTEXT_REQUIRED: '1' }, { PATH: process.env['PATH'], Path: process.env['Path'] }), runId);
         }
         catch (error) {
             this.host.emit(runId, 'run.rejected', { code: safeErrorCode(error, 'SECRET_ENVIRONMENT_INVALID') }, 'FAILED');
@@ -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/conversation-normalizer.js

@@ -141,9 +141,14 @@ export class MarAgentConversationNormalizer {
     }
     #toolStarted(event) {
         const ownItemId = itemId('tool', event.callId);
-        if (event.toolName === 'exec') {
+        if (event.toolName === 'exec' || event.toolName === 'exec_wait') {
             const input = record(event.input) ?? {};
-            const action = input.action == null && typeof input.command === 'string' ? 'start' : input.action;
+            const action = input.action ??
+                (event.toolName === 'exec_wait'
+                    ? 'poll'
+                    : typeof input.command === 'string'
+                        ? 'start'
+                        : undefined);
             if (action === 'start' && typeof input.command === 'string') {
                 const command = {
                     itemId: ownItemId,
@@ -227,7 +232,8 @@ export class MarAgentConversationNormalizer {
     }
     #toolCompleted(event) {
         const state = this.#tools.get(event.callId);
-        if (event.toolName === 'exec' && state?.commandOrigin !== undefined) {
+        if ((event.toolName === 'exec' || event.toolName === 'exec_wait') &&
+            state?.commandOrigin !== undefined) {
             const command = this.#commands.get(state.commandOrigin);
             const result = execResult(event.data, event.summary, event.truncated === true);
             if (command !== undefined && result !== undefined) {
@@ -293,7 +299,8 @@ export class MarAgentConversationNormalizer {
     }
     #toolFailed(event) {
         const state = this.#tools.get(event.callId);
-        if (event.toolName === 'exec' && state?.commandOrigin !== undefined) {
+        if ((event.toolName === 'exec' || event.toolName === 'exec_wait') &&
+            state?.commandOrigin !== undefined) {
             const command = this.#commands.get(state.commandOrigin);
             const input = record(state.input);
             if (command !== undefined &&

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

@@ -273,7 +273,9 @@ export class MarAgentManagedRunController {
                 throw new Error('MAR_AGENT_SESSION_RUNTIME_ACTIVE');
             runtime.activeRunId = input.runId;
             await runtime.mcpLease.pool.refreshForExecution();
-            const executionMcpServers = input.mcpServers.filter((server) => server.lifecycle === 'EXECUTION');
+            const executionMcpServers = input.mcpServers
+                .filter(isExecutionScopedMcp)
+                .map((server) => ({ ...server, lifecycle: 'EXECUTION' }));
             computerUseBinding = await this.#computerUse?.bind({
                 runId: input.runId,
                 sessionId: runtime.session.id,
@@ -311,6 +313,9 @@ export class MarAgentManagedRunController {
             });
             executionMcpBinding = runtime.host.bindExecutionExtensions({
                 ...imageExtensions,
+                environment: input.secretEnvironment?.['MAR_CTL_USER_TOKEN'] === undefined
+                    ? {}
+                    : { MAR_CTL_USER_TOKEN: input.secretEnvironment['MAR_CTL_USER_TOKEN'] },
                 skills: [...(imageExtensions.skills ?? []), computerUseHostSkill]
             }, {
                 tools: [...nodeTools, ...userTools],
@@ -500,7 +505,7 @@ export class MarAgentManagedRunController {
     async #createRuntime(input, sessionKey, fingerprint, hostConfiguration) {
         const dynamicCredentials = input.models.some((model) => model.credential?.type === 'RUNTIME_TICKET' ||
             model.imageGeneration?.credential?.type === 'RUNTIME_TICKET');
-        const sharedMcpServers = input.mcpServers.filter((server) => server.lifecycle !== 'EXECUTION');
+        const sharedMcpServers = input.mcpServers.filter((server) => !isExecutionScopedMcp(server));
         const mcpLease = await this.#mcpClients.acquire(sharedMcpServers, input.cwd, {
             // Native Session IDs are assigned after the first lease; do not let that promotion
             // change a confirmed actor's discovery identity when its warm runtime is recreated.
@@ -706,6 +711,10 @@ function contextUsageChanged(event) {
         (event.type === 'usage.updated' &&
             (event.contextInputTokens !== undefined || event.inputTokens !== undefined)));
 }
+function isExecutionScopedMcp(server) {
+    return (server.lifecycle === 'EXECUTION' ||
+        (server.transport === 'STDIO' && server.environment?.['MAR_CTL_USER_TOKEN'] !== undefined));
+}
 function sessionRuntimeFingerprint(input, hostConfiguration) {
     return createHash('sha256')
         .update(JSON.stringify({
@@ -713,7 +722,7 @@ function sessionRuntimeFingerprint(input, hostConfiguration) {
         defaultModelId: input.model.id,
         models: input.models.map(runtimeModelFingerprint),
         personalInstructions: input.personalInstructions ?? '',
-        mcpServers: input.mcpServers.filter((server) => server.lifecycle !== 'EXECUTION'),
+        mcpServers: input.mcpServers.filter((server) => !isExecutionScopedMcp(server)),
         environment: Object.entries(hostConfiguration.environment)
             .filter((entry) => entry[1] !== undefined)
             .sort(([left], [right]) => left.localeCompare(right)),
@@ -727,8 +736,10 @@ export function allowsUntrustedWebFetchTls(environment) {
 async function resolveMarAgentHostRuntimeConfiguration(secretEnvironment = {}) {
     const environment = nodeExecutionEnvironment({
         ...secretEnvironment,
-        MAR_MGR_CONTEXT_REQUIRED: '1'
+        MAR_CTL_CONTEXT_REQUIRED: '1'
     });
+    // CLI credentials are bound to each execution, never retained as Host configuration.
+    delete environment['MAR_CTL_USER_TOKEN'];
     const ripgrep = await availableBundledRipgrep();
     return {
         environment: ripgrep === undefined ? environment : prependBundledRipgrepToPath(environment, ripgrep),

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;
@@ -50,7 +51,7 @@ export class OpenCodeManagedRunController {
             this.host.hasActiveSessionLease(session.id))
             throw new Error('RUNNER_COMMAND_UNAVAILABLE');
         const runId = crypto.randomUUID();
-        const client = this.runner.managedClient(nodeExecutionEnvironment({ ...environment, MAR_MGR_CONTEXT_REQUIRED: '1' }, { PATH: process.env['PATH'], Path: process.env['Path'] }));
+        const client = this.runner.managedClient(nodeExecutionEnvironment({ ...environment, MAR_CTL_CONTEXT_REQUIRED: '1' }, { PATH: process.env['PATH'], Path: process.env['Path'] }));
         this.host.adopt({
             runId,
             sessionId: session.id,
@@ -111,7 +112,7 @@ export class OpenCodeManagedRunController {
         try {
             environment = nodeExecutionEnvironment({
                 ...parseSecretEnvironment(payload.secretEnvironment),
-                MAR_MGR_CONTEXT_REQUIRED: '1'
+                MAR_CTL_CONTEXT_REQUIRED: '1'
             }, { PATH: process.env['PATH'], Path: process.env['Path'] });
             mcpSecretEnvironment = parseSecretEnvironment(payload.mcpSecretEnvironment);
             mcp = this.runner.mcpConfiguration(payload.mcpInstallations, {
@@ -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

@@ -13,6 +13,7 @@ export class NodeRuntimeState {
     static MAX_COMPLETED_TURNS_PER_SESSION = 10;
     sessions = new Map();
     runs = new Map();
+    runPerformance = new Map();
     recentUserMessages = new Map();
     messageSubmissions = new Map();
     failedMessageSubmissions = new Map();
@@ -553,6 +554,28 @@ export class NodeRuntimeState {
         const canonical = this.executions.get(id)?.runId ?? id;
         return this.runs.get(canonical);
     }
+    /** Only the current execution may replace an active Run's ephemeral metrics. */
+    updateRunPerformance(id, performance) {
+        const run = this.getRun(id);
+        if (run === undefined || terminal(run.status) || performance.runId !== run.id)
+            return false;
+        if (id !== run.id && this.currentExecutionId(run.id) !== id)
+            return false;
+        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) {
+        const run = this.activeSessionRun(sessionId);
+        const performance = run === undefined ? undefined : this.runPerformance.get(run.id);
+        return performance === undefined ? undefined : { ...performance };
+    }
     findMessageRun(sessionId, clientMessageId) {
         const submission = this.messageSubmissions.get(`${sessionId}\u0000${clientMessageId}`);
         return submission?.kind === 'run' ? this.runs.get(submission.id) : undefined;
@@ -599,6 +622,8 @@ export class NodeRuntimeState {
             updatedAt: now
         };
         this.runs.set(runId, value);
+        if (terminal(next))
+            this.runPerformance.delete(runId);
         this.emitRunChanged(value, this.requireSession(value.sessionId));
         if (terminal(next) && this.leases.get(value.sessionId) === value.id)
             this.leases.delete(value.sessionId);
@@ -894,6 +919,7 @@ export class NodeRuntimeState {
         }
         this.pruneRetainedExecutionTurns(run.sessionId, retainedTurnIds);
         this.runs.delete(runId);
+        this.runPerformance.delete(runId);
         this.recentUserMessages.delete(runId);
         this.runSequences.delete(runId);
         for (const [key, candidate] of this.messageSubmissions)
@@ -931,6 +957,7 @@ export class NodeRuntimeState {
         this.leases.delete(sessionId);
         for (const runId of runIds) {
             this.runs.delete(runId);
+            this.runPerformance.delete(runId);
             this.recentUserMessages.delete(runId);
             this.runSequences.delete(runId);
         }
@@ -994,6 +1021,7 @@ export class NodeRuntimeState {
         }
         for (const runId of runIds) {
             this.runs.delete(runId);
+            this.runPerformance.delete(runId);
             this.recentUserMessages.delete(runId);
             this.runSequences.delete(runId);
         }

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/run-event-service.js

@@ -15,7 +15,7 @@ export class RunEventService {
             if (run === undefined || !isPlainRecord(payload))
                 return;
             const parsed = runPerformanceSchema.safeParse({ ...payload, runId: run.id });
-            if (parsed.success) {
+            if (parsed.success && this.options.runtime.updateRunPerformance(runId, parsed.data)) {
                 this.flushText(runId);
                 this.options.emitWorkbench('conversation', {
                     sessionId: run.sessionId,

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/terminal-service.js

@@ -61,7 +61,7 @@ export class TerminalService {
             const options = {
                 ...input,
                 workspaceId: typeof input.workspaceId === 'string' ? input.workspaceId : null,
-                environment: { ...secretEnvironment, MAR_MGR_CONTEXT_REQUIRED: '1' },
+                environment: { ...secretEnvironment, MAR_CTL_CONTEXT_REQUIRED: '1' },
                 ...(cwd === undefined ? {} : { cwd })
             };
             const terminal = commandMode

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

@@ -1,16 +1,13 @@
-import { tmpdir } from 'node:os';
 import { isAbsolute, relative, resolve, win32 } from 'node:path';
 import { realpath } from 'node:fs/promises';
-import { listWorkspaceFiles, mutateWorkspaceFile, normalizeFilePreviewPath, readAllowedFileContentRange, readWorkspaceFileContentRange, readAllowedTextFile, readWorkspaceTextFile, writeWorkspaceTextFile, WorkspaceFileIndex } from '../workspace.js';
+import { listWorkspaceFiles, mutateWorkspaceFile, normalizeFilePreviewPath, readAbsoluteFileContentRange, readWorkspaceFileContentRange, readAbsoluteTextFile, readWorkspaceTextFile, writeWorkspaceTextFile, WorkspaceFileIndex } from '../workspace.js';
 const INDEX_CACHE_LIMIT = 32;
 export class WorkspaceFileService {
     state;
-    allowedRoots;
     onInvalidated;
     mutationTails = new Map();
-    constructor(state, allowedRoots, onInvalidated) {
+    constructor(state, onInvalidated) {
         this.state = state;
-        this.allowedRoots = allowedRoots;
         this.onInvalidated = onInvalidated;
     }
     async list(workspace, input) {
@@ -38,7 +35,7 @@ export class WorkspaceFileService {
         if (workspacePath !== workspace.path && isFilePreviewAbsolutePath(path))
             throw new Error('FILE_PATH_ESCAPE');
         return isFilePreviewAbsolutePath(path)
-            ? readAllowedTextFile(path, this.previewRoots(), offset, limit)
+            ? readAbsoluteTextFile(path, offset, limit)
             : readWorkspaceTextFile(workspacePath, path, offset, limit);
     }
     async readContent(workspace, input, workspacePath = workspace.path) {
@@ -69,7 +66,7 @@ export class WorkspaceFileService {
         const offset = typeof input.offset === 'number' ? input.offset : 0;
         const limit = typeof input.limit === 'number' ? input.limit : 512 * 1024;
         return isFilePreviewAbsolutePath(path)
-            ? readAllowedFileContentRange(path, this.previewRoots(), offset, limit)
+            ? readAbsoluteFileContentRange(path, offset, limit)
             : readWorkspaceFileContentRange(workspacePath, path, offset, limit);
     }
     readDirect(workspace, input, workspacePath = workspace.path) {
@@ -218,9 +215,6 @@ export class WorkspaceFileService {
             index.dispose();
         this.state.fileIndexes.clear();
     }
-    previewRoots() {
-        return [...new Set([...this.allowedRoots(), tmpdir()])];
-    }
 }
 function isFilePreviewAbsolutePath(path) {
     return isAbsolute(path) || win32.isAbsolute(path);

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/dist/workspace.js

@@ -757,15 +757,15 @@ export async function readWorkspaceFileContentRange(workspaceRoot, requestedPath
         await handle.close();
     }
 }
-/** Reads one absolute file range only when the resolved target remains within a preview root. */
-export async function readAllowedFileContentRange(requestedPath, allowedRoots, offset = 0, limit = FILE_READ_LIMIT) {
+/** Reads one regular absolute file range using the Node account's filesystem permissions. */
+export async function readAbsoluteFileContentRange(requestedPath, offset = 0, limit = FILE_READ_LIMIT) {
     if (!Number.isSafeInteger(offset) ||
         offset < 0 ||
         !Number.isSafeInteger(limit) ||
         limit < 1 ||
         limit > FILE_READ_LIMIT)
         throw new Error('FILE_RANGE_INVALID');
-    const { file, metadata } = await resolveAllowedFile(requestedPath, allowedRoots);
+    const { file, metadata } = await resolveAbsoluteFile(requestedPath);
     if (offset > metadata.size)
         throw new Error('FILE_RANGE_INVALID');
     const length = Math.min(limit, metadata.size - offset);
@@ -792,9 +792,9 @@ function fileSourceRevision(metadata) {
         .update([metadata.dev, metadata.ino, metadata.size, metadata.mtimeMs, metadata.ctimeMs].join(':'))
         .digest('hex');
 }
-/** Reads one absolute file only when the resolved target remains within a preview root. */
-export async function readAllowedTextFile(requestedPath, allowedRoots, offset = 0, limit = FILE_READ_LIMIT) {
-    const { file, metadata } = await resolveAllowedFile(requestedPath, allowedRoots);
+/** Reads one regular absolute file using the Node account's filesystem permissions. */
+export async function readAbsoluteTextFile(requestedPath, offset = 0, limit = FILE_READ_LIMIT) {
+    const { file, metadata } = await resolveAbsoluteFile(requestedPath);
     if (metadata.size > FILE_READ_LIMIT * 16)
         throw new Error('FILE_TOO_LARGE');
     if (!Number.isSafeInteger(offset) ||
@@ -859,7 +859,7 @@ export function normalizeFilePreviewPath(requestedPath) {
         throw new Error('FILE_PATH_ESCAPE');
     return normalized;
 }
-async function resolveAllowedFile(requestedPath, allowedRoots) {
+async function resolveAbsoluteFile(requestedPath) {
     if (!isAbsolute(requestedPath))
         throw new Error('FILE_PATH_ESCAPE');
     const file = await realpath(requestedPath).catch((error) => {
@@ -867,9 +867,6 @@ async function resolveAllowedFile(requestedPath, allowedRoots) {
             throw new Error('FILE_NOT_FOUND');
         throw error;
     });
-    const roots = await Promise.all(allowedRoots.map((root) => realpath(root)));
-    if (!isWithinAllowedRoot(file, roots))
-        throw new Error('FILE_PATH_ESCAPE');
     const metadata = await lstat(file);
     if (!metadata.isFile())
         throw new Error('FILE_NOT_REGULAR');
@@ -1019,7 +1016,9 @@ export function normalizeWorkspacePath(input, platform = hostPlatform()) {
         if (!win32.isAbsolute(normalized)) {
             throw new Error('WORKSPACE_PATH_NOT_ABSOLUTE');
         }
-        return normalized.replace(/\\+$/, '').toLowerCase();
+        // A drive root must remain absolute instead of becoming drive-relative.
+        const root = win32.parse(normalized).root;
+        return (normalized === root ? root : normalized.replace(/\\+$/, '')).toLowerCase();
     }
     if (platform !== 'linux' && platform !== 'darwin') {
         throw new Error('WORKSPACE_PLATFORM_UNSUPPORTED');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.139",
+  "version": "0.9.141",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -13,7 +13,7 @@
   ],
   "bin": {
     "mar-node": "./dist/main.js",
-    "marmgr": "./dist/marmgr.js",
+    "marctl": "./dist/marctl.js",
     "marnodes": "./dist/marnodes.js",
     "marssh": "./dist/marssh.js",
     "marscp": "./dist/marscp.js"
@@ -34,10 +34,10 @@
     "npm": "11.12.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/marmgr": "0.9.119",
-    "@myagentroam/agent": "0.9.139",
-    "@myagentroam/code-navigation": "0.9.129",
-    "@myagentroam/protocol": "0.9.139"
+    "@myagentroam/marctl": "0.9.120",
+    "@myagentroam/agent": "0.9.141",
+    "@myagentroam/protocol": "0.9.141",
+    "@myagentroam/code-navigation": "0.9.129"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"