@myagentroam/node 0.9.134 → 0.9.136

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

@@ -1,7 +1,9 @@
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { getDefaultEnvironment, StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { ToolListChangedNotificationSchema } from '@modelcontextprotocol/sdk/types.js';
+import { assertMcpToolDefinition, assertMcpToolCatalog, MarAgentError } from '@myagentroam/agent';
 import { ExecutorStdioClientTransport } from './executor-stdio-client-transport.js';
 export class MarAgentMcpClientCache {
     #entries = new Map();
@@ -21,16 +23,16 @@ export class MarAgentMcpClientCache {
             const pool = await MarAgentMcpClientPool.connect(servers, cwd, options);
             return singleUseLease(pool);
         }
-        const key = mcpConfigurationFingerprint(servers, cwd);
+        const key = mcpConfigurationFingerprint(servers, cwd, options.authorizationScope);
         let entry = this.#entries.get(key);
         if (entry === undefined) {
             await this.#evictIdleEntry();
             if (this.#entries.size >= this.#maxEntries) {
-                const pool = await MarAgentMcpClientPool.connect(servers, cwd);
+                const pool = await MarAgentMcpClientPool.connect(servers, cwd, options);
                 return singleUseLease(pool);
             }
             entry = {
-                promise: MarAgentMcpClientPool.connect(servers, cwd),
+                promise: MarAgentMcpClientPool.connect(servers, cwd, options),
                 references: 0,
                 lastReleasedAt: 0
             };
@@ -103,37 +105,87 @@ export class MarAgentMcpClientCache {
         await (await entry.promise).close().catch(() => undefined);
     }
 }
+export const MCP_CATALOG_LIMITS = Object.freeze({
+    httpConcurrency: 4,
+    retryMs: 30_000,
+    timeoutMs: 30_000,
+    maximumPages: 256,
+    maximumTools: 10_000,
+    maximumBytes: 16 * 1024 * 1024
+});
 export class MarAgentMcpClientPool {
+    #unknownPrincipal = randomUUID();
     #clients = [];
+    #servers = new Map();
     #tools = new Map();
+    #snapshot = { revision: '', servers: [], tools: [] };
+    #controller = new AbortController();
+    #closed = false;
+    #ready = false;
+    #initialCatalogAvailable = true;
+    #httpRefreshActive = 0;
+    #httpWaiters = [];
     static async connect(servers, cwd, options = {}) {
         const pool = new MarAgentMcpClientPool();
-        try {
-            for (const server of servers)
+        const http = servers.filter((server) => server.transport === 'HTTP');
+        let next = 0;
+        const jobs = Array.from({ length: Math.min(MCP_CATALOG_LIMITS.httpConcurrency, http.length) }, async () => {
+            while (next < http.length)
+                await pool.#connect(http[next++], cwd, options);
+        });
+        jobs.push((async () => {
+            for (const server of servers.filter((server) => server.transport === 'STDIO'))
                 await pool.#connect(server, cwd, options);
+        })());
+        try {
+            await Promise.all(jobs);
+            pool.#publish();
+            pool.#ready = true;
+            for (const state of pool.#servers.values())
+                if (state.dirty)
+                    void pool.#refresh(state).catch(() => undefined);
             return pool;
         }
         catch (error) {
+            pool.#controller.abort();
+            await Promise.allSettled(jobs);
             await pool.close();
             throw error;
         }
     }
     definitions() {
-        return [...this.#tools].map(([name, binding]) => ({
-            name,
-            description: binding.description,
-            inputSchema: binding.inputSchema
-        }));
+        return this.#snapshot.tools.map((tool) => tool.definition);
+    }
+    catalog() {
+        return this.#snapshot;
     }
-    async call(name, arguments_) {
+    async refreshForExecution() {
+        if (this.#initialCatalogAvailable) {
+            this.#initialCatalogAvailable = false;
+            await Promise.all([...this.#servers.values()].flatMap((state) => state.refreshing ? [state.refreshing.catch(() => undefined)] : []));
+            return;
+        }
+        await Promise.all([...this.#servers.values()].map((state) => this.#refresh(state).catch(() => undefined)));
+    }
+    async call(name, arguments_, signal, expectedTool) {
         const binding = this.#tools.get(name);
-        if (!binding)
-            throw new Error('MAR_AGENT_MCP_TOOL_NOT_FOUND');
+        if (!binding || this.#closed)
+            throw new MarAgentError('MAR_AGENT_MCP_TOOL_NOT_FOUND', 'MCP tool is no longer available.');
+        if (expectedTool &&
+            (binding.metadata.sourceIdentity !== expectedTool.sourceIdentity ||
+                binding.metadata.definitionRevision !== expectedTool.definitionRevision))
+            throw new MarAgentError('MAR_AGENT_MCP_TOOL_DEFINITION_CHANGED', 'MCP tool binding or definition changed.');
+        signal?.throwIfAborted();
         const result = await binding.client.callTool({
             name: binding.nativeName,
             arguments: arguments_ !== null && typeof arguments_ === 'object' && !Array.isArray(arguments_)
                 ? arguments_
                 : {}
+        }, undefined, {
+            timeout: MCP_CATALOG_LIMITS.timeoutMs,
+            signal: signal
+                ? AbortSignal.any([signal, this.#controller.signal])
+                : this.#controller.signal
         });
         const items = Array.isArray(result.content) ? result.content : [];
         const content = items
@@ -149,12 +201,156 @@ export class MarAgentMcpClientPool {
         return { content, data: result.structuredContent ?? items };
     }
     async close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#controller.abort();
+        await Promise.allSettled([...this.#servers.values()].flatMap((state) => (state.refreshing ? [state.refreshing] : [])));
         await Promise.all(this.#clients.map((client) => client.close().catch(() => undefined)));
         this.#clients.length = 0;
+        this.#servers.clear();
         this.#tools.clear();
+        this.#snapshot = { revision: '', servers: [], tools: [] };
+    }
+    #publish(replacement) {
+        const combined = new Map();
+        for (const state of this.#servers.values())
+            for (const [name, binding] of replacement?.state === state
+                ? replacement.tools
+                : state.tools) {
+                if (combined.has(name))
+                    throw new Error('MAR_AGENT_MCP_TOOL_NAME_CONFLICT');
+                combined.set(name, binding);
+            }
+        const tools = [...combined]
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([, binding]) => binding.metadata);
+        const servers = [...this.#servers.values()]
+            .map((state) => state.metadata)
+            .sort((a, b) => a.id.localeCompare(b.id));
+        const revision = fingerprint({ servers, tools });
+        assertMcpToolCatalog({ revision, servers, tools });
+        if (replacement)
+            replacement.state.tools = replacement.tools;
+        this.#tools = combined;
+        if (revision !== this.#snapshot.revision)
+            this.#snapshot = { revision, servers, tools };
+    }
+    #refresh(state) {
+        if (state.refreshing)
+            return state.refreshing;
+        if (this.#closed || Date.now() < state.retryAt)
+            return Promise.resolve();
+        const job = (async () => {
+            do {
+                state.dirty = false;
+                const tools = await this.#enumerate(state);
+                if (this.#closed)
+                    return;
+                this.#publish({ state, tools });
+                state.retryAt = 0;
+            } while (state.dirty && !this.#closed);
+        })()
+            .catch((error) => {
+            state.retryAt = Date.now() + MCP_CATALOG_LIMITS.retryMs;
+            throw error;
+        })
+            .finally(() => {
+            delete state.refreshing;
+        });
+        state.refreshing = job;
+        return job;
+    }
+    async #enumerate(state) {
+        if (state.server.transport !== 'HTTP')
+            return this.#enumeratePages(state);
+        if (this.#httpRefreshActive < MCP_CATALOG_LIMITS.httpConcurrency)
+            this.#httpRefreshActive++;
+        else
+            await new Promise((resolve) => this.#httpWaiters.push(resolve));
+        try {
+            this.#controller.signal.throwIfAborted();
+            return await this.#enumeratePages(state);
+        }
+        finally {
+            const next = this.#httpWaiters.shift();
+            if (next)
+                next();
+            else
+                this.#httpRefreshActive--;
+        }
+    }
+    async #enumeratePages(state) {
+        const tools = new Map();
+        const cursors = new Set();
+        let cursor;
+        let bytes = 0;
+        for (let page = 0; page < MCP_CATALOG_LIMITS.maximumPages; page++) {
+            const listed = await state.client.listTools(cursor === undefined ? {} : { cursor }, {
+                signal: this.#controller.signal,
+                timeout: MCP_CATALOG_LIMITS.timeoutMs
+            });
+            bytes += Buffer.byteLength(JSON.stringify(listed));
+            if (bytes > MCP_CATALOG_LIMITS.maximumBytes)
+                throw new Error('MAR_AGENT_MCP_CATALOG_LIMIT');
+            for (const tool of listed.tools) {
+                const name = `mcp__${safeName(state.server.name)}__${safeName(tool.name)}`;
+                if (tools.has(name))
+                    throw new Error('MAR_AGENT_MCP_TOOL_NAME_CONFLICT');
+                const definition = {
+                    name,
+                    description: tool.description ?? `MCP tool ${tool.name}.`,
+                    allowedCallers: [
+                        ...(state.server.allowedToolCallers?.[tool.name] ??
+                            (state.server.origin === 'BUILTIN' ? ['direct'] : ['direct', 'programmatic']))
+                    ],
+                    inputSchema: tool.inputSchema,
+                    ...(tool.outputSchema
+                        ? { outputSchema: tool.outputSchema }
+                        : {})
+                };
+                assertMcpToolDefinition(definition);
+                const metadata = {
+                    definition,
+                    serverId: state.metadata.id,
+                    rawName: tool.name,
+                    sourceIdentity: state.sourceIdentity,
+                    definitionRevision: fingerprint(definition),
+                    lifetime: state.server.lifecycle === 'EXECUTION' ? 'execution' : 'session',
+                    exposure: state.server.origin === 'BUILTIN' ? 'direct' : 'deferred',
+                    ...(tool.annotations ? { annotations: tool.annotations } : {})
+                };
+                tools.set(name, {
+                    client: state.client,
+                    nativeName: tool.name,
+                    metadata
+                });
+                if (tools.size > MCP_CATALOG_LIMITS.maximumTools)
+                    throw new Error('MAR_AGENT_MCP_CATALOG_LIMIT');
+            }
+            cursor = listed.nextCursor;
+            if (cursor === undefined)
+                return tools;
+            if (cursors.has(cursor))
+                throw new Error('MAR_AGENT_MCP_CATALOG_CURSOR_INVALID');
+            cursors.add(cursor);
+        }
+        throw new Error('MAR_AGENT_MCP_CATALOG_LIMIT');
     }
     async #connect(server, cwd, options) {
         const client = new Client({ name: 'maragent', version: '1.0.0' });
+        this.#clients.push(client);
+        let state;
+        let initialDirty = false;
+        client.setNotificationHandler(ToolListChangedNotificationSchema, () => {
+            if (!state) {
+                initialDirty = true;
+                return;
+            }
+            state.dirty = true;
+            if (this.#ready)
+                void this.#refresh(state).catch(() => undefined);
+        });
         const environment = { ...getDefaultEnvironment(), ...(server.environment ?? {}) };
         const transport = server.transport === 'STDIO'
             ? options.processExecutor === undefined
@@ -177,22 +373,49 @@ export class MarAgentMcpClientPool {
             : new StreamableHTTPClientTransport(new URL(server.url), {
                 requestInit: { headers: { ...(server.headers ?? {}) } }
             });
-        await client.connect(transport);
-        this.#clients.push(client);
-        const listed = await client.listTools();
-        for (const tool of listed.tools) {
-            const name = `mcp__${safeName(server.name)}__${safeName(tool.name)}`;
-            if (this.#tools.has(name))
-                throw new Error('MAR_AGENT_MCP_TOOL_NAME_CONFLICT');
-            this.#tools.set(name, {
-                client,
-                nativeName: tool.name,
-                description: tool.description ?? `MCP tool ${tool.name}.`,
-                inputSchema: tool.inputSchema
-            });
-        }
+        await client.connect(transport, {
+            signal: this.#controller.signal,
+            timeout: MCP_CATALOG_LIMITS.timeoutMs
+        });
+        const sourceIdentity = fingerprint({
+            source: server.sourceIdentity ?? {
+                name: server.name,
+                transport: server.transport,
+                url: server.url,
+                command: server.command,
+                args: server.args
+            },
+            cwd,
+            allowedToolCallers: server.allowedToolCallers,
+            authorizationScope: options.authorizationScope ?? cwd,
+            principal: server.authorizationIdentity ?? this.#unknownPrincipal
+        });
+        const version = client.getServerVersion();
+        state = {
+            server,
+            client,
+            sourceIdentity,
+            retryAt: 0,
+            dirty: initialDirty,
+            tools: new Map(),
+            metadata: {
+                id: sourceIdentity,
+                name: server.name,
+                ...(version?.title ? { description: version.title } : {}),
+                ...(client.getInstructions() ? { instructions: client.getInstructions() } : {})
+            }
+        };
+        state.tools = await this.#enumerate(state);
+        if (this.#servers.has(state.metadata.id))
+            throw new Error('MAR_AGENT_MCP_SERVER_NAME_CONFLICT');
+        this.#servers.set(state.metadata.id, state);
     }
 }
+function fingerprint(value) {
+    return createHash('sha256')
+        .update(JSON.stringify(canonicalValue(value)))
+        .digest('hex');
+}
 function singleUseLease(pool) {
     let released = false;
     return {
@@ -205,10 +428,11 @@ function singleUseLease(pool) {
         }
     };
 }
-function mcpConfigurationFingerprint(servers, cwd) {
+function mcpConfigurationFingerprint(servers, cwd, authorizationScope) {
     return createHash('sha256')
         .update(JSON.stringify(canonicalValue({
         cwd,
+        authorizationScope,
         inheritedEnvironment: getDefaultEnvironment(),
         servers
     })))

package/dist/runner/mar-agent/runtime-model-factory.js

@@ -65,7 +65,12 @@ export class MarAgentRuntimeModelFactory {
                     titleGeneration: configuration.titleGeneration,
                     codeMode: configuration.codeMode,
                     highDensityCompaction: configuration.highDensityCompaction,
-                    ...(configuration.fastMode === true ? { fastMode: true } : {}),
+                    ...(configuration.serviceTier === undefined
+                        ? {}
+                        : { serviceTier: configuration.serviceTier }),
+                    ...(configuration.serviceTier === undefined && configuration.fastMode === true
+                        ? { fastMode: true }
+                        : {}),
                     hostedWebSearch: configuration.hostedWebSearch,
                     ...(imageGeneration === undefined ? {} : { imageGeneration }),
                     ...(configuration.responsesTransport === undefined
@@ -110,7 +115,7 @@ export class MarAgentRuntimeModelFactory {
                         }
                         : {}),
                     responsesEncoding: configuration.responsesEncoding ?? 'STANDARD',
-                    codexCredential: true,
+                    responsesConfigurationUpdates: configuration.responsesConfigurationUpdates === true,
                     credentialProvider: provider
                 };
             });

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

@@ -296,6 +296,9 @@ export class MarAgentRunner extends AbstractRunner {
             await catalog.close().catch(() => undefined);
         }
     }
+    supportsRollback(session) {
+        return session.externalSessionId !== null;
+    }
     async clearNative(session) {
         if (session.externalSessionId === null)
             throw new Error('SESSION_CLEAR_UNAVAILABLE');

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

@@ -116,7 +116,8 @@ export class OpenCodeManagedRunController {
             mcpSecretEnvironment = parseSecretEnvironment(payload.mcpSecretEnvironment);
             mcp = this.runner.mcpConfiguration(payload.mcpInstallations, {
                 ...environment,
-                ...mcpSecretEnvironment
+                ...mcpSecretEnvironment,
+                MAR_USERNAME: environment['MAR_USERNAME'] ?? ''
             });
             attachments = this.host.parseAttachments(payload.attachments);
         }

package/dist/runtime-state.js

@@ -79,8 +79,8 @@ export class NodeRuntimeState {
             // A first user prompt is only a process-local temporary title. A
             // Runner/native title can replace it on the next discovery refresh.
             titleSource: customTitle === null ? 'AUTO' : 'CUSTOM',
-            lastActivityAt: now,
-            createdAt: now
+            lastActivityAt: input.lastActivityAt ?? now,
+            createdAt: input.createdAt ?? now
         };
         this.sessions.set(value.id, value);
         return value;

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

@@ -384,8 +384,10 @@ export class ContinuousRunCoordinator {
         if (lease !== undefined)
             this.environmentLeases.set(nextId, lease);
     }
-    removeGoalQueue(sessionId, preservedGoal) {
+    removeGoalQueue(sessionId, preservedGoal, preservedSubmissionId) {
         for (const [id, pending] of this.preparedInputs) {
+            if (id === preservedSubmissionId)
+                continue;
             if (pending.sessionId !== sessionId || pending.goal === undefined)
                 continue;
             if (pending.goal.id === preservedGoal?.id && pending.goal.revision === preservedGoal.revision)

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

@@ -1,5 +1,4 @@
 import { discoverNativeSessions, readNativeSession } from '../native-session-history.js';
-import { coalesceImageGenerationItems } from '../runner/codex/conversation-parser.js';
 import { nativeConversationPage } from '../util/runner-native-session-parsers.js';
 import { isPlainRecord } from '../util/node-operation-parsers.js';
 import { nodeLog } from '../operational.js';
@@ -152,7 +151,28 @@ export class ConversationHistoryService {
                 0);
     }
     async readHistory(session, input, snapshotSequence, readAt) {
-        const selected = await this.readRunnerHistory(session, input);
+        let selected;
+        try {
+            selected = await this.readRunnerHistory(session, input);
+        }
+        catch (error) {
+            // An unavailable persistent source must not erase accepted live output.
+            // Older-page and external-session errors remain visible to the caller.
+            if (input.cursor !== undefined ||
+                this.options.runtime.getAgentSession(session.id) === undefined)
+                throw error;
+            const runtimePage = this.options.runtime.listConversationTurns({
+                sessionId: session.id,
+                ...input
+            });
+            if (runtimePage.turns.length === 0)
+                throw error;
+            return this.page(runtimePage.nextCursor, runtimePage.turns, {
+                snapshotSequence,
+                source: 'runtime',
+                readAt
+            });
+        }
         if (selected.page?.source === 'native')
             return this.page(selected.page.nextCursor, selected.page.turns, {
                 snapshotSequence,
@@ -179,7 +199,7 @@ export class ConversationHistoryService {
                 if (narrowed !== undefined)
                     official = { ...narrowed, source: 'official' };
             }
-            const officialTurns = await this.attachNativeImages(session, official.turns);
+            const officialTurns = official.turns;
             const runtimeTurnsByOfficialId = new Map();
             const runtimeSupplementalItemsByOfficialId = new Map();
             for (const officialTurn of officialTurns) {
@@ -261,7 +281,9 @@ export class ConversationHistoryService {
                 readAt
             });
         }
-        const page = this.options.runtime.listConversationTurns({ sessionId: session.id, ...input });
+        const page = this.options.runtime.getAgentSession(session.id) === undefined
+            ? { turns: [], nextCursor: null }
+            : this.options.runtime.listConversationTurns({ sessionId: session.id, ...input });
         if (session.externalSessionId !== null &&
             session.nativeControl === 'EXTERNAL' &&
             page.turns.length === 0)
@@ -308,6 +330,7 @@ export class ConversationHistoryService {
                     : input, runtimeTurns, (images) => this.options.attachments.registerNative(session, images));
                 return native;
             },
+            session,
             official: () => this.readOfficial(session, input)
         });
         return { page, incompleteNative };
@@ -327,9 +350,7 @@ export class ConversationHistoryService {
             const history = selected.page;
             if (history === undefined)
                 return this.page(null, [], { snapshotSequence, source: 'runtime', readAt });
-            const hydratedTurns = history.source === 'official'
-                ? await this.attachNativeImages(session, history.turns)
-                : history.turns;
+            const hydratedTurns = history.turns;
             const turns = hydratedTurns.filter((turn) => latestTurnActivityAt(turn) < beforeAt);
             return this.page(history.nextCursor === null
                 ? null
@@ -421,45 +442,13 @@ export class ConversationHistoryService {
         await discoverNativeSessions(session.runner, session.cwd);
         return readNativeSession(session.runner, session.cwd, session.externalSessionId, page, limit);
     }
-    async attachNativeImages(session, turns) {
-        const startedAt = performance.now();
-        const history = await this.readNative(session);
-        const readDurationMs = Math.round(performance.now() - startedAt);
-        if (readDurationMs >= 250)
-            nodeLog('native.session.history.attachment-source-read.completed', {
-                runner: session.runner,
-                sessionId: session.id,
-                durationMs: readDurationMs
-            });
-        if (history === undefined)
-            return turns;
-        const attachments = new Map();
-        for (const item of history.items) {
-            if (item.kind !== 'tool_call' || item.imageAttachments === undefined)
-                continue;
-            const registered = this.options.attachments.registerNative(session, item.imageAttachments);
-            if (registered.length > 0)
-                attachments.set(item.toolUseId, registered);
-        }
-        if (attachments.size === 0)
-            return turns;
-        return turns.map((turn) => ({
-            ...turn,
-            items: coalesceImageGenerationItems(turn.items.map((item) => {
-                const registered = attachments.get(item.id.slice(item.id.lastIndexOf(':') + 1));
-                if (registered === undefined || !isPlainRecord(item.payload))
-                    return item;
-                return { ...item, payload: { ...item.payload, attachments: registered } };
-            }))
-        }));
-    }
     async readOfficial(session, input) {
         const runner = this.options.runners.require(session.runner);
         if (session.externalSessionId === null || !runner.available(this.options.capabilities()))
             return undefined;
         const startedAt = performance.now();
         try {
-            return await runner.readOfficialConversation(session, input, (nativeTurnId) => this.managedRunnerTurn(session, nativeTurnId));
+            return await runner.readOfficialConversation(session, input, (nativeTurnId) => this.managedRunnerTurn(session, nativeTurnId), (images) => this.options.attachments.registerNative(session, images));
         }
         finally {
             const durationMs = Math.round(performance.now() - startedAt);

package/dist/service/external-session-resume-service.js

@@ -63,6 +63,8 @@ export class ExternalSessionResumeService {
                             : { externalSessionId: session.externalSessionId }),
                         nativeControl: 'MAR_MANAGED',
                         cwd: session.cwd,
+                        createdAt: session.createdAt,
+                        lastActivityAt: session.lastActivityAt,
                         model: configuration.model,
                         effort: configuration.effort,
                         access: configuration.access,

package/dist/service/hosted-conversation-node-service.js

@@ -519,7 +519,7 @@ export class HostedConversationNodeService {
             temporaryDirectory,
             pathMounts,
             processExecutor: this.processExecutor(paths, version, temporaryDirectory, generatedImagesDirectory, generatedImagesLogicalPath),
-            mcpServers: mcpServers ?? resolveMcpServers(version, this.options.secretEnvironment ?? process.env),
+            mcpServers: (mcpServers ?? resolveMcpServers(version, this.options.secretEnvironment ?? process.env)).map((server) => ({ ...server, authorizationIdentity: `user:${payload.userId}` })),
             webAccess: version.draft.networkMode !== 'NONE',
             onEvent: (event) => {
                 if (runtimeEventsAccepted)

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

@@ -98,6 +98,8 @@ export class NativeSessionProjectionService {
             externalSessionId: direct.externalSessionId,
             nativeControl: 'EXTERNAL',
             cwd: direct.cwd,
+            createdAt: direct.createdAt,
+            lastActivityAt: direct.lastActivityAt,
             ...(direct.model === null ? {} : { model: direct.model }),
             ...(direct.effort === null ? {} : { effort: direct.effort }),
             ...(direct.access === null ? {} : { access: direct.access }),

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

@@ -155,8 +155,13 @@ export class NativeSessionWatchService {
             setTimeout(() => void this.convergeHistory(watch, generation), 0);
         }
         for (const lease of leases) {
-            if (!lease.ready)
-                lease.pendingEvents.push(event);
+            if (!lease.ready) {
+                // Observations are useful only to an already watching page, never after a snapshot.
+                if (event.category !== 'conversation' ||
+                    !isPlainRecord(event.payload) ||
+                    event.payload.performance === undefined)
+                    lease.pendingEvents.push(event);
+            }
             else
                 this.emitLeaseEvent(lease, event);
         }
@@ -301,8 +306,12 @@ export class NativeSessionWatchService {
             if (changed || watch.page === undefined)
                 watch.page = accepted;
             stage = 'emit_page';
-            if (completingConvergence && accepted.source === 'runtime')
-                this.releasePendingEvents(session.id);
+            if (completingConvergence && accepted.source === 'runtime') {
+                if (changed)
+                    this.emitSnapshotToLeases(session, accepted, true);
+                else
+                    this.releasePendingEvents(session.id);
+            }
             else if (completingConvergence)
                 this.emitSnapshotToLeases(session, accepted, true);
             else if (changed)

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

@@ -1,3 +1,4 @@
+import { runPerformanceSchema } from '@myagentroam/protocol';
 import { nodeLog } from '../operational.js';
 import { isPlainRecord, isTerminalRunStatus } from '../util/node-operation-parsers.js';
 const COALESCE_MS = 200;
@@ -9,6 +10,18 @@ export class RunEventService {
         this.options = options;
     }
     emit(runId, eventType, payload, status) {
+        if (eventType === 'run.performance') {
+            const run = this.options.runtime.getRun(runId);
+            if (run === undefined || !isPlainRecord(payload))
+                return;
+            const parsed = runPerformanceSchema.safeParse({ ...payload, runId: run.id });
+            if (parsed.success)
+                this.options.emitWorkbench('conversation', {
+                    sessionId: run.sessionId,
+                    performance: parsed.data
+                });
+            return;
+        }
         if (eventType === 'text.delta' &&
             status === undefined &&
             isPlainRecord(payload) &&

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

@@ -115,7 +115,8 @@ export class SessionCatalogService {
             (await this.options.projection.resolve(input.sessionId));
         if (source === undefined)
             throw new Error('SESSION_NOT_FOUND');
-        if (source.runner !== 'mar-agent' || source.externalSessionId === null)
+        const runner = this.options.runners.require(source.runner);
+        if (!runner.supportsRollback(source))
             throw new Error('SESSION_ROLLBACK_UNAVAILABLE');
         if (this.options.runtime
             .listRunsForSession(source.id)
@@ -132,9 +133,7 @@ export class SessionCatalogService {
             throw new Error('SESSION_ROLLBACK_TARGET_INVALID');
         const releaseMutation = this.options.runtime.beginSessionHistoryMutation(source.id);
         try {
-            const lastActivityAt = await this.options.runners
-                .require(source.runner)
-                .rollbackNative(source, input.boundary);
+            const lastActivityAt = await runner.rollbackNative(source, input.boundary, turn.rewind?.after);
             const runtimeSession = this.options.runtime.getAgentSession(source.id);
             const session = runtimeSession === undefined
                 ? { ...source, lastActivityAt }