@myagentroam/node 0.11.68 → 0.11.70

package/dist/application/workspace-application.js

@@ -23,6 +23,9 @@ export function composeWorkspaceApplication(input) {
         uploads: resources.uploads,
         changes: input.changes,
         listSessions: input.listSessions,
+        ...(input.sessionNavigation === undefined
+            ? {}
+            : { sessionNavigation: input.sessionNavigation }),
         invalidate: resources.invalidateFiles,
         nodeId: input.nodeId,
         nodeGeneration: input.nodeGeneration,

package/dist/capabilities.js

@@ -61,6 +61,7 @@ export function unavailableCapabilities() {
         promptCompletion: { apiVersion: 1, contextVersion: 3, automaticTriggers: true },
         chatgptLogin: { apiVersion: 1, loopback: true },
         workspaceDirectTransfer: workspaceDirectTransferCapability(),
+        sessionAside: { apiVersion: 1 },
         sessionGroups: { apiVersion: 1 },
         terminalDirect: terminalDirectCapability()
     };
@@ -98,6 +99,7 @@ export function detectCapabilities(commands = {}) {
         promptCompletion: { apiVersion: 1, contextVersion: 3, automaticTriggers: true },
         chatgptLogin: { apiVersion: 1, loopback: true },
         workspaceDirectTransfer: workspaceDirectTransferCapability(),
+        sessionAside: { apiVersion: 1 },
         sessionGroups: { apiVersion: 1 },
         terminalDirect: terminalDirectCapability()
     };
@@ -139,6 +141,7 @@ export async function detectCapabilitiesAsync(commands = {}) {
         promptCompletion: { apiVersion: 1, contextVersion: 3, automaticTriggers: true },
         chatgptLogin: { apiVersion: 1, loopback: true },
         workspaceDirectTransfer: workspaceDirectTransferCapability(),
+        sessionAside: { apiVersion: 1 },
         sessionGroups: { apiVersion: 1 },
         terminalDirect: terminalDirectCapability()
     };

package/dist/connector.js

@@ -1433,6 +1433,7 @@ export class NodeConnector {
                 limit: 30,
                 ...(sessionGroup === undefined ? {} : { sessionGroup })
             }),
+            sessionNavigation: async (workspaceId, query) => this.sessionCatalogService.navigation({ workspaceId, ...query }),
             invalidatePrompt: (id) => this.promptCompletion?.invalidateWorkspace(id),
             nodeId: () => this.config?.nodeId ?? 'runtime-node',
             nodeGeneration: () => this.nodeGeneration,

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

@@ -1,5 +1,5 @@
 import { claudeContentBlocks } from './message-parsers.js';
-import { compactRunnerText, compactRunnerValue, publicOutputSnapshot, publicToolOutput } from '../normalization.js';
+import { compactRunnerText, compactRunnerValue, publicOutputSnapshot, publicToolOutput, subagentCallDetail } from '../normalization.js';
 import { shellExecution } from '../execution-presentation.js';
 import { RunnerUsageTracker, usageToken, usageTokenSum } from '../../service/runner-usage-tracker.js';
 export class ClaudeUsageNormalizer {
@@ -176,6 +176,23 @@ export function normalizeClaudeTool(toolName, input, output, failed, truncated,
                     }
                 }
                 : {}),
+            ...(toolName === 'WebFetch' && typeof values?.url === 'string'
+                ? {
+                    toolPresentation: {
+                        kind: 'WEB_FETCH',
+                        detailOnly: true,
+                        requestUrl: compactRunnerText(values.url, 8192)
+                    }
+                }
+                : toolName === 'WebSearch' && typeof values?.query === 'string'
+                    ? {
+                        toolPresentation: {
+                            kind: 'WEB_SEARCH',
+                            detailOnly: true,
+                            query: compactRunnerText(values.query, 500)
+                        }
+                    }
+                    : {}),
             ...subagent
         }
     };
@@ -229,6 +246,11 @@ function claudeSubagentProjection(toolName, input, output, knownSubagents) {
         knownSubagents.set(subagentId, title);
     return {
         subagentOperation: operation,
+        ...(operation === 'START'
+            ? subagentCallDetail(record(input)?.prompt)
+            : operation === 'MESSAGE'
+                ? subagentCallDetail(record(input)?.message)
+                : {}),
         subagentId: subagentId === '*' ? null : (subagentId ?? null),
         ...(operation === 'STATUS' ? { subagentWait: inputData?.block === true } : {}),
         ...(title.length === 0 ? {} : { title })

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

@@ -1,4 +1,4 @@
-import { compactRunnerText, publicToolOutput } from '../normalization.js';
+import { compactRunnerText, publicToolOutput, subagentCallDetail } from '../normalization.js';
 import { shellExecution } from '../execution-presentation.js';
 export function normalizeCodexApproval(method) {
     return method === 'item/commandExecution/requestApproval'
@@ -114,6 +114,9 @@ function codexSubagentProjection(namespace, toolName, input, output) {
         : '';
     return {
         subagentOperation: operation,
+        ...(operation === 'START' || operation === 'MESSAGE'
+            ? subagentCallDetail(record(input)?.message)
+            : {}),
         ...(toolName === 'wait_agent' ? { subagentWait: true } : {}),
         subagentId: Array.isArray(inputData?.targets) && inputData.targets.length > 1
             ? null

package/dist/runner/mar-agent/agent-network-extension.js

@@ -226,7 +226,7 @@ export function agentNetworkExtension(invoke, currentExecution) {
                                     : tool.action === 'view'
                                         ? { session: rows[0] }
                                         : (rows[0] ?? {});
-                                await call.publishEventData(agentOperationEvent(tool.action, {}, result).eventData);
+                                await call.publishEventData(agentOperationEvent(tool.action, operationInput, result).eventData);
                             }
                             : undefined;
                         const result = await invoke(executionId, tool.action, operationInput, call, onResolved);

package/dist/runner/mar-agent/agent-operation-presentation.js

@@ -61,6 +61,15 @@ export function agentOperationEvent(action, input, result) {
     const operation = agentOperationPresentation(`agent_${action}`, input);
     const value = isPlainRecord(result) ? result : {};
     const args = isPlainRecord(input) ? input : {};
+    const message = action === 'start' || action === 'send' ? text(args.content, 2000) : undefined;
+    const title = action === 'start' ? text(args.title, 500) : undefined;
+    if (message || title)
+        operation.detail = {
+            ...(title ? { title } : {}),
+            ...(message
+                ? { message, ...(message !== args.content ? { messageTruncated: true } : {}) }
+                : {})
+        };
     const rows = action === 'list' ? value.sessions : action === 'wait' ? value.agents : undefined;
     const records = Array.isArray(rows)
         ? rows
@@ -82,7 +91,31 @@ export function agentOperationEvent(action, input, result) {
         if (!agentId)
             return [];
         const title = text(entry.title ?? (action === 'start' ? args.title : undefined), 500);
-        return [{ agentId, sessionId: agentId, ...(title ? { title } : {}) }];
+        const status = ['list', 'view', 'wait'].includes(action) ? text(entry.status) : undefined;
+        const latest = action === 'wait' ? latestWaitMessage(entry.updates) : undefined;
+        const viewMessage = action === 'view' && isPlainRecord(entry.latestMessage) ? entry.latestMessage : undefined;
+        const summary = action === 'wait' ? text(entry.summary, 800) : undefined;
+        const rawMessage = summary ?? latest?.value ?? text(viewMessage?.text, 800);
+        const messageTruncated = summary
+            ? entry.summaryTruncated === true || summary !== entry.summary
+            : latest
+                ? latest.truncated === true
+                : viewMessage?.truncated === true ||
+                    (typeof viewMessage?.text === 'string' && viewMessage.text.length > 800);
+        return [
+            {
+                agentId,
+                sessionId: agentId,
+                ...(title ? { title } : {}),
+                ...(status ? { status } : {}),
+                ...(rawMessage
+                    ? {
+                        message: rawMessage,
+                        ...(messageTruncated ? { messageTruncated: true } : {})
+                    }
+                    : {})
+            }
+        ];
     })
         .slice(0, 100);
     // An any-wait may return one result for several requested targets; keep the call multi-target.
@@ -90,12 +123,67 @@ export function agentOperationEvent(action, input, result) {
         ? operation.targets.map((target) => returnedTargets.find((result) => result.agentId === target.agentId) ?? target)
         : returnedTargets;
     const presentation = { ...operation, targets };
-    if (records.length > returnedTargets.length)
+    const messageReceipt = isPlainRecord(value.message) ? value.message : undefined;
+    const messageResult = isPlainRecord(messageReceipt?.result) ? messageReceipt.result : undefined;
+    const auditReceipt = isPlainRecord(messageResult?.auditReceipt)
+        ? messageResult.auditReceipt
+        : undefined;
+    const failures = [value.message, value.goal, value.approval, value.observation, value.start]
+        .filter((part) => isPlainRecord(part) &&
+        ['unknown', 'failed', 'partial', 'not_attempted'].includes(String(part.status)))
+        .map((part) => (isPlainRecord(part) ? (text(part.code) ?? text(part.status)) : undefined))
+        .filter((part) => part !== undefined);
+    if (failures.length)
+        presentation.detail = {
+            ...presentation.detail,
+            failed: true,
+            error: failures.join('\n').slice(0, 500)
+        };
+    if (action === 'send' &&
+        message &&
+        failures.length === 0 &&
+        messageReceipt?.status === 'accepted') {
+        const delivery = messageResult?.delivery === 'QUEUED' || auditReceipt?.inputMode === 'QUEUE'
+            ? 'QUEUE'
+            : auditReceipt?.inputMode === 'REPLACE_CURRENT'
+                ? 'STEER'
+                : undefined;
+        if (delivery)
+            presentation.detail = { ...presentation.detail, delivery };
+    }
+    if (!presentation.detail &&
+        ((action === 'list' && Array.isArray(value.sessions)) ||
+            (action === 'view' && isPlainRecord(value.session)) ||
+            (action === 'wait' && records.length > 0) ||
+            (action === 'stop' && typeof value.agentId === 'string')))
+        presentation.detail = {};
+    if (value.truncated === true || records.length > returnedTargets.length)
         presentation.targetsTruncated = true;
     // Core accepts at most 8 KiB of explicit extension event data.
     while (Buffer.byteLength(JSON.stringify({ agentOperation: presentation }), 'utf8') > 7000) {
-        targets.pop();
-        presentation.targetsTruncated = true;
+        const targetWithMessage = targets.findLast((target) => target.message);
+        if (targetWithMessage?.message) {
+            const shortened = text(targetWithMessage.message, Math.floor(targetWithMessage.message.length / 2));
+            if (shortened)
+                targetWithMessage.message = shortened;
+            else
+                delete targetWithMessage.message;
+            targetWithMessage.messageTruncated = true;
+        }
+        else if (presentation.detail?.message) {
+            const shortened = text(presentation.detail.message, Math.floor(presentation.detail.message.length / 2));
+            if (shortened)
+                presentation.detail.message = shortened;
+            else
+                delete presentation.detail.message;
+            presentation.detail.messageTruncated = true;
+        }
+        else if (targets.length) {
+            targets.pop();
+            presentation.targetsTruncated = true;
+        }
+        else
+            break;
     }
     const receipt = {};
     if (action === 'list' && Array.isArray(value.models)) {

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

@@ -1059,11 +1059,24 @@ function mergeAgentOperationData(toolName, previous, current) {
         ...record(current),
         agentOperation: {
             ...after.data,
-            targets: before.data.targets.map((target) => ({
-                ...after.data.targets.find((candidate) => candidate.agentId === target.agentId),
-                ...target
-            })),
-            ...(before.data.targetsTruncated ? { targetsTruncated: true } : {})
+            ...(after.data.detail === undefined && before.data.detail !== undefined
+                ? { detail: before.data.detail }
+                : {}),
+            targets: (after.data.action === 'WAIT'
+                ? [
+                    ...after.data.targets,
+                    ...before.data.targets.filter((target) => !after.data.targets.some((candidate) => candidate.agentId === target.agentId))
+                ]
+                : after.data.targets).map((target) => {
+                const resolved = before.data.targets.find((candidate) => candidate.agentId === target.agentId);
+                const current = after.data.targets.find((candidate) => candidate.agentId === target.agentId);
+                return {
+                    agentId: target.agentId,
+                    ...(resolved?.sessionId ? { sessionId: resolved.sessionId } : {}),
+                    ...(resolved?.title ? { title: resolved.title } : {}),
+                    ...current
+                };
+            })
         }
     };
 }
@@ -1213,7 +1226,10 @@ function genericToolItem(id, toolName, status, input, outputSummary = null, erro
         ];
     }
     const toolCategory = isImageGenerationTool(toolName) ? 'IMAGE_GENERATION' : undefined;
-    const presentation = projectToolPresentation(toolName, input, output, sleepStartedAt);
+    const readOutput = toolName === 'read' && status === 'COMPLETED' && outputSummary !== null
+        ? publicToolOutput(outputSummary, summaryTruncated ? 'SOURCE' : outputTruncation)
+        : undefined;
+    const presentation = projectToolPresentation(toolName, input, output, sleepStartedAt, outputSummary, readOutput);
     const inputSummary = compactRunnerValue(input, 10_000);
     return {
         itemId: id,
@@ -1224,8 +1240,12 @@ function genericToolItem(id, toolName, status, input, outputSummary = null, erro
             toolName: compactRunnerText(toolName, 128) || 'unknown',
             title: compactRunnerText(toolName, 500) || 'unknown',
             inputSummary: inputSummary.text || null,
-            outputSummary: typeof output === 'string' || errorCode !== null ? null : outputSummary,
-            ...(typeof output === 'string' ? { output: publicToolOutput(output, outputTruncation) } : {}),
+            outputSummary: typeof output === 'string' || errorCode !== null || readOutput ? null : outputSummary,
+            ...(readOutput
+                ? { output: readOutput }
+                : typeof output === 'string'
+                    ? { output: publicToolOutput(output, outputTruncation) }
+                    : {}),
             ...(typeof output !== 'string' && outputSummary !== null && summaryTruncated
                 ? { outputSummaryTruncated: true }
                 : {}),
@@ -1243,7 +1263,7 @@ function genericToolItem(id, toolName, status, input, outputSummary = null, erro
         merge: true
     };
 }
-function projectToolPresentation(toolName, input, output, startedAt) {
+function projectToolPresentation(toolName, input, output, startedAt, readSummary, readOutput) {
     if (toolName === 'read') {
         const reads = record(input)?.reads;
         const paths = (Array.isArray(reads) ? reads : [])
@@ -1252,8 +1272,88 @@ function projectToolPresentation(toolName, input, output, startedAt) {
             return typeof path === 'string' && path.length > 0 ? [compactRunnerText(path, 4096)] : [];
         })
             .slice(0, 16);
-        return { kind: 'READ', paths };
+        const data = record(output);
+        if (data?.mode !== 'batch' ||
+            !Array.isArray(data.results) ||
+            readSummary == null ||
+            !readOutput)
+            return { kind: 'READ', paths };
+        const text = readOutput.blocks.find((block) => block.channel === 'TEXT')?.text ?? '';
+        const removed = readSummary.length - text.length;
+        const results = data.results.slice(0, 16).flatMap((value) => {
+            const item = record(value);
+            if (typeof item?.path !== 'string' || !item.path)
+                return [];
+            const range = record(item.contentRange);
+            const start = range?.start;
+            const end = range?.end;
+            const validRange = typeof start === 'number' &&
+                Number.isSafeInteger(start) &&
+                start >= 0 &&
+                typeof end === 'number' &&
+                Number.isSafeInteger(end) &&
+                start <= end &&
+                end <= readSummary.length &&
+                (end > removed || (start === end && start >= removed));
+            const error = record(item.error);
+            return [
+                {
+                    path: compactRunnerText(item.path, 4096),
+                    ...(item.startLine === undefined ? {} : { startLine: item.startLine }),
+                    ...(item.endLine === undefined ? {} : { endLine: item.endLine }),
+                    ...(item.empty === true ? { empty: true } : {}),
+                    ...(typeof error?.code === 'string' && typeof error.message === 'string'
+                        ? {
+                            error: {
+                                code: compactRunnerText(error.code, 80),
+                                message: compactRunnerText(error.message, 1000)
+                            }
+                        }
+                        : {}),
+                    ...(validRange
+                        ? {
+                            contentRange: {
+                                channel: 'TEXT',
+                                start: Math.max(start, removed) - removed,
+                                end: end - removed
+                            }
+                        }
+                        : {})
+                }
+            ];
+        });
+        const parsed = toolPresentationSchema.safeParse({ kind: 'READ', paths, results });
+        return parsed.success ? parsed.data : { kind: 'READ', paths };
+    }
+    const args = record(input) ?? {};
+    const data = record(output) ?? {};
+    if (toolName === 'view_image') {
+        const parsed = toolPresentationSchema.safeParse({
+            kind: 'IMAGE_VIEW',
+            path: typeof args.path === 'string' ? compactRunnerText(args.path, 4096) : undefined,
+            resourceId: typeof args.resourceId === 'string' ? compactRunnerText(args.resourceId, 512) : undefined,
+            resize: args.resize,
+            mimeType: data.mimeType,
+            width: data.width,
+            height: data.height,
+            sourceWidth: data.sourceWidth,
+            sourceHeight: data.sourceHeight,
+            region: data.region
+        });
+        return parsed.success
+            ? Object.fromEntries(Object.entries(parsed.data).filter(([, value]) => value !== undefined))
+            : { kind: 'IMAGE_VIEW' };
+    }
+    if (toolName === 'tool_search') {
+        const parsed = toolPresentationSchema.safeParse({
+            kind: 'TOOL_SEARCH',
+            ...(typeof args.query === 'string' ? { query: compactRunnerText(args.query, 500) } : {}),
+            ...(data.tools === undefined ? {} : { tools: data.tools })
+        });
+        return parsed.success ? parsed.data : { kind: 'TOOL_SEARCH' };
     }
+    if (toolName === 'smart_compact')
+        return { kind: 'COMPACT_REQUEST', ...(data.status === 'accepted' ? { accepted: true } : {}) };
     const category = toolName === 'web_search'
         ? 'WEB_SEARCH'
         : toolName === 'web_fetch'
@@ -1265,8 +1365,6 @@ function projectToolPresentation(toolName, input, output, startedAt) {
                     : undefined;
     if (category === undefined)
         return undefined;
-    const args = record(input) ?? {};
-    const data = record(output) ?? {};
     // A provider-hosted search tool can report a page-read action under its native name.
     const kind = category === 'WEB_SEARCH' && data.hostedToolKind === 'WEB_FETCH' ? 'WEB_FETCH' : category;
     const text = (value, limit) => typeof value === 'string' ? compactRunnerText(value, limit) : undefined;

package/dist/runner/normalization.js

@@ -2,6 +2,21 @@ import { boundToolOutput } from '@myagentroam/protocol';
 export function compactRunnerText(value, limit) {
     return value.length <= limit ? value : `${value.slice(0, Math.max(0, limit - 1))}…`;
 }
+/** The current native call's message, never a target's result or inferred history. */
+export function subagentCallDetail(value) {
+    if (typeof value !== 'string' || value.trim().length === 0)
+        return {};
+    let message = value.slice(0, 2000);
+    const last = message.charCodeAt(message.length - 1);
+    if (last >= 0xd800 && last <= 0xdbff)
+        message = message.slice(0, -1);
+    return {
+        subagentCallDetail: {
+            message,
+            ...(message.length < value.length ? { messageTruncated: true } : {})
+        }
+    };
+}
 export function publicOutputSnapshot(value, truncated = false) {
     const text = typeof value === 'string' ? value : compactRunnerValue(value, Number.MAX_SAFE_INTEGER).text;
     let bounded = text.slice(-10_000);

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

@@ -1,4 +1,4 @@
-import { compactRunnerText, compactRunnerValue, publicToolOutput } from '../normalization.js';
+import { compactRunnerText, compactRunnerValue, publicToolOutput, subagentCallDetail } from '../normalization.js';
 import { shellExecution } from '../execution-presentation.js';
 export function normalizeOpenCodeTool(toolName, state) {
     const status = state?.status === 'completed'
@@ -53,6 +53,23 @@ export function normalizeOpenCodeTool(toolName, state) {
                     }
                 }
                 : {}),
+            ...(normalizedName === 'webfetch' && typeof input?.url === 'string'
+                ? {
+                    toolPresentation: {
+                        kind: 'WEB_FETCH',
+                        detailOnly: true,
+                        requestUrl: compactRunnerText(input.url, 8192)
+                    }
+                }
+                : normalizedName === 'websearch' && typeof input?.query === 'string'
+                    ? {
+                        toolPresentation: {
+                            kind: 'WEB_SEARCH',
+                            detailOnly: true,
+                            query: compactRunnerText(input.query, 500)
+                        }
+                    }
+                    : {}),
             ...(typeof state?.output === 'string' ? { output: publicToolOutput(state.output) } : {}),
             ...subagent
         }
@@ -72,6 +89,7 @@ function openCodeSubagentProjection(toolName, input, output) {
     const title = typeof inputData?.description === 'string' ? compactRunnerText(inputData.description, 500) : '';
     return {
         subagentOperation: taskId === undefined ? 'START' : 'RESUME',
+        ...(taskId === undefined ? subagentCallDetail(inputData?.prompt) : {}),
         subagentId: taskId ?? nativeResult?.taskId ?? null,
         ...(title.length === 0 ? {} : { title }),
         ...(nativeResult === undefined

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

@@ -31,13 +31,16 @@ export class NativeSessionWatchService {
             typeof input.watchId !== 'string' ||
             typeof input.workbenchConnectionId !== 'string' ||
             (input.mode !== 'initial' && input.mode !== 'renew') ||
+            (input.position !== undefined &&
+                input.position !== 'primary' &&
+                input.position !== 'secondary') ||
             (input.unit !== undefined && input.unit !== 'SEGMENT'))
             throw new Error('SESSION_INVALID');
         const ownerKey = this.ownerKey(input);
         if (input.mode === 'renew') {
             const lease = this.leases.get(ownerKey);
             if (lease === undefined ||
-                !this.sessionWatchSlots.owns(ownerKey, lease.slotToken) ||
+                !this.sessionWatchSlots.owns(lease.slotOwnerKey, lease.slotToken) ||
                 lease.watchId !== input.watchId ||
                 lease.sessionId !== input.sessionId ||
                 (input.workspaceId !== undefined && lease.workspaceId !== input.workspaceId))
@@ -57,7 +60,7 @@ export class NativeSessionWatchService {
         const existing = this.leases.get(ownerKey);
         const unit = input.unit === 'SEGMENT' ? 'SEGMENT' : 'TURN';
         if (existing?.watchId === input.watchId &&
-            this.sessionWatchSlots.owns(ownerKey, existing.slotToken) &&
+            this.sessionWatchSlots.owns(existing.slotOwnerKey, existing.slotToken) &&
             existing.sessionId === input.sessionId &&
             (input.workspaceId === undefined || existing.workspaceId === input.workspaceId) &&
             existing.unit === unit &&
@@ -68,9 +71,12 @@ export class NativeSessionWatchService {
             return this.accepted(existing);
         }
         this.removeLease(ownerKey);
-        const slotToken = this.sessionWatchSlots.replace(ownerKey, 'session', () => this.removeLease(ownerKey));
+        const slotOwnerKey = this.slotOwnerKey(input);
+        const position = input.position === 'secondary' ? 'secondary' : 'primary';
+        const slotToken = this.sessionWatchSlots.replace(slotOwnerKey, 'session', () => this.removeLease(ownerKey), position);
         const lease = {
             ownerKey,
+            slotOwnerKey,
             sessionHash: this.sessionHash(input),
             workbenchConnectionId: input.workbenchConnectionId,
             watchId: input.watchId,
@@ -96,7 +102,10 @@ export class NativeSessionWatchService {
     executeUnwatch(input) {
         if (typeof input.sessionId !== 'string' ||
             typeof input.watchId !== 'string' ||
-            typeof input.workbenchConnectionId !== 'string')
+            typeof input.workbenchConnectionId !== 'string' ||
+            (input.position !== undefined &&
+                input.position !== 'primary' &&
+                input.position !== 'secondary'))
             throw new Error('SESSION_INVALID');
         const ownerKey = this.ownerKey(input);
         const lease = this.leases.get(ownerKey);
@@ -182,14 +191,13 @@ export class NativeSessionWatchService {
         return this.watches.has(sessionId);
     }
     observes(sessionHash, connectionId, workspaceId, sessionId) {
-        const ownerKey = `${sessionHash}:${connectionId}`;
-        const lease = this.leases.get(ownerKey);
-        return (lease !== undefined &&
+        const slotOwnerKey = `${sessionHash}:${connectionId}`;
+        return [...this.leases.values()].some((lease) => lease.slotOwnerKey === slotOwnerKey &&
             lease.ready &&
             lease.expiresAt > Date.now() &&
             lease.sessionId === sessionId &&
             lease.workspaceId === workspaceId &&
-            this.sessionWatchSlots.owns(ownerKey, lease.slotToken));
+            this.sessionWatchSlots.owns(slotOwnerKey, lease.slotToken));
     }
     isWatching(sessionId) {
         return this.has(sessionId);
@@ -286,6 +294,9 @@ export class NativeSessionWatchService {
             : 'local-test';
     }
     ownerKey(input) {
+        return `${this.slotOwnerKey(input)}:${input.position === 'secondary' ? 'secondary' : 'primary'}`;
+    }
+    slotOwnerKey(input) {
         return `${this.sessionHash(input)}:${input.workbenchConnectionId}`;
     }
     accepted(lease) {
@@ -378,7 +389,7 @@ export class NativeSessionWatchService {
             return;
         clearTimeout(lease.timer);
         this.leases.delete(ownerKey);
-        this.sessionWatchSlots.release(ownerKey, lease.slotToken);
+        this.sessionWatchSlots.release(lease.slotOwnerKey, lease.slotToken);
         const observer = this.watches.get(lease.sessionId);
         const nextExpiry = this.latestLeaseExpiry(lease.sessionId);
         if (nextExpiry === 0)

package/dist/service/session-watch-slot-coordinator.js

@@ -1,21 +1,35 @@
-/** Coordinates the single Session Watch slot owned by one logical Workbench connection. */
+/** Coordinates bounded ordinary positions and the mutually exclusive hosted watch. */
 export class SessionWatchSlotCoordinator {
     slots = new Map();
-    replace(ownerKey, kind, release) {
+    replace(ownerKey, kind, release, position = 'primary') {
+        const key = kind === 'session' ? position : 'hosted';
         const previous = this.slots.get(ownerKey);
         if (previous !== undefined) {
-            this.slots.delete(ownerKey);
-            previous.release();
+            for (const [slotKey, slot] of previous) {
+                if (kind === 'hosted-conversation' || slotKey === 'hosted' || slotKey === key) {
+                    previous.delete(slotKey);
+                    slot.release();
+                }
+            }
         }
         const token = Symbol(kind);
-        this.slots.set(ownerKey, { kind, token, release });
+        const slots = this.slots.get(ownerKey) ?? new Map();
+        slots.set(key, { kind, token, release });
+        this.slots.set(ownerKey, slots);
         return token;
     }
     owns(ownerKey, token) {
-        return this.slots.get(ownerKey)?.token === token;
+        return [...(this.slots.get(ownerKey)?.values() ?? [])].some((slot) => slot.token === token);
     }
     release(ownerKey, token) {
-        if (this.slots.get(ownerKey)?.token === token)
+        const slots = this.slots.get(ownerKey);
+        if (slots === undefined)
+            return;
+        for (const [key, slot] of slots) {
+            if (slot.token === token)
+                slots.delete(key);
+        }
+        if (slots.size === 0)
             this.slots.delete(ownerKey);
     }
 }

package/dist/service/web-tool-service.js

@@ -154,16 +154,18 @@ export class WebToolService {
             } while (countModelTokens(content) > budget && metadataLimit >= 32);
             if (countModelTokens(content) > budget)
                 throw invalidResult();
+            const data = {
+                query: parsed.data.query,
+                results: results.map((item, index) => ({
+                    ...item,
+                    url: parsed.data.results[index].url
+                })),
+                truncated
+            };
             return {
                 content,
-                data: {
-                    query: parsed.data.query,
-                    results: results.map((item, index) => ({
-                        ...item,
-                        url: parsed.data.results[index].url
-                    })),
-                    truncated
-                },
+                data,
+                eventData: { ...data, sourcesOnly: true },
                 truncated
             };
         }

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

@@ -48,6 +48,7 @@ export class WorkbenchManifestService {
             },
             directTransfer: capabilities.workspaceDirectTransfer,
             terminalDirect: capabilities.terminalDirect,
+            sessionAside: capabilities.sessionAside,
             sessionGroups: capabilities.sessionGroups,
             git: {
                 available: true,

package/dist/service/workspace-watch-controller.js

@@ -28,16 +28,27 @@ export class WorkspaceWatchController {
             existing.topics.changes === topics.changes &&
             JSON.stringify(existing.topics.files) === JSON.stringify(topics.files) &&
             (existing.prepareFiles === true) === (input.prepareFiles === true);
+        const navigationOnly = existing !== undefined &&
+            existing.topics.sessions === topics.sessions &&
+            existing.topics.sessionGroup === topics.sessionGroup &&
+            existing.topics.changes === topics.changes &&
+            JSON.stringify(existing.topics.files) === JSON.stringify(topics.files) &&
+            !sameNavigation(existing.topics.sessionNavigation, topics.sessionNavigation) &&
+            (existing.prepareFiles === true) === (input.prepareFiles === true);
         if (existing !== undefined &&
             existing.watchId === input.watchId &&
-            JSON.stringify(existing.topics) === JSON.stringify(topics) &&
+            existing.topics.sessions === topics.sessions &&
+            existing.topics.sessionGroup === topics.sessionGroup &&
+            existing.topics.changes === topics.changes &&
+            JSON.stringify(existing.topics.files) === JSON.stringify(topics.files) &&
+            sameNavigation(existing.topics.sessionNavigation, topics.sessionNavigation) &&
             (existing.prepareFiles === true) === (input.prepareFiles === true)) {
             this.options.watch.renew(workspace.id, key, input.watchId);
             return this.accepted(existing);
         }
         const watch = this.options.watch.create(workspace.id, input.watchId, this.options.watch.sessionHash(input), input.workbenchConnectionId, this.options.nodeGeneration(), topics, input.prepareFiles === true);
-        void this.options.snapshots.initial(workspace, watch, groupOnly ? existing : undefined);
-        if (watch.prepareFiles)
+        void this.options.snapshots.initial(workspace, watch, groupOnly || navigationOnly ? existing : undefined);
+        if (watch.prepareFiles && !navigationOnly)
             this.options.snapshots.prewarmFiles(workspace, watch);
         return this.accepted(watch);
     }
@@ -72,6 +83,16 @@ export class WorkspaceWatchController {
         };
     }
 }
+function sameNavigation(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    return (left.limit === right.limit &&
+        left.treeAnchor === right.treeAnchor &&
+        left.sessionIds.length === right.sessionIds.length &&
+        left.sessionIds.every((id, index) => id === right.sessionIds[index]) &&
+        left.summaryAnchors.length === right.summaryAnchors.length &&
+        left.summaryAnchors.every((id, index) => id === right.summaryAnchors[index]));
+}
 function record(value) {
     if (typeof value !== 'object' || value === null || Array.isArray(value))
         throw new Error('WORKSPACE_WATCH_INVALID');

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

@@ -76,23 +76,104 @@ export class SessionCatalogService {
             ancestors.add(parent.id);
             root = parent;
         }
+        const project = this.navigationProjector(input.workspaceId);
+        const queue = [root];
+        const visited = new Set([root.id]);
+        const nodes = [];
+        for (let index = 0; index < queue.length && index < limit; index += 1) {
+            const session = queue[index];
+            nodes.push(project(session));
+            const children = [...database.listChildSessionRecords(input.workspaceId, session.id)];
+            if (input.includeAncestors === true)
+                children.sort((left, right) => Number(ancestors.has(right.id)) - Number(ancestors.has(left.id)));
+            for (const child of children) {
+                if (visited.has(child.id))
+                    continue;
+                visited.add(child.id);
+                queue.push(child);
+            }
+        }
+        return { rootSessionId: root.id, nodes, truncated: queue.length > nodes.length };
+    }
+    navigation(query) {
+        const database = this.options.database();
+        const project = this.navigationProjector(query.workspaceId);
+        const get = (id) => {
+            const record = database.getSessionRecord(id);
+            return record?.workspaceId === query.workspaceId ? record : undefined;
+        };
+        const requestedIds = new Set([
+            ...query.sessionIds,
+            ...query.summaryAnchors,
+            ...(query.treeAnchor === undefined ? [] : [query.treeAnchor])
+        ]);
+        const missingSessionIds = [...requestedIds].filter((id) => get(id) === undefined);
+        const sessions = query.sessionIds.flatMap((id) => {
+            const record = get(id);
+            return record === undefined ? [] : [project(record)];
+        });
+        const descendantsByAnchor = new Map();
+        const descendants = (anchor) => {
+            let records = descendantsByAnchor.get(anchor);
+            if (records === undefined) {
+                records = database.sessionTreeRecords(query.workspaceId, anchor).slice(1);
+                descendantsByAnchor.set(anchor, records);
+            }
+            return records;
+        };
+        const summaries = query.summaryAnchors.flatMap((anchorSessionId) => {
+            if (get(anchorSessionId) === undefined)
+                return [];
+            let runningCount = 0;
+            let sleepingCount = 0;
+            const records = descendants(anchorSessionId);
+            for (const record of records) {
+                const status = sessionActivityStatus(this.options.runtime, record.id);
+                if (status === 'RUNNING')
+                    runningCount++;
+                else if (status === 'SLEEPING')
+                    sleepingCount++;
+            }
+            return [
+                {
+                    anchorSessionId,
+                    descendantCount: records.length,
+                    activeCount: runningCount + sleepingCount,
+                    runningCount,
+                    sleepingCount,
+                    hasActiveDescendants: runningCount + sleepingCount > 0
+                }
+            ];
+        });
+        const anchor = query.treeAnchor === undefined ? undefined : get(query.treeAnchor);
+        const records = anchor === undefined ? [] : descendants(anchor.id);
+        const parent = anchor?.metadata.parentSessionId
+            ? get(anchor.metadata.parentSessionId)
+            : undefined;
+        const tree = anchor === undefined
+            ? null
+            : {
+                anchorSessionId: anchor.id,
+                parent: parent === undefined ? null : project(parent),
+                nodes: records.slice(0, query.limit).map(project),
+                truncated: records.length > query.limit
+            };
+        return { sessions, summaries, tree, missingSessionIds };
+    }
+    navigationProjector(workspaceId) {
         const native = this.options
             .cachedNative()
-            .filter((session) => session.workspaceId === input.workspaceId);
+            .filter((session) => session.workspaceId === workspaceId);
         const projections = this.options.projection.projectionsForNative(native);
         const activityById = new Map();
         for (const source of native) {
             const id = projections.get(source)?.id ?? source.id;
             activityById.set(id, latestSessionActivityAt(activityById.get(id) ?? 0, source.lastActivityAt));
         }
-        const queue = [root];
-        const visited = new Set([root.id]);
-        const nodes = [];
-        for (let index = 0; index < queue.length && index < limit; index += 1) {
-            const session = queue[index];
+        return (session) => {
             const active = this.options.runtime.getAgentSession(session.id);
             const live = active === undefined ? undefined : this.options.present(active);
-            nodes.push({
+            return {
                 id: session.id,
                 parentSessionId: session.metadata.parentSessionId ?? null,
                 title: live?.customTitle ??
@@ -104,18 +185,8 @@ export class SessionCatalogService {
                 activity: live && 'activity' in live ? live.activity : 'IDLE',
                 status: sessionActivityStatus(this.options.runtime, session.id),
                 lastActivityAt: latestSessionActivityAt(live?.lastActivityAt ?? 0, activityById.get(session.id) ?? 0)
-            });
-            const children = [...database.listChildSessionRecords(input.workspaceId, session.id)];
-            if (input.includeAncestors === true)
-                children.sort((left, right) => Number(ancestors.has(right.id)) - Number(ancestors.has(left.id)));
-            for (const child of children) {
-                if (visited.has(child.id))
-                    continue;
-                visited.add(child.id);
-                queue.push(child);
-            }
-        }
-        return { rootSessionId: root.id, nodes, truncated: queue.length > nodes.length };
+            };
+        };
     }
     async collect(input) {
         const workspaceId = typeof input.workspaceId === 'string' ? input.workspaceId : undefined;

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

@@ -1,4 +1,5 @@
 import { posix } from 'node:path';
+import { workspaceSessionNavigationQuerySchema } from '@myagentroam/protocol';
 const WATCH_TTL_MS = 45_000;
 export class WorkspaceWatchService {
     onSessionWatchRequired;
@@ -22,6 +23,14 @@ export class WorkspaceWatchService {
         if (sessionGroup !== undefined && sessionGroup !== 'MAIN' && sessionGroup !== 'CHILD')
             throw new Error('WORKSPACE_WATCH_INVALID');
         const changes = input.topics.changes === true;
+        const rawNavigation = input.topics.sessionNavigation;
+        let sessionNavigation;
+        if (rawNavigation !== undefined) {
+            const parsed = workspaceSessionNavigationQuerySchema.safeParse(rawNavigation);
+            if (!parsed.success)
+                throw new Error('WORKSPACE_WATCH_INVALID');
+            sessionNavigation = parsed.data;
+        }
         const rawFiles = input.topics.files;
         let files;
         if (rawFiles !== undefined) {
@@ -40,9 +49,15 @@ export class WorkspaceWatchService {
                 ...(typeof rawFiles.limit === 'number' ? { limit: rawFiles.limit } : {})
             };
         }
-        if (!sessions && !changes && files === undefined)
+        if (!sessions && !changes && files === undefined && sessionNavigation === undefined)
             throw new Error('WORKSPACE_WATCH_INVALID');
-        return { sessions, changes, files, ...(sessionGroup === undefined ? {} : { sessionGroup }) };
+        return {
+            sessions,
+            changes,
+            files,
+            ...(sessionGroup === undefined ? {} : { sessionGroup }),
+            ...(sessionNavigation === undefined ? {} : { sessionNavigation })
+        };
     }
     key(input) {
         return `${this.sessionHash(input)}:${this.connectionId(input)}`;
@@ -81,10 +96,11 @@ export class WorkspaceWatchService {
         if (previous !== undefined) {
             clearTimeout(previous.timer);
             this.onWatchRemoved(previous);
-            if (previous.topics.sessions && !this.topicActive(workspaceId, 'sessions'))
+            if ((previous.topics.sessions || previous.topics.sessionNavigation !== undefined) &&
+                !this.topicActive(workspaceId, 'sessions'))
                 this.onSessionWatchUnused(workspaceId);
         }
-        if (topics.sessions)
+        if (topics.sessions || topics.sessionNavigation !== undefined)
             this.onSessionWatchRequired(workspaceId);
         return watch;
     }
@@ -167,7 +183,11 @@ export class WorkspaceWatchService {
         return this.watchSnapshotSequence;
     }
     topicActive(workspaceId, topic) {
-        return [...(this.watches.get(workspaceId)?.values() ?? [])].some((watch) => topic === 'files' ? watch.topics.files !== undefined : watch.topics[topic]);
+        return [...(this.watches.get(workspaceId)?.values() ?? [])].some((watch) => topic === 'files'
+            ? watch.topics.files !== undefined
+            : topic === 'sessions'
+                ? watch.topics.sessions || watch.topics.sessionNavigation !== undefined
+                : watch.topics[topic]);
     }
     activeWatches(workspaceId) {
         return [...(this.watches.get(workspaceId)?.values() ?? [])].filter((watch) => watch.expiresAt > Date.now());

package/dist/workspace/workspace-watch-snapshot-service.js

@@ -20,7 +20,9 @@ export class WorkspaceWatchSnapshotService {
         await Promise.all(this.subscribedTopics(watch).map(async (topic) => {
             const revision = this.readRevision(workspace.id, topic);
             try {
-                const retained = topic === 'sessions' || previous === undefined
+                const retained = topic === 'sessionNavigation' ||
+                    previous === undefined ||
+                    (topic === 'sessions' && previous.topics.sessionGroup !== watch.topics.sessionGroup)
                     ? undefined
                     : this.resourceSnapshots.get(previous)?.[topic];
                 const payload = retained !== undefined &&
@@ -35,7 +37,8 @@ export class WorkspaceWatchSnapshotService {
                     void this.invalidate(workspace.id, topic);
                     return;
                 }
-                this.signatures.set(this.viewKey(workspace.id, topic, watch), signature(payload));
+                if (topic !== 'sessionNavigation')
+                    this.signatures.set(this.viewKey(workspace.id, topic, watch), signature(payload));
                 this.deliver(workspace, watch, topic, payload);
             }
             catch {
@@ -64,6 +67,8 @@ export class WorkspaceWatchSnapshotService {
         this.filePrewarmTimers.delete(watch);
     }
     async invalidate(workspaceId, topic) {
+        if (topic === 'sessions')
+            void this.invalidate(workspaceId, 'sessionNavigation');
         const key = `${workspaceId}:${topic}`;
         const active = this.refreshes.get(key);
         if (active !== undefined) {
@@ -134,6 +139,18 @@ export class WorkspaceWatchSnapshotService {
         const subscribers = this.subscribers(workspaceId, topic);
         if (subscribers.length === 0)
             return;
+        if (topic === 'sessionNavigation') {
+            await Promise.all(subscribers.map(async (watch) => {
+                try {
+                    const payload = await this.read(workspace, topic, watch);
+                    this.deliver(workspace, watch, topic, payload);
+                }
+                catch {
+                    this.fail(workspaceId, watch, topic);
+                }
+            }));
+            return;
+        }
         if (topic === 'changes') {
             const first = subscribers[0];
             if (first === undefined)
@@ -191,23 +208,28 @@ export class WorkspaceWatchSnapshotService {
         }));
     }
     read(workspace, topic, watch) {
-        const key = topic === 'files'
-            ? `${workspace.id}:files:${JSON.stringify(watch.topics.files)}`
-            : `${workspace.id}:${topic}:${watch.topics.sessionGroup ?? 'ALL'}:${this.readRevision(workspace.id, topic)}`;
+        const key = topic === 'sessionNavigation'
+            ? `${workspace.id}:sessionNavigation:${watch.watchId}`
+            : topic === 'files'
+                ? `${workspace.id}:files:${JSON.stringify(watch.topics.files)}`
+                : `${workspace.id}:${topic}:${watch.topics.sessionGroup ?? 'ALL'}:${this.readRevision(workspace.id, topic)}`;
         const active = this.reads.get(key);
         if (active !== undefined)
             return active;
-        const read = (topic === 'sessions'
-            ? this.options.listSessions(workspace.id, watch.topics.sessionGroup)
-            : topic === 'changes'
-                ? workspace.kind === 'GIT_WORKSPACE'
-                    ? this.options.changes.current(workspace)
-                    : Promise.resolve(workspace.includeParentRepository === false
-                        ? { workspace, changes: [], repositories: [] }
-                        : null)
-                : this.options.files
-                    .list(workspace, watch.topics.files)
-                    .then((files) => ({ files, workspace: this.options.requireWorkspace(workspace.id) }))).finally(() => {
+        const read = (topic === 'sessionNavigation'
+            ? this.options.sessionNavigation(workspace.id, watch.topics.sessionNavigation)
+            : topic === 'sessions'
+                ? this.options.listSessions(workspace.id, watch.topics.sessionGroup)
+                : topic === 'changes'
+                    ? workspace.kind === 'GIT_WORKSPACE'
+                        ? this.options.changes.current(workspace)
+                        : Promise.resolve(workspace.includeParentRepository === false
+                            ? { workspace, changes: [], repositories: [] }
+                            : null)
+                    : this.options.files.list(workspace, watch.topics.files).then((files) => ({
+                        files,
+                        workspace: this.options.requireWorkspace(workspace.id)
+                    }))).finally(() => {
             if (this.reads.get(key) === read)
                 this.reads.delete(key);
         });
@@ -225,9 +247,11 @@ export class WorkspaceWatchSnapshotService {
         return topic === 'changes' ? this.options.changes.revision(workspaceId) : 0;
     }
     viewKey(workspaceId, topic, watch) {
-        return topic === 'files'
-            ? `${workspaceId}:files:${JSON.stringify(watch.topics.files)}`
-            : `${workspaceId}:${topic}:${watch.topics.sessionGroup ?? 'ALL'}`;
+        return topic === 'sessionNavigation'
+            ? `${workspaceId}:sessionNavigation:${watch.sessionHash}:${watch.workbenchConnectionId}`
+            : topic === 'files'
+                ? `${workspaceId}:files:${JSON.stringify(watch.topics.files)}`
+                : `${workspaceId}:${topic}:${watch.topics.sessionGroup ?? 'ALL'}`;
     }
     readActive(workspaceId, topic, watch) {
         if (topic === 'files' && watch !== undefined)
@@ -238,11 +262,16 @@ export class WorkspaceWatchSnapshotService {
     subscribers(workspaceId, topic) {
         return this.options.watch
             .activeWatches(workspaceId)
-            .filter((watch) => topic === 'files' ? watch.topics.files !== undefined : watch.topics[topic]);
+            .filter((watch) => topic === 'files'
+            ? watch.topics.files !== undefined
+            : topic === 'sessionNavigation'
+                ? watch.topics.sessionNavigation !== undefined
+                : watch.topics[topic]);
     }
     subscribedTopics(watch) {
         return [
             ...(watch.topics.sessions ? ['sessions'] : []),
+            ...(watch.topics.sessionNavigation === undefined ? [] : ['sessionNavigation']),
             ...(watch.topics.files === undefined ? [] : ['files']),
             ...(watch.topics.changes ? ['changes'] : [])
         ];
@@ -250,7 +279,7 @@ export class WorkspaceWatchSnapshotService {
     deliver(workspace, watch, topic, payload) {
         if (!this.matches(workspace.id, watch))
             return;
-        if (topic !== 'sessions') {
+        if (topic !== 'sessionNavigation') {
             const snapshots = this.resourceSnapshots.get(watch) ?? {};
             snapshots[topic] = { payload, revision: this.readRevision(workspace.id, topic) };
             this.resourceSnapshots.set(watch, snapshots);
@@ -272,7 +301,7 @@ export class WorkspaceWatchSnapshotService {
     fail(workspaceId, watch, topic) {
         if (!this.matches(workspaceId, watch))
             return;
-        if (topic !== 'sessions') {
+        if (topic !== 'sessionNavigation') {
             const snapshots = this.resourceSnapshots.get(watch);
             if (snapshots !== undefined)
                 delete snapshots[topic];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.11.68",
+  "version": "0.11.70",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -40,10 +40,10 @@
     "turndown-plugin-gfm": "^1.0.2",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.11.68",
+    "@myagentroam/agent": "0.11.70",
     "@myagentroam/code-navigation": "0.11.1",
-    "@myagentroam/marctl": "0.11.12",
-    "@myagentroam/protocol": "0.11.68"
+    "@myagentroam/protocol": "0.11.70",
+    "@myagentroam/marctl": "0.11.12"
   },
   "devDependencies": {
     "@types/turndown": "^5.0.6",