tabminal 3.0.16 → 3.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabminal",
-  "version": "3.0.16",
+  "version": "3.0.18",
   "description": "Tab(ter)minal, a Cloud-Native terminal and ACP agent workspace for desktop, tablet, and phone.",
   "type": "module",
   "bin": {

package/public/app.js

@@ -108,6 +108,8 @@ const FILE_VERSION_CHECK_INTERVAL_MS = 3000;
 const AGENT_TRANSCRIPT_INITIAL_VISIBLE_BLOCKS = 100;
 const AGENT_TRANSCRIPT_WINDOW_STEP = 50;
 const AGENT_TRANSCRIPT_FOLLOW_LATEST_TOLERANCE = 5;
+const AGENT_TRANSCRIPT_RENDER_DEBOUNCE_MS = 300;
+const AGENT_TRANSCRIPT_AUTH_SYNC_DEBOUNCE_MS = 300;
 const WORKSPACE_TAB_TITLE_MAX_LENGTH = 20;
 const MAIN_SERVER_ID = 'main';
 const RUNTIME_BOOT_ID_STORAGE_KEY = 'tabminal_runtime_boot_id';
@@ -1028,6 +1030,7 @@ class EditorManager {
         this.agentEmbeddedEditors = [];
         this.agentEmbeddedTerminals = new Map();
         this.agentTranscriptLayout = null;
+        this.agentRenderQueue = new Map();
         this.pdfPreviewState = {
             path: '',
             sessionKey: '',
@@ -1063,7 +1066,6 @@ class EditorManager {
         this.initMonaco();
         this.loadIconMap();
         this.agentTimestampTimer = window.setInterval(() => {
-            this.refreshAgentTimelineTimestamps();
             this.refreshAgentUsageHud();
         }, 1000);
         this.fileVersionCheckTimer = window.setInterval(() => {
@@ -4264,12 +4266,6 @@ class EditorManager {
         if (!(body instanceof HTMLElement) || !message?.text) {
             return;
         }
-        if (agentTab?.busy) {
-            return;
-        }
-        if (isAgentMessageStreaming(agentTab, message)) {
-            return;
-        }
         const session = this.currentSession;
         if (!session) {
             return;
@@ -4289,10 +4285,7 @@ class EditorManager {
 
         try {
             const { renderer } = await loadMarkdownPreviewBundle();
-            if (
-                String(message.text || '') !== sourceText
-                || isAgentMessageStreaming(agentTab, message)
-            ) {
+            if (String(message.text || '') !== sourceText) {
                 return;
             }
             const rendered = renderer.render(sourceText);
@@ -5624,13 +5617,133 @@ class EditorManager {
         removeAgentTab(agentTabKey);
     }
 
-    renderAgentPanel(agentTab, options = {}) {
-        const previousLayout = this.captureAgentTranscriptLayout();
-        const previousScrollTop = previousLayout?.scrollTop || 0;
-        const wasNearBottom = this.isAgentTranscriptLayoutNearBottom(
-            previousLayout,
-            36
-        );
+    getOrCreateAgentRenderState(agentTabKey) {
+        let renderState = this.agentRenderQueue.get(agentTabKey);
+        if (!renderState) {
+            renderState = {
+                timer: 0,
+                inFlight: false,
+                rerenderRequested: false,
+                full: false,
+                authoritativeSync: false,
+                delayMs: 0,
+                dirtyKeys: new Set()
+            };
+            this.agentRenderQueue.set(agentTabKey, renderState);
+        }
+        return renderState;
+    }
+
+    clearScheduledAgentPanelRender(agentTabKey) {
+        const renderState = this.agentRenderQueue.get(agentTabKey);
+        if (!renderState) {
+            return;
+        }
+        if (renderState.timer) {
+            clearTimeout(renderState.timer);
+        }
+        this.agentRenderQueue.delete(agentTabKey);
+    }
+
+    scheduleQueuedAgentPanelRender(agentTabKey, delayMs = 0) {
+        const renderState = this.agentRenderQueue.get(agentTabKey);
+        if (!renderState) {
+            return;
+        }
+        if (renderState.timer) {
+            clearTimeout(renderState.timer);
+        }
+        renderState.delayMs = Math.max(0, Math.floor(delayMs));
+        renderState.timer = window.setTimeout(() => {
+            renderState.timer = 0;
+            void this.flushQueuedAgentPanelRender(agentTabKey);
+        }, renderState.delayMs);
+    }
+
+    scheduleAgentPanelRender(agentTab, options = {}) {
+        if (!agentTab?.key) {
+            return;
+        }
+        const renderState = this.getOrCreateAgentRenderState(agentTab.key);
+        if (options.full) {
+            renderState.full = true;
+        }
+        if (options.authoritativeSync) {
+            renderState.authoritativeSync = true;
+        }
+        if (options.dirtyKey) {
+            renderState.dirtyKeys.add(String(options.dirtyKey));
+        }
+        if (renderState.inFlight) {
+            renderState.rerenderRequested = true;
+        }
+        const delayMs = renderState.full
+            ? 0
+            : (
+                Number.isFinite(options.delayMs)
+                    ? options.delayMs
+                    : AGENT_TRANSCRIPT_RENDER_DEBOUNCE_MS
+            );
+        this.scheduleQueuedAgentPanelRender(agentTab.key, delayMs);
+    }
+
+    async flushQueuedAgentPanelRender(agentTabKey) {
+        const renderState = this.agentRenderQueue.get(agentTabKey);
+        if (!renderState) {
+            return;
+        }
+        if (renderState.inFlight) {
+            renderState.rerenderRequested = true;
+            return;
+        }
+        renderState.inFlight = true;
+        const pendingFull = renderState.full;
+        const pendingAuthoritativeSync = renderState.authoritativeSync;
+        renderState.full = false;
+        renderState.authoritativeSync = false;
+        renderState.rerenderRequested = false;
+        renderState.dirtyKeys.clear();
+        try {
+            const agentTab = state.agentTabs.get(agentTabKey);
+            if (!agentTab) {
+                return;
+            }
+            if (isAgentTabVisible(agentTab)) {
+                if (pendingFull) {
+                    this.renderAgentPanel(agentTab, {
+                        reason: 'queued-full'
+                    });
+                } else {
+                    this.renderAgentTranscript(agentTab, {
+                        reason: 'queued-transcript'
+                    });
+                }
+            }
+            if (pendingAuthoritativeSync && agentTab.server?.isAuthenticated) {
+                try {
+                    await syncAgentsForServer(agentTab.server, { force: true });
+                } catch {
+                    // Ignore transient authority sync failures. The next
+                    // heartbeat or state refresh will reconcile.
+                }
+            }
+        } finally {
+            renderState.inFlight = false;
+            if (
+                renderState.full
+                || renderState.authoritativeSync
+                || renderState.dirtyKeys.size > 0
+                || renderState.rerenderRequested
+            ) {
+                const delayMs = renderState.full
+                    ? 0
+                    : AGENT_TRANSCRIPT_RENDER_DEBOUNCE_MS;
+                this.scheduleQueuedAgentPanelRender(agentTabKey, delayMs);
+            }
+        }
+    }
+
+    renderAgentPanelChrome(agentTab) {
         this.agentHeader.textContent = '';
         this.agentMeta.textContent = '';
         this.renderAgentUsageHud(agentTab);
@@ -5687,7 +5800,25 @@ class EditorManager {
         }
 
         this.renderAgentComposerAttachments(agentTab);
+        this.agentTools.innerHTML = '';
+        this.agentTools.style.display = 'none';
+        this.agentPermissions.innerHTML = '';
+        this.agentPermissions.style.display = 'none';
 
+        this.agentPrompt.disabled = false;
+        this.setAgentPromptValue(agentTab.promptDraft || '', agentTab);
+        this.agentPrompt.placeholder = buildAgentPromptPlaceholder(agentTab);
+        this.updateAgentComposerActions(agentTab);
+        this.refreshAgentUsageHud();
+    }
+
+    renderAgentTranscript(agentTab, options = {}) {
+        const previousLayout = this.captureAgentTranscriptLayout();
+        const previousScrollTop = previousLayout?.scrollTop || 0;
+        const wasNearBottom = this.isAgentTranscriptLayoutNearBottom(
+            previousLayout,
+            36
+        );
         const timeline = getAgentTimelineItems(agentTab);
         const shouldPinToBottom = wasNearBottom || (
             agentTab.scrollToBottomOnNextRender
@@ -5782,20 +5913,14 @@ class EditorManager {
         }
         this.updateAgentScrollBottomButton();
         this.rememberAgentTranscriptLayout();
-        this.agentTools.innerHTML = '';
-        this.agentTools.style.display = 'none';
-        this.agentPermissions.innerHTML = '';
-        this.agentPermissions.style.display = 'none';
-
-        this.agentPrompt.disabled = false;
-        this.setAgentPromptValue(agentTab.promptDraft || '', agentTab);
-        this.agentPrompt.placeholder = buildAgentPromptPlaceholder(agentTab);
-        this.updateAgentComposerActions(agentTab);
-        this.refreshAgentTimelineTimestamps();
-        this.refreshAgentUsageHud();
         this.scheduleAgentTranscriptViewportUpdate(shouldPinToBottom);
     }
 
+    renderAgentPanel(agentTab, options = {}) {
+        this.renderAgentPanelChrome(agentTab);
+        this.renderAgentTranscript(agentTab, options);
+    }
+
     buildAgentTimelineNode(agentTab, entry, timelineIndex) {
         if (!entry) {
             return null;
@@ -5939,20 +6064,6 @@ class EditorManager {
         }
     }
 
-    refreshAgentTimelineTimestamps() {
-        if (!this.agentContainer || this.agentContainer.style.display === 'none') {
-            return;
-        }
-        const timestamps = this.agentContainer.querySelectorAll(
-            '.agent-message-time[data-created-at]'
-        );
-        for (const node of timestamps) {
-            const createdAt = String(node.dataset.createdAt || '').trim();
-            if (!createdAt) continue;
-            node.textContent = getAgentMessageTimeLabel({ createdAt });
-        }
-    }
-
     refreshAgentUsageHud() {
         const activeTab = getActiveAgentTab();
         if (!activeTab || !this.agentUsageHud) return;
@@ -6192,9 +6303,7 @@ class EditorManager {
         const item = document.createElement('div');
         item.className = 'agent-message agent-plan-history';
         item.appendChild(buildAgentTimelineHeader(
-            buildAgentTimelineRoleLabel(agentTab, 'plan'),
-            getAgentMessageTimeLabel(planEntry),
-            planEntry.createdAt || ''
+            buildAgentTimelineRoleLabel(agentTab, 'plan')
         ));
         const body = document.createElement('div');
         body.className = 'agent-plan-history-body';
@@ -6222,9 +6331,7 @@ class EditorManager {
         item.className = `agent-message ${message.role} ${message.kind}`;
 
         item.appendChild(buildAgentTimelineHeader(
-            getAgentMessageRoleLabel(agentTab, message),
-            getAgentMessageTimeLabel(message),
-            message.createdAt || ''
+            getAgentMessageRoleLabel(agentTab, message)
         ));
         const attachments = buildAgentMessageAttachmentsNode(
             message.attachments
@@ -6241,11 +6348,7 @@ class EditorManager {
                 && message.kind === 'message'
             ) {
                 const cachedMarkdown = getAgentMessageMarkdownCache(message);
-                if (
-                    !agentTab?.busy
-                    && !isAgentMessageStreaming(agentTab, message)
-                    && cachedMarkdown
-                ) {
+                if (cachedMarkdown) {
                     body.classList.add('markdown');
                     body.innerHTML = cachedMarkdown;
                 } else {
@@ -6275,9 +6378,7 @@ class EditorManager {
         node.className = `agent-tool-call state-${toolStatusClass}`;
 
         node.appendChild(buildAgentTimelineHeader(
-            buildAgentTimelineRoleLabel(agentTab, 'tool'),
-            getAgentMessageTimeLabel(toolCall),
-            toolCall.createdAt || ''
+            buildAgentTimelineRoleLabel(agentTab, 'tool')
         ));
 
         const header = document.createElement('div');
@@ -6384,9 +6485,7 @@ class EditorManager {
                 permission.status === 'pending'
                     ? 'permission request'
                     : 'permission'
-            ),
-            getAgentMessageTimeLabel(permission),
-            permission.createdAt || ''
+            )
         ));
 
         const titleRow = document.createElement('div');
@@ -9270,11 +9369,32 @@ class AgentTab {
         ) || null;
     }
 
-    notifyUi() {
+    notifyUi(options = {}) {
         const session = this.getLinkedSession();
         if (!session) return;
-        session.updateTabUI();
-        refreshWorkspaceIfSessionActive(session);
+        const shouldUpdateTabs = options.updateTabs !== false;
+        if (shouldUpdateTabs) {
+            session.updateTabUI();
+        }
+        if (state.activeSessionKey !== session.key) {
+            return;
+        }
+        if (editorManager.currentSession?.key !== session.key) {
+            editorManager.switchTo(session);
+            return;
+        }
+        if (shouldUpdateTabs) {
+            editorManager.renderEditorTabs();
+        }
+        if (editorManager.getActiveWorkspaceTabKey(session) !== this.key) {
+            return;
+        }
+        editorManager.scheduleAgentPanelRender(this, {
+            full: options.full !== false,
+            delayMs: options.delayMs,
+            dirtyKey: options.dirtyKey || '',
+            authoritativeSync: !!options.authoritativeSync
+        });
     }
 
     update(data) {
@@ -9456,10 +9576,14 @@ class AgentTab {
 
     handleMessage(message) {
         const wasBusy = this.busy;
+        let notifyOptions = { full: true };
         switch (message.type) {
             case 'snapshot':
                 this.update(message.tab || {});
                 this.scrollToBottomOnNextRender = true;
+                notifyOptions = {
+                    full: true
+                };
                 break;
             case 'message_open':
                 this.#upsertMessage(message.message);
@@ -9470,6 +9594,12 @@ class AgentTab {
                 ) {
                     this.streamingAssistantStreamKey = message.message.streamKey;
                 }
+                notifyOptions = {
+                    full: false,
+                    delayMs: AGENT_TRANSCRIPT_RENDER_DEBOUNCE_MS,
+                    dirtyKey: this.#getMessageRenderKey(message.message),
+                    updateTabs: false
+                };
                 break;
             case 'message_chunk':
                 this.#appendChunk(message);
@@ -9480,9 +9610,15 @@ class AgentTab {
                 ) {
                     this.streamingAssistantStreamKey = message.streamKey;
                 }
+                notifyOptions = {
+                    full: false,
+                    delayMs: AGENT_TRANSCRIPT_RENDER_DEBOUNCE_MS,
+                    dirtyKey: this.#getMessageRenderKey(message),
+                    updateTabs: false
+                };
                 break;
             case 'session_update':
-                this.#applySessionUpdate(message.update || {});
+                notifyOptions = this.#applySessionUpdate(message.update || {});
                 if (message.tab?.currentModeId || message.tab?.modeId) {
                     this.currentModeId = message.tab.currentModeId
                         || message.tab.modeId;
@@ -9511,6 +9647,14 @@ class AgentTab {
                         )
                     });
                 }
+                notifyOptions = {
+                    full: false,
+                    delayMs: AGENT_TRANSCRIPT_RENDER_DEBOUNCE_MS,
+                    dirtyKey: this.#getPermissionRenderKey(
+                        message.permission?.id
+                    ),
+                    updateTabs: false
+                };
                 break;
             case 'permission_resolved': {
                 const permission = this.permissions.get(message.permissionId);
@@ -9520,6 +9664,14 @@ class AgentTab {
                         || permission.selectedOptionId
                         || '';
                 }
+                notifyOptions = {
+                    full: false,
+                    delayMs: AGENT_TRANSCRIPT_RENDER_DEBOUNCE_MS,
+                    dirtyKey: this.#getPermissionRenderKey(
+                        message.permissionId
+                    ),
+                    updateTabs: false
+                };
                 break;
             }
             case 'terminal_update':
@@ -9559,18 +9711,22 @@ class AgentTab {
                         return;
                     }
                 }
+                notifyOptions = { full: true };
                 break;
             case 'usage_state':
                 this.usage = this.#normalizeUsageState(message.usage);
+                notifyOptions = { full: true };
                 break;
             case 'status':
                 this.status = message.status || this.status;
                 this.busy = !!message.busy;
                 this.errorMessage = message.errorMessage || '';
+                notifyOptions = { full: true };
                 break;
             case 'complete':
                 this.status = message.status || 'ready';
                 this.busy = !!message.busy;
+                notifyOptions = { full: true };
                 break;
             default:
                 break;
@@ -9611,7 +9767,15 @@ class AgentTab {
             this.needsAttention = false;
         }
         this.#syncBusyWatchdog();
-        this.notifyUi();
+        if (wasBusy && !this.busy) {
+            notifyOptions = {
+                ...notifyOptions,
+                full: true,
+                authoritativeSync: true,
+                delayMs: AGENT_TRANSCRIPT_AUTH_SYNC_DEBOUNCE_MS
+            };
+        }
+        this.notifyUi(notifyOptions);
         if (shouldAutostartQueuedPrompt) {
             this.lastCompletedRunCounter = this.runCounter;
             void drainQueuedAgentPrompt(this);
@@ -9825,13 +9989,39 @@ class AgentTab {
         return this.timelineCounter;
     }
 
+    #getMessageRenderKey(message = {}) {
+        const role = String(message?.role || 'assistant');
+        const kind = String(message?.kind || 'message');
+        const identity = String(
+            message?.id
+            || message?.streamKey
+            || ''
+        ).trim();
+        if (!identity) {
+            return '';
+        }
+        return `message:${role}:${kind}:${identity}`;
+    }
+
+    #getToolRenderKey(toolCallId = '') {
+        const identity = String(toolCallId || '').trim();
+        return identity ? `tool:${identity}` : '';
+    }
+
+    #getPermissionRenderKey(permissionId = '') {
+        const identity = String(permissionId || '').trim();
+        return identity ? `permission:${identity}` : '';
+    }
+
     #findMessageIndex(candidate) {
         if (!candidate) return -1;
         if (candidate.id) {
             const byId = this.messages.findIndex(
                 (message) => message.id === candidate.id
             );
-            return byId;
+            if (byId !== -1) {
+                return byId;
+            }
         }
         if (!candidate.streamKey) return -1;
         for (let index = this.messages.length - 1; index >= 0; index -= 1) {
@@ -9859,7 +10049,12 @@ class AgentTab {
 
         const previous = this.messages[index];
         const nextMessage = this.#normalizeMessage(message, previous.order);
-        const mergedText = selectAgentMessageText(previous.text, nextMessage.text);
+        const mergedText = (
+            !previous.id
+            && nextMessage.id
+                ? (nextMessage.text || '')
+                : selectAgentMessageText(previous.text, nextMessage.text)
+        );
         this.messages[index] = {
             ...previous,
             ...nextMessage,
@@ -9883,16 +10078,22 @@ class AgentTab {
                 existing.text = nextText;
                 clearAgentMessageMarkdownCache(existing);
             }
+            if (Number.isFinite(message?.order)) {
+                existing.order = message.order;
+            }
             return;
         }
 
         const nextMessage = this.#normalizeMessage({
-            id: crypto.randomUUID(),
+            id: typeof message.id === 'string'
+                ? message.id
+                : '',
             streamKey: message.streamKey,
             role: message.role || 'assistant',
             kind: message.kind || 'message',
             text: message.text || '',
-            createdAt: new Date().toISOString()
+            createdAt: new Date().toISOString(),
+            order: message.order
         });
         clearAgentMessageMarkdownCache(nextMessage);
         this.messages.push(nextMessage);
@@ -9908,28 +10109,38 @@ class AgentTab {
                         this.#normalizeTimelineEntry(update, previous?.order)
                     );
                 }
-                break;
+                return {
+                    full: false,
+                    delayMs: AGENT_TRANSCRIPT_RENDER_DEBOUNCE_MS,
+                    dirtyKey: this.#getToolRenderKey(update.toolCallId),
+                    updateTabs: false
+                };
             case 'tool_call_update': {
                 const previous = this.toolCalls.get(update.toolCallId) || {};
                 this.toolCalls.set(update.toolCallId, {
                     ...previous,
                     ...this.#normalizeTimelineEntry(update, previous.order)
                 });
-                break;
+                return {
+                    full: false,
+                    delayMs: AGENT_TRANSCRIPT_RENDER_DEBOUNCE_MS,
+                    dirtyKey: this.#getToolRenderKey(update.toolCallId),
+                    updateTabs: false
+                };
             }
             case 'current_mode_update':
                 this.currentModeId = update.currentModeId || update.modeId || '';
-                break;
+                return { full: true };
             case 'available_commands_update':
                 this.availableCommands = Array.isArray(update.availableCommands)
                     ? update.availableCommands
                     : [];
-                break;
+                return { full: true };
             case 'config_option_update':
                 this.configOptions = Array.isArray(update.configOptions)
                     ? update.configOptions
                     : [];
-                break;
+                return { full: true };
             case 'plan':
                 this.#applyPlanState(
                     Array.isArray(update.entries)
@@ -9938,22 +10149,22 @@ class AgentTab {
                         )
                         : []
                 );
-                break;
+                return { full: true };
             case 'usage_update':
                 this.usage = this.#normalizeUsageState({
                     ...(this.usage || {}),
                     ...update
                 });
-                break;
+                return { full: true };
             case 'session_info_update':
                 if (typeof update.title === 'string') {
                     this.title = update.title;
                 } else if (update.title === null) {
                     this.title = '';
                 }
-                break;
+                return { full: true };
             default:
-                break;
+                return { full: true };
         }
     }
 
@@ -11366,9 +11577,7 @@ function getAgentMessageTimeLabel(message) {
 }
 
 function buildAgentTimelineHeader(
-    roleLabel,
-    timeLabel = '',
-    createdAt = ''
+    roleLabel
 ) {
     const header = document.createElement('div');
     header.className = 'agent-message-header';
@@ -11378,16 +11587,6 @@ function buildAgentTimelineHeader(
     role.textContent = roleLabel;
     header.appendChild(role);
 
-    if (timeLabel) {
-        const time = document.createElement('div');
-        time.className = 'agent-message-time';
-        time.textContent = timeLabel;
-        if (createdAt) {
-            time.dataset.createdAt = createdAt;
-        }
-        header.appendChild(time);
-    }
-
     return header;
 }
 
@@ -13588,18 +13787,51 @@ function upsertAgentTab(server, data) {
     return agentTab;
 }
 
-function getAgentMessageComparableSignature(message) {
-    if (!message || typeof message !== 'object') {
-        return '';
+function buildComparableAgentTimelineTail(source, limit = 6) {
+    const items = [];
+    const messages = Array.isArray(source?.messages) ? source.messages : [];
+    const toolCalls = Array.isArray(source?.toolCalls)
+        ? source.toolCalls
+        : Array.from(source?.toolCalls?.values?.() || []);
+    const permissions = Array.isArray(source?.permissions)
+        ? source.permissions
+        : Array.from(source?.permissions?.values?.() || []);
+    for (const message of messages) {
+        items.push([
+            'message',
+            Number.isFinite(message?.order) ? message.order : 0,
+            String(message?.id || ''),
+            String(message?.streamKey || ''),
+            String(message?.role || ''),
+            String(message?.kind || ''),
+            hashUiText(message?.text || '')
+        ]);
     }
-    return JSON.stringify([
-        message.id || '',
-        message.order || 0,
-        message.role || '',
-        message.kind || '',
-        message.streamKey || '',
-        hashUiText(message.text || '')
-    ]);
+    for (const toolCall of toolCalls) {
+        items.push([
+            'tool',
+            Number.isFinite(toolCall?.order) ? toolCall.order : 0,
+            String(toolCall?.toolCallId || ''),
+            String(toolCall?.status || ''),
+            hashUiText(JSON.stringify(toolCall || null))
+        ]);
+    }
+    for (const permission of permissions) {
+        items.push([
+            'permission',
+            Number.isFinite(permission?.order) ? permission.order : 0,
+            String(permission?.id || ''),
+            String(permission?.status || ''),
+            String(permission?.selectedOptionId || '')
+        ]);
+    }
+    items.sort((left, right) => {
+        if (left[1] !== right[1]) {
+            return left[1] - right[1];
+        }
+        return String(left[0]).localeCompare(String(right[0]));
+    });
+    return JSON.stringify(items.slice(-limit));
 }
 
 function shouldApplyAuthoritativeAgentSnapshot(existing, data) {
@@ -13613,16 +13845,15 @@ function shouldApplyAuthoritativeAgentSnapshot(existing, data) {
     if (!Array.isArray(data.messages)) {
         return true;
     }
-    const currentMessages = Array.isArray(existing.messages)
-        ? existing.messages
-        : [];
-    if (data.messages.length !== currentMessages.length) {
+    if (
+        Array.isArray(data.messages)
+        && Array.isArray(existing.messages)
+        && data.messages.length !== existing.messages.length
+    ) {
         return true;
     }
-    const incomingLast = data.messages[data.messages.length - 1] || null;
-    const currentLast = currentMessages[currentMessages.length - 1] || null;
-    return getAgentMessageComparableSignature(incomingLast)
-        !== getAgentMessageComparableSignature(currentLast);
+    return buildComparableAgentTimelineTail(data)
+        !== buildComparableAgentTimelineTail(existing);
 }
 
 function upsertAgentInventoryTab(server, data) {
@@ -13719,6 +13950,7 @@ function removeAgentTab(agentTabKey) {
     const agentTab = state.agentTabs.get(agentTabKey);
     if (!agentTab) return;
     const session = agentTab.getLinkedSession();
+    editorManager?.clearScheduledAgentPanelRender?.(agentTabKey);
     agentTab.dispose();
     state.agentTabs.delete(agentTabKey);
 

package/src/acp-manager.mjs

@@ -319,6 +319,28 @@ function hasGhCopilotCliInstalled() {
     return ghCopilotCliInstalledCache;
 }
 
+function getCodexAcpPlatformPackage() {
+    const suffixByPlatform = {
+        darwin: {
+            arm64: 'darwin-arm64',
+            x64: 'darwin-x64'
+        },
+        linux: {
+            arm64: 'linux-arm64',
+            x64: 'linux-x64'
+        },
+        win32: {
+            arm64: 'win32-arm64',
+            x64: 'win32-x64'
+        }
+    };
+    const platformSuffix = suffixByPlatform[process.platform]?.[process.arch];
+    if (!platformSuffix) {
+        return '';
+    }
+    return `@zed-industries/codex-acp-${platformSuffix}`;
+}
+
 function readGhAuthToken() {
     if (typeof ghAuthTokenCache === 'string') {
         return ghAuthTokenCache;
@@ -479,6 +501,10 @@ function makeBuiltInDefinitions() {
     const hasGeminiBinary = commandExists('gemini');
     const hasCopilotBinary = commandExists('copilot');
     const hasGhCopilot = hasGhCopilotWrapper();
+    const codexAcpPlatformPackage = getCodexAcpPlatformPackage();
+    const codexAcpPlatformBinary = codexAcpPlatformPackage
+        ? codexAcpPlatformPackage.split('/').pop()
+        : '';
     const definitions = [
         {
             id: 'gemini',
@@ -499,8 +525,17 @@ function makeBuiltInDefinitions() {
             description: 'Codex ACP adapter',
             websiteUrl: 'https://openai.com/codex/',
             command: NPX_COMMAND,
-            args: ['@zed-industries/codex-acp@latest'],
-            commandLabel: 'npx @zed-industries/codex-acp@latest'
+            args: codexAcpPlatformPackage
+                ? [
+                    '-p',
+                    `${codexAcpPlatformPackage}@latest`,
+                    codexAcpPlatformBinary
+                ]
+                : ['@zed-industries/codex-acp@latest'],
+            commandLabel: codexAcpPlatformPackage
+                ? `npx -p ${codexAcpPlatformPackage}@latest `
+                    + `${codexAcpPlatformBinary}`
+                : 'npx @zed-industries/codex-acp@latest'
         },
         {
             id: 'claude',
@@ -1312,8 +1347,18 @@ export function createRestoreCaptureState(messages = [], options = {}) {
     const toolCalls = Array.isArray(options.toolCalls)
         ? options.toolCalls
         : [];
+    const baselineMessages = normalizeAgentTranscriptMessages(messages);
+    const baselineMessagesByStreamKey = new Map();
+    for (const message of baselineMessages) {
+        const streamKey = String(message?.streamKey || '').trim();
+        if (!streamKey) {
+            continue;
+        }
+        baselineMessagesByStreamKey.set(streamKey, message);
+    }
     return {
-        baselineMessages: normalizeAgentTranscriptMessages(messages),
+        baselineMessages,
+        baselineMessagesByStreamKey,
         baselineToolCalls: new Map(
             toolCalls
                 .map((entry) => normalizePersistedTimelineEntry(entry, 0))
@@ -1419,6 +1464,44 @@ function getRestoreCaptureStreamKey(capture, update, role, kind, text = '') {
     return streamKey;
 }
 
+function findMessageIndexByStreamKey(
+    messages = [],
+    streamKey = '',
+    role = '',
+    kind = '',
+    options = {}
+) {
+    const normalizedStreamKey = String(streamKey || '').trim();
+    if (!normalizedStreamKey) {
+        return -1;
+    }
+    if (!options.searchWholeHistory) {
+        const lastIndex = messages.length - 1;
+        if (lastIndex < 0) {
+            return -1;
+        }
+        const lastMessage = messages[lastIndex];
+        return (
+            String(lastMessage?.streamKey || '') === normalizedStreamKey
+            && String(lastMessage?.role || '') === String(role || '')
+            && String(lastMessage?.kind || '') === String(kind || '')
+        )
+            ? lastIndex
+            : -1;
+    }
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (
+            String(message?.streamKey || '') === normalizedStreamKey
+            && String(message?.role || '') === String(role || '')
+            && String(message?.kind || '') === String(kind || '')
+        ) {
+            return index;
+        }
+    }
+    return -1;
+}
+
 export function captureRestoreReplayChunk(capture, update, role, kind, text) {
     if (!capture) return false;
     const chunk = String(text || '');
@@ -1430,20 +1513,29 @@ export function captureRestoreReplayChunk(capture, update, role, kind, text) {
         kind,
         chunk
     );
-    const last = capture.messages[capture.messages.length - 1] || null;
-    if (
-        last
-        && last.streamKey === streamKey
-        && last.role === role
-        && last.kind === kind
-    ) {
-        last.text = mergeAgentMessageText(last.text, chunk);
+    const existingIndex = findMessageIndexByStreamKey(
+        capture.messages,
+        streamKey,
+        role,
+        kind,
+        {
+            searchWholeHistory: !!update?.messageId
+        }
+    );
+    if (existingIndex !== -1) {
+        const existing = capture.messages[existingIndex];
+        existing.text = mergeAgentMessageText(existing.text, chunk);
+        if (typeof capture.nextTimelineOrder === 'function') {
+            existing.order = capture.nextTimelineOrder();
+        }
         return true;
     }
     if (!update?.messageId) {
         capture.messageCounter += 1;
     }
-    const baselineMessage = capture.baselineMessages[capture.messages.length] || null;
+    const baselineMessage = capture.baselineMessagesByStreamKey.get(streamKey)
+        || capture.baselineMessages[capture.messages.length]
+        || null;
     const canReuseBaseline = !!(
         baselineMessage
         && baselineMessage.role === role
@@ -1529,20 +1621,38 @@ export function buildRestoredToolCall(
     previous = null,
     baseline = null,
     update = {},
-    nextTimelineOrder = null
+    nextTimelineOrder = null,
+    options = {}
 ) {
     const persisted = cloneSerializable(baseline, {}) || {};
     const current = cloneSerializable(previous, {}) || {};
-    const nextOrder = normalizePersistedTimelineOrder(current.order, 0)
-        || (
-            typeof nextTimelineOrder === 'function'
-                ? nextTimelineOrder()
-                : normalizePersistedTimelineOrder(persisted.order, 0)
-        )
+    const allowEmptyCreatedAt = options.allowEmptyCreatedAt === true;
+    const hasCurrentCreatedAt = Object.prototype.hasOwnProperty.call(
+        current,
+        'createdAt'
+    );
+    const hasPersistedCreatedAt = Object.prototype.hasOwnProperty.call(
+        persisted,
+        'createdAt'
+    );
+    const nextOrder = (
+        typeof nextTimelineOrder === 'function'
+            ? nextTimelineOrder()
+            : normalizePersistedTimelineOrder(current.order, 0)
+    )
+        || normalizePersistedTimelineOrder(persisted.order, 0)
         || 1;
-    const createdAt = String(
+    const inheritedCreatedAt = String(
         current.createdAt || persisted.createdAt || ''
-    ).trim() || new Date().toISOString();
+    ).trim();
+    const createdAt = inheritedCreatedAt
+        || (
+            allowEmptyCreatedAt
+            || hasCurrentCreatedAt
+            || hasPersistedCreatedAt
+                ? ''
+                : new Date().toISOString()
+        );
     const nextToolCall = {
         ...persisted,
         ...current,
@@ -1642,6 +1752,13 @@ function normalizePersistedTerminalSummary(summary = {}) {
     };
 }
 
+function compareTimelineOrder(left = {}, right = {}) {
+    return (
+        normalizePersistedTimelineOrder(left?.order, 0)
+        - normalizePersistedTimelineOrder(right?.order, 0)
+    );
+}
+
 export function getNextSyntheticStreamTurn(messages = []) {
     if (!Array.isArray(messages) || messages.length === 0) {
         return 0;
@@ -2655,6 +2772,27 @@ class AcpRuntime extends EventEmitter {
 
     serializeTab(tab) {
         tab.messages = normalizeAgentTranscriptMessages(tab.messages);
+        const messages = cloneSerializable(tab.messages, []).sort(
+            compareTimelineOrder
+        );
+        const toolCalls = Array.from(tab.toolCalls.values())
+            .map((item) => cloneSerializable(item, {}))
+            .sort(compareTimelineOrder);
+        const permissions = Array.from(tab.permissions.values())
+            .map((item) => ({
+                id: item.id,
+                sessionId: item.sessionId,
+                toolCall: item.toolCall,
+                options: item.options,
+                status: item.status,
+                createdAt: item.createdAt || '',
+                order: item.order,
+                selectedOptionId: item.selectedOptionId || ''
+            }))
+            .sort(compareTimelineOrder);
+        const plan = Array.isArray(tab.plan)
+            ? cloneSerializable(tab.plan, []).sort(compareTimelineOrder)
+            : [];
         return {
             id: tab.id,
             runtimeId: tab.runtimeId,
@@ -2675,19 +2813,10 @@ class AcpRuntime extends EventEmitter {
             availableCommands: tab.availableCommands,
             sessionCapabilities: this.#getSessionCapabilities(),
             configOptions: tab.configOptions,
-            messages: tab.messages,
-            toolCalls: Array.from(tab.toolCalls.values()),
-            permissions: Array.from(tab.permissions.values()).map((item) => ({
-                id: item.id,
-                sessionId: item.sessionId,
-                toolCall: item.toolCall,
-                options: item.options,
-                status: item.status,
-                createdAt: item.createdAt || '',
-                order: item.order,
-                selectedOptionId: item.selectedOptionId || ''
-            })),
-            plan: Array.isArray(tab.plan) ? tab.plan : [],
+            messages,
+            toolCalls,
+            permissions,
+            plan,
             usage: serializeUsageState(tab.usage),
             terminals: Array.from(tab.terminals.values())
         };
@@ -3148,7 +3277,10 @@ class AcpRuntime extends EventEmitter {
                     previous,
                     baseline,
                     update,
-                    () => this.#nextTimelineOrder(tab)
+                    () => this.#nextTimelineOrder(tab),
+                    {
+                        allowEmptyCreatedAt: !!tab.restoreCapture
+                    }
                 );
                 tab.toolCalls.set(update.toolCallId, nextToolCall);
                 broadcastUpdate = nextToolCall;
@@ -3165,7 +3297,10 @@ class AcpRuntime extends EventEmitter {
                     previous,
                     baseline,
                     update,
-                    () => this.#nextTimelineOrder(tab)
+                    () => this.#nextTimelineOrder(tab),
+                    {
+                        allowEmptyCreatedAt: !!tab.restoreCapture
+                    }
                 );
                 tab.toolCalls.set(update.toolCallId, nextToolCall);
                 broadcastUpdate = nextToolCall;
@@ -3247,23 +3382,30 @@ class AcpRuntime extends EventEmitter {
             };
         }
         const streamKey = this.#getStreamKey(tab, update, role, kind);
-        const last = tab.messages[tab.messages.length - 1] || null;
+        const existingIndex = findMessageIndexByStreamKey(
+            tab.messages,
+            streamKey,
+            role,
+            kind,
+            {
+                searchWholeHistory: !!update?.messageId
+            }
+        );
 
-        if (
-            last
-            && last.streamKey === streamKey
-            && last.role === role
-            && last.kind === kind
-        ) {
-            const nextText = mergeAgentMessageText(last.text, text);
-            const appendedText = nextText.slice(last.text.length);
-            last.text = nextText;
+        if (existingIndex !== -1) {
+            const existing = tab.messages[existingIndex];
+            const nextText = mergeAgentMessageText(existing.text, text);
+            const appendedText = nextText.slice(existing.text.length);
+            const nextOrder = this.#nextTimelineOrder(tab);
+            existing.text = nextText;
+            existing.order = nextOrder;
             this.#broadcast(tab, {
                 type: 'message_chunk',
                 streamKey,
                 role,
                 kind,
-                text: appendedText
+                text: appendedText,
+                order: nextOrder
             });
             return {
                 didChange: true,

package/src/acp-test-agent.mjs

@@ -581,6 +581,53 @@ class TabminalTestAgent {
                 return { stopReason: 'end_turn' };
             }
 
+            if (
+                commandName === 'inline-order'
+                || /synthetic-inline-order/i.test(promptText)
+            ) {
+                await this.connection.sessionUpdate({
+                    sessionId: params.sessionId,
+                    update: {
+                        sessionUpdate: 'agent_message_chunk',
+                        messageId: 'inline-order-message',
+                        content: {
+                            type: 'text',
+                            text: 'Before tool. '
+                        }
+                    }
+                });
+                await this.connection.sessionUpdate({
+                    sessionId: params.sessionId,
+                    update: {
+                        sessionUpdate: 'tool_call',
+                        toolCallId: 'inline-order-tool',
+                        title: 'Inline order tool',
+                        kind: 'execute',
+                        status: 'pending'
+                    }
+                });
+                await this.connection.sessionUpdate({
+                    sessionId: params.sessionId,
+                    update: {
+                        sessionUpdate: 'tool_call_update',
+                        toolCallId: 'inline-order-tool',
+                        status: 'completed'
+                    }
+                });
+                await this.connection.sessionUpdate({
+                    sessionId: params.sessionId,
+                    update: {
+                        sessionUpdate: 'agent_message_chunk',
+                        messageId: 'inline-order-message',
+                        content: {
+                            type: 'text',
+                            text: 'After tool.'
+                        }
+                    }
+                });
+                return { stopReason: 'end_turn' };
+            }
+
             if (
                 commandName === 'demo'
                 || commandName === 'diff'