@myagentroam/node 0.9.2 → 0.9.3

package/dist/service/runner-interaction-service.js

@@ -162,7 +162,6 @@ export class RunnerInteractionService {
             codex.execution.runs.delete(runId);
             codex.releaseEnvironment(runId);
             this.options.state.active.delete(runId);
-            void this.options.captureSnapshot(runId, cwd);
         }
     }
     respondUserInput(runId, requestId, rawAnswers) {
@@ -194,7 +193,7 @@ export class RunnerInteractionService {
             merge: true
         });
     }
-    completeCancelledRun(runId, cwd) {
+    completeCancelledRun(runId) {
         const run = this.options.runtime.getRun(runId);
         if (run === undefined)
             return false;
@@ -206,8 +205,6 @@ export class RunnerInteractionService {
             return false;
         this.options.codex().execution.runs.delete(runId);
         this.options.state.active.delete(runId);
-        if (cwd !== undefined)
-            void this.options.captureSnapshot(runId, cwd);
         return true;
     }
     respondCodexUserInput(runId, requestId, rawAnswers) {

package/dist/service/session-context-service.d.ts

@@ -24,6 +24,7 @@ export interface SessionContextServiceOptions {
 export declare class SessionContextService {
     private readonly options;
     private readonly snapshots;
+    private readonly snapshotTimers;
     private readonly timers;
     private readonly versions;
     constructor(options: SessionContextServiceOptions);

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

@@ -1,7 +1,9 @@
 const REFRESH_DELAYS_MS = [100, 400, 1_000];
+const CONTEXT_SNAPSHOT_TTL_MS = 30 * 60_000;
 export class SessionContextService {
     options;
     snapshots = new Map();
+    snapshotTimers = new Map();
     timers = new Map();
     versions = new Map();
     constructor(options) {
@@ -20,6 +22,15 @@ export class SessionContextService {
             percentage: Math.round((usage.usedTokens / usage.maxTokens) * 1000) / 10
         };
         this.snapshots.set(session.id, context);
+        const previousTimer = this.snapshotTimers.get(session.id);
+        if (previousTimer !== undefined)
+            clearTimeout(previousTimer);
+        const timer = setTimeout(() => {
+            this.snapshotTimers.delete(session.id);
+            this.snapshots.delete(session.id);
+        }, CONTEXT_SNAPSHOT_TTL_MS);
+        timer.unref();
+        this.snapshotTimers.set(session.id, timer);
         return { context, pending: false };
     }
     schedule(sessionId) {
@@ -71,7 +82,10 @@ export class SessionContextService {
     dispose() {
         for (const timer of this.timers.values())
             clearTimeout(timer);
+        for (const timer of this.snapshotTimers.values())
+            clearTimeout(timer);
         this.timers.clear();
+        this.snapshotTimers.clear();
         this.versions.clear();
         this.snapshots.clear();
     }

package/dist/service/session-domain-state.d.ts

@@ -5,4 +5,5 @@ export declare class SessionDomainState<TSession, TActivity> {
     readonly resumeFailures: Map<string, string>;
     readonly messageResumeFailures: Map<string, string>;
     readonly resumeFailureDetails: Map<string, string>;
+    readonly failureTimers: Map<string, NodeJS.Timeout>;
 }

package/dist/service/session-domain-state.js

@@ -5,4 +5,5 @@ export class SessionDomainState {
     resumeFailures = new Map();
     messageResumeFailures = new Map();
     resumeFailureDetails = new Map();
+    failureTimers = new Map();
 }

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

@@ -68,11 +68,13 @@ export class SessionMessageService {
         this.options.attachments.cache(created.run.id, imageAttachments);
         let attachmentPaths;
         try {
-            attachmentPaths = await this.persistAttachments(session, created.run.id, attachmentIds, attachments, uploaded);
+            attachmentPaths = await this.persistAttachments(session, created.run.id, attachments);
+            await this.options.uploads.consume(attachmentIds);
         }
         catch (error) {
             this.options.runtime.deleteQueuedRun(created.run.id);
             this.options.attachments.clear(created.run.id);
+            this.options.attachments.cleanup(created.run.id);
             throw error;
         }
         const runnerInput = withNonImageAttachmentPrompt(input.content, attachmentPaths);
@@ -117,15 +119,8 @@ export class SessionMessageService {
             idempotent: false
         };
     }
-    async persistAttachments(session, runId, attachmentIds, attachments, uploaded) {
-        return [
-            ...uploaded
-                .filter(({ attachment }) => !isRunnerImageAttachment(attachment))
-                .map(({ path }) => path),
-            ...(await this.options.attachments.persistFiles(session.cwd, runId, attachmentIds.length === 0
-                ? attachments.filter((attachment) => !isRunnerImageAttachment(attachment))
-                : []))
-        ];
+    async persistAttachments(session, runId, attachments) {
+        return this.options.attachments.persistFiles(session.cwd, runId, attachments.filter((attachment) => !isRunnerImageAttachment(attachment)));
     }
     channelMessage(input) {
         if (typeof input.sessionId !== 'string' ||

package/dist/service/skill-directory-service.d.ts

@@ -12,6 +12,8 @@ export interface LocalSkillTargetInspection {
     readonly skills: readonly LocalSkillInspection[];
 }
 export declare class SkillDirectoryService {
-    inspectNodeHome(home: string): Promise<LocalSkillTargetInspection>;
+    inspectNodeHome(home: string, options?: {
+        readonly includeClaudeCompatibility?: boolean;
+    }): Promise<LocalSkillTargetInspection>;
     inspectWorkspace(workspace: string): Promise<LocalSkillTargetInspection>;
 }

package/dist/service/skill-directory-service.js

@@ -6,14 +6,20 @@ const MAX_METADATA_BYTES = 64 * 1024;
 const SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
 const WINDOWS_DEVICE_NAME = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/u;
 export class SkillDirectoryService {
-    async inspectNodeHome(home) {
+    async inspectNodeHome(home, options = {}) {
         const agentsRoot = path.join(home, '.agents', 'skills');
         const claudeRoot = path.join(home, '.claude', 'skills');
-        const skills = await scanRoot(agentsRoot, 'AGENTS');
+        const compatibilityMode = await nodeCompatibilityMode(agentsRoot, claudeRoot);
+        const agents = await scanRoot(agentsRoot, 'AGENTS');
+        const claude = options.includeClaudeCompatibility === true && compatibilityMode !== 'UNAVAILABLE'
+            ? await scanRoot(claudeRoot, 'CLAUDE')
+            : [];
         return {
             targetKind: 'NODE',
-            compatibilityMode: await nodeCompatibilityMode(agentsRoot, claudeRoot),
-            skills
+            compatibilityMode,
+            skills: options.includeClaudeCompatibility === true
+                ? mergeNodeCompatibilityRoots(agents, claude)
+                : agents.map(withoutSource)
         };
     }
     async inspectWorkspace(workspace) {
@@ -147,6 +153,24 @@ function mergeWorkspaceCopies(agents, claude) {
         return withoutSource(copies.agents);
     });
 }
+function mergeNodeCompatibilityRoots(agents, claude) {
+    const byName = new Map();
+    for (const item of agents)
+        byName.set(item.name, { agents: item });
+    for (const item of claude)
+        byName.set(item.name, { ...byName.get(item.name), claude: item });
+    return [...byName.entries()]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, copies]) => {
+        if (copies.agents === undefined || copies.claude === undefined)
+            return withoutSource((copies.agents ?? copies.claude));
+        if (copies.agents.description !== copies.claude.description ||
+            copies.agents.localStatus !== copies.claude.localStatus ||
+            JSON.stringify(copies.agents.install) !== JSON.stringify(copies.claude.install))
+            return { name, description: copies.agents.description, localStatus: 'PARTIAL' };
+        return withoutSource(copies.agents);
+    });
+}
 function withoutSource(entry) {
     return {
         name: entry.name,

package/dist/service/skill-node-operation-service.d.ts

@@ -9,7 +9,7 @@ export declare class SkillNodeOperationService {
     private readonly jobs;
     constructor(database: () => NodeDatabase, config: () => NodeConfig);
     operations(): {
-        'node.skills.inspect': () => Promise<import("./skill-directory-service.js").LocalSkillTargetInspection>;
+        'node.skills.inspect': (data: unknown) => Promise<import("./skill-directory-service.js").LocalSkillTargetInspection>;
         'node.skills.install': (data: unknown) => Promise<{
             accepted: boolean;
             installJobId: `${string}-${string}-${string}-${string}-${string}`;

package/dist/service/skill-node-operation-service.js

@@ -17,9 +17,11 @@ export class SkillNodeOperationService {
     }
     operations() {
         return {
-            'node.skills.inspect': async () => {
+            'node.skills.inspect': async (data) => {
                 await this.installer.recoverNodeHome(homedir());
-                return this.directories.inspectNodeHome(homedir());
+                return this.directories.inspectNodeHome(homedir(), {
+                    includeClaudeCompatibility: record(data)['includeClaudeCompatibility'] === true
+                });
             },
             'node.skills.install': (data) => this.install('NODE', data),
             'node.skills.remove': (data) => this.remove('NODE', data),

package/dist/service/workbench-event-service.d.ts

@@ -1,21 +1,9 @@
-import type { NodeEnvelope, WorkbenchEvent, WorkbenchEventCategory } from '@myagentroam/protocol';
-import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+import { type NodeEnvelope, type WorkbenchEventCategory } from '@myagentroam/protocol';
 export declare class WorkbenchEventService {
     private readonly send;
     private readonly accepts;
-    private readonly buffer;
     private sequence;
-    private readonly history;
     constructor(send: (envelope: NodeEnvelope) => void, accepts: (category: WorkbenchEventCategory, payload: unknown) => boolean);
     emit(category: WorkbenchEventCategory, payload: unknown): void;
-    read(after: number): {
-        readonly events: readonly WorkbenchEvent[];
-        readonly latestSequence: number;
-        readonly resyncRequired: boolean;
-    };
-    operations(): Readonly<Record<string, NodeOperationHandler>>;
     snapshotSequence(): number;
-    acknowledge(replyTo: string | undefined): boolean;
-    replay(): void;
-    get pendingCount(): number;
 }

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

@@ -1,10 +1,8 @@
-import { ReliableWorkbenchEventBuffer } from '../event-buffer.js';
+import { createEnvelope } from '@myagentroam/protocol';
 export class WorkbenchEventService {
     send;
     accepts;
-    buffer = new ReliableWorkbenchEventBuffer();
     sequence = 0;
-    history = [];
     constructor(send, accepts) {
         this.send = send;
         this.accepts = accepts;
@@ -13,41 +11,9 @@ export class WorkbenchEventService {
         if (!this.accepts(category, payload))
             return;
         const event = { sequence: ++this.sequence, category, payload };
-        this.history.push(event);
-        if (this.history.length > 1_000)
-            this.history.shift();
-        this.send(this.buffer.queue(event));
-    }
-    read(after) {
-        const first = this.history[0]?.sequence;
-        const reset = after > this.sequence || (first !== undefined && after < first - 1);
-        return {
-            events: reset ? [] : this.history.filter((event) => event.sequence > after),
-            latestSequence: this.sequence,
-            resyncRequired: reset
-        };
-    }
-    operations() {
-        return {
-            'workbench.events.read': (data) => {
-                const afterValue = data?.after;
-                const after = typeof afterValue === 'number' && Number.isInteger(afterValue) && afterValue >= 0
-                    ? afterValue
-                    : 0;
-                return this.read(after);
-            }
-        };
+        this.send(createEnvelope('workbench.event', event));
     }
     snapshotSequence() {
         return this.sequence;
     }
-    acknowledge(replyTo) {
-        return this.buffer.acknowledge(replyTo);
-    }
-    replay() {
-        this.buffer.replay(this.send);
-    }
-    get pendingCount() {
-        return this.buffer.size;
-    }
 }

package/dist/service/workbench-manifest-service.d.ts

@@ -21,7 +21,6 @@ export declare class WorkbenchManifestService {
             reasonCode: null;
             itemVersions: number[];
             supportsSessionCursor: boolean;
-            supportsWorkspaceActivityCursor: boolean;
             supportsHistoryPaging: boolean;
             supportsItemFinalSnapshots: boolean;
             maxPageSize: number;

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

@@ -30,7 +30,6 @@ export class WorkbenchManifestService {
                 reasonCode: null,
                 itemVersions: [1],
                 supportsSessionCursor: true,
-                supportsWorkspaceActivityCursor: true,
                 supportsHistoryPaging: true,
                 supportsItemFinalSnapshots: true,
                 maxPageSize: 500

package/dist/service/workspace-domain-state.d.ts

@@ -42,6 +42,7 @@ export interface CompletedComposerAttachment {
     readonly name: string;
     readonly mime: string;
     readonly size: number;
+    readonly timer: NodeJS.Timeout;
 }
 export declare class WorkspaceDomainState {
     readonly uploads: Map<string, ActiveWorkspaceUpload>;

package/dist/service/workspace-queue-workbench-service.d.ts

@@ -23,6 +23,7 @@ export interface WorkspaceQueueWorkbenchServiceOptions {
     readonly runtime: NodeRuntimeState;
     readonly emit: (workspaceId: string, sessionId: string) => void;
     readonly clearImages: (runId: string) => void;
+    readonly cleanupAttachments: (runId: string) => void;
     readonly emitRun: (runId: string, eventType: string, payload: unknown, status?: 'FAILED' | 'CANCELLED') => void;
     readonly emitConversation: (turn: unknown) => void;
     readonly control: (operation: string, payload: Record<string, unknown>) => void;

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

@@ -80,6 +80,7 @@ export class WorkspaceQueueWorkbenchService {
         this.options.runtime.deleteQueuedRun(run.id);
         this.remove(run.id);
         this.options.clearImages(run.id);
+        this.options.cleanupAttachments(run.id);
         this.options.emit(run.workspaceId, run.sessionId);
         return { queue: this.present(run.workspaceId, run.sessionId) };
     }

package/dist/service/workspace-upload-service.d.ts

@@ -23,9 +23,11 @@ export declare class WorkspaceUploadService {
     complete(uploadId: unknown): Promise<UploadStatus>;
     cancel(uploadId: unknown): Promise<void>;
     resolve(workspaceId: string, ids: readonly string[]): Promise<readonly ResolvedComposerAttachment[]>;
+    consume(ids: readonly string[]): Promise<void>;
     shutdown(): Promise<void>;
     private require;
     private remove;
+    private removeCompleted;
     private attachmentTarget;
 }
 interface UploadStatus {

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

@@ -133,16 +133,25 @@ export class WorkspaceUploadService {
         clearTimeout(upload.timer);
         this.state.uploads.delete(upload.id);
         this.onCompleted(upload.workspaceId);
-        if (upload.composerAttachment !== undefined)
-            this.state.composerAttachments.set(upload.composerAttachment.id, {
+        if (upload.composerAttachment !== undefined) {
+            const attachmentId = upload.composerAttachment.id;
+            const timer = setTimeout(() => {
+                const attachment = this.state.composerAttachments.get(attachmentId);
+                if (attachment !== undefined)
+                    void this.removeCompleted(attachment);
+            }, TTL_MS);
+            timer.unref();
+            this.state.composerAttachments.set(attachmentId, {
                 id: upload.composerAttachment.id,
                 workspaceId: upload.workspaceId,
                 path: upload.path,
                 targetPath: upload.targetPath,
                 name: upload.composerAttachment.name,
                 mime: upload.composerAttachment.mime,
-                size: upload.size
+                size: upload.size,
+                timer
             });
+        }
         return {
             uploadId: upload.id,
             path: upload.path,
@@ -159,8 +168,7 @@ export class WorkspaceUploadService {
         const attachment = this.state.composerAttachments.get(uploadId);
         if (attachment === undefined)
             throw new Error('UPLOAD_NOT_FOUND');
-        this.state.composerAttachments.delete(uploadId);
-        await rm(dirname(attachment.targetPath), { recursive: true, force: true });
+        await this.removeCompleted(attachment);
     }
     async resolve(workspaceId, ids) {
         return Promise.all(ids.map(async (id) => {
@@ -184,10 +192,17 @@ export class WorkspaceUploadService {
             };
         }));
     }
+    async consume(ids) {
+        await Promise.all(ids.map(async (id) => {
+            const attachment = this.state.composerAttachments.get(id);
+            if (attachment !== undefined)
+                await this.removeCompleted(attachment);
+        }));
+    }
     async shutdown() {
         await Promise.allSettled([...this.state.uploads.values()].map((upload) => this.remove(upload)));
         for (const attachment of this.state.composerAttachments.values())
-            await rm(dirname(attachment.targetPath), { recursive: true, force: true });
+            await this.removeCompleted(attachment);
         this.state.composerAttachments.clear();
     }
     require(id) {
@@ -206,6 +221,13 @@ export class WorkspaceUploadService {
         if (upload.composerAttachment !== undefined)
             await rm(dirname(upload.targetPath), { recursive: true, force: true }).catch(() => undefined);
     }
+    async removeCompleted(attachment) {
+        if (this.state.composerAttachments.get(attachment.id) !== attachment)
+            return;
+        this.state.composerAttachments.delete(attachment.id);
+        clearTimeout(attachment.timer);
+        await rm(dirname(attachment.targetPath), { recursive: true, force: true }).catch(() => undefined);
+    }
     async attachmentTarget(workspacePath, id, name) {
         const mar = resolve(workspacePath, '.mar');
         await mkdir(mar, { recursive: true, mode: 0o700 });

package/dist/service/workspace-workbench-service.d.ts

@@ -1,13 +1,11 @@
 import type { NodeOperationHandler } from '../connector/node-operation-router.js';
 import type { NodeWorkspace } from '../database.js';
-import { NodeRuntimeState } from '../runtime-state.js';
 import { WorkspaceChangeService } from './workspace-change-service.js';
 import { WorkspaceFileService } from './workspace-file-service.js';
 import { WorkspaceUploadService } from './workspace-upload-service.js';
 import { WorkspaceWatchService } from './workspace-watch-service.js';
 export interface WorkspaceWorkbenchServiceOptions {
     readonly requireWorkspace: (workspaceId: unknown) => NodeWorkspace;
-    readonly runtime: NodeRuntimeState;
     readonly watch: WorkspaceWatchService;
     readonly files: WorkspaceFileService;
     readonly uploads: WorkspaceUploadService;
@@ -20,7 +18,6 @@ export declare class WorkspaceWorkbenchService {
     private readonly contentSearch;
     constructor(options: WorkspaceWorkbenchServiceOptions);
     operations(): Readonly<Record<string, NodeOperationHandler>>;
-    private activity;
     private watch;
     private unwatch;
     private listFiles;

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

@@ -9,7 +9,6 @@ export class WorkspaceWorkbenchService {
     }
     operations() {
         return {
-            'workspace.activity.read': (data) => this.activity(record(data)),
             'workspace.watch': (data) => this.watch(record(data)),
             'workspace.unwatch': (data) => this.unwatch(record(data)),
             'workspace.files.list': (data) => this.listFiles(record(data)),
@@ -35,20 +34,6 @@ export class WorkspaceWorkbenchService {
             'workspace.diff': (data) => this.diff(record(data))
         };
     }
-    activity(input) {
-        if (typeof input.workspaceId !== 'string' ||
-            (input.cursor !== undefined && typeof input.cursor !== 'string') ||
-            (input.limit !== undefined &&
-                (!Number.isInteger(input.limit) ||
-                    input.limit < 1 ||
-                    input.limit > 500)))
-            throw new Error('EVENT_CURSOR_INVALID');
-        return this.options.runtime.listWorkspaceActivity({
-            workspaceId: input.workspaceId,
-            ...(typeof input.cursor === 'string' ? { cursor: input.cursor } : {}),
-            ...(typeof input.limit === 'number' ? { limit: input.limit } : {})
-        });
-    }
     async watch(input) {
         if (typeof input.workspaceId !== 'string' ||
             typeof input.watchId !== 'string' ||
@@ -143,8 +128,6 @@ export class WorkspaceWorkbenchService {
             (input.state !== 'STAGED' && input.state !== 'UNSTAGED' && input.state !== 'UNTRACKED'))
             throw new Error('GIT_CHANGE_RESTORE_UNAVAILABLE');
         const workspace = this.gitWorkspace(input.workspaceId);
-        if (this.options.runtime.hasActiveWorkspaceLease(workspace.id))
-            throw new Error('WORKSPACE_BUSY');
         const repository = await resolveGitRepository(workspace.path, input.repositoryPath ?? '');
         await restoreCurrentChange(repository, input.path, input.state);
         this.options.invalidate(workspace.id);

package/dist/util/runner-error.d.ts

@@ -0,0 +1,6 @@
+export interface RunnerErrorProjection {
+    readonly code: string;
+    readonly message: string;
+    readonly httpStatus: number | null;
+}
+export declare function runnerErrorProjection(error: unknown, fallbackCode: string): RunnerErrorProjection;

package/dist/util/runner-error.js

@@ -0,0 +1,52 @@
+const MAX_RUNNER_ERROR_MESSAGE = 1000;
+export function runnerErrorProjection(error, fallbackCode) {
+    const httpStatus = findHttpStatus(error);
+    const message = findMessage(error) ?? fallbackCode;
+    return {
+        code: httpStatus === null ? fallbackCode : `HTTP_${httpStatus}`,
+        message: message.slice(0, MAX_RUNNER_ERROR_MESSAGE),
+        httpStatus
+    };
+}
+function findHttpStatus(value, depth = 0) {
+    if (depth > 3 || value === null || typeof value !== 'object')
+        return null;
+    const record = value;
+    for (const key of ['status', 'statusCode', 'status_code', 'httpStatus', 'http_status']) {
+        const candidate = record[key];
+        if (((typeof candidate === 'number' && Number.isInteger(candidate)) ||
+            (typeof candidate === 'string' && /^\d{3}$/u.test(candidate))) &&
+            Number(candidate) >= 100 &&
+            Number(candidate) <= 599)
+            return Number(candidate);
+    }
+    const match = findMessage(value)?.match(/(?:^|\b(?:http(?:\s+status)?|status(?:\s+code)?|error)\s*[:=_-]?\s*)([1-5]\d{2})\b/iu);
+    if (match !== null && match !== undefined)
+        return Number(match[1]);
+    for (const key of ['error', 'cause', 'response', 'data']) {
+        const nested = findHttpStatus(record[key], depth + 1);
+        if (nested !== null)
+            return nested;
+    }
+    return null;
+}
+function findMessage(value, depth = 0) {
+    if (typeof value === 'string')
+        return value.trim() || undefined;
+    if (value instanceof Error && value.message.trim())
+        return value.message.trim();
+    if (depth > 3 || value === null || typeof value !== 'object')
+        return undefined;
+    const record = value;
+    for (const key of ['message', 'error_description', 'detail', 'result']) {
+        const candidate = record[key];
+        if (typeof candidate === 'string' && candidate.trim())
+            return candidate.trim();
+    }
+    for (const key of ['error', 'cause', 'response', 'data']) {
+        const nested = findMessage(record[key], depth + 1);
+        if (nested !== undefined)
+            return nested;
+    }
+    return undefined;
+}

package/dist/util/runner-native-session-parsers.js

@@ -146,23 +146,49 @@ export function deduplicateDirectSessions(sessions) {
 export function nativeConversationPage(session, history, input, runtimeTurns = [], registerImages = () => []) {
     const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
     const nativeTurns = nativeTranscriptTurns(history.items);
+    const representedClientMessageIds = new Set(nativeTurns.flatMap((entries) => entries.flatMap(({ entry, index }) => {
+        if (entry.kind !== 'message' || entry.role !== 'USER')
+            return [];
+        const clientMessageId = nativeUserClientMessageId(entry, entry.createdAt ?? index, runtimeTurns);
+        return clientMessageId === null ? [] : [clientMessageId];
+    })));
+    const missingRuntimeErrorTurns = input.cursor === undefined
+        ? runtimeTurns.filter((turn) => {
+            const clientMessageId = runtimeTurnClientMessageId(turn);
+            return (turn.items.some((item) => item.kind === 'error') &&
+                (clientMessageId === undefined || !representedClientMessageIds.has(clientMessageId)));
+        })
+        : [];
     const end = nativePageEnd(input.cursor, session.id, nativeTurns.length);
     const start = Math.max(0, end - limit);
-    const turns = nativeTurns
+    const nativePageTurns = nativeTurns
         .slice(start, end)
         .map((entries, relativeIndex) => {
         const firstIndex = entries[0]?.index ?? 0;
         const turnId = `${session.id}:native:${firstIndex}`;
-        const items = entries.map(({ entry, index }) => nativeTranscriptConversationItem(session, entry, index, turnId, runtimeTurns, registerImages));
+        const nativeItems = entries.map(({ entry, index }) => nativeTranscriptConversationItem(session, entry, index, turnId, runtimeTurns, registerImages));
+        const clientMessageId = nativeItems.flatMap((item) => item.kind === 'user_message' && isPlainRecord(item.payload)
+            ? [item.payload.clientMessageId]
+            : [])[0];
+        const runtimeTurn = typeof clientMessageId === 'string'
+            ? runtimeTurns.find((turn) => runtimeTurnClientMessageId(turn) === clientMessageId)
+            : undefined;
+        const runtimeErrors = (runtimeTurn?.items ?? [])
+            .filter((item) => item.kind === 'error')
+            .map((item) => ({ ...item, turnId, runId: runtimeTurn?.runId ?? null }));
+        const items = [
+            ...nativeItems,
+            ...runtimeErrors.filter((error) => !nativeItems.some((item) => item.id === error.id))
+        ];
         const startedAt = items[0]?.startedAt ?? firstIndex;
         const completedAt = items.at(-1)?.completedAt ?? startedAt;
         const after = lastNativeItemId(entries);
         return {
             id: turnId,
             sessionId: session.id,
-            runId: null,
+            runId: runtimeTurn?.runId ?? null,
             userItemId: items.find((item) => item.kind === 'user_message')?.id ?? null,
-            status: 'SUCCEEDED',
+            status: runtimeErrors.length > 0 ? 'FAILED' : 'SUCCEEDED',
             model: null,
             effort: null,
             access: null,
@@ -179,13 +205,24 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
             completedAt
         };
     });
+    const combined = [...nativePageTurns, ...missingRuntimeErrorTurns].sort((left, right) => (left.startedAt ?? 0) - (right.startedAt ?? 0));
+    const dropped = combined.slice(0, Math.max(0, combined.length - limit));
+    const turns = combined.slice(-limit);
+    const nativePageIds = new Set(nativePageTurns.map((turn) => turn.id));
+    const nextEnd = start + dropped.filter((turn) => nativePageIds.has(turn.id)).length;
     return {
         turns,
-        nextCursor: start > 0
-            ? Buffer.from(JSON.stringify({ sessionId: session.id, end: start })).toString('base64url')
+        nextCursor: nextEnd > 0
+            ? Buffer.from(JSON.stringify({ sessionId: session.id, end: nextEnd })).toString('base64url')
             : null
     };
 }
+function runtimeTurnClientMessageId(turn) {
+    const user = turn.items.find((item) => item.kind === 'user_message');
+    return isPlainRecord(user?.payload) && typeof user.payload.clientMessageId === 'string'
+        ? user.payload.clientMessageId
+        : undefined;
+}
 function lastNativeItemId(entries) {
     return entries.findLast(({ entry }) => entry.nativeId !== undefined)?.entry.nativeId;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "MyAgentRoam Node runtime CLI.",
   "type": "module",
   "files": [
@@ -24,7 +24,7 @@
     "node-pty": "1.1.0",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/protocol": "^0.9.2"
+    "@myagentroam/protocol": "^0.9.3"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"