newmark-agent 0.3.11 → 0.3.12

package/dist/llm/provider.js

@@ -43,6 +43,19 @@ const child_process_1 = require("child_process");
 const agentKernelDiagnostics_1 = require("../core/agentKernelDiagnostics");
 const chat_messages_1 = require("../providers/chat-messages");
 const providers_1 = require("../providers");
+// Keep provider requests below the release-harness/user-visible command
+// deadline. A provider that does not answer must produce one bounded error;
+// it must not restart the same request through every Windows transport.
+const DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS = 90_000;
+const MIN_PROVIDER_REQUEST_TIMEOUT_MS = 50;
+function providerTimeoutError(timeoutMs) {
+    const error = new Error(`Provider request timed out after ${timeoutMs}ms`);
+    error.name = 'TimeoutError';
+    return error;
+}
+function isProviderTimeoutError(error) {
+    return error instanceof Error && error.name === 'TimeoutError';
+}
 function abortFailure(signal) {
     const reason = signal?.reason;
     const error = reason instanceof Error ? reason : new Error(reason ? String(reason) : 'LLM request aborted');
@@ -84,15 +97,37 @@ class LLMProvider {
     explicitProtocol;
     openAIMode;
     useProviderAdaptersV2;
+    requestTimeoutMs;
     static nodeHttpTransport = null;
     static powershellTransport = null;
-    constructor(name, baseUrl, apiKey, explicitProtocol, openAIMode = 'chat_stream', useProviderAdaptersV2 = false) {
+    constructor(name, baseUrl, apiKey, explicitProtocol, openAIMode = 'chat_stream', useProviderAdaptersV2 = false, requestTimeoutMs = DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS) {
         this.name = name;
         this.baseUrl = baseUrl;
         this.apiKey = apiKey;
         this.explicitProtocol = explicitProtocol;
         this.openAIMode = openAIMode;
         this.useProviderAdaptersV2 = useProviderAdaptersV2;
+        this.requestTimeoutMs = requestTimeoutMs;
+    }
+    effectiveRequestTimeout(timeoutMs) {
+        const requested = Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS;
+        const configured = Number.isFinite(this.requestTimeoutMs) && this.requestTimeoutMs > 0
+            ? this.requestTimeoutMs
+            : DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS;
+        return Math.max(MIN_PROVIDER_REQUEST_TIMEOUT_MS, Math.min(requested, configured));
+    }
+    async withRequestTimeout(promise, timeoutMs, signal) {
+        let timer;
+        const timeoutPromise = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(providerTimeoutError(timeoutMs)), timeoutMs);
+        });
+        try {
+            return await abortable(Promise.race([promise, timeoutPromise]), signal);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
     }
     intelligenceConfig(tier) {
         switch (tier) {
@@ -212,6 +247,7 @@ class LLMProvider {
         };
     }
     async postJsonWithFetchFallback(url, headers, body, timeoutMs = 120000, signal) {
+        const effectiveTimeout = this.effectiveRequestTimeout(timeoutMs);
         // Electron utility processes can leave an undici response body pending when
         // several isolated workers concurrently call a plain-HTTP local provider.
         // Node's HTTP client owns the full body lifecycle and is deterministic for
@@ -224,7 +260,7 @@ class LLMProvider {
                 return '';
             } })();
             this.transportDiagnostic('loopback:start', pathname);
-            const local = await this.nodeHttpJson('POST', url, headers, JSON.stringify(body), signal);
+            const local = await this.nodeHttpJson('POST', url, headers, JSON.stringify(body), signal, effectiveTimeout);
             this.transportDiagnostic('loopback:complete', `status=${local.status} bytes=${Buffer.byteLength(local.body || '')}`);
             return {
                 ok: local.status >= 200 && local.status < 300,
@@ -240,7 +276,7 @@ class LLMProvider {
             forwardAbort();
         else
             signal?.addEventListener('abort', forwardAbort, { once: true });
-        const timer = setTimeout(() => abort.abort(), timeoutMs);
+        const timer = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
         try {
             const response = await fetch(url, {
                 method: 'POST',
@@ -253,9 +289,11 @@ class LLMProvider {
         catch (e) {
             if (signal?.aborted)
                 throw abortFailure(signal);
+            if (abort.signal.aborted)
+                throw abortFailure(abort.signal);
             if (!this.shouldUseNodeHttpFallback(e))
                 throw e;
-            const fallback = await this.nodeHttpJson('POST', url, headers, JSON.stringify(body), signal);
+            const fallback = await this.nodeHttpJson('POST', url, headers, JSON.stringify(body), signal, effectiveTimeout);
             return {
                 ok: fallback.status >= 200 && fallback.status < 300,
                 status: fallback.status,
@@ -270,16 +308,19 @@ class LLMProvider {
         }
     }
     async getJsonWithFetchFallback(url, headers, timeoutMs = 30000) {
+        const effectiveTimeout = this.effectiveRequestTimeout(timeoutMs);
         const abort = new AbortController();
-        const timer = setTimeout(() => abort.abort(), timeoutMs);
+        const timer = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
         try {
             const response = await fetch(url, { method: 'GET', headers, signal: abort.signal });
             return response;
         }
         catch (e) {
+            if (abort.signal.aborted)
+                throw abortFailure(abort.signal);
             if (!this.shouldUseNodeHttpFallback(e))
                 throw e;
-            const fallback = await this.nodeHttpJson('GET', url, headers);
+            const fallback = await this.nodeHttpJson('GET', url, headers, '', undefined, effectiveTimeout);
             return {
                 ok: fallback.status >= 200 && fallback.status < 300,
                 status: fallback.status,
@@ -293,16 +334,21 @@ class LLMProvider {
         }
     }
     shouldUseNodeHttpFallback(error) {
-        return ((error instanceof TypeError && /fetch failed/i.test(error.message)) ||
-            (error instanceof Error && /abort/i.test(error.name || error.message)));
+        // Abort is a completed control decision (user cancellation or our own
+        // deadline), not evidence that a second transport can succeed. Retrying it
+        // on Windows used to create a second 120s request after the first timeout.
+        return error instanceof TypeError && /fetch failed/i.test(error.message);
     }
-    nodeHttpJson(method, urlValue, headers, body = '', signal) {
+    nodeHttpJson(method, urlValue, headers, body = '', signal, timeoutMs = DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS) {
+        const effectiveTimeout = this.effectiveRequestTimeout(timeoutMs);
         if (LLMProvider.nodeHttpTransport) {
-            return abortable(LLMProvider.nodeHttpTransport(method, urlValue, headers, body), signal).catch(error => {
+            return this.withRequestTimeout(LLMProvider.nodeHttpTransport(method, urlValue, headers, body), effectiveTimeout, signal).catch(error => {
                 if (signal?.aborted)
                     throw abortFailure(signal);
+                if (isProviderTimeoutError(error))
+                    throw error;
                 if (process.platform === 'win32') {
-                    return this.powershellJson(method, urlValue, headers, body, signal);
+                    return this.powershellJson(method, urlValue, headers, body, signal, effectiveTimeout);
                 }
                 throw error;
             });
@@ -350,8 +396,8 @@ class LLMProvider {
                         fail(new Error('Node HTTP response closed before completion'));
                 });
             });
-            req.setTimeout(120000, () => {
-                req.destroy(new Error('Node HTTP fallback timeout'));
+            req.setTimeout(effectiveTimeout, () => {
+                req.destroy(providerTimeoutError(effectiveTimeout));
             });
             req.on('error', reject);
             const onAbort = () => req.destroy(abortFailure(signal));
@@ -366,15 +412,18 @@ class LLMProvider {
         }).catch(error => {
             if (signal?.aborted)
                 throw abortFailure(signal);
+            if (isProviderTimeoutError(error))
+                throw error;
             if (process.platform === 'win32') {
-                return this.powershellJson(method, urlValue, headers, body, signal);
+                return this.powershellJson(method, urlValue, headers, body, signal, effectiveTimeout);
             }
             throw error;
         });
     }
-    powershellJson(method, urlValue, headers, body = '', signal) {
+    powershellJson(method, urlValue, headers, body = '', signal, timeoutMs = DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS) {
+        const effectiveTimeout = this.effectiveRequestTimeout(timeoutMs);
         if (LLMProvider.powershellTransport) {
-            return LLMProvider.powershellTransport(method, urlValue, headers, body);
+            return this.withRequestTimeout(LLMProvider.powershellTransport(method, urlValue, headers, body), effectiveTimeout, signal);
         }
         return new Promise((resolve, reject) => {
             const headerJson = JSON.stringify(headers);
@@ -403,7 +452,7 @@ class LLMProvider {
                 '  $raw = $headerJson | ConvertFrom-Json',
                 '  foreach ($p in $raw.PSObject.Properties) { $headers[$p.Name] = [string]$p.Value }',
                 '}',
-                '$params = @{ Uri = $uri; Method = $method; Headers = $headers; UseBasicParsing = $true; TimeoutSec = 120 }',
+                `'$params = @{ Uri = $uri; Method = $method; Headers = $headers; UseBasicParsing = $true; TimeoutSec = ${Math.max(1, Math.ceil(effectiveTimeout / 1000))} }`,
                 'if ($method -eq "POST") { $params["Body"] = $bodyJson }',
                 'if ($method -eq "POST") { $params["ContentType"] = "application/json; charset=utf-8" }',
                 '$resp = Invoke-WebRequest @params',
@@ -437,8 +486,8 @@ class LLMProvider {
             const timer = setTimeout(() => {
                 child.kill();
                 cleanup();
-                reject(new Error('PowerShell HTTP fallback timeout'));
-            }, 130000);
+                reject(providerTimeoutError(effectiveTimeout));
+            }, effectiveTimeout + 5000);
             child.stdout.setEncoding('utf8');
             child.stderr.setEncoding('utf8');
             child.stdout.on('data', chunk => { stdout += chunk; });
@@ -926,10 +975,10 @@ class LLMProvider {
         return this.shouldUseResponsesFallback(Number(match[1]), errorText);
     }
     /**
-     * Loopback-aware transport injected into adapter `execute`. Mirrors the
-     * legacy orchestration exactly: streaming requests go through fetch with a
-     * 120s timeout and degrade to a non-streaming node-http request on fetch
-     * failure; non-streaming requests reuse postJsonWithFetchFallback.
+     * Loopback-aware transport injected into adapter `execute`. Streaming
+     * requests retain the fetch-to-node fallback for transport failures, while
+     * a local deadline is returned directly so one request cannot become a
+     * second Windows fallback request.
      */
     buildProviderAdapterTransport() {
         return async (request, signal) => {
@@ -940,7 +989,8 @@ class LLMProvider {
                     forwardAbort();
                 else
                     signal?.addEventListener('abort', forwardAbort, { once: true });
-                const timer = setTimeout(() => abort.abort(), 120000);
+                const effectiveTimeout = this.effectiveRequestTimeout(120000);
+                const timer = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
                 try {
                     try {
                         return await fetch(request.url, {
@@ -953,11 +1003,13 @@ class LLMProvider {
                     catch (error) {
                         if (signal?.aborted)
                             throw abortFailure(signal);
+                        if (abort.signal.aborted)
+                            throw abortFailure(abort.signal);
                         if (!this.shouldUseNodeHttpFallback(error))
                             throw error;
                         const fallbackHeaders = { ...request.headers };
                         delete fallbackHeaders['Accept'];
-                        const fallback = await this.postJsonWithFetchFallback(request.url, fallbackHeaders, { ...request.body, stream: false }, 120000, signal);
+                        const fallback = await this.postJsonWithFetchFallback(request.url, fallbackHeaders, { ...request.body, stream: false }, effectiveTimeout, signal);
                         return this.toTransportResponse(fallback);
                     }
                 }
@@ -1071,7 +1123,8 @@ class LLMProvider {
             forwardAbort();
         else
             signal?.addEventListener('abort', forwardAbort, { once: true });
-        const timeout = setTimeout(() => abort.abort(), 120000);
+        const effectiveTimeout = this.effectiveRequestTimeout(120000);
+        const timeout = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
         let reader = null;
         try {
             let response;
@@ -1084,11 +1137,13 @@ class LLMProvider {
                 });
             }
             catch (e) {
+                if (signal?.aborted)
+                    throw abortFailure(signal);
+                if (abort.signal.aborted)
+                    throw abortFailure(abort.signal);
                 if (!this.shouldUseNodeHttpFallback(e))
                     throw e;
                 clearTimeout(timeout);
-                if (signal?.aborted)
-                    throw abortFailure(signal);
                 yield* this.githubModelsChatNonStreaming(url, body, signal);
                 return;
             }
@@ -1108,12 +1163,9 @@ class LLMProvider {
             let currentReasoningContent = '';
             let contentPolicyBlocked = false;
             let emittedContent = false;
+            const streamSignal = signal || new AbortController().signal;
             while (true) {
-                if (signal?.aborted)
-                    throw abortFailure(signal);
-                const readPromise = reader.read();
-                const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Stream read timeout')), 30000));
-                const { done, value } = await Promise.race([readPromise, timeoutPromise]);
+                const { done, value } = await (0, providers_1.readProviderStreamChunk)(reader, streamSignal);
                 if (done)
                     break;
                 buffer += decoder.decode(value, { stream: true });

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");
@@ -426,7 +427,11 @@ function createAppIconImage(size) {
     return size ? icon.resize({ width: size, height: size }) : icon;
 }
 function userArgs() {
-    return process.argv.slice(1);
+    const args = process.argv.slice(1);
+    // The native Windows console wrapper inserts Electron's `--` boundary before
+    // user arguments. Electron leaves that boundary in process.argv; normalize it
+    // before command discovery so the literal `Newmark.exe help` path terminates.
+    return args[0] === '--' ? args.slice(1) : args;
 }
 function argValue(args, key) {
     const idx = args.indexOf(key);
@@ -486,14 +491,14 @@ function positionalAfter(args, commandName) {
     return values;
 }
 // First-run initialization
-function firstRunInit(root) {
+function firstRunInit(root, options = {}) {
     fs.mkdirSync(root, { recursive: true });
     for (const d of ['skills', 'Work', 'Flow', 'archive', 'Memory Lab']) {
         fs.mkdirSync(path.join(root, d), { recursive: true });
     }
     new memoryLab_1.MemoryLabManager(root);
     const configModule = require('./core/config');
-    configModule.ensureRootConfig(root);
+    configModule.ensureRootConfig(root, options);
     if (!fs.existsSync(path.join(root, 'agent.md'))) {
         fs.writeFileSync(path.join(root, 'agent.md'), '# Newmark Agent\n\nYou are a powerful coding assistant.\n', 'utf-8');
     }
@@ -583,18 +588,13 @@ function ensureElectronUtilityRuntimeHost() {
     return host;
 }
 function legacyUserDataRoot() {
-    try {
-        return electron_1.app.getPath('userData');
-    }
-    catch {
-        if (process.platform === 'win32') {
-            const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
-            return path.join(appData, 'Newmark Agent');
-        }
-        if (process.platform === 'darwin')
-            return path.join(os.homedir(), 'Library', 'Application Support', 'Newmark Agent');
-        return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'Newmark Agent');
+    if (process.platform === 'win32') {
+        const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+        return path.join(appData, 'Newmark Agent');
     }
+    if (process.platform === 'darwin')
+        return path.join(os.homedir(), 'Library', 'Application Support', 'Newmark Agent');
+    return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'Newmark Agent');
 }
 function migrateLegacyRuntimeRoot(root) {
     const targetRoot = path.resolve(root);
@@ -677,6 +677,15 @@ function resolveRoot(args) {
         return writableRuntimeRoot(explicitRoot);
     return getRoot();
 }
+function resolveTuiWorkspacePath(args, root) {
+    const explicitWorkspace = pathArgValue(args, '--workspace');
+    if (explicitWorkspace)
+        return explicitWorkspace;
+    // An explicitly isolated runtime must not silently register the caller's
+    // cwd as an external workspace. Keep the opt-in --workspace escape hatch,
+    // while making the safe one-argument form fully self-contained.
+    return pathArgValue(args, '--root') ? root : process.cwd();
+}
 function startupLogPath() {
     try {
         const userData = userRuntimeRoot();
@@ -1026,24 +1035,54 @@ const args = userArgs();
 const command = args.find(a => a === 'flow' || a === 'edit');
 const isTuiArg = args.some(arg => arg.toLowerCase() === '--tui');
 const hasCliCommand = args.some(a => cli_commands_1.CLI_COMMANDS.includes(a));
+const isFlowArg = command === 'flow';
+const isEditArg = command === 'edit';
 const isHelpArg = !hasCliCommand && (args.some(arg => ['--help', '-h'].includes(arg.toLowerCase())) || args[0]?.toLowerCase() === 'help');
-const isVersionArg = !hasCliCommand && 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);
+}
+// Electron's Chromium profile is a separate state boundary from Newmark's
+// business root. Bind both before any ready event so --root cannot leave
+// Preferences, DIPS, DevTools ports, cookies, or session storage in the real
+// default AppData directory. The dedicated subdirectories keep Chromium's
+// files separate from the durable Newmark config/workspace files.
+const runtimeRoot = resolveRoot(args);
+const electronUserDataRoot = path.join(runtimeRoot, 'Electron');
+const electronSessionDataRoot = path.join(electronUserDataRoot, 'session-data');
+try {
+    fs.mkdirSync(electronSessionDataRoot, { recursive: true });
+    electron_1.app.setPath('userData', electronUserDataRoot);
+    electron_1.app.setPath('sessionData', electronSessionDataRoot);
+}
+catch (error) {
+    console.error(`Unable to isolate Electron user-data directory: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+}
 // Help/version are terminating discovery commands. They must be handled
 // before Electron's GUI/TUI/server branches can initialize runtime state or
 // spawn a window, so a product-new tester can use them safely in any surface.
 if (isHelpArg) {
-    console.log((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 +1157,9 @@ if (isViewerArg) {
     }).catch(error => { console.error(`Unable to open Newmark viewer: ${error instanceof Error ? error.message : String(error)}`); electron_1.app.quit(); });
 }
 else if (isTuiArg) {
-    const isConsoleLauncher = electron_1.app.isPackaged && path.basename(process.execPath).toLowerCase() === 'newmark.exe';
+    const isConsoleLauncher = electron_1.app.isPackaged && (path.basename(process.execPath).toLowerCase() === 'newmark.exe'
+        || path.basename(process.execPath).toLowerCase() === 'newmark console runtime.exe'
+        || process.env.NEWMARK_CONSOLE_WRAPPER === '1');
     if (isConsoleLauncher && process.env.NEWMARK_TUI_SIDECAR !== '1') {
         const tuiProcess = (0, child_process_1.spawnSync)(process.execPath, [path.join(__dirname, 'launcher.js'), ...args], {
             cwd: process.cwd(),
@@ -1126,6 +1167,11 @@ else if (isTuiArg) {
                 ...process.env,
                 ELECTRON_RUN_AS_NODE: '1',
                 NEWMARK_TUI_SIDECAR: '1',
+                // The GUI Electron host does not expose the inherited ConPTY handles
+                // as Node TTY streams. The console wrapper has already established
+                // that this is the terminal entrypoint, so preserve the terminal
+                // contract for the sidecar without weakening ordinary GUI launches.
+                NEWMARK_FORCE_TTY: isConsoleLauncher ? '1' : process.env.NEWMARK_FORCE_TTY,
             },
             stdio: 'inherit',
             windowsHide: false,
@@ -1146,12 +1192,12 @@ else if (isTuiArg) {
     const root = resolveRoot(args);
     firstRunInit(root);
     const { start } = require('./tui/src/app');
-    start({ root, workspacePath: process.cwd(), desktopDist: __dirname });
+    start({ root, workspacePath: resolveTuiWorkspacePath(args, root), desktopDist: __dirname });
 }
 else if (hasCliCommand) {
     (async () => {
         const root = resolveRoot(args);
-        firstRunInit(root);
+        firstRunInit(root, { readOnly: isReadOnlyValidation });
         const handled = await (0, cli_commands_1.runCliCommand)(root, args);
         const code = typeof process.exitCode === 'number' ? process.exitCode : 0;
         exitCli(handled ? code : 1);
@@ -1312,6 +1358,51 @@ else {
         });
         electron_1.app.whenReady().then(async () => {
             let root = resolveRoot(args);
+            let workspaceRegistryWatcher = null;
+            let workspaceRegistryWatchTimer = null;
+            const workspaceRegistryFiles = new Set(['Local.json', 'External.json', 'State.json']);
+            const broadcastWorkspaceChanged = (files) => {
+                for (const win of electron_1.BrowserWindow.getAllWindows()) {
+                    if (win.isDestroyed())
+                        continue;
+                    win.webContents.send('workspace:changed', { files, root });
+                }
+            };
+            const refreshWorkspaceRegistryFromDisk = (files) => {
+                if (!agent)
+                    return;
+                agent.refreshWorkspaceRegistryFromStorage();
+                const current = agent.workspace.current;
+                if (current)
+                    workspaceSelectionCoordinator?.setCurrent(current.id || current.path || current.name);
+                broadcastWorkspaceChanged(files);
+            };
+            const ensureWorkspaceRegistryWatcher = () => {
+                if (workspaceRegistryWatcher)
+                    return;
+                const workDir = path.join(root, 'Work');
+                try {
+                    workspaceRegistryWatcher = fs.watch(workDir, { persistent: false }, (_eventType, filename) => {
+                        const changed = String(filename || '');
+                        if (changed && !workspaceRegistryFiles.has(path.basename(changed)))
+                            return;
+                        if (workspaceRegistryWatchTimer)
+                            clearTimeout(workspaceRegistryWatchTimer);
+                        workspaceRegistryWatchTimer = setTimeout(() => {
+                            workspaceRegistryWatchTimer = null;
+                            try {
+                                refreshWorkspaceRegistryFromDisk(changed ? [path.basename(changed)] : ['Work']);
+                            }
+                            catch (error) {
+                                logStartupFailure('workspace-registry-refresh', error);
+                            }
+                        }, 90);
+                    });
+                }
+                catch (error) {
+                    logStartupFailure('workspace-registry-watch', error);
+                }
+            };
             const fileRouter = new workspaceFileRouter_1.WorkspaceFileRouter(() => path.resolve(agent?.workspace.current?.path || root));
             const pdfPreviewServer = new pdfPreviewServer_1.PdfPreviewServer((token, ownerId) => fileRouter.resolvePdfCapability(token, ownerId));
             await pdfPreviewServer.start();
@@ -1718,6 +1809,7 @@ else {
                     agent = new agent_1.Agent(root);
                     mcpManager = new mcpManager_1.McpManager(root);
                     activeAgentBackendMode = process.platform === 'win32' && agent.config.getBool('agent', 'run_in_wsl') ? 'wsl' : 'windows';
+                    ensureWorkspaceRegistryWatcher();
                     restoreStoredFlowSuspension();
                     recordStartup('agent-ready');
                 }
@@ -2207,8 +2299,17 @@ else {
                     (0, runtimeLifecycle_1.markRuntimeLifecycleClean)(root, 'main');
             };
             electron_1.app.on('will-quit', event => {
-                if (_forceQuit)
+                // Window-close and tray-exit both enter this path. The runtime pools
+                // must get a bounded graceful-shutdown window regardless of which
+                // surface initiated the close; otherwise a stuck child can keep the
+                // Electron parent and its renderer tree alive indefinitely.
+                if (_forceQuit || !appExitCleanupComplete)
                     armForcedExitDeadline('will-quit');
+                if (workspaceRegistryWatchTimer)
+                    clearTimeout(workspaceRegistryWatchTimer);
+                workspaceRegistryWatchTimer = null;
+                workspaceRegistryWatcher?.close();
+                workspaceRegistryWatcher = null;
                 startupDeferredTasks?.cancel();
                 agent?.flushWorkspaceConversationState();
                 conversationKernel?.flushPersistence();
@@ -2539,6 +2640,13 @@ else {
                 else
                     await electronUtilityRuntimePool?.stopTarget(target);
             };
+            const forceStopTargetRuntime = async (target) => {
+                if (wslBackendEnabled())
+                    await wslAgentRuntimePool?.forceStopTarget(target);
+                else
+                    await electronUtilityRuntimePool?.forceStopTarget(target);
+            };
+            const archiveInFlight = new Map();
             const isolatedConversationAgent = (target) => {
                 const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
                 const isolated = new agent_1.Agent(root, { agentOnly: true });
@@ -3732,32 +3840,46 @@ else {
                     return { ok: false, error: 'Agent not initialized' };
                 const target = conversationRuntimeTarget(targetInput || agent.activeConversationId || 'default');
                 const normalized = (0, conversationTarget_1.normalizeConversationTarget)(target);
-                assertTargetNotMutating(normalized);
-                mutatingRuntimeKeys.add(normalized.runtimeKey);
+                const existing = archiveInFlight.get(normalized.runtimeKey);
+                if (existing)
+                    return existing;
+                const operation = (async () => {
+                    mutatingRuntimeKeys.add(normalized.runtimeKey);
+                    try {
+                        // Archive is a destructive lifecycle command. It intentionally
+                        // bypasses the normal mutation/active-prompt guard and hard-stops
+                        // any resident runtime before touching conversation persistence.
+                        await forceStopTargetRuntime(normalized);
+                        const currentWorkspacePath = path.resolve(agent.workspace.current?.path || '');
+                        const targetWorkspacePath = path.resolve(normalized.workspace?.path || '');
+                        const ownsTargetWorkspace = !!normalized.workspace
+                            && !!agent.workspace.current
+                            && currentWorkspacePath === targetWorkspacePath;
+                        // The host Agent owns the current workspace persistence cache. An
+                        // isolated owner is used for another workspace. The archive writer
+                        // starts payload I/O in parallel and finalizes deletion against the
+                        // latest locked state snapshot, so rapid clicks do not serialize on
+                        // large Markdown bodies or lose a sibling deletion.
+                        const archiveOwner = ownsTargetWorkspace ? agent : isolatedConversationAgent(normalized);
+                        const archived = await archiveOwner.archiveConversationAsync(normalized.conversationId);
+                        if (!archived)
+                            return { ok: false, error: 'Conversation archive could not be written.' };
+                        return { ok: true, fileName: archived, conversationId: normalized.conversationId, workspaceId: normalized.workspaceId };
+                    }
+                    catch (error) {
+                        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+                    }
+                    finally {
+                        mutatingRuntimeKeys.delete(normalized.runtimeKey);
+                    }
+                })();
+                archiveInFlight.set(normalized.runtimeKey, operation);
                 try {
-                    const peek = peekTargetRuntime(normalized);
-                    if (peek.running || peek.stopping)
-                        return { ok: false, error: 'Cannot archive a conversation while its runtime is running or stopping.' };
-                    if (peek.resident)
-                        await stopTargetRuntime(normalized);
-                    const currentWorkspacePath = path.resolve(agent.workspace.current?.path || '');
-                    const targetWorkspacePath = path.resolve(normalized.workspace?.path || '');
-                    const ownsTargetWorkspace = !!normalized.workspace
-                        && !!agent.workspace.current
-                        && currentWorkspacePath === targetWorkspacePath;
-                    // The host Agent owns the current workspace persistence cache. Archiving
-                    // through it prevents a delayed host flush from resurrecting the target.
-                    const archiveOwner = ownsTargetWorkspace ? agent : isolatedConversationAgent(normalized);
-                    const archived = archiveOwner.archiveConversation(normalized.conversationId);
-                    if (!archived)
-                        return { ok: false, error: 'Conversation archive could not be written.' };
-                    return { ok: true, fileName: archived, conversationId: normalized.conversationId, workspaceId: normalized.workspaceId };
-                }
-                catch (error) {
-                    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+                    return await operation;
                 }
                 finally {
-                    mutatingRuntimeKeys.delete(normalized.runtimeKey);
+                    if (archiveInFlight.get(normalized.runtimeKey) === operation)
+                        archiveInFlight.delete(normalized.runtimeKey);
                 }
             });
             electron_1.ipcMain.handle('agent:listArchives', async (_event, scope) => {

package/dist/preload.js

@@ -173,6 +173,12 @@ contextBridge.exposeInMainWorld('api', {
     onAgentWorkEvent: (callback) => {
         ipcRenderer.on('agent:workEvent', callback);
     },
+    onWorkspaceChanged: (callback) => {
+        ipcRenderer.on('workspace:changed', (_event, payload) => callback(payload));
+    },
+    removeWorkspaceChangedListener: () => {
+        ipcRenderer.removeAllListeners('workspace:changed');
+    },
     removeAgentWorkEventListener: () => {
         ipcRenderer.removeAllListeners('agent:workEvent');
     },

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

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

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

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