newmark-agent 0.3.12 → 0.4.2

package/dist/core/wslAgentRuntimePool.d.ts

@@ -11,6 +11,10 @@ export interface WslTargetRuntimeClient {
     requestStop(target: ConversationRuntimeTarget, runId?: string): Promise<WslAgentStopResult>;
     enqueueGuide(target: ConversationRuntimeTarget, envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
     checkpoint(target: ConversationRuntimeTarget): Promise<Record<string, unknown>>;
+    contextCompress?(target: ConversationRuntimeTarget, options?: {
+        keepRecent?: number;
+        force?: boolean;
+    }): Promise<Record<string, unknown>>;
     rateAutoRoute?(target: ConversationRuntimeTarget, score: number, routeId?: string): Promise<WslAutoRouteRatingResult>;
     setWorkRunExpanded(target: ConversationRuntimeTarget, runId: string, expanded: boolean): Promise<boolean>;
     setMode?(target: ConversationRuntimeTarget, mode: AgentMode): Promise<AgentMode>;
@@ -69,6 +73,10 @@ export declare class WslAgentRuntimePool {
     requestStop(target: ConversationRuntimeTarget, runId?: string): Promise<WslPoolStopResult>;
     enqueueGuide(envelope: ConversationInputEnvelope): Promise<GuideReceipt>;
     checkpoint(target: ConversationRuntimeTarget): Promise<Record<string, unknown>>;
+    contextCompress(target: ConversationRuntimeTarget, options?: {
+        keepRecent?: number;
+        force?: boolean;
+    }): Promise<Record<string, unknown>>;
     rateAutoRoute(target: ConversationRuntimeTarget, score: number, routeId?: string): Promise<WslAutoRouteRatingResult>;
     setWorkRunExpanded(target: ConversationRuntimeTarget, runId: string, expanded: boolean): Promise<boolean>;
     setInputMode(target: ConversationRuntimeTarget, mode: string): Promise<'guide' | 'next' | null>;

package/dist/core/wslAgentRuntimePool.js

@@ -214,6 +214,21 @@ class WslAgentRuntimePool {
             this.release(entry, true);
         }
     }
+    async contextCompress(target, options = {}) {
+        const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
+        const entry = await this.acquire(normalized);
+        try {
+            if (entry.stopIntent)
+                return { ok: false, error: 'Context compression is unavailable while this conversation is stopping.' };
+            if (!entry.client.contextCompress)
+                return { ok: false, error: 'Context compression is unavailable in this runtime.' };
+            entry.lastSnapshot = null;
+            return await entry.client.contextCompress(normalized, options);
+        }
+        finally {
+            this.release(entry, true);
+        }
+    }
     async rateAutoRoute(target, score, routeId = '') {
         const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
         const entry = await this.acquireExisting(normalized);

package/dist/launcher.js

@@ -49,6 +49,7 @@ const cli_help_1 = require("./cli-help");
 const rawArgs = process.argv.slice(2);
 const args = rawArgs[0] === '--' ? rawArgs.slice(1) : rawArgs;
 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 isEdit = args[0] === 'edit';
 const editFile = isEdit ? args[1] : '';
 const isFlow = args[0] === 'flow';
@@ -64,6 +65,13 @@ if (invalidArgument) {
     console.error(`Invalid Newmark argument: ${invalidArgument}`);
     process.exit(2);
 }
+// Command help is a terminating, read-only discovery operation. Resolve it
+// before first-run initialization or GUI forwarding so `Newmark.exe send
+// --help` cannot accidentally enter Electron or instantiate an Agent.
+if (hasCliCommand && cliCommand && (0, cli_commands_1.cliHelpRequested)(args)) {
+    console.log((0, cli_commands_1.cliCommandHelp)(cliCommand));
+    process.exit(0);
+}
 function pathArgValue(values, key) {
     const prefix = `${key}=`;
     const inlineIdx = values.findIndex(a => a.startsWith(prefix));

package/dist/llm/provider.d.ts

@@ -97,7 +97,7 @@ export declare class LLMProvider {
     private toTransportResponse;
     private toNormalizedMessages;
     private toNormalizedTools;
-    chatStreamWithTools(model: string, messages: Array<Record<string, unknown>>, systemPrompt: string | null, temperature: number, maxTokens: number, tools: unknown[], signal?: AbortSignal, reasoningTier?: string): AsyncGenerator<StreamToken>;
+    chatStreamWithTools(model: string, messages: Array<Record<string, unknown>>, systemPrompt: string | null, temperature: number, maxTokens: number, tools: unknown[], signal?: AbortSignal, reasoningTier?: string, sessionId?: string): AsyncGenerator<StreamToken>;
     /**
      * GitHub Models streaming path. Preserved as a dedicated implementation
      * because the provider adapters (V2) do not serialize the GitHub Models

package/dist/llm/provider.js

@@ -843,7 +843,7 @@ class LLMProvider {
      * The emitted request body and StreamToken stream are byte-equivalent to
      * the legacy inlined path.
      */
-    async *chatStreamWithToolsV2(model, messages, systemPrompt, temperature, maxTokens, tools, signal, reasoningTier) {
+    async *chatStreamWithToolsV2(model, messages, systemPrompt, temperature, maxTokens, tools, signal, reasoningTier, sessionId) {
         const mode = this.openAITransportMode();
         if (mode === 'responses') {
             yield* this.adapterResponsesBridge(model, messages, systemPrompt, temperature, maxTokens, tools, signal, reasoningTier);
@@ -861,6 +861,7 @@ class LLMProvider {
             maxOutputTokens: maxTokens,
             apiKey: this.apiKey,
             baseUrl: this.cleanBaseUrl(),
+            ...(sessionId ? { sessionId } : {}),
         };
         const serialized = await adapter.serializeRequest(request);
         serialized.body.stream = mode === 'chat' ? false : true;
@@ -1080,7 +1081,7 @@ class LLMProvider {
             };
         });
     }
-    async *chatStreamWithTools(model, messages, systemPrompt, temperature, maxTokens, tools, signal, reasoningTier) {
+    async *chatStreamWithTools(model, messages, systemPrompt, temperature, maxTokens, tools, signal, reasoningTier, sessionId) {
         if (signal?.aborted)
             throw abortFailure(signal);
         if (this.protocol() === 'anthropic') {
@@ -1092,7 +1093,7 @@ class LLMProvider {
             return;
         }
         if (this.useProviderAdaptersV2) {
-            yield* this.chatStreamWithToolsV2(model, messages, systemPrompt, temperature, maxTokens, tools, signal, reasoningTier);
+            yield* this.chatStreamWithToolsV2(model, messages, systemPrompt, temperature, maxTokens, tools, signal, reasoningTier, sessionId);
             return;
         }
         throw new Error('LLMProvider legacy OpenAI streaming was removed in dev-0.3.0: enable provider_adapters_v2 (useProviderAdaptersV2).');

package/dist/main.js

@@ -73,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';
@@ -123,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;
 }
@@ -686,9 +688,13 @@ function resolveTuiWorkspacePath(args, root) {
     // 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');
     }
@@ -841,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);
@@ -1035,6 +1063,7 @@ 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');
@@ -1048,18 +1077,34 @@ 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);
-const electronUserDataRoot = path.join(runtimeRoot, 'Electron');
+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)}`);
@@ -1659,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) {
@@ -1674,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', () => {
@@ -2299,6 +2353,7 @@ else {
                     (0, runtimeLifecycle_1.markRuntimeLifecycleClean)(root, 'main');
             };
             electron_1.app.on('will-quit', event => {
+                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
@@ -2462,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()),
@@ -2851,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;
@@ -2944,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);
@@ -2978,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;
@@ -2999,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'
@@ -3154,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: '' };
@@ -3691,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' };
@@ -3847,9 +3964,14 @@ else {
                     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);
+                        // 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
@@ -3861,6 +3983,7 @@ else {
                         // 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.' };
@@ -4205,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();
@@ -4502,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' };
             });
@@ -4605,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.' };
@@ -4619,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)

package/dist/preload.js

@@ -12,6 +12,7 @@ contextBridge.exposeInMainWorld('api', {
     sendMessage: (message, target) => ipcRenderer.invoke('agent:send', message, target),
     enqueueGuide: (envelope) => ipcRenderer.invoke('agent:enqueueGuide', envelope),
     checkpointConversation: (request) => ipcRenderer.invoke('agent:checkpointConversation', request),
+    compressContext: (request) => ipcRenderer.invoke('agent:compressContext', request),
     rateAutoRoute: (request) => ipcRenderer.invoke('agent:rateAutoRoute', request),
     stopConversation: (request) => ipcRenderer.invoke('agent:stopConversation', request),
     setWorkRunExpanded: (request) => ipcRenderer.invoke('agent:setWorkRunExpanded', request),
@@ -32,12 +33,16 @@ contextBridge.exposeInMainWorld('api', {
     getConversationPlan: (conversationId) => ipcRenderer.invoke('agent:getConversationPlan', conversationId),
     updateConversationPlan: (plan, conversationId) => ipcRenderer.invoke('agent:updateConversationPlan', plan, conversationId),
     setConversationPinned: (id, pinned) => ipcRenderer.invoke('agent:setConversationPinned', id, pinned),
+    setConversationBranchCommunication: (target, enabled) => ipcRenderer.invoke('agent:setConversationBranchCommunication', target, enabled),
     renameConversation: (id, title) => ipcRenderer.invoke('agent:renameConversation', id, title),
     reorderConversations: (ids) => ipcRenderer.invoke('agent:reorderConversations', ids),
     browserRegisterGuest: (guestContentsId, target) => ipcRenderer.invoke('browser:registerGuest', guestContentsId, target),
     onBrowserEnsureGuest: (callback) => {
         ipcRenderer.on('browser:ensureGuest', (_event, target) => callback(target));
     },
+    onKeyboardCommand: (callback) => {
+        ipcRenderer.on('keyboard:command', (_event, payload) => callback(payload));
+    },
     browserControl: (request) => ipcRenderer.invoke('browser:control', request),
     computerUseState: (target) => ipcRenderer.invoke('agent:computerUseState', target),
     setComputerUseEnabled: (target, enabled) => ipcRenderer.invoke('agent:setComputerUseEnabled', target, enabled),
@@ -72,6 +77,10 @@ contextBridge.exposeInMainWorld('api', {
     readWorkspacePrompt: () => ipcRenderer.invoke('workspace:readPrompt'),
     saveWorkspacePrompt: (content) => ipcRenderer.invoke('workspace:savePrompt', content),
     editorComplete: (request) => ipcRenderer.invoke('agent:editorComplete', request),
+    editorCompleteCancel: () => ipcRenderer.invoke('agent:editorCompleteCancel'),
+    onEditorCompletionDelta: (callback) => {
+        ipcRenderer.on('agent:editorCompletionDelta', (_event, payload) => callback(payload));
+    },
     editorAssist: (request) => ipcRenderer.invoke('agent:editorAssist', request),
     filePathForFile: (file) => {
         try {
@@ -85,6 +94,7 @@ contextBridge.exposeInMainWorld('api', {
     selectFolder: () => ipcRenderer.invoke('dialog:selectFolder'),
     executeBash: (cmd, shell, cwd) => ipcRenderer.invoke('agent:executeBash', cmd, shell, cwd),
     openExternal: (path) => ipcRenderer.invoke('agent:openExternal', path),
+    openWebUrl: (url) => ipcRenderer.invoke('app:openWebUrl', url),
     selectWorkspace: (id) => ipcRenderer.invoke('agent:selectWorkspace', id),
     createWorkspace: (name) => ipcRenderer.invoke('agent:createWorkspace', name),
     createExternalWorkspace: (name, dirPath) => ipcRenderer.invoke('agent:createExternalWorkspace', name, dirPath),
@@ -113,6 +123,7 @@ contextBridge.exposeInMainWorld('api', {
     removeSkill: (name) => ipcRenderer.invoke('skills:remove', name),
     refreshSkills: () => ipcRenderer.invoke('skills:refresh'),
     listMcpServers: () => ipcRenderer.invoke('mcp:list'),
+    discoverDshCompatibility: () => ipcRenderer.invoke('dsh:discover'),
     upsertMcpServer: (input) => ipcRenderer.invoke('mcp:upsert', input),
     setMcpServerEnabled: (id, enabled) => ipcRenderer.invoke('mcp:setEnabled', id, enabled),
     removeMcpServer: (id) => ipcRenderer.invoke('mcp:remove', id),

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

@@ -48,6 +48,10 @@ class ChatCompletionsAdapter {
         };
         if (request.reasoningEffort)
             body.reasoning_effort = request.reasoningEffort;
+        // 会话标识透传：仅当上层（支持 session_id 语义的 provider）显式填充时写进
+        // body，否则省略，避免严格 API 拒绝未知字段。
+        if (request.sessionId)
+            body.session_id = request.sessionId;
         const base = request.baseUrl.replace(/\/+$/, '');
         return {
             url: `${base}/chat/completions`,
@@ -90,7 +94,10 @@ class ChatCompletionsAdapter {
         }
         const decoder = new TextDecoder();
         let buffer = '';
-        let currentToolCall = null;
+        const toolCalls = new Map();
+        const toolCallOrder = [];
+        let syntheticToolIndex = 0;
+        let lastToolIndex = 0;
         let contentPolicyBlocked = false;
         let emittedContent = false;
         let emittedTool = false;
@@ -137,32 +144,51 @@ class ChatCompletionsAdapter {
                         emittedContent = true;
                         yield { type: 'text.delta', delta: textDelta };
                     }
-                    const toolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
-                    for (const raw of toolCalls) {
+                    const deltaToolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+                    for (const raw of deltaToolCalls) {
                         const tc = raw;
                         const fn = tc.function && typeof tc.function === 'object' ? tc.function : {};
-                        if (tc.id) {
-                            if (currentToolCall) {
-                                emittedTool = true;
-                                yield { type: 'tool_call.completed', id: currentToolCall.id, name: currentToolCall.name, arguments: currentToolCall.arguments };
-                            }
+                        const rawIndex = Number(tc.index);
+                        const index = Number.isInteger(rawIndex) && rawIndex >= 0
+                            ? rawIndex
+                            : (tc.id ? syntheticToolIndex++ : lastToolIndex);
+                        lastToolIndex = index;
+                        let currentToolCall = toolCalls.get(index);
+                        if (!currentToolCall && tc.id) {
                             currentToolCall = {
                                 id: String(tc.id || ''),
                                 name: (0, chat_messages_1.openAIToolName)(String(fn.name || '')),
-                                arguments: String(fn.arguments || ''),
+                                argumentParts: [],
                             };
+                            toolCalls.set(index, currentToolCall);
+                            toolCallOrder.push(index);
                             yield { type: 'tool_call.started', id: currentToolCall.id, name: currentToolCall.name };
                         }
-                        else if (fn.arguments && currentToolCall) {
-                            currentToolCall.arguments += String(fn.arguments);
-                            yield { type: 'tool_call.arguments.delta', id: currentToolCall.id, delta: String(fn.arguments) };
+                        if (currentToolCall && fn.name && !currentToolCall.name)
+                            currentToolCall.name = (0, chat_messages_1.openAIToolName)(String(fn.name));
+                        if (currentToolCall && fn.arguments !== undefined && fn.arguments !== null) {
+                            const argumentDelta = String(fn.arguments);
+                            if (argumentDelta) {
+                                currentToolCall.argumentParts.push(argumentDelta);
+                                yield { type: 'tool_call.arguments.delta', id: currentToolCall.id, delta: argumentDelta };
+                            }
                         }
                     }
                 }
             }
-            if (currentToolCall && currentToolCall.arguments) {
-                emittedTool = true;
-                yield { type: 'tool_call.completed', id: currentToolCall.id, name: currentToolCall.name, arguments: currentToolCall.arguments };
+            if (toolCallOrder.length) {
+                for (const index of toolCallOrder) {
+                    const currentToolCall = toolCalls.get(index);
+                    if (!currentToolCall)
+                        continue;
+                    emittedTool = true;
+                    yield {
+                        type: 'tool_call.completed',
+                        id: currentToolCall.id,
+                        name: currentToolCall.name,
+                        arguments: currentToolCall.argumentParts.join(''),
+                    };
+                }
             }
             else if (!emittedContent && !emittedTool && contentPolicyBlocked) {
                 yield { type: 'response.failed', error: '[Error] Content policy refusal (content_filter).' };

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

@@ -55,6 +55,9 @@ export interface NormalizedAgentRequest {
     reasoningEffort?: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     apiKey: string;
     baseUrl: string;
+    /** 可选的会话标识。仅当目标 provider 显式支持 session_id 语义的上下文缓存
+     *  时才由上层填充；adapter 在存在时透传，否则省略该字段（避免严格 API 拒绝未知字段）。 */
+    sessionId?: string;
 }
 export interface TokenEstimate {
     inputTokens: number;