newmark-agent 0.4.9 → 0.5.0

package/dist/server.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOBILE_WORKSPACE_UPLOAD_MAX_BYTES = void 0;
 exports.configureHostedServer = configureHostedServer;
 exports.stopHostedServer = stopHostedServer;
 exports.hostedServerStatus = hostedServerStatus;
@@ -43,6 +44,7 @@ const http = __importStar(require("http"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
+const crypto_1 = require("crypto");
 const uiPreferences_1 = require("./core/uiPreferences");
 const child_process_1 = require("child_process");
 const agent_1 = require("./core/agent");
@@ -53,6 +55,7 @@ const workspaceFileRouter_1 = require("./core/workspaceFileRouter");
 const nativeBash_1 = require("./core/nativeBash");
 const installUpdate_1 = require("./core/installUpdate");
 const mobilePairing_1 = require("./core/mobilePairing");
+const workEventCoalescer_1 = require("./core/workEventCoalescer");
 const PORT = 47890;
 let agent = null;
 let automation = null;
@@ -86,9 +89,12 @@ function publishMobileWorkEvent(event) {
     }
 }
 function publishServerWorkEvent(event) {
+    serverWorkEventCoalescer.push(event);
+}
+const serverWorkEventCoalescer = new workEventCoalescer_1.WorkEventCoalescer(event => {
     publishMobileWorkEvent(event);
     hostedWorkEventSink?.(event);
-}
+});
 function mobileAuthorized(req) {
     if (!mobileToken)
         return false;
@@ -124,6 +130,8 @@ const MOBILE_EDITABLE_EXTENSIONS = new Set([
     '.bash', '.zsh', '.ps1', '.bat', '.cmd', '.sql', '.tex', '.typ', '.properties', '.gradle', '.gitignore',
 ]);
 const MOBILE_EDITOR_MAX_BYTES = 1024 * 1024;
+const MAX_API_BODY_BYTES = 30 * 1024 * 1024;
+exports.MOBILE_WORKSPACE_UPLOAD_MAX_BYTES = 64 * 1024 * 1024;
 function resolveMobileWorkspacePath(ws, relativePath) {
     const root = path.resolve(ws.path);
     const clean = String(relativePath || '').replace(/\\/g, '/').replace(/^\/+/, '');
@@ -142,6 +150,156 @@ function mobileEditableFile(target) {
     const base = path.basename(target).toLowerCase();
     return MOBILE_EDITABLE_EXTENSIONS.has(path.extname(base)) || MOBILE_EDITABLE_EXTENSIONS.has(base);
 }
+function validMobileUploadDirectory(value) {
+    const clean = String(value || '').replace(/\\/g, '/');
+    return !path.isAbsolute(clean)
+        && !/^[A-Za-z]:\//.test(clean)
+        && !clean.split('/').some(segment => segment === '..' || segment.includes('\0'));
+}
+function validMobileUploadFileName(value) {
+    const clean = String(value || '');
+    return clean.length > 0
+        && clean.length <= 255
+        && clean !== '.'
+        && clean !== '..'
+        && !clean.includes('/')
+        && !clean.includes('\\')
+        && !clean.includes('\0')
+        && path.basename(clean) === clean;
+}
+function numberedUploadName(fileName, index) {
+    if (index <= 0)
+        return fileName;
+    const extension = path.extname(fileName);
+    const stem = fileName.slice(0, fileName.length - extension.length);
+    return `${stem} (${index})${extension}`;
+}
+async function handleMobileWorkspaceUpload(req, res) {
+    if (agent && !agent.config.getBool('remote', 'touch_enabled')) {
+        mobileJson(res, { error: 'Remote touch disabled' }, 403);
+        req.resume();
+        return;
+    }
+    if (!mobileAuthorized(req)) {
+        mobileJson(res, { error: 'Unauthorized' }, 401);
+        req.resume();
+        return;
+    }
+    if (!agent) {
+        mobileJson(res, { error: 'Agent not initialized' }, 500);
+        req.resume();
+        return;
+    }
+    const url = new URL(req.url || '/', `http://localhost:${PORT}`);
+    const workspaceId = url.searchParams.get('workspaceId') || '';
+    const directory = url.searchParams.get('directory') || '';
+    const fileName = url.searchParams.get('fileName') || '';
+    const ws = resolveMobileWorkspace(agent, workspaceId);
+    if (!ws) {
+        mobileJson(res, { error: 'Unknown workspace' }, 404);
+        req.resume();
+        return;
+    }
+    if (!validMobileUploadDirectory(directory) || !validMobileUploadFileName(fileName)) {
+        mobileJson(res, { error: 'Invalid upload path or file name' }, 400);
+        req.resume();
+        return;
+    }
+    const declaredLength = Number(req.headers['content-length'] || -1);
+    if (Number.isFinite(declaredLength) && declaredLength > exports.MOBILE_WORKSPACE_UPLOAD_MAX_BYTES) {
+        mobileJson(res, { error: 'Upload exceeds the 64 MiB limit' }, 413);
+        req.resume();
+        return;
+    }
+    let temporaryPath = '';
+    try {
+        const resolved = resolveMobileWorkspacePath(ws, directory);
+        const realRoot = await fs.promises.realpath(resolved.root);
+        if (directory === 'Uploaded') {
+            await fs.promises.mkdir(resolved.target, { recursive: true });
+        }
+        const realDirectory = await fs.promises.realpath(resolved.target);
+        const canonicalRelative = path.relative(realRoot, realDirectory);
+        if (canonicalRelative === '..' || canonicalRelative.startsWith(`..${path.sep}`) || path.isAbsolute(canonicalRelative)) {
+            throw new Error('Path escapes workspace through a symbolic link');
+        }
+        const directoryStat = await fs.promises.stat(realDirectory);
+        if (!directoryStat.isDirectory()) {
+            mobileJson(res, { error: 'Upload destination is not a directory' }, 400);
+            req.resume();
+            return;
+        }
+        temporaryPath = path.join(realDirectory, `.newmark-upload-${(0, crypto_1.randomUUID)()}.tmp`);
+        const handle = await fs.promises.open(temporaryPath, 'wx', 0o600);
+        const hash = (0, crypto_1.createHash)('sha256');
+        let size = 0;
+        try {
+            for await (const part of req) {
+                const chunk = Buffer.isBuffer(part) ? part : Buffer.from(part);
+                size += chunk.length;
+                if (size > exports.MOBILE_WORKSPACE_UPLOAD_MAX_BYTES)
+                    throw new RangeError('Upload exceeds the 64 MiB limit');
+                hash.update(chunk);
+                let offset = 0;
+                while (offset < chunk.length) {
+                    const { bytesWritten } = await handle.write(chunk, offset, chunk.length - offset);
+                    if (bytesWritten <= 0)
+                        throw new Error('Unable to write the complete upload');
+                    offset += bytesWritten;
+                }
+            }
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        let finalPath = '';
+        let finalName = '';
+        let published = false;
+        for (let index = 0; index < 10_000; index++) {
+            finalName = numberedUploadName(fileName, index);
+            finalPath = path.join(realDirectory, finalName);
+            try {
+                // A hard link publishes the already-complete inode atomically and fails
+                // with EEXIST, so parallel uploads can never overwrite one another.
+                await fs.promises.link(temporaryPath, finalPath);
+                published = true;
+                break;
+            }
+            catch (error) {
+                if (error?.code === 'EEXIST')
+                    continue;
+                throw error;
+            }
+        }
+        if (!published)
+            throw new Error('Unable to allocate a unique upload name');
+        await fs.promises.unlink(temporaryPath);
+        temporaryPath = '';
+        const relativePath = path.posix.join(resolved.relative, finalName).replace(/^\.\//, '');
+        const suppliedMime = String(req.headers['content-type'] || 'application/octet-stream').split(';')[0].trim();
+        const mimeType = /^[\w.+-]+\/[\w.+-]+$/.test(suppliedMime) ? suppliedMime : 'application/octet-stream';
+        mobileJson(res, {
+            ok: true,
+            file: { name: finalName, path: relativePath, size, mimeType, sha256: hash.digest('hex'), created: true },
+        }, 201);
+    }
+    catch (error) {
+        if (temporaryPath)
+            await fs.promises.unlink(temporaryPath).catch(() => { });
+        if (error instanceof RangeError)
+            mobileJson(res, { error: error.message }, 413);
+        else if (error?.code === 'ENOENT' || error?.code === 'ENOTDIR') {
+            mobileJson(res, { error: 'Upload destination does not exist' }, 400);
+        }
+        else if (String(error?.message || '').toLowerCase().includes('workspace')) {
+            mobileJson(res, { error: 'Invalid upload destination' }, 400);
+        }
+        else {
+            mobileJson(res, { error: 'Upload could not be stored' }, 500);
+        }
+    }
+}
 function mobileRightSidebarState(current, ws, conversationId) {
     const scoped = mobileScopedAgent(ws, conversationId);
     return {
@@ -1483,10 +1641,30 @@ function startServer(root, options = {}) {
             handleMobileEvents(req, res);
             return;
         }
+        if (req.method === 'POST' && url.pathname === '/api/mobile/workspace-file-upload') {
+            await handleMobileWorkspaceUpload(req, res);
+            return;
+        }
         if (req.method === 'POST' && url.pathname.startsWith('/api/')) {
             let body = '';
-            req.on('data', chunk => body += chunk);
-            req.on('end', () => handleApi(req, res, body));
+            let bodyBytes = 0;
+            let rejected = false;
+            req.on('data', chunk => {
+                if (rejected)
+                    return;
+                bodyBytes += Buffer.byteLength(chunk);
+                if (bodyBytes > MAX_API_BODY_BYTES) {
+                    rejected = true;
+                    if (url.pathname.startsWith('/api/mobile/'))
+                        mobileJson(res, { error: 'Request body too large' }, 413);
+                    else
+                        jsonResponse(res, { error: 'Request body too large' }, 413);
+                    return;
+                }
+                body += chunk;
+            });
+            req.on('end', () => { if (!rejected)
+                handleApi(req, res, body); });
             return;
         }
         if (url.pathname.startsWith('/api/')) {

package/dist/ui/index.html

@@ -6156,6 +6156,8 @@ var state = {
   agentWorkUiByConversation: {},
   workRunsByTarget: {},
   workRunsByBranch: {},
+  conversationMessagesByTarget: {},
+  pendingConversationActivations: {},
   runtimeBranchPathsByTarget: {},
   workRunAnchorIndexesByTarget: {},
   guideMessagesByTarget: {},
@@ -9656,11 +9658,18 @@ function recordGuideUiMessage(input, target) {
     createdAt: String(receipt.createdAt || input.createdAt || (prior && prior.createdAt) || new Date().toISOString()),
     updatedAt: String(receipt.updatedAt || input.updatedAt || new Date().toISOString()),
     reason: explicitReason || (status === 'deferred' || status === 'rejected' ? String(prior && prior.reason || '') : ''),
+    awaitingAck: input.awaitingAck === true || receipt.awaitingAck === true,
     attachments: normalizeConversationImageAttachments(input.attachments || receipt.attachments || (prior && prior.attachments) || [])
   };
   messages[clientMessageId] = record;
   if (isActiveConversationTarget(target)) {
     var element = findGuideMessageElement(clientMessageId);
+    if (element) {
+      if (prior && prior.awaitingAck && !record.awaitingAck && element.closest && element.closest('.work-run-pending-guides')) {
+        element.remove();
+        element = null;
+      }
+    }
     if (element) {
       applyGuideMessageMeta(element, record);
       if (record.runId && !element.classList.contains('work-run-guide-message')) element.remove();
@@ -9701,6 +9710,26 @@ function renderPendingGuideMessages(target, persistedGuideIds) {
   });
   pending.forEach(function(item) {
     var element = findGuideMessageElement(item.clientMessageId);
+    if (item.awaitingAck && item.runId) {
+      var runElement = findWorkRunElement({ runId: item.runId });
+      var runBody = runElement && runElement.querySelector('.conversation-work-run-body');
+      if (runBody) {
+        var pendingStack = runBody.querySelector(':scope > .work-run-pending-guides');
+        if (!pendingStack) {
+          pendingStack = document.createElement('div');
+          pendingStack.className = 'work-run-pending-guides';
+          runBody.appendChild(pendingStack);
+        }
+        if (!element || !pendingStack.contains(element)) {
+          var holder = document.createElement('div');
+          holder.innerHTML = renderWorkRunGuideMessage(Object.assign({}, item, { status: 'accepted' }));
+          element = holder.firstElementChild;
+          if (element) pendingStack.appendChild(element);
+        }
+        if (element) applyGuideMessageMeta(element, item);
+        return;
+      }
+    }
     if (element) applyGuideMessageMeta(element, item);
     else addMsg('user', item.content || 'Guide', 'guide', item.model || state.model, undefined, {
       clientMessageId: item.clientMessageId,
@@ -9964,7 +9993,7 @@ function normalizedWorkRun(run, target) {
   var status = String(run.status || 'running');
   var live = ['running', 'stopping', 'force_restarting'].indexOf(status) >= 0;
   var expanded = run.expanded === undefined
-    ? live && state.expandToolsDefault !== false
+    ? (status === 'error' || (live && state.expandToolsDefault !== false))
     : !!run.expanded;
   return {
     runId: String(run.runId || run.id || ('run-' + Date.now() + '-' + Math.random().toString(16).slice(2))),
@@ -10632,6 +10661,7 @@ function updateConversationWorkRunElement(run, element) {
     '<span class="conversation-work-run-status">' + esc(String(run.status || '')) + '</span>' +
     '<span class="conversation-work-run-chevron" aria-hidden="true"></span></button>' +
     '<div class="conversation-work-run-body">' + renderWorkRunEvents(run, expanded) + '</div>';
+  renderPendingGuideMessages(run.target, {});
   var wrapper = element.closest ? element.closest('.work-run-message') : null;
   if (wrapper) {
     wrapper.classList.toggle('flow-result-only', !!(run.flow && run.flow.activityVisibility === 'result-only'));
@@ -10778,14 +10808,14 @@ function applyAgentWorkEventToRun(event) {
   }
   run.sequence = Math.max(Number(run.sequence || 0), Number(event.sequence || 0));
   if (type === 'done') { run.status = 'completed'; run.endedAt = event.endedAt || event.timestampIso || new Date().toISOString(); if (run.userToggled !== true) run.expanded = false; }
-  else if (type === 'error') { run.status = 'error'; run.endedAt = event.endedAt || event.timestampIso || new Date().toISOString(); if (run.userToggled !== true) run.expanded = false; }
+  else if (type === 'error') { run.status = 'error'; run.endedAt = event.endedAt || event.timestampIso || new Date().toISOString(); if (run.userToggled !== true) run.expanded = true; }
   else if (type === 'interrupted') { run.status = 'interrupted'; run.endedAt = event.endedAt || event.timestampIso || new Date().toISOString(); if (run.userToggled !== true) run.expanded = false; }
   else if (type === 'force_interrupted') { run.status = 'force_interrupted'; run.endedAt = event.endedAt || event.timestampIso || new Date().toISOString(); if (run.userToggled !== true) run.expanded = false; }
   else if (event.status && type.indexOf('guide') !== 0) {
     run.status = String(event.status);
     if (['completed', 'interrupted', 'force_interrupted', 'error'].indexOf(run.status) >= 0) {
       run.endedAt = event.endedAt || event.timestampIso || new Date().toISOString();
-      if (run.userToggled !== true) run.expanded = false;
+      if (run.userToggled !== true) run.expanded = run.status === 'error';
     }
   }
   if (isActiveConversationTarget(target) && (!branchIds.viewed || !eventBranchId || branchIds.viewed === eventBranchId)) {
@@ -11066,14 +11096,58 @@ function renderPersistedToolMessage(message) {
   }, resultPrefix.test(content) || /\bcompleted\.?$/i.test(content) ? 'completed' : '');
 }
 
-function renderChatMessages(messages) {
-  state.renderedChatMessages = Array.isArray(messages) ? messages.map(function(message) { return Object.assign({}, message); }) : [];
+function conversationMessageCache(target) {
+  var scopedTarget = target || currentConversationTarget();
+  var key = runtimeKeyFor(scopedTarget.workspaceId, scopedTarget.conversationId);
+  if (!state.conversationMessagesByTarget) state.conversationMessagesByTarget = {};
+  return Array.isArray(state.conversationMessagesByTarget[key])
+    ? state.conversationMessagesByTarget[key].map(function(message) { return Object.assign({}, message); })
+    : [];
+}
+
+function cacheConversationMessages(messages, target) {
+  var scopedTarget = target || currentConversationTarget();
+  var key = runtimeKeyFor(scopedTarget.workspaceId, scopedTarget.conversationId);
+  var cloned = Array.isArray(messages) ? messages.map(function(message) { return Object.assign({}, message); }) : [];
+  if (!state.conversationMessagesByTarget) state.conversationMessagesByTarget = {};
+  state.conversationMessagesByTarget[key] = cloned;
+  return cloned.map(function(message) { return Object.assign({}, message); });
+}
+
+function conversationHasReadableHistory(target) {
+  return conversationMessageCache(target).length > 0 || workRunsForTarget(target).length > 0;
+}
+
+function snapshotHasReadableConversationHistory(snapshot) {
+  return !!(snapshot && ((Array.isArray(snapshot.chatMessages) && snapshot.chatMessages.length > 0)
+    || (Array.isArray(snapshot.workRuns) && snapshot.workRuns.length > 0)));
+}
+
+function renderConversationHistoryFirst(target) {
+  if (!isActiveConversationTarget(target)) return false;
+  var cachedMessages = conversationMessageCache(target);
+  if (cachedMessages.length > 0) {
+    renderChatMessages(cachedMessages, target);
+    renderLoadEarlierButton();
+    return true;
+  }
+  if (workRunsForTarget(target).length > 0) {
+    renderChatMessages([], target);
+    renderLoadEarlierButton();
+    return true;
+  }
+  return false;
+}
+
+function renderChatMessages(messages, target) {
+  var renderTarget = target || currentConversationTarget(activeConversationId());
+  var normalizedMessages = cacheConversationMessages(messages, renderTarget);
+  state.renderedChatMessages = normalizedMessages;
   if (!els['chat-area']) return;
   var chatWasAtBottom = shouldAutoScroll(els['chat-area']);
   els['chat-area'].innerHTML = '';
   if (chatWasAtBottom) _chatShouldAutoScroll = true;
-  var renderConversationId = activeConversationId();
-  var renderTarget = currentConversationTarget(renderConversationId);
+  var renderConversationId = renderTarget.conversationId;
   var guideMessages = guideMessagesForTarget(renderTarget);
   var persistedGuideIds = {};
   var persistedRuns = workRunsForTarget(renderTarget).slice();
@@ -11099,7 +11173,7 @@ function renderChatMessages(messages) {
       persistedRunIndexes[runId] = runIndex;
     }
   });
-  (Array.isArray(messages) ? messages : []).forEach(function(message, messageIndex) {
+  normalizedMessages.forEach(function(message, messageIndex) {
     var runId = String(message && message.runId || '');
     var role = String(message && message.role || '');
     var indexedGuideId = String(message && message.clientMessageId || '');
@@ -11144,7 +11218,7 @@ function renderChatMessages(messages) {
   var pendingWorkReview = conversationWorkUiState(renderConversationId).pendingWorkReview;
   resetConversationWorkUi(renderConversationId, false);
   conversationWorkUiState(renderConversationId).pendingWorkReview = pendingWorkReview;
-  if (!messages || !messages.length) {
+  if (!normalizedMessages.length) {
     persistedRuns.forEach(function(run) { renderOwnedWorkRun(run, true); });
     var pendingGuideCount = renderPendingGuideMessages(renderTarget, persistedGuideIds);
     if (!persistedRuns.length && !pendingGuideCount) {
@@ -11582,8 +11656,19 @@ function loadActiveConversationMessages(conversationId) {
       requestedConversationId === String(activeConversationId() || 'default') &&
       responseConversationId === requestedConversationId;
     if (!responseIsCurrent) return;
-    applyConversationSnapshot(s, requestedConversationId);
-  }).catch(function(){});
+    applyConversationSnapshot(s, requestedConversationId, { preserveReadableHistory: true, allowEmptyHistory: true });
+  }).catch(function(error) {
+    var stillCurrent = loadGeneration === state.conversationLoadGeneration &&
+      requestedWorkspaceKey === currentWorkspaceKey() &&
+      requestedConversationId === String(activeConversationId() || 'default');
+    if (!stillCurrent) return;
+    showUiNotice(
+      currentLang() === 'zh' ? '历史记录增强加载失败，已保留当前内容。' : 'History enhancement failed; current content was preserved.',
+      'error',
+      'conversation-history-load-' + requestedWorkspaceKey + '-' + requestedConversationId
+    );
+    console.error('[Conversation] history enhancement failed:', error && error.message ? error.message : String(error));
+  });
 }
 
 function hydrateConversationBranchState(snapshot) {
@@ -11600,7 +11685,7 @@ function hydrateConversationBranchState(snapshot) {
   rememberRuntimeConversationBranchPath(currentConversationTarget(s.conversationId || activeConversationId()));
 }
 
-function applyConversationSnapshot(s, requestedConversationId) {
+function applyConversationSnapshot(s, requestedConversationId, options) {
   if (!s) return;
   if (s.computerUse) {
     var computerTarget = currentConversationTarget(s.conversationId || requestedConversationId || activeConversationId());
@@ -11616,18 +11701,21 @@ function applyConversationSnapshot(s, requestedConversationId) {
       workspaceId: String((s && (s.workspaceId || (s.target && s.target.workspaceId))) || runtimeWorkspaceId('')),
       conversationId: String((s && (s.conversationId || (s.target && s.target.conversationId))) || requestedConversationId)
     };
+    var preserveReadableHistory = !!(options && options.preserveReadableHistory
+      && !snapshotHasReadableConversationHistory(s)
+      && (!options.allowEmptyHistory || conversationHasReadableHistory(snapshotTarget)));
     if (s && s.runtimeKey) registerRuntimeKey(snapshotTarget, s.runtimeKey);
     hydrateConversationBranchState(s);
     rebindQueueToRuntimeBranch(snapshotTarget);
-    if (s && Array.isArray(s.workRuns)) {
+    if (s && Array.isArray(s.workRuns) && !preserveReadableHistory) {
       var viewedBranchIdForSync = Array.isArray(s.viewedBranchNodePath) && s.viewedBranchNodePath.length
         ? String(s.viewedBranchNodePath[s.viewedBranchNodePath.length - 1])
         : '';
       syncWorkRunsSnapshot(s.workRuns, snapshotTarget, viewedBranchIdForSync || undefined);
     }
     applyAutoRouteRatingState(s);
-    if (s && s.chatMessages) {
-      renderChatMessages(s.chatMessages);
+    if (s && Array.isArray(s.chatMessages) && !preserveReadableHistory) {
+      renderChatMessages(s.chatMessages, snapshotTarget);
       renderLoadEarlierButton();
     }
     if (s && s.conversationId) {
@@ -13513,18 +13601,10 @@ window.sendMessage = async function(modeOverride, queuedText, opts) {
       attachments: optimisticAttachments,
       model: state.model,
       createdAt: envelope.createdAt,
+      awaitingAck: true,
       allowStatusReset: retryingUnacknowledgedGuide
     }, lockedTarget);
-    applyAgentWorkEventToRun({
-      id: 'guide-' + clientMessageId + '-accepted',
-      type: 'guide_accepted',
-      content: displayText,
-      workspaceId: lockedTarget.workspaceId,
-      conversationId: lockedTarget.conversationId,
-      runId: envelope.runId,
-      clientMessageId: clientMessageId,
-      guide: optimisticGuide
-    });
+    renderPendingGuideMessages(lockedTarget, {});
     var enqueue = api.enqueueGuide ? api.enqueueGuide(envelope) : api.sendMessage(requestMessage, lockedConversationId);
     return Promise.resolve(enqueue).then(function(receipt) {
       if (!receipt || typeof receipt !== 'object' || !String(receipt.status || '').trim()) {
@@ -13680,6 +13760,8 @@ window.sendMessage = async function(modeOverride, queuedText, opts) {
   var responseMsg = null;
   var sendFailure = '';
   try {
+    var activationBeforeSend = pendingConversationActivation(lockedTarget);
+    if (activationBeforeSend) await activationBeforeSend;
     var sendPromise = api.sendMessage(requestMessage, lockedTarget);
     if (requestedMode === 'goal') activateSubmittedGoal(opts.goalObjective || rawText);
     var r = await sendPromise;
@@ -19348,6 +19430,12 @@ function holdForegroundConversation(id, ms) {
   state.foregroundConversationHoldUntil = Date.now() + (ms || 4500);
 }
 
+function pendingConversationActivation(target) {
+  var scopedTarget = target || currentConversationTarget();
+  var key = runtimeKeyFor(scopedTarget.workspaceId, scopedTarget.conversationId);
+  return state.pendingConversationActivations && state.pendingConversationActivations[key];
+}
+
 function applyBackendConversations(items, activeId, workspaceId) {
   if (!state.currentWorkspace || !items || !items.length) return;
   var key = currentWorkspaceKey(workspaceId);
@@ -19409,14 +19497,24 @@ function syncBackendConversation() {
   }
   if (conv && api.ensureConversation) {
     var requestedTarget = currentConversationTarget(conv.id);
+    state.activeBackendConversationId = conv.id;
+    var historyPromise = loadActiveConversationMessages(conv.id);
     var activate = api.activateConversation ? api.activateConversation(requestedTarget) : api.ensureConversation(requestedTarget);
-    return activate.then(function(s) {
+    var activationPromise = activate.then(function(s) {
       var id = (s && s.conversationId) || conv.id;
       if (!requestIsCurrent() || String(id) !== requestedConversationId) return;
       state.activeBackendConversationId = id;
-      applyConversationSnapshot(s, id);
-      if (s && s.runtimeDeferred) return loadActiveConversationMessages(id);
-    }).catch(function(){});
+      applyConversationSnapshot(s, id, { preserveReadableHistory: true });
+    }).catch(function(error) {
+      if (!requestIsCurrent()) return;
+      showUiNotice(
+        currentLang() === 'zh' ? '对话运行时激活失败，历史记录仍可查看。' : 'Conversation runtime activation failed; history remains available.',
+        'error',
+        'conversation-activation-' + requestedWorkspaceKey + '-' + requestedConversationId
+      );
+      console.error('[Conversation] runtime activation failed:', error && error.message ? error.message : String(error));
+    });
+    return Promise.allSettled([historyPromise, activationPromise]);
   }
   if (conv) {
     if (!requestIsCurrent()) return Promise.resolve();
@@ -19632,10 +19730,11 @@ window.newConversation = function(workspaceReference, branchCommunication) {
   els['chat-area'].innerHTML = '';
   var target = currentConversationTarget(id);
   var activation = api.activateConversation ? api.activateConversation(target) : (api.ensureConversation ? api.ensureConversation(target) : Promise.resolve(null));
-  return activation.then(function(s) {
+  var activationKey = runtimeKeyFor(target.workspaceId, target.conversationId);
+  var activationReady = activation.then(function(s) {
     if (createdWorkspaceKey !== currentWorkspaceKey() || id !== String(activeConversationId() || 'default')) return;
     state.activeBackendConversationId = String((s && s.conversationId) || id);
-    if (s) applyConversationSnapshot(s, id);
+    if (s) applyConversationSnapshot(s, id, { preserveReadableHistory: true });
     if (branchCommunication && api.setConversationBranchCommunication) {
       api.setConversationBranchCommunication(target, true).then(function() {
         var convsNow = currentWorkspaceConversations();
@@ -19645,16 +19744,23 @@ window.newConversation = function(workspaceReference, branchCommunication) {
     }
   }).then(function() {
     if (createdWorkspaceKey !== currentWorkspaceKey() || id !== String(activeConversationId() || 'default')) return;
-    state.foregroundConversationHoldId = '';
-    state.foregroundConversationHoldUntil = 0;
-    renderChatMessages([]);
-    addMsg('system', '[System] ' + t('workspace.newConversation') + ': ' + summary, 'system', '');
+    if (!conversationHasReadableHistory(target)) {
+      renderChatMessages([], target);
+      addMsg('system', '[System] ' + t('workspace.newConversation') + ': ' + summary, 'system', '');
+    }
   }).catch(function(error) {
     if (createdWorkspaceKey === currentWorkspaceKey() && id === String(activeConversationId() || 'default')) {
       showUiNotice((currentLang() === 'zh' ? '新对话持久化失败：' : 'Failed to persist the new conversation: ') + (error && error.message ? error.message : String(error)), 'error', 'new-conversation-activation-' + id);
     }
     throw error;
+  }).finally(function() {
+    if (state.pendingConversationActivations && state.pendingConversationActivations[activationKey] === activationReady) {
+      delete state.pendingConversationActivations[activationKey];
+    }
   });
+  if (!state.pendingConversationActivations) state.pendingConversationActivations = {};
+  state.pendingConversationActivations[activationKey] = activationReady;
+  return activationReady;
 };
 
 window.showNewConversationPage = function() {
@@ -19724,7 +19830,7 @@ window.switchConversation = function(idx) {
   renderConversations();
   var switchSeq = (state._conversationSwitchSeq || 0) + 1;
   state._conversationSwitchSeq = switchSeq;
-  els['chat-area'].innerHTML = '';
+  var restoredReadableHistory = renderConversationHistoryFirst(activeBrowserTarget);
   // The Flow takeover bubble is conversation-local. Immediately reconcile it to
   // the newly active conversation: if the incoming conversation owns a Flow,
   // show it; otherwise hide the bubble instantly so no takeover ever leaks
@@ -19733,7 +19839,9 @@ window.switchConversation = function(idx) {
   if (state._conversationLoadingMsgEl && state._conversationLoadingMsgEl.parentNode) {
     state._conversationLoadingMsgEl.parentNode.removeChild(state._conversationLoadingMsgEl);
   }
-  state._conversationLoadingMsgEl = addMsg('workflow running', t('conversation.loadingIsolated'), 'system', state.model);
+  state._conversationLoadingMsgEl = restoredReadableHistory
+    ? null
+    : addMsg('workflow running', t('conversation.loadingIsolated'), 'system', state.model);
   syncBackendConversation().then(function() {
     // Only the latest switch may touch the UI: an earlier switch's sync
     // resolution must not restore drafts into or re-render the now-current