newmark-agent 0.3.11 → 0.4.0

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");
@@ -72,6 +73,7 @@ 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 dshCompatibility_1 = require("./core/dshCompatibility");
 const mcpManager_1 = require("./core/mcpManager");
 const cli_help_1 = require("./cli-help");
 const APP_NAME = 'Newmark Agent';
@@ -122,6 +124,7 @@ let browserUseEngine = null;
 // the authoritative Browser-Use/right-sidebar binding.
 const browserGuestContentsByHost = new Map();
 const browserGuestBindingsByRuntime = new Map();
+const browserGuestKeyboardBridgeIds = new Set();
 function browserGuestRuntimeKey(target) {
     return (0, conversationTarget_1.normalizeConversationTarget)(target).runtimeKey;
 }
@@ -426,7 +429,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);
@@ -486,14 +493,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');
     }
@@ -583,18 +590,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);
@@ -677,9 +679,22 @@ 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();
+}
+// Set immediately after argument resolution so startup failures from an
+// explicit temporary root are recorded beside that root instead of leaking a
+// diagnostic file into the user's canonical runtime.
+let startupRuntimeRoot = '';
 function startupLogPath() {
     try {
-        const userData = userRuntimeRoot();
+        const userData = startupRuntimeRoot || userRuntimeRoot();
         fs.mkdirSync(userData, { recursive: true });
         return path.join(userData, 'startup.log');
     }
@@ -832,7 +847,29 @@ function registerBrowserGuest(host, guest, requestedTarget) {
         conversationId: target.conversationId,
     });
     browserGuestContentsByHost.set(host.id, guest.id);
+    if (!browserGuestKeyboardBridgeIds.has(guest.id)) {
+        browserGuestKeyboardBridgeIds.add(guest.id);
+        // WebView keyboard events do not bubble to the host renderer. Reserve only
+        // the two app-wide discovery surfaces and leave navigation/editing keys to
+        // the page itself.
+        guest.on('before-input-event', (event, input) => {
+            if (input.type !== 'keyDown' || input.isAutoRepeat || host.isDestroyed())
+                return;
+            const key = String(input.key || '').toLowerCase();
+            const noSecondaryModifiers = !input.alt && !input.control && !input.meta && !input.shift;
+            let commandId = '';
+            if (key === 'f1' && noSecondaryModifiers)
+                commandId = 'help.keyboardShortcuts';
+            else if (key === 'p' && (input.control || input.meta) && input.shift && !input.alt)
+                commandId = 'app.commandPalette';
+            if (!commandId)
+                return;
+            event.preventDefault();
+            host.send('keyboard:command', { id: commandId, source: 'browserGuest' });
+        });
+    }
     guest.once('destroyed', () => {
+        browserGuestKeyboardBridgeIds.delete(guest.id);
         if (browserGuestContentsByHost.get(host.id) === guest.id)
             browserGuestContentsByHost.delete(host.id);
         const binding = browserGuestBindingsByRuntime.get(target.runtimeKey);
@@ -1026,24 +1063,71 @@ 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 cliCommand = args.find(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 && args.some(arg => ['--version', '-v'].includes(arg.toLowerCase()));
+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 invalidArgument = (0, cli_discovery_1.invalidTopLevelArgument)(args);
+if (invalidArgument) {
+    console.error(`Invalid Newmark argument: ${invalidArgument}`);
+    process.exit(2);
+}
+// Keep command-specific help on the same early-exit path as top-level help.
+// This matters for the packaged Electron entry: a command such as
+// `send --help` must never create a GUI window, start prewarm work, or touch a
+// user-data profile merely to print its contract.
+if (hasCliCommand && cliCommand && (0, cli_commands_1.cliHelpRequested)(args)) {
+    console.log((0, cli_commands_1.cliCommandHelp)(cliCommand));
+    process.exit(0);
+}
+// 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);
+startupRuntimeRoot = runtimeRoot;
+const explicitElectronUserDataRoot = pathArgValue(args, '--user-data-dir');
+const electronUserDataRoot = path.resolve(explicitElectronUserDataRoot || 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);
+    // app.setPath is the Electron API contract; the switch makes the same
+    // boundary visible to Chromium children, including the console-wrapper
+    // `--` forwarding path where an early child may otherwise retain the default
+    // profile before the first BrowserWindow is created.
+    electron_1.app.commandLine.removeSwitch('user-data-dir');
+    electron_1.app.commandLine.appendSwitch('user-data-dir', electronUserDataRoot);
+}
+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((0, cli_help_1.newmarkHelpText)((0, installUpdate_1.currentAppVersion)()));
+    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);
 }
@@ -1118,7 +1202,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(),
@@ -1126,6 +1212,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,
@@ -1146,12 +1237,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);
@@ -1312,6 +1403,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();
@@ -1568,6 +1704,12 @@ else {
                         win.focus();
                     }, 150);
                 });
+                win.webContents.on('unresponsive', () => {
+                    logStartupFailure('renderer-unresponsive', new Error(`Window renderer became unresponsive (webContents ${win.webContents.id})`));
+                });
+                win.webContents.on('responsive', () => {
+                    recordStartup(`renderer-responsive-${win.webContents.id}`);
+                });
                 if (!automationWakeMode)
                     win.maximize();
                 if (!automationWakeMode && showWindow) {
@@ -1583,15 +1725,18 @@ else {
                         return;
                     if (agent) {
                         const closeBehavior = agent.config.getStr('general', 'close_behavior');
+                        recordStartup(`window-close-requested-${closeBehavior || 'exit'}`);
                         if (closeBehavior === 'minimize') {
                             e.preventDefault();
                             win.hide();
                             createTray();
+                            recordStartup('window-hidden-to-tray');
                             return;
                         }
                         if (agent.config.getBool('general', 'auto_archive_on_close')) {
                             agent.archiveSession();
                         }
+                        recordStartup('window-close-exit');
                     }
                 });
                 win.on('closed', () => {
@@ -1718,6 +1863,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');
                 }
@@ -2207,8 +2353,18 @@ else {
                     (0, runtimeLifecycle_1.markRuntimeLifecycleClean)(root, 'main');
             };
             electron_1.app.on('will-quit', event => {
-                if (_forceQuit)
+                recordStartup('will-quit');
+                // 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();
@@ -2361,6 +2517,32 @@ else {
                 activeFlowsByRuntimeKey.delete(key);
                 agent.clearStoredFlowSuspension(state.target.conversationId);
             };
+            // Archive is a destructive lifecycle boundary. It must cancel the Flow
+            // owner itself before touching the runtime pool; Flow runs bypass the
+            // ConversationKernel and therefore cannot be stopped by the pool alone.
+            // Marking the state before aborting is important: the provider may reject
+            // on the same turn, and its late catch/finally must not recreate a paused
+            // conversation after archive has removed it.
+            const interruptActiveFlowForArchive = (target) => {
+                const key = activeFlowStateKey(target);
+                const state = activeFlowsByRuntimeKey.get(key) || null;
+                if (!state)
+                    return;
+                state.archiveRequested = true;
+                try {
+                    state.abortController?.abort(new Error(`Flow discarded because conversation was archived: ${state.name || state.workflow.name}`));
+                }
+                catch { }
+                state.flowAgent?.abortActiveKernelRun();
+                state.flowAgent?.interruptRunningConversationWorkRuns(state.target, 'force_interrupted');
+                state.flowAgent?.clearStoredFlowSuspension(state.target.conversationId);
+                if (agent?.workspace.current
+                    && target.workspace
+                    && path.resolve(agent.workspace.current.path) === path.resolve(target.workspace.path)) {
+                    agent.clearStoredFlowSuspension(target.conversationId);
+                }
+                activeFlowsByRuntimeKey.delete(key);
+            };
             const utilityHostToolHandler = (0, utilityHostToolRouter_1.createUtilityHostToolHandler)({
                 persistenceRoot: root,
                 isToolEnabled: toolName => !!agent && (0, nativeTools_1.isNativeToolEnabled)(toolName, agent.config.nativeToolEnabled()),
@@ -2539,6 +2721,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 });
@@ -2743,6 +2932,14 @@ else {
                     };
                 }
                 catch (e) {
+                    if (flowState.archiveRequested) {
+                        // Archive already force-finalized the current Build ledger. Do not
+                        // persist an interrupted Flow suspension or return Flow ownership
+                        // to the renderer after the target has been removed.
+                        flowAgent.pendingOptions = [];
+                        suspended = false;
+                        return { ok: false, archived: true, error: 'Flow discarded because the conversation was archived.' };
+                    }
                     if (e instanceof flow_runner_1.FlowQuestionPendingError) {
                         suspended = true;
                         flowAgent.flowPc = e.componentId;
@@ -2836,6 +3033,11 @@ else {
                 const flowKey = activeFlowStateKey(flowTarget);
                 const flowAgent = isolatedConversationAgent(flowTarget);
                 suspension.flowAgent = flowAgent;
+                // A previous Flow may have been interrupted just before its isolated
+                // Agent flushed the work ledger. Reconcile only this explicitly paused
+                // target before starting the next component; the normal runner guard
+                // remains intact for genuine concurrent Builds.
+                flowAgent.interruptRunningConversationWorkRuns(flowTarget, 'interrupted');
                 const flowAbortController = new AbortController();
                 suspension.abortController = flowAbortController;
                 activeFlowsByRuntimeKey.set(flowKey, suspension);
@@ -2870,6 +3072,11 @@ else {
                     };
                 }
                 catch (error) {
+                    if (suspension.archiveRequested) {
+                        flowAgent.pendingOptions = [];
+                        suspendedAgain = false;
+                        return { ok: false, archived: true, error: 'Flow discarded because the conversation was archived.' };
+                    }
                     if (error instanceof flow_runner_1.FlowQuestionPendingError) {
                         suspendedAgain = true;
                         flowAgent.flowPc = error.componentId;
@@ -2891,9 +3098,9 @@ else {
                             workRuns: flowAgent.getConversationSnapshot(flowAgent.activeConversationId).workRuns,
                         };
                     }
-                    if (isUserFlowAbort(error)) {
-                        return { ok: false, error: error instanceof Error ? error.message : String(error) };
-                    }
+                    // A Stop/Esc during a resumed Flow is another pause, not a terminal
+                    // IPC failure. Fall through to the same interrupted-suspension path as
+                    // the initial Flow run so repeated pause/resume clicks remain valid.
                     suspendedAgain = true;
                     const resumeFailure = error;
                     const interruptedComponentId = typeof resumeFailure.componentId === 'number'
@@ -3046,6 +3253,12 @@ else {
                     runtimeDeferred: false,
                 };
             });
+            electron_1.ipcMain.handle('agent:setConversationBranchCommunication', async (_event, targetInput, enabled) => {
+                if (!agent)
+                    return false;
+                const target = conversationRuntimeTarget(targetInput || agent.activeConversationId || 'default');
+                return mutateTargetConversation(target, () => isolatedConversationAgent(target).setBranchCommunication(enabled !== false));
+            });
             electron_1.ipcMain.handle('agent:computerUseState', async (_event, targetInput) => {
                 if (!agent)
                     return { enabled: false, occupied: false, runtimeKey: '' };
@@ -3583,6 +3796,18 @@ else {
                     ? await ensureWslConversationPool().checkpoint(target)
                     : await ensureElectronUtilityPool().checkpoint(target);
             });
+            electron_1.ipcMain.handle('agent:compressContext', async (_event, request) => {
+                if (!agent)
+                    throw new Error('Agent not initialized');
+                const target = conversationRuntimeTarget(request);
+                const options = {
+                    keepRecent: Number.isFinite(Number(request?.keepRecent)) ? Math.floor(Number(request.keepRecent)) : undefined,
+                    force: request?.force !== false,
+                };
+                return wslBackendEnabled()
+                    ? await ensureWslConversationPool().contextCompress(target, options)
+                    : await ensureElectronUtilityPool().contextCompress(target, options);
+            });
             electron_1.ipcMain.handle('agent:rateAutoRoute', async (_event, request) => {
                 if (!agent)
                     return { ok: false, reason: 'no_active_auto_route' };
@@ -3732,32 +3957,52 @@ 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. Cancel the
+                        // conversation-local Flow synchronously, then start the resident
+                        // runtime hard-stop in the background so a stuck child cannot hold
+                        // the archive click hostage.
+                        interruptActiveFlowForArchive(normalized);
+                        void forceStopTargetRuntime(normalized).catch(error => {
+                            console.error('[Newmark] archive runtime force-stop failed:', error instanceof Error ? error.message : String(error));
+                        });
+                        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);
+                        archiveOwner.clearStoredFlowSuspension(normalized.conversationId);
+                        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) => {
@@ -4083,6 +4328,20 @@ else {
                 }
                 return { error: 'Agent not initialized' };
             });
+            electron_1.ipcMain.handle('app:openWebUrl', async (_event, rawUrl) => {
+                try {
+                    const target = new URL(String(rawUrl || ''));
+                    const allowedHosts = new Set(['github.com', 'www.github.com', 'npmjs.com', 'www.npmjs.com']);
+                    if (target.protocol !== 'https:' || !allowedHosts.has(target.hostname.toLowerCase()) || !!target.username || !!target.password || (!!target.port && target.port !== '443')) {
+                        return { ok: false, error: 'Only approved HTTPS documentation hosts can be opened.' };
+                    }
+                    await electron_1.shell.openExternal(target.toString());
+                    return { ok: true };
+                }
+                catch (error) {
+                    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+                }
+            });
             electron_1.ipcMain.handle('agent:selectWorkspace', async (_event, id) => {
                 if (agent) {
                     const requested = String(id || '').trim();
@@ -4380,13 +4639,25 @@ else {
                 const controller = new AbortController();
                 editorCompletionControllers.set(ownerId, controller);
                 try {
-                    return await (agent?.editorModelRequest({ ...request, completion: true, preferCopilot: true }, controller.signal) || { ok: false, text: '', error: 'Agent not initialized' });
+                    const requestId = String(request.requestId || '');
+                    const onTextDelta = requestId
+                        ? (text) => {
+                            if (!controller.signal.aborted && !event.sender.isDestroyed())
+                                event.sender.send('agent:editorCompletionDelta', { requestId, text });
+                        }
+                        : undefined;
+                    return await (agent?.editorModelRequest({ ...request, completion: true, preferCopilot: true, onTextDelta }, controller.signal) || { ok: false, text: '', error: 'Agent not initialized' });
                 }
                 finally {
                     if (editorCompletionControllers.get(ownerId) === controller)
                         editorCompletionControllers.delete(ownerId);
                 }
             });
+            electron_1.ipcMain.handle('agent:editorCompleteCancel', async (event) => {
+                const ownerId = event.sender.id;
+                editorCompletionControllers.get(ownerId)?.abort(new Error('Editor completion cancelled'));
+                return { ok: true };
+            });
             electron_1.ipcMain.handle('agent:editorAssist', async (_event, request) => {
                 return agent?.editorModelRequest({ ...request, completion: false }) || { ok: false, text: '', error: 'Agent not initialized' };
             });
@@ -4483,6 +4754,7 @@ else {
                 })));
                 return { servers: mcpManager.list(), discovered };
             });
+            electron_1.ipcMain.handle('dsh:discover', async () => (0, dshCompatibility_1.discoverDshCompatibility)(root));
             electron_1.ipcMain.handle('mcp:upsert', async (_event, input) => {
                 if (!mcpManager)
                     return { ok: false, error: 'MCP manager is unavailable.' };
@@ -4497,12 +4769,14 @@ else {
             electron_1.ipcMain.handle('mcp:setEnabled', async (_event, id, enabled) => {
                 if (!mcpManager)
                     return { ok: false, error: 'MCP manager is unavailable.' };
-                return { ok: mcpManager.setEnabled(id, enabled), servers: mcpManager.list() };
+                const ok = mcpManager.setEnabled(id, enabled);
+                return { ok, error: ok ? undefined : 'MCP server was not found.', servers: mcpManager.list() };
             });
             electron_1.ipcMain.handle('mcp:remove', async (_event, id) => {
                 if (!mcpManager)
                     return { ok: false, error: 'MCP manager is unavailable.' };
-                return { ok: mcpManager.remove(id), servers: mcpManager.list() };
+                const ok = mcpManager.remove(id);
+                return { ok, error: ok ? undefined : 'MCP server was not found.', servers: mcpManager.list() };
             });
             electron_1.ipcMain.handle('memoryLab:read', async (_event, selector) => {
                 if (!agent)