@myagentroam/node 0.9.7 → 0.9.9

package/dist/connector.d.ts

@@ -68,6 +68,7 @@ export declare class NodeConnector {
     private readonly workspaceChangeService;
     private readonly workspaceWorkbenchService;
     private database;
+    private readonly recentRunProjectionService;
     /** Runtime/session state is intentionally not persisted to Node SQLite. */
     private readonly runtime;
     private readonly metrics;

package/dist/connector.js

@@ -30,6 +30,7 @@ import { WorkspaceChangeService } from './service/workspace-change-service.js';
 import { WorkspaceSessionService } from './service/workspace-session-service.js';
 import { WorkbenchEventService } from './service/workbench-event-service.js';
 import { RunDomainState } from './service/run-domain-state.js';
+import { RecentRunProjectionService } from './service/recent-run-projection-service.js';
 import { SessionDomainState } from './service/session-domain-state.js';
 import { RunEventService } from './service/run-event-service.js';
 import { RunAttachmentService } from './service/run-attachment-service.js';
@@ -166,8 +167,9 @@ export class NodeConnector {
     workspaceChangeService = new WorkspaceChangeService(this.workspaceState);
     workspaceWorkbenchService;
     database;
+    recentRunProjectionService = new RecentRunProjectionService((message) => this.send('recent-runs', message));
     /** Runtime/session state is intentionally not persisted to Node SQLite. */
-    runtime = new NodeRuntimeState(() => this.config?.nodeId ?? 'runtime-node', (workspaceId) => this.database?.getWorkspace(workspaceId));
+    runtime = new NodeRuntimeState(() => this.config?.nodeId ?? 'runtime-node', (workspaceId) => this.database?.getWorkspace(workspaceId), Date.now, (run, session) => this.recentRunProjectionService.record(run, session));
     metrics = new NodeMetrics();
     runEventService = new RunEventService({
         runtime: this.runtime,
@@ -684,7 +686,8 @@ export class NodeConnector {
             terminal: this.terminalChannel,
             metrics: this.metrics,
             heartbeatMs: HEARTBEAT_MS,
-            refreshMs: CAPABILITY_REFRESH_MS
+            refreshMs: CAPABILITY_REFRESH_MS,
+            onConnected: () => this.recentRunProjectionService.publishSnapshot()
         });
         const requireDatabase = () => {
             if (this.database === undefined)
@@ -763,6 +766,7 @@ export class NodeConnector {
     }
     stop() {
         this.stopped = true;
+        this.recentRunProjectionService.dispose();
         this.upgradeCoordinator.stop();
         this.connectionLifecycle.stop();
         for (const approval of this.claudeClient.execution.approvals.values()) {

package/dist/runner/codex/conversation-parser.d.ts

@@ -1,7 +1,7 @@
 import type { NodeAgentSession, NodeConversationItem, NodeConversationTurn, NodeMessageAttachmentInput } from '../../database.js';
 export type PublicConversationItem = {
     readonly itemId: string;
-    readonly kind: 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'plan' | 'context_compaction' | 'file_change' | 'error' | 'unknown';
+    readonly kind: 'assistant_message' | 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'plan' | 'context_compaction' | 'file_change' | 'error' | 'unknown';
     readonly status: 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'DECLINED';
     readonly payload: Record<string, unknown>;
     readonly merge?: boolean;

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

@@ -1,5 +1,6 @@
 const MAX_COMPOSER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 const MAX_COMPOSER_ATTACHMENTS_BYTES = 10 * 1024 * 1024;
+const MAX_ASSISTANT_MESSAGE_CHARACTERS = 64 * 1024;
 export * from '../../util/runner-native-session-parsers.js';
 export function codexOfficialConversationPage(session, result, input, managedTurnForNative) {
     if (!isPlainRecord(result) || !isPlainRecord(result.thread))
@@ -43,7 +44,7 @@ export function codexOfficialTurn(session, value, sequence, managedTurn) {
         const officialNativeItemIds = codexNativeItemIds(value.items);
         const officialAssistantCount = items.filter((item) => item.kind === 'assistant_message').length;
         const officialAssistantMessage = officialAssistantCount > 0;
-        const managedAssistants = managedTurn.items.filter((item) => item.kind === 'assistant_message');
+        const managedAssistants = managedTurn.items.filter((item) => item.kind === 'assistant_message' && conversationItemNativeId(item.id) === undefined);
         const managedAssistantCandidates = officialAssistantCount === 0 ? [] : managedAssistants.slice(-officialAssistantCount);
         const assistantLength = (values) => values.reduce((length, item) => {
             if (item.kind !== 'assistant_message' || !isPlainRecord(item.payload))
@@ -108,6 +109,15 @@ export function codexOfficialTurn(session, value, sequence, managedTurn) {
                     replacement = officialAssistants.find((item) => !consumedOfficialIds.has(item.id));
             }
             if (replacement !== undefined) {
+                if (managedItem.kind === 'assistant_message' &&
+                    replacement.kind === 'assistant_message' &&
+                    (assistantLength([managedItem]) > assistantLength([replacement]) ||
+                        ((managedTurn.completedAt ?? 0) > (completedAt ?? 0) &&
+                            assistantLength([managedItem]) > 0))) {
+                    reconciledItems.push(managedItem);
+                    consumedOfficialIds.add(replacement.id);
+                    continue;
+                }
                 if (!consumedOfficialIds.has(replacement.id)) {
                     reconciledItems.push(replacement);
                     consumedOfficialIds.add(replacement.id);
@@ -504,6 +514,20 @@ export function codexLiveConversationItem(value, completed, imageAttachments = [
             status: completed ? 'COMPLETED' : 'IN_PROGRESS',
             payload: { explanation: compactRunnerText(planText, 20_000), steps: [] }
         };
+    if (value.type === 'agentMessage') {
+        if (!completed || typeof value.text !== 'string' || value.text.length === 0)
+            return undefined;
+        return {
+            itemId,
+            kind: 'assistant_message',
+            status: 'COMPLETED',
+            payload: {
+                text: compactRunnerText(value.text, MAX_ASSISTANT_MESSAGE_CHARACTERS),
+                format: 'markdown',
+                model: null
+            }
+        };
+    }
     if (value.type === 'commandExecution') {
         const output = typeof value.aggregatedOutput === 'string' ? value.aggregatedOutput : '';
         return {

package/dist/runner/codex/managed-run-controller.d.ts

@@ -53,7 +53,7 @@ export interface CodexManagedRunHost<TAttachment> {
     }): void;
     emitItem(runId: string, item: {
         readonly itemId: string;
-        readonly kind: 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'plan' | 'context_compaction' | 'file_change' | 'error' | 'unknown';
+        readonly kind: 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'assistant_message' | 'plan' | 'context_compaction' | 'file_change' | 'error' | 'unknown';
         readonly status: 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'DECLINED';
         readonly payload: Record<string, unknown>;
         readonly merge?: boolean;

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

@@ -155,7 +155,13 @@ export class CodexManagedRunController {
             return;
         }
         if (notification.method === 'item/agentMessage/delta' && typeof params.delta === 'string') {
-            this.host.emit(runId, 'text.delta', { text: params.delta });
+            const itemId = typeof params.itemId === 'string'
+                ? boundedConversationItemId('codex', params.itemId)
+                : undefined;
+            this.host.emit(runId, 'text.delta', {
+                text: params.delta,
+                ...(itemId === undefined ? {} : { itemId })
+            });
             return;
         }
         if (notification.method === 'item/reasoning/summaryTextDelta' &&

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

@@ -1,4 +1,5 @@
 import { boundedConversationItemId, compactRunnerText, compactRunnerValue } from '../codex/conversation-parser.js';
+import { runtimeAssistantProjectionMoreComplete } from '../../util/runner-native-session-parsers.js';
 export function openCodeConversationPage(session, messages, input, managedTurn) {
     const records = messages.flatMap((value) => {
         const entry = record(value);
@@ -63,6 +64,9 @@ function openCodeTurn(session, user, userParts, assistants, sequence, managed) {
     const completedAt = Math.max(startedAt ?? 0, ...assistants.map(({ info }) => number(record(info.time)?.completed) ?? 0)) || startedAt;
     const id = managed?.id ?? `${session.id}:official:${nativeTurnId}`;
     const runId = managed?.runId ?? null;
+    const projectedItems = runtimeAssistantProjectionMoreComplete(managed, items)
+        ? managed.items
+        : items;
     return {
         id,
         sessionId: session.id,
@@ -72,7 +76,7 @@ function openCodeTurn(session, user, userParts, assistants, sequence, managed) {
         model: assistants.find(({ info }) => typeof info.modelID === 'string')?.info.modelID ?? null,
         effort: managed?.effort ?? null,
         access: managed?.access ?? null,
-        items: items.map((value) => ({ ...value, turnId: id, runId })),
+        items: projectedItems.map((value) => ({ ...value, turnId: id, runId })),
         startedAt,
         completedAt
     };

package/dist/runtime-state.d.ts

@@ -10,6 +10,8 @@ export declare class NodeRuntimeState {
     private readonly nodeId;
     private readonly getWorkspace;
     private readonly now;
+    private readonly onRunChanged?;
+    private static readonly MAX_RUN_EVENTS_PER_RUN;
     private static readonly MAX_COMPLETED_TURNS_PER_SESSION;
     private readonly sessions;
     private readonly runs;
@@ -26,7 +28,7 @@ export declare class NodeRuntimeState {
     /** Bounded tombstones reject stale internal start envelopes after terminal cleanup. */
     private readonly terminalRunIds;
     private nextEventId;
-    constructor(nodeId: () => string, getWorkspace: (id: string) => NodeWorkspace | undefined, now?: () => number);
+    constructor(nodeId: () => string, getWorkspace: (id: string) => NodeWorkspace | undefined, now?: () => number, onRunChanged?: ((run: NodeAgentRun, session: NodeAgentSession) => void) | undefined);
     activeWorkspaceLeaseCount(): number;
     activeSessionRun(sessionId: string): NodeAgentRun | undefined;
     hasActiveSessionLease(sessionId: string): boolean;

package/dist/runtime-state.js

@@ -9,6 +9,8 @@ export class NodeRuntimeState {
     nodeId;
     getWorkspace;
     now;
+    onRunChanged;
+    static MAX_RUN_EVENTS_PER_RUN = 100;
     static MAX_COMPLETED_TURNS_PER_SESSION = 10;
     sessions = new Map();
     runs = new Map();
@@ -25,10 +27,11 @@ export class NodeRuntimeState {
     /** Bounded tombstones reject stale internal start envelopes after terminal cleanup. */
     terminalRunIds = new Set();
     nextEventId = 1;
-    constructor(nodeId, getWorkspace, now = Date.now) {
+    constructor(nodeId, getWorkspace, now = Date.now, onRunChanged) {
         this.nodeId = nodeId;
         this.getWorkspace = getWorkspace;
         this.now = now;
+        this.onRunChanged = onRunChanged;
     }
     activeWorkspaceLeaseCount() {
         return this.leases.size;
@@ -118,6 +121,7 @@ export class NodeRuntimeState {
         };
         this.runs.set(run.id, run);
         this.leases.set(run.sessionId, run.id);
+        this.onRunChanged?.(run, session);
         return run;
     }
     getAgentSession(id) {
@@ -322,6 +326,7 @@ export class NodeRuntimeState {
         this.bumpQueueVersion(session.id);
         this.turns.set(session.id, [...(this.turns.get(session.id) ?? []), fixedTurn]);
         this.replaceSession(session.id, { lastActivityAt: now });
+        this.onRunChanged?.(run, this.requireSession(session.id));
         return { run, created: true };
     }
     sessionQueue(sessionId) {
@@ -434,6 +439,7 @@ export class NodeRuntimeState {
             throw new Error('RUN_STATE_INVALID');
         const value = { ...current, status: next, version: current.version + 1, updatedAt: this.now() };
         this.runs.set(id, value);
+        this.onRunChanged?.(value, this.requireSession(value.sessionId));
         if (terminal(next) && this.leases.get(value.sessionId) === value.id)
             this.leases.delete(value.sessionId);
         this.updateTurnForRun(id, (turn) => ({
@@ -464,7 +470,7 @@ export class NodeRuntimeState {
             ...(input.status === undefined ? {} : { status: input.status }),
             createdAt: this.now()
         };
-        this.events.set(input.runId, [...prior, value]);
+        this.events.set(input.runId, [...prior, value].slice(-NodeRuntimeState.MAX_RUN_EVENTS_PER_RUN));
         if (input.status !== undefined)
             this.transitionRun(input.runId, input.status);
         this.projectEvent(value);
@@ -630,7 +636,13 @@ export class NodeRuntimeState {
         }
         this.runs.delete(runId);
         this.events.delete(runId);
-        const turns = this.turns.get(run.sessionId) ?? [];
+        const turns = (this.turns.get(run.sessionId) ?? []).filter((turn) => {
+            const hasVisibleError = turn.items.some((item) => item.kind === 'error');
+            if (turn.runId === runId)
+                return run.status === 'SUCCEEDED' || run.status === 'INTERRUPTED' || hasVisibleError;
+            const isTransientErrorTurn = hasVisibleError && turn.status !== 'SUCCEEDED' && turn.status !== 'INTERRUPTED';
+            return run.status !== 'SUCCEEDED' || !isTransientErrorTurn;
+        });
         const completed = turns.filter((turn) => terminalTurn(turn.status));
         const retainedCompleted = new Set(completed.slice(-NodeRuntimeState.MAX_COMPLETED_TURNS_PER_SESSION).map((turn) => turn.id));
         this.turns.set(run.sessionId, turns.filter((turn) => !terminalTurn(turn.status) || retainedCompleted.has(turn.id)));
@@ -708,6 +720,9 @@ export class NodeRuntimeState {
         const value = this.requireSession(id);
         const next = { ...value, ...patch };
         this.sessions.set(id, next);
+        if (value.customTitle !== next.customTitle || value.runnerTitle !== next.runnerTitle)
+            for (const run of this.listRunsForSession(id))
+                this.onRunChanged?.(run, next);
         return next;
     }
     bumpQueueVersion(sessionId) {
@@ -742,13 +757,19 @@ export class NodeRuntimeState {
             if (event.eventType === 'text.delta' &&
                 isRecord(event.payload) &&
                 typeof event.payload.text === 'string') {
-                const lastItem = turn.items.at(-1);
-                const existing = lastItem?.kind === 'assistant_message' && activeConversationItem(lastItem.status)
-                    ? lastItem
+                const nativeItemId = typeof event.payload.itemId === 'string' && event.payload.itemId.length <= 88
+                    ? event.payload.itemId
                     : undefined;
+                const stableItemId = nativeItemId === undefined ? undefined : `${event.runId}:${nativeItemId}`;
+                const lastItem = turn.items.at(-1);
+                const existing = stableItemId === undefined
+                    ? lastItem?.kind === 'assistant_message' && activeConversationItem(lastItem.status)
+                        ? lastItem
+                        : undefined
+                    : turn.items.find((item) => item.id === stableItemId && item.kind === 'assistant_message');
                 const text = `${existing === undefined ? '' : readableText(existing.payload)}${event.payload.text}`;
                 const item = {
-                    id: existing?.id ?? `${event.runId}:assistant:${event.sequence}`,
+                    id: existing?.id ?? stableItemId ?? `${event.runId}:assistant:${event.sequence}`,
                     sessionId: run.sessionId,
                     turnId: turn.id,
                     runId: event.runId,
@@ -829,7 +850,7 @@ function terminal(status) {
     return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED', 'LOST'].includes(status);
 }
 function terminalTurn(status) {
-    return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED'].includes(status);
+    return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED', 'LOST'].includes(status);
 }
 function transitionAllowed(from, to) {
     return !terminal(from) || from === to;
@@ -869,7 +890,8 @@ function conversationItemFromEvent(event) {
     };
 }
 function projectableConversationKind(value) {
-    return (value === 'reasoning_summary' ||
+    return (value === 'assistant_message' ||
+        value === 'reasoning_summary' ||
         value === 'tool_call' ||
         value === 'command_execution' ||
         value === 'user_input_request' ||

package/dist/service/node-connection-lifecycle-service.d.ts

@@ -17,6 +17,7 @@ interface NodeConnectionLifecycleServiceOptions {
     readonly metrics: NodeMetrics;
     readonly heartbeatMs: number;
     readonly refreshMs: number;
+    readonly onConnected?: () => void;
 }
 /** Owns registration completion, heartbeat and background capability refresh timers. */
 export declare class NodeConnectionLifecycleService {

package/dist/service/node-connection-lifecycle-service.js

@@ -47,6 +47,7 @@ export class NodeConnectionLifecycleService {
         this.options.control.send('capabilities', this.options.capabilities());
         this.options.terminal.connect();
         this.options.control.send('heartbeat', {});
+        this.options.onConnected?.();
         this.options.metrics.heartbeatSent();
         this.heartbeat = setInterval(() => {
             this.options.metrics.heartbeatSent();

package/dist/service/recent-run-projection-service.d.ts

@@ -0,0 +1,14 @@
+import type { NodeAgentRun, NodeAgentSession } from '../database.js';
+import type { RecentRunProjection, RecentRunProjectionMessage } from '@myagentroam/protocol';
+export declare class RecentRunProjectionService {
+    private readonly emit;
+    private readonly now;
+    private readonly runs;
+    private readonly cleanupTimer;
+    constructor(emit: (message: RecentRunProjectionMessage) => void, now?: () => number);
+    record(run: NodeAgentRun, session: NodeAgentSession): void;
+    snapshot(): readonly RecentRunProjection[];
+    publishSnapshot(): void;
+    dispose(): void;
+    private cleanup;
+}

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

@@ -0,0 +1,78 @@
+const TERMINAL_TTL_MS = 12 * 60 * 60_000;
+const CLEANUP_INTERVAL_MS = 5 * 60_000;
+const TERMINAL_LIMIT = 100;
+export class RecentRunProjectionService {
+    emit;
+    now;
+    runs = new Map();
+    cleanupTimer;
+    constructor(emit, now = Date.now) {
+        this.emit = emit;
+        this.now = now;
+        this.cleanupTimer = setInterval(() => this.cleanup(), CLEANUP_INTERVAL_MS);
+        this.cleanupTimer.unref();
+    }
+    record(run, session) {
+        if (!Number.isSafeInteger(run.initiatedByUserId) || run.initiatedByUserId === undefined)
+            return;
+        const existing = this.runs.get(run.id);
+        if (existing !== undefined && existing.version > run.version)
+            return;
+        const startedAt = existing?.startedAt ?? (run.status === 'QUEUED' ? null : run.updatedAt);
+        const completedAt = terminal(run.status) ? (existing?.completedAt ?? run.updatedAt) : null;
+        const projection = {
+            runId: run.id,
+            nodeId: run.nodeId,
+            workspaceId: run.workspaceId,
+            sessionId: run.sessionId,
+            sessionTitle: session.customTitle ?? session.runnerTitle ?? session.id,
+            runner: run.runner,
+            status: run.status,
+            createdAt: run.createdAt,
+            startedAt,
+            completedAt,
+            sortAt: startedAt ?? run.createdAt,
+            updatedAt: run.updatedAt,
+            version: run.version,
+            userId: run.initiatedByUserId
+        };
+        this.runs.set(run.id, projection);
+        this.cleanup();
+        this.emit({ kind: 'UPDATE', run: projection });
+    }
+    snapshot() {
+        this.cleanup();
+        return [...this.runs.values()].sort(compareRecentRuns);
+    }
+    publishSnapshot() {
+        this.emit({ kind: 'SNAPSHOT', runs: [...this.snapshot()] });
+    }
+    dispose() {
+        clearInterval(this.cleanupTimer);
+    }
+    cleanup() {
+        const cutoff = this.now() - TERMINAL_TTL_MS;
+        for (const [runId, run] of this.runs)
+            if (run.completedAt !== null && run.completedAt <= cutoff)
+                this.runs.delete(runId);
+        const byUser = new Map();
+        for (const run of this.runs.values()) {
+            if (run.completedAt === null)
+                continue;
+            const values = byUser.get(run.userId) ?? [];
+            values.push(run);
+            byUser.set(run.userId, values);
+        }
+        for (const values of byUser.values())
+            for (const run of values.sort(compareRecentRuns).slice(TERMINAL_LIMIT))
+                this.runs.delete(run.runId);
+    }
+}
+function compareRecentRuns(left, right) {
+    return (right.sortAt - left.sortAt ||
+        right.createdAt - left.createdAt ||
+        right.runId.localeCompare(left.runId));
+}
+function terminal(status) {
+    return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED'].includes(status);
+}

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

@@ -14,7 +14,7 @@ export class RunEventService {
             status === undefined &&
             isPlainRecord(payload) &&
             typeof payload.text === 'string') {
-            this.enqueueText(runId, payload.text);
+            this.enqueueText(runId, payload.text, typeof payload.itemId === 'string' ? payload.itemId : undefined);
             return;
         }
         this.flushText(runId);
@@ -28,18 +28,20 @@ export class RunEventService {
     flushPendingText(runId) {
         this.flushText(runId);
     }
-    enqueueText(runId, text) {
+    enqueueText(runId, text, itemId) {
         if (text.length === 0)
             return;
         const pending = this.pendingText.get(runId);
-        if (pending !== undefined) {
+        if (pending !== undefined && pending.itemId === itemId) {
             pending.text += text;
             if (pending.text.length >= MAX_BATCH_CHARS)
                 this.flushText(runId);
             return;
         }
+        if (pending !== undefined)
+            this.flushText(runId);
         const timer = setTimeout(() => this.flushText(runId), COALESCE_MS);
-        this.pendingText.set(runId, { text, timer });
+        this.pendingText.set(runId, { text, ...(itemId === undefined ? {} : { itemId }), timer });
     }
     flushText(runId) {
         const pending = this.pendingText.get(runId);
@@ -47,7 +49,10 @@ export class RunEventService {
             return;
         clearTimeout(pending.timer);
         this.pendingText.delete(runId);
-        this.emitNow(runId, 'text.delta', { text: pending.text });
+        this.emitNow(runId, 'text.delta', {
+            text: pending.text,
+            ...(pending.itemId === undefined ? {} : { itemId: pending.itemId })
+        });
     }
     emitNow(runId, eventType, payload, status) {
         if (this.options.runtime.getRun(runId) === undefined)

package/dist/util/runner-native-session-parsers.d.ts

@@ -1,5 +1,5 @@
 import type { SessionActivityState } from '@myagentroam/protocol';
-import type { NodeAgentSession, NodeConversationTurn } from '../database.js';
+import type { NodeAgentSession, NodeConversationItem, NodeConversationTurn } from '../database.js';
 import type { NativeSessionHistory, NativeTranscriptImageAttachment } from '../native-session-history.js';
 export interface SessionContextUsage {
     readonly model: string | null;
@@ -46,6 +46,7 @@ export declare function nativeConversationPage(session: NodeAgentSession, histor
     readonly turns: readonly NodeConversationTurn[];
     readonly nextCursor: string | null;
 };
+export declare function runtimeAssistantProjectionMoreComplete(runtimeTurn: NodeConversationTurn | undefined, projectedItems: readonly NodeConversationItem[]): boolean;
 /**
  * Claude JSONL does not retain browser request IDs. While the Node process is alive, match current
  * runtime user messages by content and creation time so native history replaces the optimistic Turn.

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

@@ -156,19 +156,6 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
     const effectiveCursor = history.cursorReset === true ? undefined : input.cursor;
     const nativeTurns = nativeTranscriptTurns(history.items);
     const nativeTurnIds = nativeTranscriptTurnIds(session.id, nativeTurns);
-    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 = effectiveCursor === undefined
-        ? runtimeTurns.filter((turn) => {
-            const clientMessageId = runtimeTurnClientMessageId(turn);
-            return (turn.items.some((item) => item.kind === 'error') &&
-                (clientMessageId === undefined || !representedClientMessageIds.has(clientMessageId)));
-        })
-        : [];
     const end = nativePageEnd(effectiveCursor, session.id, nativeTurns.length);
     const start = Math.max(0, end - limit);
     const nativePageTurns = nativeTurns
@@ -190,10 +177,16 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
         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 items = runtimeAssistantProjectionMoreComplete(runtimeTurn, nativeItems)
+            ? runtimeTurn.items.map((item) => ({
+                ...item,
+                turnId,
+                runId: runtimeTurn.runId
+            }))
+            : [
+                ...nativeItems,
+                ...runtimeErrors.filter((error) => !nativeItems.some((item) => item.id === error.id))
+            ];
         const startedAt = items[0]?.startedAt ?? null;
         const completedAt = items.at(-1)?.completedAt ?? startedAt;
         const after = lastNativeItemId(entries);
@@ -219,11 +212,8 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
             completedAt
         };
     });
-    const combined = [...nativePageTurns, ...missingRuntimeErrorTurns];
-    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;
+    const turns = nativePageTurns;
+    const nextEnd = start;
     const cursorBase = {
         sessionId: session.id,
         ...(history.snapshotEnd === undefined ? {} : { snapshotEnd: history.snapshotEnd }),
@@ -253,6 +243,22 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
             : precedingWindow
     };
 }
+export function runtimeAssistantProjectionMoreComplete(runtimeTurn, projectedItems) {
+    if (runtimeTurn === undefined)
+        return false;
+    const assistantStats = (items) => items.reduce((stats, item) => {
+        if (item.kind !== 'assistant_message' || !isPlainRecord(item.payload))
+            return stats;
+        return {
+            count: stats.count + 1,
+            characters: stats.characters +
+                (typeof item.payload.text === 'string' ? item.payload.text.length : 0)
+        };
+    }, { count: 0, characters: 0 });
+    const runtime = assistantStats(runtimeTurn.items);
+    const projected = assistantStats(projectedItems);
+    return runtime.count > projected.count || runtime.characters > projected.characters;
+}
 function runtimeTurnClientMessageId(turn) {
     const user = turn.items.find((item) => item.kind === 'user_message');
     return isPlainRecord(user?.payload) && typeof user.payload.clientMessageId === 'string'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.7",
+  "version": "0.9.9",
   "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.7"
+    "@myagentroam/protocol": "^0.9.9"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"