@myagentroam/node 0.11.25 → 0.11.26

package/dist/codex-app-server.js

@@ -235,8 +235,8 @@ export class CodexAppServerClient {
             ...codexThreadConfiguration(cwd, configuration)
         });
     }
-    listThreads() {
-        return this.request('thread/list', {});
+    listThreads(params = {}) {
+        return this.request('thread/list', params);
     }
     readThread(threadId) {
         return this.request('thread/read', { threadId, includeTurns: false });

package/dist/connector.js

@@ -1079,7 +1079,7 @@ export class NodeConnector {
             cachedNative: () => [...this.sessionState.directNative.values()],
             cachedWorkspace: (workspaceId) => this.workspaceCoordinator.cachedSessions(workspaceId),
             discoveryPending: (workspaceId) => this.workspaceSessionService.discoveryPending(workspaceId),
-            discoverWorkspace: (workspaceId) => this.nativeSessionProjectionService.discoverWorkspace(workspaceId),
+            discoverWorkspace: (workspaceId, cleanup) => this.nativeSessionProjectionService.discoverWorkspace(workspaceId, undefined, cleanup),
             present: (session) => this.sessionPresentationService.present(session),
             nativeIds: (session) => this.nativeSessionProjectionService.nativeIds(session),
             forget: (session, nativeIds) => {

package/dist/runner/abstract-runner.js

@@ -76,10 +76,6 @@ export class AbstractRunner {
             ...(input.pinned === undefined ? {} : { pinned: input.pinned })
         });
     }
-    async isNativeSessionMissing(session) {
-        void session;
-        return false;
-    }
     async removeNative(session, nativeSessionId) {
         void [session, nativeSessionId];
         return false;
@@ -92,8 +88,8 @@ export class AbstractRunner {
         void session;
         return false;
     }
-    async rollbackNative(session, boundary, targetTurnBoundary) {
-        void [session, boundary, targetTurnBoundary];
+    async rollbackNative(session, boundary, targetTurnBoundary, targetClientMessageId) {
+        void [session, boundary, targetTurnBoundary, targetClientMessageId];
         throw new RunnerCapabilityError(this.name, 'session.rollback');
     }
     async clearNative(session) {

package/dist/runner/claude-code-runner.js

@@ -128,7 +128,9 @@ export class ClaudeCodeRunner extends AbstractRunner {
             try {
                 official = await this.listSessions(target.path);
             }
-            catch {
+            catch (error) {
+                if (context.cleanup)
+                    throw error;
                 // Native transcripts remain authoritative when SDK listing is unavailable.
             }
             const native = await discoverNativeSessions(this.name, target.path);

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

@@ -1376,7 +1376,17 @@ export function extractCodexThreads(result) {
         const preview = typeof value.preview === 'string' ? value.preview.trim() : '';
         const title = name || preview || undefined;
         const titleOrigin = name ? 'OFFICIAL' : preview ? 'PREVIEW' : undefined;
-        return [{ id: value.id, source, derived, cwd: value.cwd, title, titleOrigin }];
+        return [
+            {
+                id: value.id,
+                source,
+                derived,
+                cwd: value.cwd,
+                title,
+                titleOrigin,
+                lastActivityAt: codexTimestamp(value.updatedAt) ?? 0
+            }
+        ];
     });
 }
 export function codexThreadCwd(value) {

package/dist/runner/codex-runner.js

@@ -1,5 +1,5 @@
 import { withMarctlGuide } from '../mcp/marctl-guide.js';
-import { CodexAppServerClient, CodexAppServerRpcError, isCodexRolloutMissingError } from '../codex-app-server.js';
+import { CodexAppServerClient, isCodexRolloutMissingError } from '../codex-app-server.js';
 import { AbstractRunner } from './abstract-runner.js';
 import { declaredRunnerProfiles } from '../runner-profiles.js';
 import { homedir } from 'node:os';
@@ -280,22 +280,6 @@ export class CodexRunner extends AbstractRunner {
         }
         return input.title;
     }
-    async isNativeSessionMissing(session) {
-        if (session.externalSessionId === null)
-            return false;
-        await this.start();
-        try {
-            await this.client.readThread(session.externalSessionId);
-            return false;
-        }
-        catch (error) {
-            if (error instanceof CodexAppServerRpcError &&
-                error.code === -32600 &&
-                /^no rollout found for thread id\b/i.test(error.rpcMessage))
-                return true;
-            throw error;
-        }
-    }
     async readConversationHistory(readers) {
         const page = await readers.official();
         return page === undefined ? undefined : { ...page, source: 'official' };
@@ -422,16 +406,50 @@ export class CodexRunner extends AbstractRunner {
             return { failureCode: 'RUNNER_RESUME_FAILED' };
         }
     }
+    async cleanupThreads() {
+        await this.start();
+        const threads = [];
+        const cursors = new Set();
+        let cursor;
+        do {
+            const result = await this.client.listThreads({
+                limit: 200,
+                ...(cursor === undefined ? {} : { cursor })
+            });
+            if (!isPlainRecord(result) ||
+                !Array.isArray(result.data) ||
+                result.data.some((entry) => !isPlainRecord(entry) ||
+                    typeof entry.id !== 'string' ||
+                    entry.id.length === 0 ||
+                    typeof entry.cwd !== 'string' ||
+                    entry.cwd.length === 0))
+                throw new Error('CODEX_THREAD_LIST_INVALID');
+            threads.push(...extractCodexThreads(result));
+            const next = result.nextCursor;
+            if (next === null || next === undefined)
+                return threads;
+            if (typeof next !== 'string' || next.length === 0 || cursors.has(next))
+                throw new Error('CODEX_THREAD_LIST_INVALID');
+            cursors.add(next);
+            cursor = next;
+        } while (true);
+    }
     async discoverSessions(context, workspace) {
-        let threads = [];
-        try {
-            await this.start();
-            const result = await this.listThreads();
-            threads = extractCodexThreads(result);
-        }
-        catch {
-            // Native transcripts remain a valid read-only discovery source.
-        }
+        const [threads, nativeSessions] = context.cleanup
+            ? [await this.cleanupThreads(), []]
+            : await Promise.all([
+                (async () => {
+                    try {
+                        await this.start();
+                        return extractCodexThreads(await this.listThreads());
+                    }
+                    catch {
+                        // Native transcripts remain a valid read-only discovery source.
+                        return [];
+                    }
+                })(),
+                discoverAllNativeSessions(this.name)
+            ]);
         const sessions = [];
         for (const thread of threads) {
             if (thread.derived || (thread.source !== 'cli' && thread.source !== 'vscode'))
@@ -440,7 +458,9 @@ export class CodexRunner extends AbstractRunner {
             try {
                 cwd = codexThreadCwd(thread.cwd);
             }
-            catch {
+            catch (error) {
+                if (context.cleanup)
+                    throw error;
                 continue;
             }
             const target = workspace ?? context.workspaces.find((candidate) => isWithinWorkspace(cwd, candidate.path));
@@ -451,11 +471,12 @@ export class CodexRunner extends AbstractRunner {
                 runner: this.name,
                 externalSessionId: thread.id,
                 cwd,
+                ...(context.cleanup ? { lastActivityAt: thread.lastActivityAt } : {}),
                 ...(thread.title === undefined ? {} : { title: thread.title }),
                 ...(thread.titleOrigin === undefined ? {} : { titleOrigin: thread.titleOrigin })
             }));
         }
-        for (const entry of await discoverAllNativeSessions(this.name)) {
+        for (const entry of nativeSessions) {
             const target = workspace ??
                 context.workspaces.find((candidate) => isWithinWorkspace(entry.cwd, candidate.path));
             if (target === undefined || !isWithinWorkspace(entry.cwd, target.path))
@@ -707,8 +728,10 @@ export class CodexRunner extends AbstractRunner {
         return (session.externalSessionId !== null &&
             this.threadHistoryModes.get(session.externalSessionId) === true);
     }
-    async rollbackNative(session, boundary, targetTurnBoundary) {
+    async rollbackNative(session, boundary, targetTurnBoundary, targetClientMessageId) {
         void boundary;
+        if (targetClientMessageId !== undefined)
+            throw new Error('SESSION_ROLLBACK_TARGET_INVALID');
         if (!this.supportsRollback(session) || targetTurnBoundary === undefined)
             throw new Error('SESSION_ROLLBACK_UNAVAILABLE');
         const threadId = session.externalSessionId;

package/dist/runner/mar-agent/hosted-conversation-runtime.js

@@ -114,9 +114,9 @@ export class MarAgentHostedConversationRuntime {
         await this.releaseSession(input);
         const catalog = await this.#openCatalog({ homeDirectory: input.homeDirectory });
         try {
-            const rolledBack = await catalog.rollback(input.sessionId, {
-                boundaryTurnId: input.boundaryTurnId
-            });
+            const rolledBack = await catalog.rollback(input.sessionId, input.beforeInput === undefined
+                ? { boundaryTurnId: input.boundaryTurnId }
+                : { beforeInput: input.beforeInput });
             return { lastActivityAt: Date.parse(rolledBack.lastActivityAt) };
         }
         catch (error) {

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

@@ -271,6 +271,30 @@ export class MarAgentRunner extends AbstractRunner {
             catalog = await openMarAgentSessionCatalog({ homeDirectory: this.homeDirectory });
             const activeCatalog = catalog;
             const listed = await activeCatalog.list({ limit: 200 });
+            if (context.cleanup) {
+                const sessions = [...listed.sessions];
+                let cursor = listed.nextCursor;
+                while (cursor !== undefined) {
+                    const next = await activeCatalog.list({ limit: 200, cursor });
+                    sessions.push(...next.sessions);
+                    cursor = next.nextCursor;
+                }
+                const workspaces = workspace ? [workspace] : context.workspaces;
+                return sessions.flatMap((session) => {
+                    const target = workspaces.find((candidate) => resolve(candidate.path) === resolve(session.workspace));
+                    return target
+                        ? [
+                            context.createProjection({
+                                workspace: target,
+                                runner: this.name,
+                                externalSessionId: session.id,
+                                cwd: session.workspace,
+                                lastActivityAt: Date.parse(session.lastActivityAt)
+                            })
+                        ]
+                        : [];
+                });
+            }
             const workspaces = workspace ? [workspace] : context.workspaces;
             return (await Promise.all(listed.sessions.map(async (session) => {
                 const target = workspaces.find((candidate) => resolve(candidate.path) === resolve(session.workspace));
@@ -300,7 +324,9 @@ export class MarAgentRunner extends AbstractRunner {
                 ];
             }))).flat();
         }
-        catch {
+        catch (error) {
+            if (context.cleanup)
+                throw error;
             return [];
         }
         finally {
@@ -324,15 +350,19 @@ export class MarAgentRunner extends AbstractRunner {
             await catalog.close().catch(() => undefined);
         }
     }
-    async rollbackNative(session, boundary) {
+    async rollbackNative(session, boundary, targetTurnBoundary, targetClientMessageId) {
         if (session.externalSessionId === null)
             throw new Error('SESSION_ROLLBACK_UNAVAILABLE');
         await this.#releaseSessionResources?.(session.externalSessionId);
         const catalog = await openMarAgentSessionCatalog({ homeDirectory: this.homeDirectory });
         try {
-            const rolledBack = await catalog.rollback(session.externalSessionId, {
-                boundaryTurnId: boundary
-            });
+            if (targetClientMessageId !== undefined && targetTurnBoundary === undefined)
+                throw new Error('SESSION_ROLLBACK_TARGET_INVALID');
+            const rolledBack = await catalog.rollback(session.externalSessionId, targetClientMessageId === undefined
+                ? { boundaryTurnId: boundary }
+                : {
+                    beforeInput: { turnId: targetTurnBoundary, clientMessageId: targetClientMessageId }
+                });
             return Date.parse(rolledBack.lastActivityAt);
         }
         catch (error) {

package/dist/runner/opencode-runner.js

@@ -200,7 +200,9 @@ export class OpenCodeRunner extends AbstractRunner {
             try {
                 sessions = await this.client.sessions(target.path);
             }
-            catch {
+            catch (error) {
+                if (context.cleanup)
+                    throw error;
                 continue;
             }
             for (const value of sessions) {
@@ -209,7 +211,9 @@ export class OpenCodeRunner extends AbstractRunner {
                     session.parentId !== undefined ||
                     !isWithinWorkspace(session.directory, target.path))
                     continue;
-                const title = await this.sessionTitle(session);
+                const title = context.cleanup
+                    ? { title: session.title, titleOrigin: 'OFFICIAL' }
+                    : await this.sessionTitle(session);
                 result.push(context.createProjection({
                     workspace: target,
                     runner: this.name,

package/dist/runtime-state.js

@@ -765,6 +765,9 @@ export class NodeRuntimeState {
         const value = {
             ...current,
             status: next,
+            ...(next === 'INTERRUPTED' && current.status === 'CANCELLING'
+                ? { interruptionReason: 'USER_STOP' }
+                : {}),
             version: current.version + 1,
             completedAt: terminal(next) ? now : current.completedAt,
             updatedAt: now
@@ -795,7 +798,7 @@ export class NodeRuntimeState {
     appendRunEvent(input) {
         const execution = this.executions.get(input.runId);
         const runId = execution?.runId ?? input.runId;
-        this.requireRun(runId);
+        const run = this.requireRun(runId);
         const priorSequence = this.runSequences.get(runId) ?? 0;
         if (input.sequence <= priorSequence)
             return undefined;
@@ -818,7 +821,8 @@ export class NodeRuntimeState {
                 completedAt: terminal(input.status) ? value.createdAt : execution.completedAt
             });
         }
-        if (input.status !== undefined && !terminal(input.status))
+        // Runner startup can arrive after a user stop; keep the Run cancelling.
+        if (input.status !== undefined && !terminal(input.status) && run.status !== 'CANCELLING')
             this.transitionRun(runId, input.status);
         this.projectEvent(value, execution?.turnId);
         if (input.status !== undefined && terminal(input.status) && execution !== undefined)

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

@@ -1,4 +1,6 @@
+import { resolveSessionRollbackTarget } from './session-rollback-target.js';
 import { assertMcpServerNames } from '../mcp/naming.js';
+import { imagePreviews, MAX_IMAGE_PREVIEW_SOURCE_BYTES } from './image-preview-service.js';
 import { modelUsageGrantSchema, steerComposerMessage } from '@myagentroam/protocol';
 import { randomUUID } from 'node:crypto';
 import { constants } from 'node:fs';
@@ -792,10 +794,10 @@ export class HostedConversationNodeService {
         const turns = await this.readAllHistory(conversation, paths);
         const targetIndex = turns.findIndex((turn) => turn.id === input.turnId);
         const target = turns[targetIndex];
-        const userMessage = target?.items.find((item) => item.kind === 'user_message' && item.status === 'COMPLETED');
+        const selectedInput = target === undefined ? undefined : resolveSessionRollbackTarget(target, input.itemId);
         if (target === undefined ||
             !terminalHostedTurnStatus(target.status) ||
-            userMessage === undefined ||
+            selectedInput === undefined ||
             target.rewind?.before !== input.boundary)
             throw new Error('HOSTED_CONVERSATION_ROLLBACK_TARGET_INVALID');
         let rolledBack;
@@ -805,7 +807,15 @@ export class HostedConversationNodeService {
                 sessionId: conversation.sessionId,
                 homeDirectory: paths.homeDirectory,
                 modelId: conversation.modelId,
-                boundaryTurnId: input.boundary
+                boundaryTurnId: input.boundary,
+                ...(selectedInput.clientMessageId === undefined
+                    ? {}
+                    : {
+                        beforeInput: {
+                            turnId: target.rewind.after,
+                            clientMessageId: selectedInput.clientMessageId
+                        }
+                    })
             });
         }
         catch (error) {
@@ -1016,14 +1026,16 @@ export class HostedConversationNodeService {
         const image = await this.options.readImage(input.runId, input.imageRef);
         if (image === undefined)
             throw new Error('RUN_IMAGE_NOT_FOUND');
-        return { image };
+        return {
+            image: input.preview === undefined ? image : await imagePreviews.fromImage(image, input.preview)
+        };
     }
     async readFile(raw) {
         const payload = hostedRequest(raw);
         const input = hostedConversationFileReadInputSchema.parse(payload.data);
         const file = this.options.store.requireFile(payload.userId, input.conversationId, input.fileId);
         const path = this.options.store.filePath(payload.userId, file);
-        const offset = input.offset ?? 0;
+        const offset = input.preview === undefined ? (input.offset ?? 0) : 0;
         const limit = Math.min(input.limit ?? MAX_FILE_READ_BYTES, MAX_FILE_READ_BYTES);
         const handle = await openRegularFile(path);
         try {
@@ -1034,12 +1046,26 @@ export class HostedConversationNodeService {
                 throw new Error('HOSTED_CONVERSATION_FILE_INVALID');
             if (offset > before.size)
                 throw new Error('HOSTED_CONVERSATION_FILE_RANGE_INVALID');
-            const buffer = Buffer.alloc(Math.min(limit, Math.max(0, before.size - offset)));
+            if (input.preview !== undefined && before.size > MAX_IMAGE_PREVIEW_SOURCE_BYTES)
+                throw new Error('IMAGE_PREVIEW_TOO_LARGE');
+            const buffer = Buffer.alloc(input.preview === undefined
+                ? Math.min(limit, Math.max(0, before.size - offset))
+                : before.size);
             const read = await handle.read(buffer, 0, buffer.length, offset);
+            if (input.preview !== undefined) {
+                while (read.bytesRead < buffer.length) {
+                    const next = await handle.read(buffer, read.bytesRead, buffer.length - read.bytesRead, read.bytesRead);
+                    if (next.bytesRead === 0)
+                        throw new Error('HOSTED_CONVERSATION_FILE_INVALID');
+                    read.bytesRead += next.bytesRead;
+                }
+            }
             const after = await handle.stat();
             const currentPathMetadata = await regularFileMetadata(path);
             if (!sameFileSnapshot(before, after) || !sameFileSnapshot(after, currentPathMetadata))
                 throw new Error('HOSTED_CONVERSATION_FILE_INVALID');
+            if (input.preview !== undefined)
+                return { image: await imagePreviews.create(buffer, input.preview) };
             const next = offset + read.bytesRead;
             const eof = next >= after.size;
             const currentFile = {

package/dist/service/image-preview-service.js

@@ -0,0 +1,100 @@
+import { createHash } from 'node:crypto';
+import sharp from 'sharp';
+export const MAX_IMAGE_PREVIEW_SOURCE_BYTES = 32 * 1024 * 1024;
+const MAX_CACHE_BYTES = 8 * 1024 * 1024;
+const MAX_CACHE_ENTRIES = 64;
+const MAX_PENDING = 16;
+const MAX_PENDING_BYTES = 64 * 1024 * 1024;
+/** Sources must be read through their original authorization boundary before every call. */
+export class ImagePreviewService {
+    cache = new Map();
+    pending = new Map();
+    cacheBytes = 0;
+    pendingBytes = 0;
+    tail = Promise.resolve();
+    async create(bytes, options) {
+        if (bytes.length === 0)
+            throw new Error('IMAGE_PREVIEW_INVALID');
+        if (bytes.length > MAX_IMAGE_PREVIEW_SOURCE_BYTES)
+            throw new Error('IMAGE_PREVIEW_TOO_LARGE');
+        const key = createHash('sha256')
+            .update(`${options.maxWidth}x${options.maxHeight}\0`)
+            .update(bytes)
+            .digest('hex');
+        const cached = this.cache.get(key);
+        if (cached !== undefined) {
+            this.cache.delete(key);
+            this.cache.set(key, cached);
+            return {
+                mime: 'image/webp',
+                dataBase64: cached.bytes.toString('base64'),
+                resized: cached.resized
+            };
+        }
+        const current = this.pending.get(key);
+        if (current !== undefined)
+            return current;
+        if (this.pending.size >= MAX_PENDING || this.pendingBytes + bytes.length > MAX_PENDING_BYTES)
+            throw new Error('IMAGE_PREVIEW_BUSY');
+        this.pendingBytes += bytes.length;
+        const result = this.tail
+            .catch(() => undefined)
+            .then(async () => {
+            let output;
+            let resized;
+            try {
+                const pipeline = sharp(bytes, { limitInputPixels: 64 * 1024 * 1024, pages: 1 });
+                const metadata = await pipeline.metadata();
+                const rotated = [5, 6, 7, 8].includes(metadata.orientation ?? 1);
+                const width = rotated ? metadata.height : metadata.width;
+                const height = rotated ? metadata.width : metadata.height;
+                if (width === undefined || height === undefined)
+                    throw new Error('IMAGE_PREVIEW_INVALID');
+                resized = width > options.maxWidth || height > options.maxHeight;
+                output = await pipeline
+                    .rotate()
+                    .resize({
+                    width: options.maxWidth,
+                    height: options.maxHeight,
+                    fit: 'inside',
+                    withoutEnlargement: true
+                })
+                    .webp({ quality: 85, effort: 3 })
+                    .toBuffer();
+            }
+            catch {
+                throw new Error('IMAGE_PREVIEW_INVALID');
+            }
+            this.cache.set(key, { bytes: output, resized });
+            this.cacheBytes += output.length;
+            while (this.cache.size > MAX_CACHE_ENTRIES || this.cacheBytes > MAX_CACHE_BYTES) {
+                const oldest = this.cache.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                this.cacheBytes -= this.cache.get(oldest).bytes.length;
+                this.cache.delete(oldest);
+            }
+            return { mime: 'image/webp', dataBase64: output.toString('base64'), resized };
+        });
+        this.pending.set(key, result);
+        this.tail = result;
+        try {
+            return await result;
+        }
+        finally {
+            this.pending.delete(key);
+            this.pendingBytes -= bytes.length;
+        }
+    }
+    fromImage(image, options) {
+        const source = image;
+        if (typeof source?.dataBase64 !== 'string')
+            throw new Error('IMAGE_PREVIEW_INVALID');
+        if (source.dataBase64.length > Math.ceil(MAX_IMAGE_PREVIEW_SOURCE_BYTES / 3) * 4)
+            throw new Error('IMAGE_PREVIEW_TOO_LARGE');
+        if (this.pendingBytes + Math.floor((source.dataBase64.length * 3) / 4) > MAX_PENDING_BYTES)
+            throw new Error('IMAGE_PREVIEW_BUSY');
+        return this.create(Buffer.from(source.dataBase64, 'base64'), options);
+    }
+}
+export const imagePreviews = new ImagePreviewService();

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

@@ -4,7 +4,7 @@ export class NativeSessionProjectionService {
     constructor(options) {
         this.options = options;
     }
-    async discover(runnerName, workspaceId) {
+    async discover(runnerName, workspaceId, cleanup = false) {
         const database = this.requireDatabase();
         const workspace = workspaceId === undefined ? undefined : database.getWorkspace(workspaceId);
         if (workspaceId !== undefined && workspace === undefined)
@@ -13,11 +13,13 @@ export class NativeSessionProjectionService {
         if (runner === undefined || !runner.available(this.options.capabilities()))
             throw new Error('RUNNER_UNAVAILABLE');
         const sessions = await runner.discoverSessions({
+            ...(cleanup ? { cleanup: true } : {}),
             workspaces: database.listWorkspaces(),
             createProjection: (input) => this.project(input)
         }, workspace);
         const ordered = deduplicateDirectSessions(sessions);
-        this.remember(ordered);
+        if (!cleanup)
+            this.remember(ordered);
         return ordered;
     }
     async discoverCodex(workspaceId) {
@@ -33,13 +35,13 @@ export class NativeSessionProjectionService {
         this.remember(sessions);
         return sessions.map(this.options.present);
     }
-    async discoverWorkspace(workspaceId, onRunnerDiscovered) {
+    async discoverWorkspace(workspaceId, onRunnerDiscovered, cleanup = false) {
         const discovered = await Promise.allSettled(this.options.runners
             .advertised()
             .filter((runner) => runner.available(this.options.capabilities()))
             .map(async (runner) => {
             const name = runner.name;
-            const sessions = await this.discover(name, workspaceId);
+            const sessions = await this.discover(name, workspaceId, cleanup);
             onRunnerDiscovered?.(name, sessions);
             return sessions;
         }));
@@ -47,7 +49,8 @@ export class NativeSessionProjectionService {
         if (failed?.status === 'rejected')
             throw failed.reason;
         const sessions = deduplicateDirectSessions(discovered.flatMap((result) => (result.status === 'fulfilled' ? result.value : [])));
-        this.remember(sessions);
+        if (!cleanup)
+            this.remember(sessions);
         return sessions;
     }
     async resolve(sessionId, registeredOnly = false) {

package/dist/service/recent-run-projection-service.js

@@ -41,6 +41,9 @@ export class RecentRunProjectionService {
             ...(latestUserMessage === undefined ? {} : { userMessage: latestUserMessage }),
             runner: run.runner,
             status: run.status,
+            ...(run.interruptionReason === undefined
+                ? {}
+                : { interruptionReason: run.interruptionReason }),
             createdAt: run.createdAt,
             startedAt,
             completedAt,

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

@@ -4,6 +4,7 @@ import { isTerminalRunStatus } from '../util/node-operation-parsers.js';
 import { isPlainRecord } from '../util/node-operation-parsers.js';
 import { isHostedConversationImageRunId } from '../runner/mar-agent/generated-images.js';
 import { assertRunOwner } from './run-ownership-policy.js';
+import { imagePreviews } from './image-preview-service.js';
 export class RunWorkbenchService {
     options;
     constructor(options) {
@@ -47,7 +48,11 @@ export class RunWorkbenchService {
         const image = await this.options.readImage(reference.runId, selector);
         if (image === undefined)
             throw new Error('RUN_IMAGE_NOT_FOUND');
-        return { image };
+        return {
+            image: reference.preview === undefined
+                ? image
+                : await imagePreviews.fromImage(image, reference.preview)
+        };
     }
     respond(input) {
         if (typeof input.runId !== 'string' ||

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

@@ -1,9 +1,11 @@
+import { resolveSessionRollbackTarget } from './session-rollback-target.js';
 import { sessionGroup } from './session-presentation-service.js';
 import { removeNativeSession } from '../native-session-history.js';
 import { nodeLog } from '../operational.js';
 import { isTerminalRunStatus, sessionPage } from '../util/node-operation-parsers.js';
 import { latestSessionActivityAt } from './session-presentation-service.js';
 import { marctlSessionSummary } from './session-recent-activity.js';
+import { WorkspaceSessionCleanupBudget, WorkspaceSessionCleanupDeadline } from './workspace-session-cleanup-budget.js';
 export class SessionCatalogService {
     options;
     rewindQueue = Promise.resolve();
@@ -15,7 +17,7 @@ export class SessionCatalogService {
             'session.list': (data) => this.list(record(data)),
             'session.graph': (data) => this.graph(record(data)),
             'session.remove': (data) => this.enqueueMutation(() => this.remove(record(data))),
-            'workspace.sessions.cleanup': (data) => this.enqueueMutation(() => this.cleanupWorkspaceSessions(record(data))),
+            'workspace.sessions.cleanup': (data) => this.cleanupWorkspaceSessions(record(data)),
             'session.rewind': (data) => this.enqueueMutation(() => this.rewind(record(data))),
             'session.rollback': (data) => this.enqueueMutation(() => this.rollback(record(data)))
         };
@@ -195,6 +197,7 @@ export class SessionCatalogService {
     async rollback(input) {
         if (!validRewindId(input.sessionId, 128) ||
             !validRewindId(input.turnId, 128) ||
+            (input.itemId !== undefined && !validRewindId(input.itemId, 128)) ||
             (input.boundary !== null && !validRewindId(input.boundary, 256)))
             throw new Error('SESSION_ROLLBACK_INVALID');
         const source = this.options.runtime.getAgentSession(input.sessionId) ??
@@ -211,15 +214,17 @@ export class SessionCatalogService {
         if (this.options.runtime.sessionQueue(source.id).itemIds.length > 0)
             throw new Error('SESSION_QUEUE_NOT_EMPTY');
         const turn = await this.findTurn(source, input.turnId);
-        const userMessage = turn?.items.find((item) => item.kind === 'user_message' && item.status === 'COMPLETED');
+        const target = turn === undefined
+            ? undefined
+            : resolveSessionRollbackTarget(turn, input.itemId);
         if (turn === undefined ||
             !terminalConversationStatus(turn.status) ||
-            userMessage === undefined ||
+            target === undefined ||
             turn.rewind?.before !== input.boundary)
             throw new Error('SESSION_ROLLBACK_TARGET_INVALID');
         const releaseMutation = this.options.runtime.beginSessionHistoryMutation(source.id);
         try {
-            const lastActivityAt = await runner.rollbackNative(source, input.boundary, turn.rewind?.after);
+            const lastActivityAt = await runner.rollbackNative(source, input.boundary, turn.rewind?.after, target.clientMessageId);
             const runtimeSession = this.options.runtime.getAgentSession(source.id);
             const session = runtimeSession === undefined
                 ? { ...source, lastActivityAt }
@@ -313,22 +318,50 @@ export class SessionCatalogService {
             throw new Error('WORKSPACE_SESSION_CLEANUP_INVALID');
         if (this.options.database().getWorkspace(input.workspaceId) === undefined)
             throw new Error('WORKSPACE_NOT_FOUND');
-        const cutoff = Date.now() - inactiveDays * 24 * 60 * 60 * 1000;
-        const nativeSessions = await this.options.discoverWorkspace(input.workspaceId);
-        const candidates = new Map();
-        for (const native of deduplicateNativeSessions(nativeSessions)) {
-            if (native.workspaceId !== input.workspaceId)
-                continue;
-            const session = this.cleanupCandidate(native);
-            candidates.set(session.id, session);
+        const workspaceId = input.workspaceId;
+        const budget = new WorkspaceSessionCleanupBudget();
+        const started = Promise.withResolvers();
+        const work = this.enqueueMutation(() => {
+            started.resolve();
+            return this.performWorkspaceSessionCleanup(workspaceId, inactiveDays, budget);
+        });
+        // A queued cleanup may expire before acquiring the mutation queue. Its late
+        // callback still checks the budget and cannot start discovery or deletion.
+        void work.catch(() => undefined);
+        try {
+            await budget.read(() => started.promise);
+        }
+        catch (error) {
+            if (!(error instanceof WorkspaceSessionCleanupDeadline))
+                throw error;
+            return { deleted: 0, skipped: 0, failed: 0, deletedByRunner: {}, timedOut: true };
         }
-        this.mergePersisted(candidates, input.workspaceId, false);
+        return work;
+    }
+    async performWorkspaceSessionCleanup(workspaceId, inactiveDays, budget) {
+        const startedAt = performance.now();
+        const cutoff = Date.now() - inactiveDays * 24 * 60 * 60 * 1000;
         let deleted = 0;
         let skipped = 0;
         let failed = 0;
         const deletedByRunner = {};
+        let candidateCount;
+        let timedOut = false;
+        let discoveryMs = 0;
         try {
+            const nativeSessions = await budget.read(() => this.options.discoverWorkspace(workspaceId, true));
+            discoveryMs = Math.round(performance.now() - startedAt);
+            const candidates = new Map();
+            for (const native of deduplicateNativeSessions(nativeSessions)) {
+                if (native.workspaceId !== workspaceId)
+                    continue;
+                const session = this.cleanupCandidate(native);
+                candidates.set(session.id, session);
+            }
+            this.mergePersisted(candidates, workspaceId, false);
+            candidateCount = candidates.size;
             for (const session of candidates.values()) {
+                budget.check();
                 const missingCandidate = session.externalDiscovered === false;
                 if (session.externalSessionId === null ||
                     (missingCandidate &&
@@ -350,7 +383,7 @@ export class SessionCatalogService {
                     continue;
                 }
                 try {
-                    if ((await this.removeResolved(session, true)) === 'deleted') {
+                    if ((await this.removeResolved(session, true, budget)) === 'deleted') {
                         deleted += 1;
                         deletedByRunner[session.runner] = (deletedByRunner[session.runner] ?? 0) + 1;
                     }
@@ -358,12 +391,14 @@ export class SessionCatalogService {
                         skipped += 1;
                 }
                 catch (error) {
+                    if (error instanceof WorkspaceSessionCleanupDeadline)
+                        throw error;
                     if (isCleanupSkip(error))
                         skipped += 1;
                     else {
                         failed += 1;
                         nodeLog('workspace.session.cleanup.failed', {
-                            workspaceId: input.workspaceId,
+                            workspaceId,
                             sessionId: session.id,
                             runner: session.runner,
                             ...cleanupFailureDiagnostic(error)
@@ -371,11 +406,38 @@ export class SessionCatalogService {
                     }
                 }
             }
-            return { deleted, skipped, failed, deletedByRunner };
+        }
+        catch (error) {
+            if (!(error instanceof WorkspaceSessionCleanupDeadline))
+                throw error;
+            if (candidateCount === undefined)
+                discoveryMs = Math.round(performance.now() - startedAt);
+            timedOut = true;
         }
         finally {
-            this.options.invalidateWorkspaceSessions(input.workspaceId);
+            this.options.invalidateWorkspaceSessions(workspaceId);
         }
+        const result = {
+            deleted,
+            skipped,
+            failed,
+            deletedByRunner,
+            ...(timedOut
+                ? {
+                    timedOut: true,
+                    ...(candidateCount === undefined
+                        ? {}
+                        : { remaining: candidateCount - deleted - skipped - failed })
+                }
+                : {})
+        };
+        nodeLog('workspace.sessions.cleanup.completed', {
+            workspaceId,
+            ...result,
+            discoveryMs,
+            durationMs: Math.round(performance.now() - startedAt)
+        });
+        return result;
     }
     cleanupCandidate(native) {
         const projected = this.options.projection.projectionForNative(native);
@@ -389,23 +451,21 @@ export class SessionCatalogService {
             lastActivityAt: latestSessionActivityAt(projected.lastActivityAt, native.lastActivityAt)
         };
     }
-    async removeResolved(session, requireCleanupSafety = false) {
+    async removeResolved(session, requireCleanupSafety = false, budget) {
         if (session.externalSessionId === null)
             throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
         const releaseMutation = this.options.runtime.beginSessionHistoryMutation(session.id, requireCleanupSafety ? undefined : { allowQueued: true });
         try {
             if (this.options.isRecovering?.(session.id))
                 throw new Error('SESSION_RESTART_PENDING');
-            const runner = this.options.runners.require(session.runner);
             const missingCandidate = requireCleanupSafety && session.externalDiscovered === false;
-            if (missingCandidate && !(await runner.isNativeSessionMissing(session)))
-                return 'skipped';
             if (this.options.runtime
                 .listRunsForSession(session.id)
                 .some((run) => !isTerminalRunStatus(run.status)))
                 throw new Error('SESSION_ACTIVE');
-            if (session.nativeControl === 'EXTERNAL') {
-                await this.options.refreshActivity(session);
+            if (session.nativeControl === 'EXTERNAL' && !missingCandidate) {
+                const refresh = () => this.options.refreshActivity(session);
+                await (budget ? budget.read(refresh) : refresh());
                 if (this.options.externalActivity(session.id) === 'BUSY')
                     throw new Error('SESSION_ACTIVE');
             }
@@ -414,17 +474,25 @@ export class SessionCatalogService {
                     throw new Error('SESSION_WATCHING');
                 if (this.options.runtime.sessionQueue(session.id).itemIds.length > 0)
                     throw new Error('SESSION_QUEUE_NOT_EMPTY');
+                // Pin updates do not share the cleanup mutation queue.
+                const pinOrder = this.options
+                    .database()
+                    .getNativeSessionMetadata(session.runner, session.externalSessionId, session.workspaceId)?.pinOrder;
+                if (pinOrder !== undefined && pinOrder !== null)
+                    return 'skipped';
                 if (this.options.runtime
                     .listRunsForSession(session.id)
                     .some((run) => !isTerminalRunStatus(run.status)))
                     throw new Error('SESSION_ACTIVE');
             }
+            budget?.check();
             const nativeIds = this.options.nativeIds(session);
             if (missingCandidate) {
                 this.options.database().deleteSessionRecord(session.id);
                 this.options.forget(session, nativeIds);
                 return 'deleted';
             }
+            const runner = this.options.runners.require(session.runner);
             let deleted = false;
             for (const externalSessionId of nativeIds) {
                 try {

package/dist/service/session-rollback-target.js

@@ -0,0 +1,22 @@
+/** A missing message selector is unambiguous only when the Turn has one user input. */
+export function resolveSessionRollbackTarget(turn, itemId) {
+    const inputs = turn.items.filter((item) => item.kind === 'user_message');
+    const selected = itemId === undefined
+        ? inputs.length === 1
+            ? inputs[0]
+            : undefined
+        : inputs.find((item) => item.id === itemId);
+    if (selected?.status !== 'COMPLETED')
+        return undefined;
+    if (selected === inputs[0])
+        return {};
+    const payload = selected.payload;
+    if (payload === null || typeof payload !== 'object' || Array.isArray(payload))
+        return undefined;
+    const clientMessageId = payload['clientMessageId'];
+    return typeof clientMessageId === 'string' &&
+        clientMessageId.trim() &&
+        clientMessageId.length <= 512
+        ? { clientMessageId }
+        : undefined;
+}

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

@@ -1,8 +1,9 @@
 import { basename, dirname, isAbsolute, relative, resolve, win32 } from 'node:path';
 import { lstat, realpath } from 'node:fs/promises';
-import { isComposerAttachmentResourcePath } from '@myagentroam/protocol';
+import { imagePreviewOptionsSchema, isComposerAttachmentResourcePath } from '@myagentroam/protocol';
 import { listWorkspaceFiles, mutateWorkspaceFile, normalizeFilePreviewPath, readAbsoluteFileContentRange, readWorkspaceFileContentRange, readAbsoluteTextFile, readWorkspaceTextFile, writeWorkspaceTextFile, WorkspaceFileIndex } from '../workspace.js';
 import { revealWorkspaceFileInFileManager } from './workspace-file-manager-service.js';
+import { imagePreviews, MAX_IMAGE_PREVIEW_SOURCE_BYTES } from './image-preview-service.js';
 const INDEX_CACHE_LIMIT = 32;
 const INDEX_CACHE_BYTE_LIMIT = 128 * 1024 * 1024;
 const INDEX_QUEUE_LIMIT = 16;
@@ -96,6 +97,27 @@ export class WorkspaceFileService {
             ? readAbsoluteFileContentRange(path, offset, limit)
             : readWorkspaceFileContentRange(workspacePath, path, offset, limit);
     }
+    async previewImage(workspace, input, workspacePath = workspace.path) {
+        const preview = imagePreviewOptionsSchema.parse(input.preview);
+        const chunks = [];
+        let offset = 0;
+        let revision;
+        for (;;) {
+            const chunk = (await this.readContent(workspace, { ...input, offset, limit: 512 * 1024 }, workspacePath));
+            if (chunk.size > MAX_IMAGE_PREVIEW_SOURCE_BYTES)
+                throw new Error('IMAGE_PREVIEW_TOO_LARGE');
+            if (revision !== undefined && revision !== chunk.sourceRevision)
+                throw new Error('FILE_CHANGED');
+            revision = chunk.sourceRevision;
+            chunks.push(Buffer.from(chunk.contentBase64, 'base64'));
+            if (chunk.nextOffset === null)
+                break;
+            if (chunk.nextOffset <= offset)
+                throw new Error('FILE_RANGE_INVALID');
+            offset = chunk.nextOffset;
+        }
+        return imagePreviews.create(Buffer.concat(chunks), preview);
+    }
     async resolveAttachmentResource(workspaceId, path) {
         if (!isComposerAttachmentResourcePath(path))
             throw new Error('FILE_PATH_ESCAPE');

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

@@ -0,0 +1,32 @@
+const CLEANUP_EXECUTION_BUDGET_MS = 25_000;
+export class WorkspaceSessionCleanupDeadline extends Error {
+    constructor() {
+        super('Workspace session cleanup reached its execution budget.');
+    }
+}
+/** Read-only work can expire; an admitted native write must settle before returning counts. */
+export class WorkspaceSessionCleanupBudget {
+    deadline = performance.now() + CLEANUP_EXECUTION_BUDGET_MS;
+    get expired() {
+        return performance.now() >= this.deadline;
+    }
+    check() {
+        if (this.expired)
+            throw new WorkspaceSessionCleanupDeadline();
+    }
+    async read(operation) {
+        this.check();
+        let timer;
+        try {
+            return await Promise.race([
+                operation(),
+                new Promise((_resolve, reject) => {
+                    timer = setTimeout(() => reject(new WorkspaceSessionCleanupDeadline()), Math.max(0, this.deadline - performance.now()));
+                })
+            ]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}

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

@@ -164,6 +164,9 @@ export class WorkspaceWorkbenchService {
             throw new Error('WORKSPACE_NOT_FOUND');
         const workspace = this.options.requireWorkspace(input.workspaceId);
         const repository = await this.fileRepository(workspace, input);
+        if (input.preview !== undefined) {
+            return { image: await this.options.files.previewImage(workspace, input, repository) };
+        }
         return {
             file: await this.options.files.readContent(workspace, input, repository),
             ...(input.previewDirectory === undefined ? {} : { previewBoundaryVerified: true })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.11.25",
+  "version": "0.11.26",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -35,12 +35,13 @@
     "node-pty": "1.1.0",
     "npm": "11.12.1",
     "playwright": "1.62.1",
+    "sharp": "0.35.5",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.11.25",
-    "@myagentroam/protocol": "0.11.25",
+    "@myagentroam/agent": "0.11.26",
+    "@myagentroam/code-navigation": "0.11.0",
     "@myagentroam/marctl": "0.11.1",
-    "@myagentroam/code-navigation": "0.11.0"
+    "@myagentroam/protocol": "0.11.26"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"