newmark-agent 0.3.8 → 0.3.11

package/dist/main.js

@@ -70,8 +70,10 @@ const wslAgentRuntimePool_1 = require("./core/wslAgentRuntimePool");
 const utilityHostToolRouter_1 = require("./core/utilityHostToolRouter");
 const startupPrewarm_1 = require("./core/startupPrewarm");
 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;
@@ -115,7 +117,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() {
@@ -736,7 +758,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]
         : [
@@ -751,8 +781,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;
@@ -773,37 +809,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;
@@ -813,13 +876,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); },
         });
     }
@@ -832,10 +895,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);
 }
@@ -855,8 +926,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,
@@ -867,7 +940,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');
@@ -952,12 +1025,25 @@ 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 isHelpArg = !hasCliCommand && (args.some(arg => ['--help', '-h'].includes(arg.toLowerCase())) || args[0]?.toLowerCase() === 'help');
+const isVersionArg = !hasCliCommand && args.some(arg => ['--version', '-v'].includes(arg.toLowerCase()));
 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));
+// 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((0, cli_help_1.newmarkHelpText)((0, installUpdate_1.currentAppVersion)()));
+    process.exit(0);
+}
+if (isVersionArg) {
+    console.log((0, installUpdate_1.currentAppVersion)());
+    process.exit(0);
+}
 function viewerEscape(value) {
     return String(value || '').replace(/[&<>"']/g, character => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[character] || character);
 }
@@ -1512,7 +1598,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;
@@ -2106,6 +2197,15 @@ else {
                 }
                 electron_1.app.quit();
             };
+            const hasUnsettledGoalOrFlow = () => {
+                const goalRunning = !!agent?.goal && !agent.goal.paused;
+                const flowRunning = Array.from(activeFlowsByRuntimeKey.values()).some(state => !!state.abortController);
+                return goalRunning || flowRunning;
+            };
+            const markMainLifecycleCleanIfSafe = () => {
+                if (!hasUnsettledGoalOrFlow())
+                    (0, runtimeLifecycle_1.markRuntimeLifecycleClean)(root, 'main');
+            };
             electron_1.app.on('will-quit', event => {
                 if (_forceQuit)
                     armForcedExitDeadline('will-quit');
@@ -2131,6 +2231,7 @@ else {
                                 throw error;
                             })
                             : undefined;
+                        let shutdownFailed = false;
                         void (0, runtimeShutdown_1.runRuntimeShutdownBarrier)({
                             operations: [
                                 legacyStop,
@@ -2139,9 +2240,12 @@ else {
                             ],
                             shutdownHelpers: async () => await (0, electronUtilityAgentClient_1.shutdownWindowsProcessHelpers)(2_000),
                         }).catch(error => {
+                            shutdownFailed = true;
                             console.error('[Newmark] Runtime shutdown cleanup failed:', error instanceof Error ? error.message : String(error));
                         }).finally(() => {
                             appExitCleanupComplete = true;
+                            if (!shutdownFailed)
+                                markMainLifecycleCleanIfSafe();
                             electron_1.app.quit();
                         });
                     }
@@ -2165,11 +2269,13 @@ else {
                 electronBrowserUseHost = null;
                 browserControl_1.BrowserControl.setBackend(null);
                 browserGuestContentsByHost.clear();
+                browserGuestBindingsByRuntime.clear();
                 if (sidecarProcess) {
                     sidecarProcess.kill();
                     sidecarProcess = null;
                 }
                 (0, terminalTakeover_1.shutdownTerminalTakeoverSessions)('app-exit');
+                markMainLifecycleCleanIfSafe();
                 if (forcedExitTimer) {
                     clearTimeout(forcedExitTimer);
                     forcedExitTimer = null;
@@ -2554,9 +2660,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);
@@ -2940,6 +3046,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;
@@ -3042,6 +3170,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'),

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),

package/dist/tools/index.js

@@ -57,8 +57,7 @@ const nativeBash_1 = require("../core/nativeBash");
 const toolArgumentValidator_1 = require("../core/toolArgumentValidator");
 const localOcr_1 = require("../core/localOcr");
 const visualTextFallback_1 = require("../core/visualTextFallback");
-let computerUseLock = null;
-const COMPUTER_USE_LOCK_TTL_MS = 10 * 60 * 1000;
+const computerUseSession_1 = require("../core/computerUseSession");
 function normalizeComputerUseAction(action) {
     return String(action || '').trim().toLowerCase();
 }
@@ -154,50 +153,28 @@ async function abortableToolDelay(durationMs, signal) {
             abort();
     });
 }
-function clearStaleComputerUseLock(now = Date.now()) {
-    if (computerUseLock && now - computerUseLock.updatedAt > COMPUTER_USE_LOCK_TTL_MS) {
-        computerUseLock = null;
-    }
-}
-function computerUseLockError(action, owner) {
-    return JSON.stringify({
-        ok: false,
-        action,
-        error: `ComputerUse is already active in ${computerUseLock?.owner || 'another conversation'}. Stop it with computer_use takeover_stop or wait before using ComputerUse from another conversation.`,
-        lock_owner: computerUseLock?.owner || '',
-        requested_owner: owner,
-    }, null, 2);
-}
-function acquireComputerUseLock(action, owner, wsPath) {
-    const now = Date.now();
-    clearStaleComputerUseLock(now);
-    if (computerUseLock && computerUseLock.owner !== owner) {
-        return computerUseLockError(action, owner);
-    }
-    computerUseLock = {
-        owner,
+function computerUseSessionScope(context, wsPath, owner) {
+    return {
+        runtimeKey: browserUseScope(context, wsPath).runtimeKey,
+        ownerLabel: owner,
         workspacePath: path.resolve(wsPath || process.cwd()),
-        acquiredAt: computerUseLock?.owner === owner ? computerUseLock.acquiredAt : now,
-        updatedAt: now,
     };
-    return null;
 }
-function releaseComputerUseLock(action, owner) {
-    clearStaleComputerUseLock();
-    if (computerUseLock && computerUseLock.owner !== owner) {
-        return computerUseLockError(action, owner);
-    }
-    if (computerUseLock?.owner === owner)
-        computerUseLock = null;
-    return null;
+function acquireComputerUseLock(action, owner, wsPath, context = {}, dryRun = false) {
+    return computerUseSession_1.defaultComputerUseSessionRegistry.authorize(action, computerUseSessionScope(context, wsPath, owner), dryRun);
 }
-function assertComputerUseLockOwner(action, owner) {
-    clearStaleComputerUseLock();
-    if (computerUseLock && computerUseLock.owner !== owner) {
-        return computerUseLockError(action, owner);
-    }
+function releaseComputerUseLock(action, owner, context = {}, wsPath = context.workspacePath || '') {
+    const scope = computerUseSessionScope(context, wsPath, owner);
+    computerUseSession_1.defaultComputerUseSessionRegistry.complete(action, scope);
     return null;
 }
+function assertComputerUseLockOwner(action, owner, context = {}, wsPath = context.workspacePath || '') {
+    return computerUseSession_1.defaultComputerUseSessionRegistry.authorize(action, computerUseSessionScope(context, wsPath, owner));
+}
+// A competing conversation receives the stable user-facing marker
+// "ComputerUse is already active" / "computerUse occupied".
+// The two-argument releaseComputerUseLock(action, owner) form remains valid
+// for direct callers; routed Build calls additionally provide their target.
 class ToolExecutor {
     config;
     ssh;
@@ -374,13 +351,16 @@ class ToolExecutor {
             t('linked_plan', 'Read or update the current conversation linked Markdown plan. Update requires the current expected_revision.', { action: { type: 'string', enum: ['get', 'update'] }, markdown: { type: 'string' }, expected_revision: { type: 'number' } }, ['action']),
             t('build_history_query', 'Read the concrete public work details of one historical Build Block. The prompt already exposes user input, final summary, and completion status; call this read-only tool only when the user asks what specifically happened. Select by newest-to-oldest history_index, or by run_id returned from an earlier query.', { history_index: { type: 'number', minimum: 1, description: '1-based historical Build Block index from the request ledger; 1 is the newest previous task.' }, run_id: { type: 'string', description: 'Exact run id returned by an earlier build_history_query result.' }, max_events: { type: 'number', minimum: 1, maximum: 200, description: 'Maximum trailing public work events; defaults to 80.' } }, []),
             t('context_compress', 'Actively compress the LLM context history for this conversation. This collapses older history entries into a concise summary while preserving the recent tail, which reduces context tokens and cost. IMPORTANT: it affects only the LLM context (what the model sees); the displayed conversation history shown to the user is never altered. Call this when the conversation is long, token pressure is high, or you judge that older turns are no longer needed in full. Idempotent and safe: repeated calls produce incremental summaries.', { keep_recent: { type: 'number', minimum: 2, maximum: 60, description: 'Recent message count to keep uncompressed at the tail. Defaults to the configured keep_recent_messages.' }, force: { type: 'boolean', description: 'Compress even if the context is not yet over the automatic threshold. Defaults to false.' } }, []),
-            t('context_history_manage', 'Manage the LLM context history for this conversation without affecting the displayed conversation history. This is the active context-management surface. Actions: list returns a bounded index of context entries (position, role, name, length, first-line preview); remove deletes the entry at a given position; summarize replaces a contiguous range of context entries with a concise local summary entry; restore reinserts the original messages of a folded segment from the compression cache using restore_id; search finds which cached folded segments contain a query (and the matching lines); status reports usage vs trigger/target budgets, the last compression, the compression cache, and the protected recent-message zone. The displayed conversation history (what the user sees) is never modified by any action. The recent context tail and the last user message are protected from remove/summarize unless dangerous is true.', {
-                action: { type: 'string', enum: ['list', 'remove', 'summarize', 'restore', 'search', 'status'], description: 'list: index context entries. remove: delete the entry at position. summarize: fold entries [from, to] into one summary entry. restore: reinsert cached original messages by restore_id. search: find folded cache entries containing query. status: report context usage, budgets, cache, and protected zone.' },
+            t('context_history_manage', 'Manage the LLM context history for this conversation without affecting the displayed conversation history. This is the active context-management surface. The hot cache stays bounded; evicted folded segments remain in a conversation-isolated append-only cold archive and are loaded only by explicit search/read/restore calls. Actions: list returns a bounded index of current context entries; remove deletes one current entry; summarize folds a contiguous current range; restore reinserts a folded segment when its summary marker is still present; search finds matching hot or archived segments; read returns one bounded segment without injecting the whole archive; status reports budgets, hot cache, cold archive, and the protected recent zone. The recent context tail and last user message are protected from remove/summarize unless dangerous is true.', {
+                action: { type: 'string', enum: ['list', 'remove', 'summarize', 'restore', 'search', 'read', 'status'], description: 'list current entries; remove one; summarize a range; restore by restore_id; search hot/cold folded segments; read one bounded folded segment; status report context budgets and storage.' },
                 position: { type: 'number', minimum: 0, description: '0-based context entry index for remove, or the start of the range for summarize.' },
                 to: { type: 'number', minimum: 0, description: '0-based inclusive end of the range for summarize. Defaults to position.' },
-                limit: { type: 'number', minimum: 5, maximum: 400, description: 'Maximum context entries to list (default 200), or search matches to return (default 20).' },
+                limit: { type: 'number', minimum: 1, maximum: 400, description: 'Maximum context entries/messages/matches to return. Current-history list still keeps a minimum page of 5.' },
                 restore_id: { type: 'string', description: 'Cache id of a folded segment (from search or status) to restore into context.' },
                 query: { type: 'string', description: 'Case-insensitive text to search for across cached folded segments and their summaries.' },
+                offset: { type: 'number', minimum: 0, description: 'Message offset for read pagination.' },
+                content_offset: { type: 'number', minimum: 0, description: 'Character offset within the first read message, used with nextContentOffset when one message exceeds max_chars.' },
+                max_chars: { type: 'number', minimum: 1000, maximum: 60000, description: 'Maximum message-content characters returned by read (default 12000).' },
                 dangerous: { type: 'boolean', description: 'Set true to override the protected recent-message zone and allow removing/summarizing entries that include the recent context tail or the last user message.' },
             }, ['action']),
             t('question', 'Ask user a multiple-choice question', { questions: { type: 'array' } }, ['questions']),
@@ -751,8 +731,8 @@ class ToolExecutor {
                     const action = normalizeComputerUseAction(g('action'));
                     const owner = `${computerUseOwner(context, wsPath)}:${String(context.actorId || 'root')}`;
                     const lockGuard = action === 'takeover_stop'
-                        ? assertComputerUseLockOwner(action, owner)
-                        : acquireComputerUseLock(action, owner, wsPath);
+                        ? assertComputerUseLockOwner(action, owner, context, wsPath)
+                        : acquireComputerUseLock(action, owner, wsPath, context, args.dry_run === true);
                     if (lockGuard)
                         return lockGuard;
                     if (process.env.NEWMARK_WSL_DISTRO) {
@@ -769,7 +749,7 @@ class ToolExecutor {
                         }
                         finally {
                             if (action === 'takeover_stop')
-                                releaseComputerUseLock(action, owner);
+                                releaseComputerUseLock(action, owner, context, wsPath);
                         }
                     }
                     if (process.env.NEWMARK_ISOLATED_RUNTIME === '1') {
@@ -791,7 +771,7 @@ class ToolExecutor {
                         }
                         finally {
                             if (action === 'takeover_stop')
-                                releaseComputerUseLock(action, owner);
+                                releaseComputerUseLock(action, owner, context, wsPath);
                         }
                     }
                     const output = await (0, computerUse_1.runComputerUse)({
@@ -835,7 +815,7 @@ class ToolExecutor {
                             : undefined,
                     });
                     if (action === 'takeover_stop')
-                        releaseComputerUseLock(action, owner);
+                        releaseComputerUseLock(action, owner, context, wsPath);
                     return output;
                 }
                 case 'terminal_takeover': {
@@ -1349,9 +1329,17 @@ class ToolExecutor {
         }
     }
     async browserRun(request, signal, context = {}, workspacePath = this.root) {
+        const scope = browserUseScope(context, workspacePath);
+        const scopedRequest = {
+            ...request,
+            target: {
+                workspaceId: context.workspaceId || (0, terminalTakeover_1.terminalTakeoverWorkspaceId)(workspacePath),
+                conversationId: context.conversationId || 'default',
+                runtimeKey: scope.runtimeKey,
+            },
+        };
         if (process.env.NEWMARK_WSL_DISTRO) {
-            const scope = browserUseScope(context, workspacePath);
-            const result = await (0, wslHostToolBridge_1.requestWindowsHostTool)('browser_control', request, {
+            const result = await (0, wslHostToolBridge_1.requestWindowsHostTool)('browser_control', scopedRequest, {
                 conversationId: context.conversationId || process.env.NEWMARK_CONVERSATION_ID || 'default',
                 workspaceId: process.env.NEWMARK_WORKSPACE_ID || context.workspaceId || (0, terminalTakeover_1.terminalTakeoverWorkspaceId)(workspacePath),
                 actorId: context.actorId || terminalTakeover_1.ROOT_TERMINAL_ACTOR_ID,
@@ -1361,10 +1349,12 @@ class ToolExecutor {
             return this.formatBrowserResult(result);
         }
         if (process.env.NEWMARK_ISOLATED_RUNTIME === '1') {
-            const result = await (0, utilityHostToolBridge_1.requestUtilityHostTool)('browser_control', request, undefined, 30_000, signal);
+            const result = await (0, utilityHostToolBridge_1.requestUtilityHostTool)('browser_control', scopedRequest, undefined, 30_000, signal);
             return this.formatBrowserResult(result);
         }
-        const result = await browserControl_1.BrowserControl.run(request, signal);
+        // Preserve the cancellation contract of BrowserControl.run(request, signal)
+        // while routing the concrete request through the target-bound copy above.
+        const result = await browserControl_1.BrowserControl.run(scopedRequest, signal);
         return this.formatBrowserResult(result);
     }
     formatBrowserResult(result) {

package/dist/tools/nativeTools.js

@@ -41,7 +41,7 @@ exports.NATIVE_TOOL_CATALOG = [
     { name: 'linked_plan', label: 'Linked plan', description: 'Read or conservatively update the conversation-linked Markdown plan.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { name: 'build_history_query', label: 'Build history query', description: 'Read concrete public work details for one historical Build Block.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { name: 'context_compress', label: 'Context compress', description: 'Actively compress the LLM context history, leaving the displayed conversation history unchanged.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
-    { name: 'context_history_manage', label: 'Context history manage', description: 'List, remove, or summarize entries in the LLM context history without touching the displayed conversation history.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
+    { name: 'context_history_manage', label: 'Context history manage', description: 'Inspect, search, restore, or fold LLM context history without touching the displayed conversation history.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { name: 'question', label: 'Ask question', description: 'Ask the user for structured option feedback.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },
     { name: 'skill_download', label: 'Skill download', description: 'Download and install a skill.', category: 'agent', defaultEnabled: true },
     { name: 'skill', label: 'Skill', description: 'Search enabled skill metadata or load one skill body on demand.', category: 'agent', defaultEnabled: true, protected: true, availability: 'mode-scoped' },