newmark-agent 0.3.10 → 0.3.12

package/dist/main.js

@@ -51,6 +51,7 @@ const electronBrowserUseHost_1 = require("./core/electronBrowserUseHost");
 const flow_1 = require("./core/flow");
 const flow_runner_1 = require("./core/flow-runner");
 const cli_commands_1 = require("./cli-commands");
+const cli_discovery_1 = require("./cli-discovery");
 const config_1 = require("./core/config");
 const memoryLab_1 = require("./core/memoryLab");
 const installUpdate_1 = require("./core/installUpdate");
@@ -73,6 +74,7 @@ const runtimeShutdown_1 = require("./core/runtimeShutdown");
 const runtimeLifecycle_1 = require("./core/runtimeLifecycle");
 const compat_1 = require("./core/compat");
 const mcpManager_1 = require("./core/mcpManager");
+const cli_help_1 = require("./cli-help");
 const APP_NAME = 'Newmark Agent';
 const APP_ID = 'ai.newmark.agent';
 const CONFIG_RELOAD_RUNTIME_TIMEOUT_MS = 6_000;
@@ -116,7 +118,27 @@ let _forceQuit = false;
 let forcedExitTimer = null;
 let electronBrowserUseHost = null;
 let browserUseEngine = null;
+// A single renderer can host several hidden conversation-bound guests. The
+// legacy host map is retained for focused-window discovery, while this map is
+// the authoritative Browser-Use/right-sidebar binding.
 const browserGuestContentsByHost = new Map();
+const browserGuestBindingsByRuntime = new Map();
+function browserGuestRuntimeKey(target) {
+    return (0, conversationTarget_1.normalizeConversationTarget)(target).runtimeKey;
+}
+function browserGuestBindingFor(runtimeKey) {
+    const binding = browserGuestBindingsByRuntime.get(String(runtimeKey || ''));
+    if (!binding)
+        return null;
+    const guest = electron_1.webContents.fromId(binding.guestId);
+    if (!guest || guest.isDestroyed() || guest.getType() !== 'webview' || guest.hostWebContents?.id !== binding.hostId) {
+        browserGuestBindingsByRuntime.delete(String(runtimeKey || ''));
+        if (browserGuestContentsByHost.get(binding.hostId) === binding.guestId)
+            browserGuestContentsByHost.delete(binding.hostId);
+        return null;
+    }
+    return binding;
+}
 let workspaceSwitchGeneration = 0;
 let workspaceSelectionCoordinator = null;
 function defaultTerminalShell() {
@@ -405,7 +427,11 @@ function createAppIconImage(size) {
     return size ? icon.resize({ width: size, height: size }) : icon;
 }
 function userArgs() {
-    return process.argv.slice(1);
+    const args = process.argv.slice(1);
+    // The native Windows console wrapper inserts Electron's `--` boundary before
+    // user arguments. Electron leaves that boundary in process.argv; normalize it
+    // before command discovery so the literal `Newmark.exe help` path terminates.
+    return args[0] === '--' ? args.slice(1) : args;
 }
 function argValue(args, key) {
     const idx = args.indexOf(key);
@@ -465,14 +491,14 @@ function positionalAfter(args, commandName) {
     return values;
 }
 // First-run initialization
-function firstRunInit(root) {
+function firstRunInit(root, options = {}) {
     fs.mkdirSync(root, { recursive: true });
     for (const d of ['skills', 'Work', 'Flow', 'archive', 'Memory Lab']) {
         fs.mkdirSync(path.join(root, d), { recursive: true });
     }
     new memoryLab_1.MemoryLabManager(root);
     const configModule = require('./core/config');
-    configModule.ensureRootConfig(root);
+    configModule.ensureRootConfig(root, options);
     if (!fs.existsSync(path.join(root, 'agent.md'))) {
         fs.writeFileSync(path.join(root, 'agent.md'), '# Newmark Agent\n\nYou are a powerful coding assistant.\n', 'utf-8');
     }
@@ -562,18 +588,13 @@ function ensureElectronUtilityRuntimeHost() {
     return host;
 }
 function legacyUserDataRoot() {
-    try {
-        return electron_1.app.getPath('userData');
-    }
-    catch {
-        if (process.platform === 'win32') {
-            const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
-            return path.join(appData, 'Newmark Agent');
-        }
-        if (process.platform === 'darwin')
-            return path.join(os.homedir(), 'Library', 'Application Support', 'Newmark Agent');
-        return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'Newmark Agent');
+    if (process.platform === 'win32') {
+        const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+        return path.join(appData, 'Newmark Agent');
     }
+    if (process.platform === 'darwin')
+        return path.join(os.homedir(), 'Library', 'Application Support', 'Newmark Agent');
+    return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'Newmark Agent');
 }
 function migrateLegacyRuntimeRoot(root) {
     const targetRoot = path.resolve(root);
@@ -656,6 +677,15 @@ function resolveRoot(args) {
         return writableRuntimeRoot(explicitRoot);
     return getRoot();
 }
+function resolveTuiWorkspacePath(args, root) {
+    const explicitWorkspace = pathArgValue(args, '--workspace');
+    if (explicitWorkspace)
+        return explicitWorkspace;
+    // An explicitly isolated runtime must not silently register the caller's
+    // cwd as an external workspace. Keep the opt-in --workspace escape hatch,
+    // while making the safe one-argument form fully self-contained.
+    return pathArgValue(args, '--root') ? root : process.cwd();
+}
 function startupLogPath() {
     try {
         const userData = userRuntimeRoot();
@@ -737,7 +767,15 @@ async function waitForWebContentsLoad(contents, timeoutMs = 15000) {
         contents.once('did-fail-load', finish);
     });
 }
-function registeredBrowserGuest(hostContentsId) {
+function registeredBrowserGuest(hostContentsId, runtimeKey) {
+    if (runtimeKey) {
+        const binding = browserGuestBindingFor(runtimeKey);
+        if (binding && (!hostContentsId || binding.hostId === hostContentsId)) {
+            const guest = electron_1.webContents.fromId(binding.guestId);
+            if (guest && !guest.isDestroyed())
+                return guest;
+        }
+    }
     const hostIds = hostContentsId
         ? [hostContentsId]
         : [
@@ -752,8 +790,14 @@ function registeredBrowserGuest(hostContentsId) {
         if (!guestId)
             continue;
         const guest = electron_1.webContents.fromId(guestId);
-        if (guest && !guest.isDestroyed() && guest.getType() === 'webview' && guest.hostWebContents?.id === hostId)
+        if (guest && !guest.isDestroyed() && guest.getType() === 'webview' && guest.hostWebContents?.id === hostId) {
+            if (runtimeKey) {
+                const bound = browserGuestBindingsByRuntime.get(runtimeKey);
+                if (!bound || bound.hostId !== hostId || bound.guestId !== guest.id)
+                    continue;
+            }
             return guest;
+        }
         browserGuestContentsByHost.delete(hostId);
     }
     return null;
@@ -774,37 +818,64 @@ async function boundedOperation(operation, timeoutMs, label) {
             clearTimeout(timer);
     }
 }
-function registerBrowserGuest(host, guest) {
+function registerBrowserGuest(host, guest, requestedTarget) {
     if (host.isDestroyed() || guest.isDestroyed() || guest.getType() !== 'webview' || guest.hostWebContents?.id !== host.id)
         return false;
+    let target;
+    try {
+        target = (0, conversationTarget_1.normalizeConversationTarget)(conversationRuntimeTarget(requestedTarget));
+    }
+    catch {
+        return false;
+    }
+    const prior = browserGuestBindingsByRuntime.get(target.runtimeKey);
+    if (prior && prior.guestId !== guest.id) {
+        const priorGuest = electron_1.webContents.fromId(prior.guestId);
+        if (priorGuest && !priorGuest.isDestroyed())
+            priorGuest.hostWebContents?.send('browser:guestVisibility', { runtimeKey: target.runtimeKey, visible: false });
+    }
+    browserGuestBindingsByRuntime.set(target.runtimeKey, {
+        hostId: host.id,
+        guestId: guest.id,
+        workspaceId: target.workspaceId,
+        conversationId: target.conversationId,
+    });
     browserGuestContentsByHost.set(host.id, guest.id);
     guest.once('destroyed', () => {
         if (browserGuestContentsByHost.get(host.id) === guest.id)
             browserGuestContentsByHost.delete(host.id);
+        const binding = browserGuestBindingsByRuntime.get(target.runtimeKey);
+        if (binding?.guestId === guest.id)
+            browserGuestBindingsByRuntime.delete(target.runtimeKey);
     });
     ensureElectronBrowserUseHost().attach(guest);
     return true;
 }
-async function waitForRegisteredBrowserGuest(host, timeoutMs = 12_000) {
+async function waitForRegisteredBrowserGuest(host, runtimeKey, timeoutMs = 12_000) {
     const deadline = Date.now() + Math.max(250, timeoutMs);
     while (!host.isDestroyed() && Date.now() < deadline) {
-        const guest = registeredBrowserGuest(host.id);
+        const guest = registeredBrowserGuest(host.id, runtimeKey);
         if (guest)
             return guest;
         await new Promise(resolve => setTimeout(resolve, 25));
     }
     throw new Error('Built-in Browser guest did not become ready before the Browser-Use timeout');
 }
-async function ensureBrowserWebContents(boundContentsId) {
+async function ensureBrowserWebContents(boundContentsId, runtimeKey) {
     if (boundContentsId) {
         const bound = electron_1.webContents.fromId(boundContentsId);
         if (bound && !bound.isDestroyed() && bound.getType() === 'webview'
             && browserGuestContentsByHost.get(bound.hostWebContents?.id || 0) === bound.id) {
+            if (runtimeKey) {
+                const binding = browserGuestBindingsByRuntime.get(runtimeKey);
+                if (!binding || binding.guestId !== bound.id)
+                    return await ensureBrowserWebContents(undefined, runtimeKey);
+            }
             bound.hostWebContents?.send('browser:ensureGuest');
             return bound;
         }
     }
-    const registered = registeredBrowserGuest();
+    const registered = registeredBrowserGuest(undefined, runtimeKey);
     if (registered) {
         registered.hostWebContents?.send('browser:ensureGuest');
         return registered;
@@ -814,13 +885,13 @@ async function ensureBrowserWebContents(boundContentsId) {
     const host = hostWindow?.webContents;
     if (!host || host.isDestroyed())
         throw new Error('Built-in Browser UI is unavailable');
-    host.send('browser:ensureGuest');
-    return await waitForRegisteredBrowserGuest(host);
+    host.send('browser:ensureGuest', runtimeKey ? { runtimeKey } : undefined);
+    return await waitForRegisteredBrowserGuest(host, runtimeKey, 12_000);
 }
 function ensureElectronBrowserUseHost() {
     if (!electronBrowserUseHost) {
         electronBrowserUseHost = new electronBrowserUseHost_1.ElectronBrowserUseHost({
-            resolveContents: async (_scope, boundContentsId) => await ensureBrowserWebContents(boundContentsId),
+            resolveContents: async (scope, boundContentsId) => await ensureBrowserWebContents(boundContentsId, scope.runtimeKey),
             openExternal: async (url) => { await electron_1.shell.openExternal(url); },
         });
     }
@@ -833,10 +904,18 @@ function ensureBrowserUseEngine() {
     }
     return browserUseEngine;
 }
-function currentBrowserUseContext() {
-    const target = (0, conversationTarget_1.normalizeConversationTarget)(conversationRuntimeTarget());
+function currentBrowserUseContext(requestedTarget) {
+    const target = (0, conversationTarget_1.normalizeConversationTarget)(conversationRuntimeTarget(requestedTarget));
     return { runtimeKey: target.runtimeKey, actorId: agent?.runtimeActorId || terminalTakeover_1.ROOT_TERMINAL_ACTOR_ID };
 }
+function browserControlTargetInput(input) {
+    if (!input)
+        return undefined;
+    return {
+        workspaceId: String(input.workspaceId || ''),
+        conversationId: String(input.conversationId || 'default'),
+    };
+}
 async function runBoundBrowserUse(input, context, signal) {
     return await ensureBrowserUseEngine().run((0, browserUse_1.bindBrowserUseRequest)(input, context), signal);
 }
@@ -856,8 +935,10 @@ function browserSnapshotScript(maxChars) {
 }
 async function runBrowserControl(request) {
     const action = request.action;
+    const requestedTarget = browserControlTargetInput(request.target);
+    const target = (0, conversationTarget_1.normalizeConversationTarget)(conversationRuntimeTarget(requestedTarget));
     if (action === 'use') {
-        const receipt = await runBoundBrowserUse(request.browserUse, currentBrowserUseContext());
+        const receipt = await runBoundBrowserUse(request.browserUse, currentBrowserUseContext(requestedTarget));
         return {
             ok: receipt.ok,
             action,
@@ -868,7 +949,7 @@ async function runBrowserControl(request) {
             error: receipt.error,
         };
     }
-    const contents = await ensureBrowserWebContents();
+    const contents = await ensureBrowserWebContents(undefined, target.runtimeKey);
     try {
         if (action === 'open') {
             await contents.loadURL(request.url || 'about:blank');
@@ -953,12 +1034,55 @@ function installBrowserControlBackend() {
 const args = userArgs();
 const command = args.find(a => a === 'flow' || a === 'edit');
 const isTuiArg = args.some(arg => arg.toLowerCase() === '--tui');
+const hasCliCommand = args.some(a => cli_commands_1.CLI_COMMANDS.includes(a));
+const isFlowArg = command === 'flow';
+const isEditArg = command === 'edit';
+const isHelpArg = !hasCliCommand && (args.some(arg => ['--help', '-h'].includes(arg.toLowerCase())) || args[0]?.toLowerCase() === 'help');
+const isVersionArg = !hasCliCommand && (0, cli_discovery_1.isVersionArgument)(args);
+const isReadOnlyValidation = hasCliCommand && args.includes('validate-models') && !args.includes('--persist');
 const isViewerArg = args.some(arg => arg.toLowerCase() === '--newmark-viewer');
 const isCliArg = args.includes('--cli');
 const isServerArg = args.includes('--server');
-const isFlowArg = command === 'flow';
-const isEditArg = command === 'edit';
-const hasCliCommand = args.some(a => cli_commands_1.CLI_COMMANDS.includes(a));
+const invalidArgument = (0, cli_discovery_1.invalidTopLevelArgument)(args);
+if (invalidArgument) {
+    console.error(`Invalid Newmark argument: ${invalidArgument}`);
+    process.exit(2);
+}
+// Electron's Chromium profile is a separate state boundary from Newmark's
+// business root. Bind both before any ready event so --root cannot leave
+// Preferences, DIPS, DevTools ports, cookies, or session storage in the real
+// default AppData directory. The dedicated subdirectories keep Chromium's
+// files separate from the durable Newmark config/workspace files.
+const runtimeRoot = resolveRoot(args);
+const electronUserDataRoot = path.join(runtimeRoot, 'Electron');
+const electronSessionDataRoot = path.join(electronUserDataRoot, 'session-data');
+try {
+    fs.mkdirSync(electronSessionDataRoot, { recursive: true });
+    electron_1.app.setPath('userData', electronUserDataRoot);
+    electron_1.app.setPath('sessionData', electronSessionDataRoot);
+}
+catch (error) {
+    console.error(`Unable to isolate Electron user-data directory: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+}
+// Help/version are terminating discovery commands. They must be handled
+// before Electron's GUI/TUI/server branches can initialize runtime state or
+// spawn a window, so a product-new tester can use them safely in any surface.
+if (isHelpArg) {
+    console.log(isFlowArg ? (0, cli_help_1.newmarkFlowHelpText)() : isEditArg ? (0, cli_help_1.newmarkEditHelpText)() : (0, cli_help_1.newmarkHelpText)((0, installUpdate_1.currentAppVersion)()));
+    process.exit(0);
+}
+if (isVersionArg) {
+    console.log((0, installUpdate_1.currentAppVersion)());
+    process.exit(0);
+}
+const unknownCommand = electron_1.app.isPackaged && !hasCliCommand && !isTuiArg && !isCliArg && !isServerArg && !isViewerArg
+    ? (0, cli_discovery_1.unknownTopLevelCommand)(args)
+    : undefined;
+if (unknownCommand) {
+    console.error(`Unknown Newmark command or argument: ${unknownCommand}. Run --help to see the supported entrypoints.`);
+    process.exit(2);
+}
 function viewerEscape(value) {
     return String(value || '').replace(/[&<>"']/g, character => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[character] || character);
 }
@@ -1033,7 +1157,9 @@ if (isViewerArg) {
     }).catch(error => { console.error(`Unable to open Newmark viewer: ${error instanceof Error ? error.message : String(error)}`); electron_1.app.quit(); });
 }
 else if (isTuiArg) {
-    const isConsoleLauncher = electron_1.app.isPackaged && path.basename(process.execPath).toLowerCase() === 'newmark.exe';
+    const isConsoleLauncher = electron_1.app.isPackaged && (path.basename(process.execPath).toLowerCase() === 'newmark.exe'
+        || path.basename(process.execPath).toLowerCase() === 'newmark console runtime.exe'
+        || process.env.NEWMARK_CONSOLE_WRAPPER === '1');
     if (isConsoleLauncher && process.env.NEWMARK_TUI_SIDECAR !== '1') {
         const tuiProcess = (0, child_process_1.spawnSync)(process.execPath, [path.join(__dirname, 'launcher.js'), ...args], {
             cwd: process.cwd(),
@@ -1041,6 +1167,11 @@ else if (isTuiArg) {
                 ...process.env,
                 ELECTRON_RUN_AS_NODE: '1',
                 NEWMARK_TUI_SIDECAR: '1',
+                // The GUI Electron host does not expose the inherited ConPTY handles
+                // as Node TTY streams. The console wrapper has already established
+                // that this is the terminal entrypoint, so preserve the terminal
+                // contract for the sidecar without weakening ordinary GUI launches.
+                NEWMARK_FORCE_TTY: isConsoleLauncher ? '1' : process.env.NEWMARK_FORCE_TTY,
             },
             stdio: 'inherit',
             windowsHide: false,
@@ -1061,12 +1192,12 @@ else if (isTuiArg) {
     const root = resolveRoot(args);
     firstRunInit(root);
     const { start } = require('./tui/src/app');
-    start({ root, workspacePath: process.cwd(), desktopDist: __dirname });
+    start({ root, workspacePath: resolveTuiWorkspacePath(args, root), desktopDist: __dirname });
 }
 else if (hasCliCommand) {
     (async () => {
         const root = resolveRoot(args);
-        firstRunInit(root);
+        firstRunInit(root, { readOnly: isReadOnlyValidation });
         const handled = await (0, cli_commands_1.runCliCommand)(root, args);
         const code = typeof process.exitCode === 'number' ? process.exitCode : 0;
         exitCli(handled ? code : 1);
@@ -1227,6 +1358,51 @@ else {
         });
         electron_1.app.whenReady().then(async () => {
             let root = resolveRoot(args);
+            let workspaceRegistryWatcher = null;
+            let workspaceRegistryWatchTimer = null;
+            const workspaceRegistryFiles = new Set(['Local.json', 'External.json', 'State.json']);
+            const broadcastWorkspaceChanged = (files) => {
+                for (const win of electron_1.BrowserWindow.getAllWindows()) {
+                    if (win.isDestroyed())
+                        continue;
+                    win.webContents.send('workspace:changed', { files, root });
+                }
+            };
+            const refreshWorkspaceRegistryFromDisk = (files) => {
+                if (!agent)
+                    return;
+                agent.refreshWorkspaceRegistryFromStorage();
+                const current = agent.workspace.current;
+                if (current)
+                    workspaceSelectionCoordinator?.setCurrent(current.id || current.path || current.name);
+                broadcastWorkspaceChanged(files);
+            };
+            const ensureWorkspaceRegistryWatcher = () => {
+                if (workspaceRegistryWatcher)
+                    return;
+                const workDir = path.join(root, 'Work');
+                try {
+                    workspaceRegistryWatcher = fs.watch(workDir, { persistent: false }, (_eventType, filename) => {
+                        const changed = String(filename || '');
+                        if (changed && !workspaceRegistryFiles.has(path.basename(changed)))
+                            return;
+                        if (workspaceRegistryWatchTimer)
+                            clearTimeout(workspaceRegistryWatchTimer);
+                        workspaceRegistryWatchTimer = setTimeout(() => {
+                            workspaceRegistryWatchTimer = null;
+                            try {
+                                refreshWorkspaceRegistryFromDisk(changed ? [path.basename(changed)] : ['Work']);
+                            }
+                            catch (error) {
+                                logStartupFailure('workspace-registry-refresh', error);
+                            }
+                        }, 90);
+                    });
+                }
+                catch (error) {
+                    logStartupFailure('workspace-registry-watch', error);
+                }
+            };
             const fileRouter = new workspaceFileRouter_1.WorkspaceFileRouter(() => path.resolve(agent?.workspace.current?.path || root));
             const pdfPreviewServer = new pdfPreviewServer_1.PdfPreviewServer((token, ownerId) => fileRouter.resolvePdfCapability(token, ownerId));
             await pdfPreviewServer.start();
@@ -1513,7 +1689,12 @@ else {
                     rejectUiReadinessById(Number(fileRouterOwnerId), new Error('Startup window closed before UI readiness'));
                     fileRouter.revokeOwner(fileRouterOwnerId);
                     pdfPreviewServer.revokeOwner(fileRouterOwnerId);
-                    browserGuestContentsByHost.delete(Number(fileRouterOwnerId));
+                    const closedHostId = Number(fileRouterOwnerId);
+                    browserGuestContentsByHost.delete(closedHostId);
+                    for (const [runtimeKey, binding] of browserGuestBindingsByRuntime) {
+                        if (binding.hostId === closedHostId)
+                            browserGuestBindingsByRuntime.delete(runtimeKey);
+                    }
                     const remaining = electron_1.BrowserWindow.getAllWindows().filter(candidate => !candidate.isDestroyed() && candidate !== win);
                     if (mainWindow === win)
                         mainWindow = remaining[0] || null;
@@ -1628,6 +1809,7 @@ else {
                     agent = new agent_1.Agent(root);
                     mcpManager = new mcpManager_1.McpManager(root);
                     activeAgentBackendMode = process.platform === 'win32' && agent.config.getBool('agent', 'run_in_wsl') ? 'wsl' : 'windows';
+                    ensureWorkspaceRegistryWatcher();
                     restoreStoredFlowSuspension();
                     recordStartup('agent-ready');
                 }
@@ -2117,8 +2299,17 @@ else {
                     (0, runtimeLifecycle_1.markRuntimeLifecycleClean)(root, 'main');
             };
             electron_1.app.on('will-quit', event => {
-                if (_forceQuit)
+                // Window-close and tray-exit both enter this path. The runtime pools
+                // must get a bounded graceful-shutdown window regardless of which
+                // surface initiated the close; otherwise a stuck child can keep the
+                // Electron parent and its renderer tree alive indefinitely.
+                if (_forceQuit || !appExitCleanupComplete)
                     armForcedExitDeadline('will-quit');
+                if (workspaceRegistryWatchTimer)
+                    clearTimeout(workspaceRegistryWatchTimer);
+                workspaceRegistryWatchTimer = null;
+                workspaceRegistryWatcher?.close();
+                workspaceRegistryWatcher = null;
                 startupDeferredTasks?.cancel();
                 agent?.flushWorkspaceConversationState();
                 conversationKernel?.flushPersistence();
@@ -2179,6 +2370,7 @@ else {
                 electronBrowserUseHost = null;
                 browserControl_1.BrowserControl.setBackend(null);
                 browserGuestContentsByHost.clear();
+                browserGuestBindingsByRuntime.clear();
                 if (sidecarProcess) {
                     sidecarProcess.kill();
                     sidecarProcess = null;
@@ -2448,6 +2640,13 @@ else {
                 else
                     await electronUtilityRuntimePool?.stopTarget(target);
             };
+            const forceStopTargetRuntime = async (target) => {
+                if (wslBackendEnabled())
+                    await wslAgentRuntimePool?.forceStopTarget(target);
+                else
+                    await electronUtilityRuntimePool?.forceStopTarget(target);
+            };
+            const archiveInFlight = new Map();
             const isolatedConversationAgent = (target) => {
                 const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
                 const isolated = new agent_1.Agent(root, { agentOnly: true });
@@ -2569,9 +2768,9 @@ else {
                     }
                 }
             });
-            electron_1.ipcMain.handle('browser:registerGuest', (event, guestContentsId) => {
+            electron_1.ipcMain.handle('browser:registerGuest', (event, guestContentsId, target) => {
                 const guest = electron_1.webContents.fromId(Number(guestContentsId || 0));
-                return { accepted: !!guest && registerBrowserGuest(event.sender, guest) };
+                return { accepted: !!guest && registerBrowserGuest(event.sender, guest, target) };
             });
             electron_1.ipcMain.handle('browser:control', async (_event, request) => {
                 return await browserControl_1.BrowserControl.run(request);
@@ -2955,6 +3154,28 @@ else {
                     runtimeDeferred: false,
                 };
             });
+            electron_1.ipcMain.handle('agent:computerUseState', async (_event, targetInput) => {
+                if (!agent)
+                    return { enabled: false, occupied: false, runtimeKey: '' };
+                const target = (0, conversationTarget_1.normalizeConversationTarget)(conversationRuntimeTarget(targetInput || agent.activeConversationId || 'default'));
+                return utilityHostToolHandler.computerUseState(target.runtimeKey);
+            });
+            electron_1.ipcMain.handle('agent:setComputerUseEnabled', async (_event, targetInput, enabled) => {
+                if (!agent)
+                    return { ok: false, error: 'Agent not initialized' };
+                const target = (0, conversationTarget_1.normalizeConversationTarget)(conversationRuntimeTarget(targetInput || agent.activeConversationId || 'default'));
+                const result = utilityHostToolHandler.setComputerUseEnabled(target.runtimeKey, enabled !== false, `conversation:${target.conversationId}`);
+                if (!result.ok)
+                    return result;
+                if (enabled === false) {
+                    try {
+                        const { runComputerUse } = require('./tools/computerUse');
+                        await runComputerUse({ action: 'takeover_stop', workspacePath: target.workspace?.path || root, ownerId: target.runtimeKey, invocation: 'agent' });
+                    }
+                    catch { }
+                }
+                return result;
+            });
             electron_1.ipcMain.handle('agent:updateGoal', async (_event, goal, targetInput) => {
                 if (!agent)
                     return null;
@@ -3057,6 +3278,7 @@ else {
                     pendingOptions: conversationSnapshot.pendingOptions || agent.pendingOptions,
                     flowSuspension: flowSuspensionForTarget(target),
                     flowRunning: flowRunningForTarget(target),
+                    computerUse: utilityHostToolHandler.computerUseState((0, conversationTarget_1.normalizeConversationTarget)(target).runtimeKey),
                     draft: agent.getStoredConversationDraft(target.conversationId) || '',
                     proxyEnabled: agent.config.getBool('proxy', 'enabled'),
                     proxyUrl: agent.config.getStr('proxy', 'url'),
@@ -3618,32 +3840,46 @@ else {
                     return { ok: false, error: 'Agent not initialized' };
                 const target = conversationRuntimeTarget(targetInput || agent.activeConversationId || 'default');
                 const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
-                assertTargetNotMutating(normalized);
-                mutatingRuntimeKeys.add(normalized.runtimeKey);
+                const existing = archiveInFlight.get(normalized.runtimeKey);
+                if (existing)
+                    return existing;
+                const operation = (async () => {
+                    mutatingRuntimeKeys.add(normalized.runtimeKey);
+                    try {
+                        // Archive is a destructive lifecycle command. It intentionally
+                        // bypasses the normal mutation/active-prompt guard and hard-stops
+                        // any resident runtime before touching conversation persistence.
+                        await forceStopTargetRuntime(normalized);
+                        const currentWorkspacePath = path.resolve(agent.workspace.current?.path || '');
+                        const targetWorkspacePath = path.resolve(normalized.workspace?.path || '');
+                        const ownsTargetWorkspace = !!normalized.workspace
+                            && !!agent.workspace.current
+                            && currentWorkspacePath === targetWorkspacePath;
+                        // The host Agent owns the current workspace persistence cache. An
+                        // isolated owner is used for another workspace. The archive writer
+                        // starts payload I/O in parallel and finalizes deletion against the
+                        // latest locked state snapshot, so rapid clicks do not serialize on
+                        // large Markdown bodies or lose a sibling deletion.
+                        const archiveOwner = ownsTargetWorkspace ? agent : isolatedConversationAgent(normalized);
+                        const archived = await archiveOwner.archiveConversationAsync(normalized.conversationId);
+                        if (!archived)
+                            return { ok: false, error: 'Conversation archive could not be written.' };
+                        return { ok: true, fileName: archived, conversationId: normalized.conversationId, workspaceId: normalized.workspaceId };
+                    }
+                    catch (error) {
+                        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+                    }
+                    finally {
+                        mutatingRuntimeKeys.delete(normalized.runtimeKey);
+                    }
+                })();
+                archiveInFlight.set(normalized.runtimeKey, operation);
                 try {
-                    const peek = peekTargetRuntime(normalized);
-                    if (peek.running || peek.stopping)
-                        return { ok: false, error: 'Cannot archive a conversation while its runtime is running or stopping.' };
-                    if (peek.resident)
-                        await stopTargetRuntime(normalized);
-                    const currentWorkspacePath = path.resolve(agent.workspace.current?.path || '');
-                    const targetWorkspacePath = path.resolve(normalized.workspace?.path || '');
-                    const ownsTargetWorkspace = !!normalized.workspace
-                        && !!agent.workspace.current
-                        && currentWorkspacePath === targetWorkspacePath;
-                    // The host Agent owns the current workspace persistence cache. Archiving
-                    // through it prevents a delayed host flush from resurrecting the target.
-                    const archiveOwner = ownsTargetWorkspace ? agent : isolatedConversationAgent(normalized);
-                    const archived = archiveOwner.archiveConversation(normalized.conversationId);
-                    if (!archived)
-                        return { ok: false, error: 'Conversation archive could not be written.' };
-                    return { ok: true, fileName: archived, conversationId: normalized.conversationId, workspaceId: normalized.workspaceId };
-                }
-                catch (error) {
-                    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+                    return await operation;
                 }
                 finally {
-                    mutatingRuntimeKeys.delete(normalized.runtimeKey);
+                    if (archiveInFlight.get(normalized.runtimeKey) === operation)
+                        archiveInFlight.delete(normalized.runtimeKey);
                 }
             });
             electron_1.ipcMain.handle('agent:listArchives', async (_event, scope) => {

package/dist/preload.js

@@ -34,11 +34,13 @@ contextBridge.exposeInMainWorld('api', {
     setConversationPinned: (id, pinned) => ipcRenderer.invoke('agent:setConversationPinned', id, pinned),
     renameConversation: (id, title) => ipcRenderer.invoke('agent:renameConversation', id, title),
     reorderConversations: (ids) => ipcRenderer.invoke('agent:reorderConversations', ids),
-    browserRegisterGuest: (guestContentsId) => ipcRenderer.invoke('browser:registerGuest', guestContentsId),
+    browserRegisterGuest: (guestContentsId, target) => ipcRenderer.invoke('browser:registerGuest', guestContentsId, target),
     onBrowserEnsureGuest: (callback) => {
-        ipcRenderer.on('browser:ensureGuest', () => callback());
+        ipcRenderer.on('browser:ensureGuest', (_event, target) => callback(target));
     },
     browserControl: (request) => ipcRenderer.invoke('browser:control', request),
+    computerUseState: (target) => ipcRenderer.invoke('agent:computerUseState', target),
+    setComputerUseEnabled: (target, enabled) => ipcRenderer.invoke('agent:setComputerUseEnabled', target, enabled),
     runFlow: (name, input, start) => ipcRenderer.invoke('flow:run', name, input, start),
     resumeFlow: (response, target) => ipcRenderer.invoke('flow:resume', response, target),
     guideFlow: (message, target) => ipcRenderer.invoke('flow:guide', message, target),
@@ -171,6 +173,12 @@ contextBridge.exposeInMainWorld('api', {
     onAgentWorkEvent: (callback) => {
         ipcRenderer.on('agent:workEvent', callback);
     },
+    onWorkspaceChanged: (callback) => {
+        ipcRenderer.on('workspace:changed', (_event, payload) => callback(payload));
+    },
+    removeWorkspaceChangedListener: () => {
+        ipcRenderer.removeAllListeners('workspace:changed');
+    },
     removeAgentWorkEventListener: () => {
         ipcRenderer.removeAllListeners('agent:workEvent');
     },

package/dist/providers/chat-completions.adapter.js

@@ -96,11 +96,7 @@ class ChatCompletionsAdapter {
         let emittedTool = false;
         try {
             while (true) {
-                if (signal.aborted)
-                    throw (0, provider_events_1.providerAbortError)(signal);
-                const readPromise = reader.read();
-                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Stream read timeout')), 30000));
-                const { done, value } = await Promise.race([readPromise, timeoutPromise]);
+                const { done, value } = await (0, provider_events_1.readProviderStreamChunk)(reader, signal);
                 if (done)
                     break;
                 buffer += decoder.decode(value, { stream: true });

package/dist/providers/provider-events.d.ts

@@ -12,6 +12,13 @@ export declare function defaultProviderTransport(request: SerializedProviderRequ
  * (`name === 'AbortError'`, preserves the abort reason when present).
  */
 export declare function providerAbortError(signal?: AbortSignal): Error;
+export declare function providerStreamTimeoutError(timeoutMs: number): Error;
+/**
+ * Read one SSE chunk with both user cancellation and an inactivity deadline.
+ * Cancelling the reader is important: rejecting the race alone leaves the
+ * provider socket alive and lets later requests accumulate behind it.
+ */
+export declare function readProviderStreamChunk(reader: ReadableStreamDefaultReader<Uint8Array>, signal: AbortSignal, timeoutMs?: number): Promise<ReadableStreamReadResult<Uint8Array>>;
 export declare function parseProviderSse(raw: string): Array<{
     event?: string;
     data: string;