newmark-agent 0.3.10 → 0.3.12

package/dist/ui/index.html

@@ -5461,6 +5461,7 @@ html.newmark-memory-overview-viewer body {
             <button class="shell-btn browser-action-btn" onclick="window.browserReload()" title="Reload"><svg class="nm-icon small" aria-hidden="true" focusable="false"><use href="#refresh-cw"></use></svg><span class="icon-only-label">Reload</span></button>
             <input class="browser-url-input" id="browser-url" placeholder="Enter URL..." onkeydown="if(event.key==='Enter')window.navigateBrowser(this.value)">
             <button class="shell-btn" onclick="window.navigateBrowser(document.getElementById('browser-url').value)" title="Go"><svg class="nm-icon small" aria-hidden="true" focusable="false"><use href="#send"></use></svg><span class="icon-only-label">Go</span></button>
+            <button class="shell-btn" id="computer-use-toggle" onclick="window.toggleComputerUse()" title="ComputerUse: enabled for this conversation" aria-pressed="true">CU</button>
           </div>
           <div class="browser-frame" id="browser-frame">
             <div class="browser-guest-placeholder" id="browser-guest-placeholder">Browser loads on first use</div>
@@ -5681,6 +5682,7 @@ var state = {
   terminalInterruptTimeoutMs: 0,
   nativeTools: [],
   nativeToolEnabled: {},
+  computerUseByTarget: {},
   sshConnections: [],
   _layoutSaveTimer: null,
   _sendInFlight: false
@@ -6061,6 +6063,7 @@ var NEWMARK_I18N = {
     'flow.nextDisabled': 'Flow only accepts Guide input; Next is disabled.',
     'flow.saved': 'Flow saved',
     'flow.emptyRun': 'Flow is empty and cannot run.',
+    'flow.noAvailable': 'No workflows are available to run.',
     'flow.started': 'Flow started',
     'plugins.title': 'Plugins',
     'plugins.mcp': 'MCP Management',
@@ -6626,6 +6629,7 @@ var NEWMARK_I18N = {
     'flow.nextDisabled': 'Flow 仅允许 Guide 输入，已禁用 Next。',
     'flow.saved': 'Flow 已保存',
     'flow.emptyRun': 'Flow 为空，无法运行。',
+    'flow.noAvailable': '当前没有可运行的工作流。',
     'flow.started': 'Flow 已启动',
     'plugins.title': '插件',
     'plugins.mcp': 'MCP 管理',
@@ -8327,15 +8331,26 @@ function addWorkReview(diffs) {
   return review;
 }
 
-function updateMsg(div, text, role, mode, model) {
+var STREAMING_PLAIN_TEXT_THRESHOLD = 12000;
+var STREAMING_LARGE_TEXT_INTERVAL_MS = 100;
+
+function updateMsg(div, text, role, mode, model, options) {
   if (!div) return;
   if (role) div.className = 'chat-msg ' + role;
   text = redactSensitiveText(text);
   div._newmarkMessageText = String(text || '');
   var body = div.querySelector('.msg-body');
-  if (body) body.innerHTML = renderMessageContent(text);
+  var streaming = !!(options && options.streaming);
+  if (body) {
+    // Re-running the full Markdown parser and rebuilding the entire message
+    // DOM for every streamed token makes long responses monopolize the
+    // renderer event loop. Keep large in-flight responses as one safe text
+    // node; the terminal `done`/`final_response` path renders Markdown once.
+    if (streaming && String(text || '').length >= STREAMING_PLAIN_TEXT_THRESHOLD) body.textContent = text;
+    else body.innerHTML = renderMessageContent(text);
+  }
   var meta = div.querySelector('.meta');
-  if (meta && (mode || model)) {
+  if (meta && (mode || model) && !streaming) {
     var roleLabel = div.classList.contains('user')
       ? (String(mode || '').toLowerCase() === 'flow-user-input' ? t('flow.userInput') : t('message.user'))
       : (div.classList.contains('workflow') ? t('message.workflow') : (div.classList.contains('system') ? t('message.system') : t('message.agent')));
@@ -8744,6 +8759,60 @@ function setConversationRuntimeState(target, status, runId, extra) {
   return next;
 }
 
+// A renderer send marks its target as provisionally running before the IPC
+// request reaches the target runtime. Escape/Stop can therefore arrive in
+// that handoff window while the backend still reports `not_running`. Remember
+// the exact provisional run so the pending send can be cancelled before it
+// allocates a provider request; once the backend has a real run, the normal
+// target-scoped stop path takes over.
+function markProvisionalStop(target, runId) {
+  if (!state.pendingProvisionalStops) state.pendingProvisionalStops = {};
+  state.pendingProvisionalStops[runtimeKeyFor(target.workspaceId, target.conversationId)] = String(runId || '');
+}
+
+function pendingProvisionalStopRunId(target) {
+  var key = runtimeKeyFor(target.workspaceId, target.conversationId);
+  if (!state.pendingProvisionalStops || !Object.prototype.hasOwnProperty.call(state.pendingProvisionalStops, key)) return undefined;
+  return state.pendingProvisionalStops[key];
+}
+
+function clearProvisionalStop(target) {
+  if (state.pendingProvisionalStops) delete state.pendingProvisionalStops[runtimeKeyFor(target.workspaceId, target.conversationId)];
+}
+
+function consumeProvisionalStop(target, runId) {
+  var pending = pendingProvisionalStopRunId(target);
+  if (pending === undefined || String(pending) !== String(runId || '')) return false;
+  clearProvisionalStop(target);
+  return true;
+}
+
+function requestBackendStopForProvisionalStart(target, runId) {
+  var stopPromise = api.stopConversation
+    ? api.stopConversation({ target: target, runId: String(runId || ''), force: false })
+    : (api.abortConversation ? api.abortConversation(target) : Promise.resolve({ action: 'not_running' }));
+  Promise.resolve(stopPromise).then(function(result) {
+    var action = String(result && result.action || '');
+    if (action === 'not_running' || action === 'stale') {
+      return refreshConversationRuntimeAfterStopRace(target, runId, result);
+    }
+    if (action === 'force' || String(result && result.status || '') === 'force_interrupted') {
+      setConversationRuntimeState(target, 'force_interrupted', runId, { provisional: false });
+      return;
+    }
+    if (action === 'graceful') {
+      setConversationRuntimeState(target, 'stopping', runId, { provisional: false });
+      return;
+    }
+    if (result === true || ['idle', 'interrupted'].indexOf(String(result && result.status || '')) >= 0) {
+      setConversationRuntimeState(target, 'interrupted', runId, { provisional: false });
+    }
+  }).catch(function(error) {
+    setConversationRuntimeState(target, 'running', runId, { provisional: false });
+    showUiNotice(error && error.message ? error.message : String(error), 'error', 'stop-provisional-' + runtimeKeyFor(target.workspaceId, target.conversationId) + '-' + String(runId || ''));
+  });
+}
+
 function formatWorkDuration(milliseconds) {
   var seconds = Math.max(0, Math.floor(Number(milliseconds || 0) / 1000));
   var hours = Math.floor(seconds / 3600);
@@ -9474,7 +9543,14 @@ function renderWorkRunEvents(run, includeGuides) {
       var responseLabel = type === 'response' && terminalInterrupted
         ? (currentLang() === 'zh' ? '未完成回复片段\n' : 'Incomplete response fragment\n') + workEventLabel(event)
         : workEventLabel(event);
-      return '<div class="conversation-work-event narrative"><div class="conversation-work-event-content">' + renderMessageContent(responseLabel) + '</div></div>';
+      // While a run is still receiving text, this view can be rebuilt once per
+      // event. Avoid invoking the full Markdown parser for a large live
+      // narrative; the final response path still gets the normal rich render.
+      var liveNarrative = ['running', 'stopping', 'force_restarting'].indexOf(String(run && run.status || '').toLowerCase()) >= 0;
+      var narrativeHtml = liveNarrative && String(responseLabel || '').length >= STREAMING_PLAIN_TEXT_THRESHOLD
+        ? esc(responseLabel)
+        : renderMessageContent(responseLabel);
+      return '<div class="conversation-work-event narrative"><div class="conversation-work-event-content">' + narrativeHtml + '</div></div>';
     }
     if (type.indexOf('guide') === 0 || event.guide) return renderWorkRunGuideMessage(event);
     if (type === 'tool_group') return renderWorkToolGroup(event, eventIndex);
@@ -9594,17 +9670,22 @@ function renderConversationWorkRuns(runs, target) {
   return normalized;
 }
 
-var pendingLargeWorkRunRenders = {};
-var scheduledLargeWorkRunRenders = {};
-function scheduleLargeConversationWorkRunRender(run) {
+// Work events can arrive much faster than the browser can paint them (text
+// deltas are especially noisy). Keep the authoritative run in memory for
+// every event, but coalesce its DOM replacement to one animation frame. This
+// is important for long real-model runs: replacing the whole work block for
+// every delta can starve Chromium's renderer/CDP event loop.
+var pendingConversationWorkRunRenders = {};
+var scheduledConversationWorkRunRenders = {};
+function scheduleConversationWorkRunRender(run) {
   var key = runtimeKeyFor(run.target && run.target.workspaceId, run.target && run.target.conversationId) + '::' + String(run.runId || '');
-  pendingLargeWorkRunRenders[key] = run;
-  if (scheduledLargeWorkRunRenders[key]) return;
-  scheduledLargeWorkRunRenders[key] = true;
+  pendingConversationWorkRunRenders[key] = run;
+  if (scheduledConversationWorkRunRenders[key]) return;
+  scheduledConversationWorkRunRenders[key] = true;
   requestAnimationFrame(function() {
-    var latest = pendingLargeWorkRunRenders[key];
-    delete pendingLargeWorkRunRenders[key];
-    delete scheduledLargeWorkRunRenders[key];
+    var latest = pendingConversationWorkRunRenders[key];
+    delete pendingConversationWorkRunRenders[key];
+    delete scheduledConversationWorkRunRenders[key];
     if (latest && isActiveConversationTarget(latest.target)) renderConversationWorkRun(latest);
   });
 }
@@ -9640,7 +9721,9 @@ function applyAgentWorkEventToRun(event) {
         var priorGuideEvent = run.events[guideEventIndex];
         if (guideWorkEventKey(priorGuideEvent) === incomingGuideKey) {
           run.events[guideEventIndex] = mergeGuideWorkEvent(priorGuideEvent, event);
-          updateConversationWorkRunElement(run);
+          if (isActiveConversationTarget(target) && (!branchIds.viewed || !eventBranchId || branchIds.viewed === eventBranchId)) {
+            scheduleConversationWorkRunRender(run);
+          }
           return run;
         }
       }
@@ -9667,8 +9750,8 @@ function applyAgentWorkEventToRun(event) {
   if (isActiveConversationTarget(target) && (!branchIds.viewed || !eventBranchId || branchIds.viewed === eventBranchId)) {
     state.workRunsByTarget[runtimeKeyFor(target.workspaceId, target.conversationId)] = runs;
     var existingElement = findWorkRunElement(run);
-    if (existingElement && run.events.length >= 12 && (type === 'tool_call' || type === 'tool_result')) scheduleLargeConversationWorkRunRender(run);
-    else renderConversationWorkRun(run);
+    if (!existingElement || type === 'start') renderConversationWorkRun(run);
+    else scheduleConversationWorkRunRender(run);
   }
   return run;
 }
@@ -10214,7 +10297,13 @@ function applyStreamingWorkflowText(ui, eventConversationId, mode, model) {
     }
     return;
   }
-  updateMsg(ensureActiveAssistantMsg(mode, model, eventConversationId), ui.activeWorkflowText, 'assistant', mode, model);
+  var largeText = ui.activeWorkflowText.length >= STREAMING_PLAIN_TEXT_THRESHOLD;
+  if (largeText) {
+    var now = Date.now();
+    if (ui._lastLargeStreamRenderAt && now - ui._lastLargeStreamRenderAt < STREAMING_LARGE_TEXT_INTERVAL_MS) return;
+    ui._lastLargeStreamRenderAt = now;
+  }
+  updateMsg(ensureActiveAssistantMsg(mode, model, eventConversationId), ui.activeWorkflowText, 'assistant', mode, model, { streaming: true });
 }
 
 function scheduleStreamingWorkflowTextFlush(ui, eventConversationId, eventWorkspaceId) {
@@ -10245,6 +10334,7 @@ function renderAgentWorkEvent(event) {
     ui.activeWorkflowText = '';
     ui.lastCompletedWorkflow = null;
     ui._streamFlushPending = false;
+    ui._lastLargeStreamRenderAt = 0;
   } else if (type === 'text') {
     ui.activeWorkflowText = (ui.activeWorkflowText || '') + content;
     if (workRun) return;
@@ -10255,6 +10345,7 @@ function renderAgentWorkEvent(event) {
     ui.activeWorkflowText = '';
     ui.activeWorkflowMsg = null;
     ui._streamFlushPending = false;
+    ui._lastLargeStreamRenderAt = 0;
   } else if (type === 'final_response' && workRun) {
     ui.activeWorkflowText = '';
     ui.activeWorkflowMsg = null;
@@ -10288,6 +10379,7 @@ function renderAgentWorkEvent(event) {
     }
     ui.activeWorkflowMsg = null;
     ui.activeWorkflowText = '';
+    ui._lastLargeStreamRenderAt = 0;
     finishToolBatch(eventConversationId);
   } else if (type === 'error') {
     flushStreamingWorkflowTextNow(ui, eventConversationId, event.mode || state.mode, event.model || state.model);
@@ -10357,7 +10449,14 @@ function appendAgentWorkEvent(event) {
   var visibleRuntimeBranch = active && isViewingRuntimeConversationBranch(target);
   if (active) markConversationTracked(id, state.conversationTrackMs || 300000, workspaceId);
   if (active || isConversationTracked(id, workspaceId)) cacheAgentWorkEvent(event);
-  if (event.type === 'start') setConversationRuntimeState(target, event.status || 'running', event.runId || '', { provisional: false, generation: event.generation || 0, runtimeKey: event.runtimeKey || '' });
+  var pendingProvisionalStop = (event.type === 'start' || event.status === 'running')
+    ? pendingProvisionalStopRunId(target)
+    : undefined;
+  if (pendingProvisionalStop !== undefined && event.runId) {
+    clearProvisionalStop(target);
+    setConversationRuntimeState(target, 'stopping', event.runId, { provisional: false, generation: event.generation || 0, runtimeKey: event.runtimeKey || '' });
+    requestBackendStopForProvisionalStart(target, event.runId);
+  } else if (event.type === 'start') setConversationRuntimeState(target, event.status || 'running', event.runId || '', { provisional: false, generation: event.generation || 0, runtimeKey: event.runtimeKey || '' });
   else if (event.status && ['running', 'stopping', 'force_restarting'].indexOf(String(event.status)) >= 0) setConversationRuntimeState(target, event.status, event.runId || '');
   else if (event.status && ['completed', 'interrupted', 'force_interrupted', 'error'].indexOf(String(event.status)) >= 0) {
     setConversationRuntimeState(target, event.status, event.runId || '');
@@ -10459,7 +10558,14 @@ function hydrateConversationBranchState(snapshot) {
 }
 
 function applyConversationSnapshot(s, requestedConversationId) {
-    if (!s) return;
+  if (!s) return;
+  if (s.computerUse) {
+    var computerTarget = currentConversationTarget(s.conversationId || requestedConversationId || activeConversationId());
+    var computerKey = computerUseTargetKey(computerTarget);
+    if (!state.computerUseByTarget) state.computerUseByTarget = {};
+    state.computerUseByTarget[computerKey] = s.computerUse;
+    if (isActiveConversationTarget(computerTarget)) renderComputerUseToggle(s.computerUse, computerTarget);
+  }
     state.goalText = s.goal && s.goal.objective ? String(s.goal.objective) : '';
     state.goalVisible = !!state.goalText;
     state.goalPaused = !!(s.goal && s.goal.paused);
@@ -10813,6 +10919,44 @@ function isCurrentConversationRunning() {
   return !!(id && runningConversationRecord(id));
 }
 
+// A terminal final_response event can reach the renderer before the awaited
+// send promise performs its final local cleanup. If a user submits in that
+// small window, trusting the stale local running/active-send flags silently
+// drops the new message. Reconcile only when a send is already considered
+// active; a backend-confirmed running snapshot still keeps the guard intact.
+async function reconcileStaleLocalRuntimeBeforeSend(target) {
+  if (!target || !api.getState) return false;
+  var snapshot;
+  try {
+    snapshot = await api.getState(target);
+  } catch (_) {
+    return false;
+  }
+  var runtimeSnapshot = snapshot && snapshot.runtime || null;
+  var snapshotStatus = String(snapshot && snapshot.status || '').toLowerCase();
+  var backendStillRunning = !!(runtimeSnapshot && (runtimeSnapshot.running || runtimeSnapshot.stopRequested))
+    || ['running', 'stopping', 'force_restarting'].indexOf(snapshotStatus) >= 0;
+  if (backendStillRunning) return false;
+  if (['idle', 'completed', 'interrupted', 'force_interrupted', 'error'].indexOf(snapshotStatus) < 0) return false;
+  var runId = String((runtimeSnapshot && runtimeSnapshot.runId) || snapshot.runId || '');
+  var generation = Number((runtimeSnapshot && runtimeSnapshot.generation) || snapshot.generation || 0);
+  setConversationRuntimeState(target, snapshotStatus, runId, { provisional: false, generation: generation });
+  var targetKey = runtimeKeyFor(target.workspaceId, target.conversationId);
+  if (state.activeSendCallsByTarget) {
+    delete state.activeSendCallsByTarget[targetKey];
+    delete state.activeSendCallsByTarget[runtimeKeyFor('', target.conversationId)];
+  }
+  if (state.nextQueueSchedulesByTarget) {
+    delete state.nextQueueSchedulesByTarget[targetKey];
+    delete state.nextQueueSchedulesByTarget[runtimeKeyFor('', target.conversationId)];
+  }
+  state._sendInFlight = Object.keys(state.runningConversations || {}).length > 0;
+  setWorking(state._sendInFlight);
+  updateSubmitButtonState();
+  if (window.renderInputStack) window.renderInputStack();
+  return true;
+}
+
 function setSubmitButtonVisual(icon, label, running, stopMode) {
   var btn = els['submit-btn'] || document.getElementById('submit-btn');
   if (!btn) return;
@@ -10923,18 +11067,33 @@ window.stopCurrentConversation = async function() {
   if (!conversationId || !runtime) return false;
   var target = runtime.target || currentConversationTarget(conversationId);
   var runId = String(runtime.runId || '');
+  var provisional = runtime.provisional === true;
   if (String(runtime.status || '') === 'force_restarting') return false;
+  if (provisional) markProvisionalStop(target, runId);
   var force = String(runtime.status || '') === 'stopping';
   if (typeof pauseQueueForTarget === 'function') pauseQueueForTarget(target);
   setConversationRuntimeState(target, force ? 'force_restarting' : 'stopping', runId);
   updateSubmitButtonState();
   renderConversations();
+  if (provisional) {
+    // The backend may not have allocated a utility runtime yet. Keep the
+    // exact local cancellation marker and let sendMessage consume it, or let
+    // the first backend start event issue a stop with the real run id. An
+    // empty-run stop request here races runtime allocation and can return
+    // not_running before the prompt reaches the worker.
+    if (window.renderInputStack) window.renderInputStack();
+    return true;
+  }
   try {
     var result;
     // The target runtime supervisor owns the checkpoint + cooperative-stop
     // transaction. A separate awaited checkpoint can itself be starved by a
     // blocked worker and would prevent the supervisor from recording the first
     // stop, making a second-click hard restart impossible.
+    // A provisional renderer run has no backend run id yet. Omitting the
+    // expected id lets a concurrently-created backend run be stopped, while
+    // the pending marker above cancels a request that has not reached the
+    // runtime at all.
     if (api.stopConversation) result = await api.stopConversation({ target: target, runId: runId, force: force });
     else if (api.abortConversation) result = await api.abortConversation(currentConversationTarget(conversationId));
     var resultAction = String(result && result.action || '');
@@ -10945,6 +11104,9 @@ window.stopCurrentConversation = async function() {
       await refreshConversationRuntimeAfterStopRace(target, runId, result);
       return true;
     }
+    if (provisional && state.pendingProvisionalStops) {
+      delete state.pendingProvisionalStops[runtimeKeyFor(target.workspaceId, target.conversationId)];
+    }
     var latestAfterStop = state.conversationRuntimeStates && state.conversationRuntimeStates[runtimeKeyFor(target.workspaceId, target.conversationId)];
     if (!force && latestAfterStop && String(latestAfterStop.runId || '') === runId && String(latestAfterStop.status || '') !== 'stopping') {
       // A second click or a terminal worker event won the race while the first
@@ -11837,6 +11999,13 @@ window.endQueueDrag = function(event) {
   if (event.currentTarget) event.currentTarget.classList.remove('dragging');
 };
 
+function recoverableGuideRejection(receipt) {
+  if (!receipt || String(receipt.status || '').toLowerCase() !== 'rejected') return false;
+  var reason = String(receipt.reason || receipt.error || '').trim();
+  return reason === 'Target conversation is not running'
+    || reason === 'Guide runId does not match the active run';
+}
+
 window.sendMessage = async function(modeOverride, queuedText, opts) {
   if (!window.requireWorkspace('send')) return;
   opts = opts || {};
@@ -11960,6 +12129,28 @@ window.sendMessage = async function(modeOverride, queuedText, opts) {
   var conversationRunning = !!activeRuntime;
   markConversationTracked(lockedConversationId, state.conversationTrackMs || 300000, lockedTarget.workspaceId);
 
+  var activeSendCall = !!(state.activeSendCallsByTarget && state.activeSendCallsByTarget[lockedRuntimeKey]);
+  if ((conversationRunning || activeSendCall) && api.getState) {
+    var reconciledLocalRuntime = await reconcileStaleLocalRuntimeBeforeSend(lockedTarget);
+    if (reconciledLocalRuntime) {
+      activeRuntime = runningConversationRecord(lockedConversationId, lockedTarget.workspaceId);
+      conversationRunning = !!activeRuntime;
+      if (!conversationRunning && effectiveInputMode === 'guide') effectiveInputMode = 'next';
+    }
+  }
+
+  if (opts.retryAfterGuideRejection && conversationRunning && api.getState) {
+    try {
+      var freshRuntimeState = await api.getState(lockedTarget);
+      var freshStatus = String(freshRuntimeState && freshRuntimeState.status || '').toLowerCase();
+      if (['idle', 'completed', 'interrupted', 'force_interrupted', 'error'].indexOf(freshStatus) >= 0) {
+        setConversationRuntimeState(lockedTarget, 'idle', '');
+        activeRuntime = null;
+        conversationRunning = false;
+      }
+    } catch (_) {}
+  }
+
   if (effectiveInputMode === 'next' && !opts.fromQueue && conversationRunning) {
     if (!state.nextQueue) state.nextQueue = [];
     if (!state.nextQueueRequests) state.nextQueueRequests = [];
@@ -12041,6 +12232,57 @@ window.sendMessage = async function(modeOverride, queuedText, opts) {
         throw new Error(currentLang() === 'zh' ? '未收到有效的 Guide 回执' : 'A valid Guide acknowledgement was not received');
       }
       var status = normalizeGuideUiStatus(receipt.status);
+      if (recoverableGuideRejection(receipt)) {
+        // Renderer runtime state can lag the backend's finalization event by
+        // one IPC turn. The Guide was explicitly rejected, so replaying the
+        // exact payload as a fresh Build is safe and prevents a normal user
+        // send from disappearing behind a stale Guide route.
+        var fallbackRequest = {
+          text: typeof requestMessage === 'string' ? requestMessage : String(requestMessage.text || ''),
+          images: typeof requestMessage === 'object' && Array.isArray(requestMessage.images)
+            ? requestMessage.images.map(function(image) { return Object.assign({}, image); })
+            : []
+        };
+        recordGuideUiMessage({
+          clientMessageId: clientMessageId,
+          target: receipt.target || lockedTarget,
+          runId: receipt.runId || envelope.runId,
+          status: 'deferred',
+          content: displayText,
+          attachments: optimisticAttachments,
+          createdAt: receipt.createdAt || envelope.createdAt,
+          updatedAt: receipt.updatedAt,
+          reason: currentLang() === 'zh'
+            ? '运行已结束，输入已作为新的 Build 继续。'
+            : 'The run ended before Guide delivery; the input continued as a new Build.'
+        }, lockedTarget);
+        applyAgentWorkEventToRun({
+          id: 'guide-' + clientMessageId + '-deferred',
+          type: 'guide_deferred',
+          content: displayText,
+          workspaceId: lockedTarget.workspaceId,
+          conversationId: lockedTarget.conversationId,
+          runId: receipt.runId || envelope.runId,
+          sequence: receipt.sequence || 0,
+          guideStatus: 'deferred',
+          clientMessageId: clientMessageId,
+          guide: guideMessagesForTarget(lockedTarget)[clientMessageId]
+        });
+        return Promise.resolve(window.sendMessage('next', undefined, {
+          requestedMode: requestedMode,
+          goalObjective: opts.goalObjective,
+          forceBuild: true,
+          retryAfterGuideRejection: true,
+          queuedRequest: fallbackRequest
+        })).then(function(fallbackResult) {
+          return {
+            ok: !(fallbackResult && fallbackResult.ok === false),
+            guideReceipt: receipt,
+            recoveredAsBuild: true,
+            fallback: fallbackResult
+          };
+        });
+      }
       var guideRecord = recordGuideUiMessage({
         clientMessageId: clientMessageId,
         target: receipt.target || lockedTarget,
@@ -12099,6 +12341,15 @@ window.sendMessage = async function(modeOverride, queuedText, opts) {
   var executionMode = opts.goalDeclaration || requestedMode === 'goal' ? 'build'
     : ((opts.forceBuild || idleBuildNextImmediate) && requestedMode === 'build' ? 'build' : requestedMode);
   await syncConversationExecutionState(executionMode, effectiveInputMode);
+  if (consumeProvisionalStop(lockedTarget, localRunId)) {
+    // Stop/Escape won before the backend accepted the prompt. Do not send the
+    // provider request after the user has already cancelled it.
+    delete state.activeSendCallsByTarget[lockedRuntimeKey];
+    setConversationRuntimeState(lockedTarget, 'interrupted', localRunId, { provisional: false });
+    setWorking(!!runningConversationRecord(activeConversationId()));
+    window.renderInputStack();
+    return { status: 'interrupted', runId: localRunId, target: lockedTarget, cancelledBeforeStart: true };
+  }
   var renderOnViewedBranch = !queuedRuntimeBranch || queueBranchPathForTarget(lockedTarget, 'viewed') === queueBranchPathForTarget(lockedTarget, 'runtime');
   if (isActiveConversationTarget(lockedTarget) && renderOnViewedBranch) {
     if (opts.resumeGuideRunId && requestMessage.clientMessageId) {
@@ -12128,10 +12379,12 @@ window.sendMessage = async function(modeOverride, queuedText, opts) {
     renderAutoRouteRatingControls();
   }
   var responseMsg = null;
+  var sendFailure = '';
   try {
     var sendPromise = api.sendMessage(requestMessage, lockedTarget);
     if (requestedMode === 'goal') activateSubmittedGoal(opts.goalObjective || rawText);
     var r = await sendPromise;
+    if (r && r.error) sendFailure = String(r.error);
     if (isActiveConversationTarget(lockedTarget)) applyReturnedGoalState(r);
     if (r && r.runId) {
       var anchorStore = workRunAnchorIndexStore(lockedTarget);
@@ -12212,9 +12465,10 @@ window.sendMessage = async function(modeOverride, queuedText, opts) {
       }
     }
   } catch(e) {
+    sendFailure = e && e.message ? String(e.message) : String(e || 'Agent run failed.');
     if (isActiveConversationTarget(lockedTarget)) {
       responseMsg = conversationWorkUiState(lockedConversationId, lockedTarget.workspaceId).activeWorkflowMsg || addMsg('assistant', '', state.mode, state.model);
-      updateMsg(responseMsg, formatChatError(e && e.message, 'Agent run failed.'), 'error', state.mode, state.model);
+      updateMsg(responseMsg, formatChatError(sendFailure, 'Agent run failed.'), 'error', state.mode, state.model);
     }
   }
   if (api.getState) {
@@ -12265,7 +12519,15 @@ window.sendMessage = async function(modeOverride, queuedText, opts) {
     if (resumedModeResult != null) state._syncedMode = state.mode;
   }
   var finalRuntime = state.conversationRuntimeStates && state.conversationRuntimeStates[lockedRuntimeKey];
-  if (!finalRuntime || !finalRuntime.runId || finalRuntime.runId === localRunId || (r && finalRuntime.runId === r.runId)) {
+  var finalRunMatches = !finalRuntime || !finalRuntime.runId || finalRuntime.runId === localRunId || (r && finalRuntime.runId === r.runId);
+  if (sendFailure) {
+    // The IPC contract returns terminal failures as { error } while the
+    // target-scoped error work event may arrive on the next task. Never let
+    // the renderer's provisional run fall through to completed in that gap.
+    if (finalRunMatches) {
+      setConversationRuntimeState(lockedTarget, 'error', (r && r.runId) || (finalRuntime && finalRuntime.runId) || localRunId, { provisional: false });
+    }
+  } else if (finalRunMatches) {
     setConversationRuntimeState(lockedTarget, 'completed', (r && r.runId) || localRunId);
   }
   setWorking(!!runningConversationRecord(activeConversationId()));
@@ -12683,6 +12945,7 @@ window.switchRightTab = function(tab) {
   if (tab === 'subagent') window.renderSubagentList();
   if (tab === 'browser') {
     cancelBrowserGuestIdleDestroy();
+    window.refreshComputerUseState(currentConversationTarget());
     window.ensureBrowserPanel({ activate: true }).catch(function(error) {
       console.error('[Browser] guest initialization failed:', error && error.message ? error.message : String(error));
     });
@@ -13167,7 +13430,7 @@ window.terminalSend = function() {
       var startedPane = document.querySelector('.terminal-pane[data-session="' + resp.sessionId + '"]');
       var startedInput = startedPane && startedPane.querySelector('.terminal-input');
       if (startedInput && startedInput.value === cmd) startedInput.value = '';
-      return api.terminalWrite(resp.sessionId, cmd + '\r\n');
+      return api.terminalWrite(resp.sessionId, cmd + '\r');
     }).catch(function(err) {
       input.disabled = false;
       var currentPane = window.getActiveTerminalPane();
@@ -13176,7 +13439,7 @@ window.terminalSend = function() {
     });
   }
   input.value = '';
-  api.terminalWrite(sessionId, cmd + '\r\n').catch(function(err) {
+  api.terminalWrite(sessionId, cmd + '\r').catch(function(err) {
     if (output) output.innerHTML += '\r\n<span style="color:#ff6666;">[' + esc(t('common.error')) + '] ' + esc(err.message) + '</span>';
   });
 };
@@ -15019,36 +15282,12 @@ renderArchiveSettings = function() {
 };
 
 window.archiveCurrent = function() {
-  if (!api.archive) return;
   var currentId = activeConversationId();
-  if (currentId && runningConversationRecord(currentId)) {
-    showUiNotice(currentLang() === 'zh' ? '请先停止当前对话再归档。' : 'Stop the active conversation before archiving it.', 'error', 'archive-running-' + currentRuntimeKey(currentId));
-    return;
-  }
-  api.archive(currentConversationTarget(currentId)).then(function(receipt) {
-    if (!receipt || !receipt.ok) throw new Error((receipt && receipt.error) || 'Archive failed');
-    showUiNotice('[Archive] ' + t('archive.saved') + ': ' + receipt.fileName, 'success', 'archive-saved-' + receipt.conversationId);
-    return Promise.all([api.listArchives ? api.listArchives('workspace') : [], api.getState ? api.getState() : null]);
-  }).then(function(result) {
-    var items = result[0] || [];
-    var refreshed = result[1];
-    state.workspaceArchives = (items || []).map(function(a) {
-      return { id: a.id || a.name || String(a), name: a.name || String(a), firstLine: a.firstLine || '', date: a.date || '', scope: a.scope || 'workspace', workspace: a.workspace || state.currentWorkspace || '', restorable: !!a.restorable, conversationId: a.conversationId || '' };
-    });
-    state.allArchives = [];
-    if (refreshed && refreshed.conversations) {
-      state.activeBackendConversationId = refreshed.conversationId || state.activeBackendConversationId;
-      applyBackendConversations(refreshed.conversations, state.activeBackendConversationId, refreshed.workspaceId || runtimeWorkspaceId(''));
-      if (refreshed.chatMessages) renderChatMessages(refreshed.chatMessages);
-      renderConversations();
-    }
-    window.renderRightArchives();
-    var stab = document.getElementById('stab-archive');
-    if (stab) stab.innerHTML = renderArchiveSettings();
-    if (state.settingsActiveTab === 'archive') window.settingsTab('archive');
-  }).catch(function(err) {
-    addMsg('assistant', '[Archive] ' + t('workspace.saveFailed') + ': ' + (err.message || String(err)), 'error', '');
-  });
+  if (!currentId || !window.archiveConv) return;
+  // Use the same optimistic path as the conversation-row action. This keeps
+  // the active conversation immediately gone even while a running/queued
+  // runtime is being hard-stopped by the main process.
+  return window.archiveConv(currentId);
 };
 
 window.loadArchive = function(idx, scope) {
@@ -16088,11 +16327,17 @@ window.loadFileTree = async function(options) {
 };
 
 window.submitSelectedFlow = function() {
+  if (!state._flowsLoaded && window.ensureFlowsLoaded) {
+    return window.ensureFlowsLoaded().then(function() { return window.submitSelectedFlow(); });
+  }
   var selected = String(state.defaultFlow || (document.getElementById('flow-select') && document.getElementById('flow-select').value) || '');
   var workIdx = state.flowWorks.findIndex(function(work) { return String(work && work.name || '') === selected; });
   if (workIdx < 0) {
-    showUiNotice(currentLang() === 'zh' ? '请先选择一个 Flow。' : 'Select a Flow first.', 'error', 'flow-select-required');
-    return;
+    var message = state.flowWorks.length
+      ? (currentLang() === 'zh' ? '请先选择一个 Flow。' : 'Select a Flow first.')
+      : t('flow.noAvailable');
+    showUiNotice(message, 'error', 'flow-select-required');
+    return { ok: false, error: message };
   }
   return window.runFlowWork(workIdx);
 };
@@ -16849,11 +17094,63 @@ var NEWMARK_BROWSER_PARTITION = 'persist:newmark-browser';
 var NEWMARK_BROWSER_MIN_CREATE_DELAY_MS = 5000;
 var NEWMARK_BROWSER_IDLE_DESTROY_MS = 60000;
 var browserGuestCreatePromise = null;
+var browserGuestCreatePromises = {};
 var browserGuestIdleTimer = null;
 var browserRetainedUrl = 'about:blank';
+var browserRetainedUrls = {};
 var browserGuestCreateCount = 0;
 var browserGuestFirstCreatedAtMs = null;
 
+function computerUseTargetKey(target) {
+  target = target || currentConversationTarget();
+  return runtimeKeyFor(target.workspaceId, target.conversationId);
+}
+
+function renderComputerUseToggle(value, target) {
+  var button = document.getElementById('computer-use-toggle');
+  if (!button) return;
+  var enabled = value && value.enabled !== false;
+  var occupied = !!(value && value.occupied);
+  var owner = value && value.ownerLabel ? ' · ' + String(value.ownerLabel) : '';
+  button.classList.toggle('active', enabled);
+  button.setAttribute('aria-pressed', enabled ? 'true' : 'false');
+  button.title = (enabled ? 'ComputerUse enabled for this conversation' : 'ComputerUse disabled for this conversation') + owner;
+  button.textContent = enabled ? (occupied ? 'CU●' : 'CU') : 'CU×';
+  button.dataset.computerUseRuntimeKey = computerUseTargetKey(target);
+}
+
+window.refreshComputerUseState = function(target) {
+  target = target || currentConversationTarget();
+  var key = computerUseTargetKey(target);
+  var cached = state.computerUseByTarget && state.computerUseByTarget[key];
+  if (cached) renderComputerUseToggle(cached, target);
+  if (!api.computerUseState) return Promise.resolve(cached || { enabled: true, occupied: false, runtimeKey: key });
+  return api.computerUseState(target).then(function(value) {
+    if (!state.computerUseByTarget) state.computerUseByTarget = {};
+    state.computerUseByTarget[key] = value || { enabled: true, occupied: false, runtimeKey: key };
+    if (isActiveConversationTarget(target)) renderComputerUseToggle(state.computerUseByTarget[key], target);
+    return state.computerUseByTarget[key];
+  }).catch(function() { return cached || { enabled: true, occupied: false, runtimeKey: key }; });
+};
+
+window.toggleComputerUse = function() {
+  var target = currentConversationTarget();
+  var key = computerUseTargetKey(target);
+  var current = state.computerUseByTarget && state.computerUseByTarget[key];
+  var enabled = !(current && current.enabled !== false);
+  if (!api.setComputerUseEnabled) return Promise.resolve(null);
+  return api.setComputerUseEnabled(target, enabled).then(function(result) {
+    if (result && result.ok === false) {
+      showUiNotice(String(result.error || 'ComputerUse occupied'), 'error', 'computer-use-toggle-' + key);
+      return result;
+    }
+    if (!state.computerUseByTarget) state.computerUseByTarget = {};
+    state.computerUseByTarget[key] = result && result.state ? result.state : { enabled: enabled, occupied: false, runtimeKey: key };
+    renderComputerUseToggle(state.computerUseByTarget[key], target);
+    return result;
+  });
+};
+
 window.browserGuestLifecycleSnapshot = function() {
   return {
     createCount: browserGuestCreateCount,
@@ -16870,15 +17167,60 @@ function browserUrlsEquivalent(left, right) {
   return !!a && a === b;
 }
 
-function currentBrowserGuest() {
-  var view = document.getElementById('browser-webview');
-  return view && view.isConnected ? view : null;
+function browserTargetKey(target) {
+  target = target || currentConversationTarget();
+  return runtimeKeyFor(target.workspaceId, target.conversationId);
+}
+
+function browserPartitionForTarget(target) {
+  var key = browserTargetKey(target).replace(/[^A-Za-z0-9_.-]/g, '_').slice(0, 150) || 'default';
+  return NEWMARK_BROWSER_PARTITION + '-' + key;
+}
+
+function browserGuestForTarget(target) {
+  var key = browserTargetKey(target);
+  var frame = els['browser-frame'] || document.getElementById('browser-frame');
+  if (!frame) return null;
+  var views = frame.querySelectorAll('webview[data-newmark-browser-runtime-key]');
+  for (var i = 0; i < views.length; i++) {
+    if (String(views[i].getAttribute('data-newmark-browser-runtime-key') || '') === key && views[i].isConnected) return views[i];
+  }
+  return null;
 }
 
-function rememberBrowserUrl(url, force) {
+function setActiveBrowserGuest(view, target) {
+  var key = browserTargetKey(target);
+  var frame = els['browser-frame'] || document.getElementById('browser-frame');
+  if (frame) {
+    var views = frame.querySelectorAll('webview[data-newmark-browser-runtime-key]');
+    for (var i = 0; i < views.length; i++) {
+      var same = views[i] === view || String(views[i].getAttribute('data-newmark-browser-runtime-key') || '') === key;
+      views[i].style.display = same ? '' : 'none';
+      if (same) views[i].id = 'browser-webview';
+      else if (views[i].id === 'browser-webview') views[i].id = 'browser-webview-' + String(views[i].getAttribute('data-newmark-browser-runtime-key') || 'guest').replace(/[^A-Za-z0-9_.-]/g, '_').slice(-80);
+    }
+  }
+  els['browser-webview'] = view || null;
+  if (view) view._newmarkBrowserTargetKey = key;
+}
+
+function currentBrowserGuest(target) {
+  var view = browserGuestForTarget(target || currentConversationTarget());
+  if (view) return view;
+  var active = document.getElementById('browser-webview');
+  return active && active.isConnected ? active : null;
+}
+
+function rememberBrowserUrl(url, force, target) {
+  target = target || currentConversationTarget();
+  var targetKey = browserTargetKey(target);
   url = String(url || '').trim();
-  if (!force && url === 'about:blank' && browserRetainedUrl !== 'about:blank') return;
-  if (url) browserRetainedUrl = url;
+  var prior = browserRetainedUrls[targetKey] || 'about:blank';
+  if (!force && url === 'about:blank' && prior !== 'about:blank') return;
+  if (url) {
+    browserRetainedUrls[targetKey] = url;
+    if (isActiveConversationTarget(target)) browserRetainedUrl = url;
+  }
 }
 
 function waitForBrowserCreationFloor() {
@@ -16887,8 +17229,9 @@ function waitForBrowserCreationFloor() {
   return new Promise(function(resolve) { setTimeout(resolve, remaining); });
 }
 
-function createBrowserGuestElement() {
-  var existing = currentBrowserGuest();
+function createBrowserGuestElement(target) {
+  target = target || currentConversationTarget();
+  var existing = browserGuestForTarget(target);
   if (existing) return existing;
   var frame = els['browser-frame'] || document.getElementById('browser-frame');
   if (!frame) throw new Error('Built-in Browser frame is unavailable');
@@ -16898,8 +17241,14 @@ function createBrowserGuestElement() {
   browserGuestCreateCount += 1;
   if (browserGuestFirstCreatedAtMs === null) browserGuestFirstCreatedAtMs = Date.now() - newmarkRendererStartedAt;
   view.id = 'browser-webview';
-  view.setAttribute('partition', NEWMARK_BROWSER_PARTITION);
+  view.setAttribute('data-newmark-browser-runtime-key', browserTargetKey(target));
+  view.setAttribute('partition', browserPartitionForTarget(target));
   frame.appendChild(view);
+  if (isActiveConversationTarget(target)) setActiveBrowserGuest(view, target);
+  else {
+    view.style.display = 'none';
+    view.id = 'browser-webview-' + browserTargetKey(target).replace(/[^A-Za-z0-9_.-]/g, '_').slice(-80);
+  }
   els['browser-webview'] = view;
   return view;
 }
@@ -16922,11 +17271,14 @@ function cancelBrowserGuestIdleDestroy() {
 function destroyIdleBrowserGuest() {
   browserGuestIdleTimer = null;
   if (state.rightTab === 'browser') return;
-  var view = currentBrowserGuest();
+  var view = currentBrowserGuest(currentConversationTarget());
   if (!view) return;
-  try { rememberBrowserUrl(view.getURL ? view.getURL() : ''); } catch {}
+  var target = { workspaceId: state.currentWorkspaceId || state.currentWorkspacePath || state.currentWorkspace || 'none', conversationId: activeConversationId() || 'default' };
+  try { rememberBrowserUrl(view.getURL ? view.getURL() : '', false, target); } catch {}
   if (view.parentNode) view.parentNode.removeChild(view);
   if (els['browser-webview'] === view) els['browser-webview'] = null;
+  var key = browserTargetKey(target);
+  delete browserGuestCreatePromises[key];
   browserGuestCreatePromise = null;
   restoreBrowserPlaceholder();
 }
@@ -16958,16 +17310,17 @@ function navigateBrowserView(view, url) {
 }
 
 window.navigateBrowser = function(url) {
+  var target = currentConversationTarget();
   url = String(url || '').trim();
   if (!/^(?:https?:\/\/|about:blank$|newmark-preview:\/\/)/i.test(url)) {
     url = 'https://' + url;
   }
   if (state.browserPreviewToken && url !== state.browserPreviewUrl) window.revokeBrowserPreviewCapability();
-  rememberBrowserUrl(url, true);
+  rememberBrowserUrl(url, true, target);
   var input = els['browser-url'];
   if (input) input.value = url;
   cancelBrowserGuestIdleDestroy();
-  return window.ensureBrowserPanel({ activate: false }).then(function(view) {
+  return window.ensureBrowserPanel({ activate: false, target: target }).then(function(view) {
     navigateBrowserView(view, url);
     if (state.rightTab !== 'browser') scheduleBrowserGuestIdleDestroy();
     return view;
@@ -16996,6 +17349,8 @@ window.browserReload = function() {
 };
 
 function initializeBrowserGuest(view) {
+  var target = arguments.length > 1 && arguments[1] ? arguments[1] : currentConversationTarget();
+  var targetKey = browserTargetKey(target);
   if (!view._newmarkReadyPromise) {
     view._newmarkDomReady = false;
     view._newmarkReadySettled = false;
@@ -17011,12 +17366,12 @@ function initializeBrowserGuest(view) {
         currentUrl = view.getURL ? view.getURL() : '';
         if (input && currentUrl && currentUrl !== 'about:blank') input.value = currentUrl;
       } catch {}
-      rememberBrowserUrl(currentUrl);
+      rememberBrowserUrl(currentUrl, false, target);
       if (view._newmarkReadySettled) return;
       var registration = Promise.resolve({ accepted: true });
       try {
         if (!api.browserRegisterGuest || !view.getWebContentsId) throw new Error('Built-in Browser registration API is unavailable');
-        registration = api.browserRegisterGuest(view.getWebContentsId());
+        registration = api.browserRegisterGuest(view.getWebContentsId(), target);
       } catch (registrationError) {
         registration = Promise.reject(registrationError);
       }
@@ -17056,13 +17411,13 @@ function initializeBrowserGuest(view) {
     view.addEventListener('did-navigate', function(e) {
       var input = els['browser-url'];
       if (input && e.url && e.url !== 'about:blank') input.value = e.url;
-      rememberBrowserUrl(e.url);
+      rememberBrowserUrl(e.url, false, target);
       if (browserUrlsEquivalent(e.url, view._newmarkPendingUrl)) view._newmarkPendingUrl = '';
     });
     view.addEventListener('did-navigate-in-page', function(e) {
       var input = els['browser-url'];
       if (input && e.url && e.url !== 'about:blank') input.value = e.url;
-      rememberBrowserUrl(e.url);
+      rememberBrowserUrl(e.url, false, target);
       if (browserUrlsEquivalent(e.url, view._newmarkPendingUrl)) view._newmarkPendingUrl = '';
     });
     view.addEventListener('did-fail-load', function(e) {
@@ -17076,27 +17431,38 @@ function initializeBrowserGuest(view) {
     });
     var current = '';
     try { current = view.getURL ? view.getURL() : ''; } catch { current = ''; }
-    if (!current && !view.getAttribute('src')) view.setAttribute('src', 'about:blank');
+    if (!current && !view.getAttribute('src')) view.setAttribute('src', browserRetainedUrls[targetKey] || 'about:blank');
   }
   return view._newmarkReadyPromise;
 }
 
 window.ensureBrowserPanel = function(options) {
   options = options || {};
+  var target = options.target || currentConversationTarget();
+  var targetKey = browserTargetKey(target);
   cancelBrowserGuestIdleDestroy();
-  if (!browserGuestCreatePromise) {
-    browserGuestCreatePromise = waitForBrowserCreationFloor().then(function() {
-      return initializeBrowserGuest(createBrowserGuestElement());
+  if (!browserGuestCreatePromises[targetKey]) {
+    // Keep background Browser-Use demand off the startup hot path, but never
+    // make a deliberate visible-tab click wait behind that memory guard. A
+    // user explicitly opening Browser is an interaction deadline, not a
+    // background prewarm request.
+    var creationWait = options.activate === true
+      ? Promise.resolve()
+      : waitForBrowserCreationFloor();
+    browserGuestCreatePromises[targetKey] = creationWait.then(function() {
+      return initializeBrowserGuest(createBrowserGuestElement(target), target);
     }).catch(function(error) {
-      browserGuestCreatePromise = null;
+      delete browserGuestCreatePromises[targetKey];
       throw error;
     });
   }
-  return browserGuestCreatePromise.then(function(view) {
+  browserGuestCreatePromise = browserGuestCreatePromises[targetKey];
+  return browserGuestCreatePromises[targetKey].then(function(view) {
+    if (isActiveConversationTarget(target)) setActiveBrowserGuest(view, target);
     if (options.activate === true) {
       var current = '';
       try { current = view.getURL ? view.getURL() : ''; } catch { current = ''; }
-      var targetUrl = browserRetainedUrl || 'about:blank';
+      var targetUrl = browserRetainedUrls[targetKey] || 'about:blank';
       if (targetUrl !== 'about:blank' && (!current || current === 'about:blank') && !view._newmarkPendingUrl) {
         navigateBrowserView(view, targetUrl);
       }
@@ -17323,7 +17689,7 @@ function renderConversations() {
       ? '<span class="conv-runtime-badge ' + escAttr(String(runtimeState.status)) + '">' + esc(String(runtimeState.status)) + '</span>' : '';
     div.innerHTML = '<span class="conv-summary" title="' + escAttr(String(conv.id || '')) + '">' + esc(displaySummary) + (conv.messageCount ? ' (' + esc(String(conv.messageCount)) + ')' : '') + '</span>' + runtimeBadge +
       '<button class="conv-rename-btn" onclick="event.stopPropagation();window.editConversationName(' + i + ')" title="' + escAttr(t('conversation.rename')) + '">' + iconOnly('pencil', t('conversation.rename')) + '</button>' +
-      '<button class="conv-archive-btn" ' + (runtimeState && ['running', 'stopping', 'force_restarting'].indexOf(String(runtimeState.status || '')) >= 0 ? 'disabled ' : '') + 'onclick="event.stopPropagation();window.archiveConv(this.closest(&quot;.conv-item&quot;).getAttribute(&quot;data-conversation-id&quot;))" title="' + escAttr(t('conversation.archive')) + '">' + iconOnly('archive', t('conversation.archive')) + '</button>' +
+      '<button class="conv-archive-btn" onclick="event.stopPropagation();window.archiveConv(this.closest(&quot;.conv-item&quot;).getAttribute(&quot;data-conversation-id&quot;))" title="' + escAttr(t('conversation.archive')) + '">' + iconOnly('archive', t('conversation.archive')) + '</button>' +
       '<button class="conv-pin-btn' + (conv.pinned ? ' active' : '') + '" onclick="event.stopPropagation();window.toggleConversationPinned(' + i + ')" title="' + escAttr(conv.pinned ? t('conversation.unpin') : t('conversation.pin')) + '">' + iconOnly('pin', conv.pinned ? t('conversation.unpin') : t('conversation.pin')) + '</button>';
     div.onclick = function(idx) { return function() { window.switchConversation(idx); }; }(i);
     div.addEventListener('dragstart', function(event) {
@@ -17479,6 +17845,13 @@ window.switchConversation = function(idx) {
   if (previousId) markConversationTracked(previousId, state.conversationTrackMs || 300000);
   setActiveWorkspaceConversation(idx);
   var activeId = activeConversationId();
+  var activeBrowserTarget = currentConversationTarget(activeId);
+  var activeBrowserView = browserGuestForTarget(activeBrowserTarget);
+  if (activeBrowserView) setActiveBrowserGuest(activeBrowserView, activeBrowserTarget);
+  else if (state.rightTab === 'browser') window.ensureBrowserPanel({ target: activeBrowserTarget, activate: true }).catch(function(error) {
+    console.error('[Browser] conversation-bound guest initialization failed:', error && error.message ? error.message : String(error));
+  });
+  window.refreshComputerUseState(activeBrowserTarget);
   state.backendQueue = backendQueueForTarget(currentConversationTarget(activeId));
   holdForegroundConversation(activeId, 4500);
   markConversationTracked(activeId, state.conversationTrackMs || 300000);
@@ -17518,8 +17891,13 @@ function refreshConversationArchivesAfterBatch() {
     state.workspaceArchives = (items || []).map(function(a) {
       return { id: a.id || a.name || String(a), name: a.name || String(a), firstLine: a.firstLine || '', date: a.date || '', scope: a.scope || 'workspace', workspace: a.workspace || state.currentWorkspace || '', restorable: !!a.restorable, conversationId: a.conversationId || '' };
     });
-    state.allArchives = [];
+    var archiveSettingsOpen = typeof document !== 'undefined'
+      && state.settingsActiveTab === 'archive'
+      && !!document.getElementById('stab-archive');
+    if (!archiveSettingsOpen) state.allArchives = [];
     window.renderRightArchives();
+    var stab = typeof document !== 'undefined' ? document.getElementById('stab-archive') : null;
+    if (stab && archiveSettingsOpen) stab.innerHTML = renderArchiveSettings();
     return items || [];
   });
 }
@@ -17554,10 +17932,6 @@ window.archiveConv = function(conversationId) {
     var targetRuntime = currentConversationTarget(targetId);
     var workspaceKey = currentWorkspaceKey();
     var pendingKey = workspaceKey + '::' + targetId;
-    if (runningConversationRecord(targetId)) {
-      showUiNotice(currentLang() === 'zh' ? '运行中的对话不能归档。' : 'A running conversation cannot be archived.', 'error', 'archive-running-' + currentRuntimeKey(targetId));
-      return;
-    }
     if (state.conversationArchivePending[pendingKey]) return;
     var priorActiveId = String(((convs.find(function(item) { return item && item.active; }) || {}).id) || '');
     var rollbackOrder = convs.map(function(item) { return String(item && item.id || 'default'); });
@@ -17597,39 +17971,37 @@ window.archiveConv = function(conversationId) {
     archivePromise.then(function(receipt) {
       if (!receipt || receipt.ok !== true) throw new Error((receipt && receipt.error) || 'Archive failed');
       delete state.conversationArchivePending[pendingKey];
+      var optimisticArchive = {
+        id: receipt.fileName,
+        name: receipt.fileName,
+        firstLine: target.summary || '',
+        date: new Date().toISOString(),
+        scope: 'workspace',
+        workspace: state.currentWorkspace || '',
+        restorable: true,
+        conversationId: receipt.conversationId || targetId,
+      };
+      state.workspaceArchives = (state.workspaceArchives || []).filter(function(item) {
+        return String(item && item.id || item && item.name || '') !== String(optimisticArchive.id);
+      });
+      state.workspaceArchives.unshift(optimisticArchive);
+      if (Array.isArray(state.allArchives) && state.allArchives.length) {
+        state.allArchives = state.allArchives.filter(function(item) {
+          return String(item && item.id || item && item.name || '') !== String(optimisticArchive.id);
+        });
+        state.allArchives.unshift(optimisticArchive);
+      }
+      window.renderRightArchives();
+      var archiveSettings = typeof document !== 'undefined' ? document.getElementById('stab-archive') : null;
+      if (archiveSettings && state.settingsActiveTab === 'archive') archiveSettings.innerHTML = renderArchiveSettings();
       showUiNotice('[Archive] ' + t('archive.saved') + ': ' + receipt.fileName, 'success', 'archive-saved-' + targetId);
       scheduleConversationArchiveRefresh(workspaceKey);
     }).catch(function(err) {
-      var pending = state.conversationArchivePending[pendingKey];
       delete state.conversationArchivePending[pendingKey];
-      var workspaceConversations = state.workspaceConversations[workspaceKey] || [];
-      if (pending && !workspaceConversations.some(function(item) { return String(item && item.id || '') === targetId; })) {
-        var restoreAt = -1;
-        var orderIds = Array.isArray(pending.orderIds) ? pending.orderIds : [];
-        var targetOrderIndex = orderIds.indexOf(targetId);
-        for (var beforeIndex = targetOrderIndex - 1; beforeIndex >= 0 && restoreAt < 0; beforeIndex--) {
-          var precedingIndex = workspaceConversations.findIndex(function(item) { return String(item && item.id || '') === orderIds[beforeIndex]; });
-          if (precedingIndex >= 0) restoreAt = precedingIndex + 1;
-        }
-        for (var afterIndex = targetOrderIndex + 1; afterIndex < orderIds.length && restoreAt < 0; afterIndex++) {
-          var followingIndex = workspaceConversations.findIndex(function(item) { return String(item && item.id || '') === orderIds[afterIndex]; });
-          if (followingIndex >= 0) restoreAt = followingIndex;
-        }
-        if (restoreAt < 0) restoreAt = Math.min(Number(pending.index || 0), workspaceConversations.length);
-        workspaceConversations.splice(restoreAt, 0, pending.target);
-        if (pending.wasActive) {
-          for (var j = 0; j < workspaceConversations.length; j++) workspaceConversations[j].active = String(workspaceConversations[j].id || '') === targetId;
-        }
-      }
-      if (workspaceKey === currentWorkspaceKey()) {
-        state.conversations = workspaceConversations;
-        state.activeConversation = Math.max(0, workspaceConversations.findIndex(function(item) { return item && item.active; }));
-        if (pending && pending.wasActive) {
-          state.activeBackendConversationId = targetId;
-          if (els['chat-area']) els['chat-area'].innerHTML = pending.chatHtml || '';
-        }
-        renderConversations();
-      }
+      // Keep the optimistic removal authoritative for this renderer session.
+      // A failed IPC receipt is surfaced, but never resurrects the row under
+      // the user's pointer; the next explicit workspace refresh is the only
+      // path allowed to reconcile a failed destructive operation.
       showUiNotice('[Archive] ' + t('workspace.saveFailed') + ': ' + (err.message || String(err)), 'error', 'archive-failed-' + targetId);
     });
   }
@@ -19404,18 +19776,26 @@ window.saveWsSetting = function(key, value) {
 window.renderFlowSelector = function() {
   var flowSel = document.getElementById('flow-select');
   if (!flowSel) return;
+  var flows = Array.isArray(state.flowWorks) ? state.flowWorks : [];
   var defaultFlow = state.defaultFlow || '';
+  if (flows.length === 0) {
+    state.defaultFlow = '';
+    flowSel.disabled = true;
+    flowSel.innerHTML = '<option value="">' + esc(t('flow.noAvailable')) + '</option>';
+    if (window.syncNewmarkSelect) window.syncNewmarkSelect(flowSel);
+    return;
+  }
+  flowSel.disabled = false;
   var html = '';
-  for (var fi = 0; fi < state.flowWorks.length; fi++) {
-    var selected = state.flowWorks[fi].name === defaultFlow ? ' selected' : '';
-    html += '<option value="' + esc(state.flowWorks[fi].name) + '"' + selected + '>' + esc(state.flowWorks[fi].name) + '</option>';
+  for (var fi = 0; fi < flows.length; fi++) {
+    var selected = flows[fi].name === defaultFlow ? ' selected' : '';
+    html += '<option value="' + esc(flows[fi].name) + '"' + selected + '>' + esc(flows[fi].name) + '</option>';
   }
   flowSel.innerHTML = html;
-  if (state.flowWorks.length > 0) {
-    if (defaultFlow) flowSel.value = defaultFlow;
-    state.defaultFlow = flowSel.value;
-  }
+  if (defaultFlow) flowSel.value = defaultFlow;
+  state.defaultFlow = flowSel.value;
   flowSel.onchange = function() { state.defaultFlow = this.value; api.saveConfig({defaultFlow: state.defaultFlow}); };
+  if (window.syncNewmarkSelect) window.syncNewmarkSelect(flowSel);
 };
 
 window.loadFlows = function(options) {
@@ -19680,9 +20060,10 @@ function schedulePostStartupUiRendering() {
   cacheEls();
   setupAgentWorkEvents();
   if (api.onBrowserEnsureGuest) {
-    api.onBrowserEnsureGuest(function() {
+    api.onBrowserEnsureGuest(function(target) {
       cancelBrowserGuestIdleDestroy();
-      window.ensureBrowserPanel({ activate: false }).catch(function(error) {
+      var requestedTarget = target || currentConversationTarget();
+      window.ensureBrowserPanel({ target: requestedTarget, activate: isActiveConversationTarget(requestedTarget) }).catch(function(error) {
         console.error('[Browser] guest initialization failed:', error && error.message ? error.message : String(error));
       });
     });
@@ -19814,6 +20195,48 @@ function schedulePostStartupUiRendering() {
   updateWorkspaceGate();
 
   // === Event Listeners ===
+  function escapeBelongsToFocusedControl(event) {
+    var target = event && event.target;
+    if (!target || target === document || target === document.body || target === document.documentElement) return false;
+    if (els.prompt && (target === els.prompt || (els.prompt.contains && els.prompt.contains(target)))) return false;
+    if (target.closest && target.closest('.modal.active, .sub-win.open, .newmark-select-shell.open')) return true;
+    return !!(target.matches && target.matches('input, textarea, select, [contenteditable="true"]'));
+  }
+  if (api.onWorkspaceChanged) {
+    var workspaceRefreshTimer = null;
+    api.onWorkspaceChanged(function() {
+      if (workspaceRefreshTimer) clearTimeout(workspaceRefreshTimer);
+      workspaceRefreshTimer = setTimeout(function() {
+        workspaceRefreshTimer = null;
+        if (window.refreshWorkspaceState) window.refreshWorkspaceState().catch(function(){});
+        if (document.getElementById('right-archive-list')) window.refreshRightArchives();
+      }, 120);
+    });
+  }
+
+  function stopRunningFromEscape(event) {
+    if (!event || event.key !== 'Escape' || event.defaultPrevented || escapeBelongsToFocusedControl(event)) return false;
+    if (currentFlowRunning() && flowTakeoverMatchesCurrent() && !promptHasText()) {
+      event.preventDefault();
+      window.stopFlowRun();
+      return true;
+    }
+    if (isCurrentConversationRunning() && !promptHasText()) {
+      event.preventDefault();
+      window.stopCurrentConversation();
+      return true;
+    }
+    return false;
+  }
+
+  // The prompt handler below covers the normal focused-input path. Keep a
+  // document-level fallback so a physical Escape still stops a running target
+  // after focus moved to the chat, title bar, button, or another non-editor
+  // surface. Modal/editor/select Escape behavior remains owned by that UI.
+  document.addEventListener('keydown', function(event) {
+    if (stopRunningFromEscape(event)) event.stopPropagation();
+  });
+
   if (els.prompt) {
     els.prompt.addEventListener('keydown', function(e) {
       if (e.key === 'Escape' && currentFlowRunning() && flowTakeoverMatchesCurrent() && !promptHasText()) {