newmark-agent 0.3.11 → 0.3.12

package/dist/wsl-agent-host.bundle.cjs

@@ -326959,7 +326959,12 @@ async function runFlowBuild(agent, prompt, options) {
       if (!options.signal?.aborted && typeof agent.emitWorkEvent === "function") {
         agent.emitWorkEvent({ type: "error", content: reportedError.message, runId });
       }
-      agent.finishConversationWorkRun(runId, options.signal?.aborted ? "interrupted" : "error");
+      agent.finishConversationWorkRun(
+        runId,
+        options.signal?.aborted ? "interrupted" : "error",
+        void 0,
+        options.signal?.aborted ? "" : reportedError.message
+      );
       agent.flushWorkspaceConversationState();
     }
     throw reportedError;
@@ -327623,8 +327628,10 @@ var ConfigManager = class {
   rootPath;
   config;
   workspaceOverrides;
-  constructor(rootPath) {
+  readOnly;
+  constructor(rootPath, options = {}) {
     this.rootPath = rootPath;
+    this.readOnly = options.readOnly === true;
     this.workspaceOverrides = /* @__PURE__ */ new Map();
     this.config = this.load();
   }
@@ -327639,17 +327646,19 @@ var ConfigManager = class {
         const raw = JSON.parse(readJsonText(cp));
         const normalized = normalizeConfigShape(raw, true);
         if (isCorruptConfig(raw, normalized)) {
+          if (this.readOnly) return defaultConfig();
           this.backupConfig(cp, "invalid-shape");
           return this.writeRecoveredConfig(cp);
         }
         if (migrateProviderIdsInConfig(normalized)) {
           try {
-            fs3.writeFileSync(cp, JSON.stringify(normalized, null, 2), "utf-8");
+            if (!this.readOnly) fs3.writeFileSync(cp, JSON.stringify(normalized, null, 2), "utf-8");
           } catch {
           }
         }
         return normalized;
       } catch {
+        if (this.readOnly) return defaultConfig();
         this.backupConfig(cp, "invalid-json");
         return this.writeRecoveredConfig(cp);
       }
@@ -327695,10 +327704,12 @@ var ConfigManager = class {
     this.config[section][key3] = { value: normalizedValue };
   }
   save() {
+    if (this.readOnly) return;
     const j2 = JSON.stringify(this.config, null, 2);
     fs3.writeFileSync(path3.join(this.rootPath, "config.json"), j2, "utf-8");
   }
   saveTo(targetPath) {
+    if (this.readOnly) return;
     const j2 = JSON.stringify(this.config, null, 2);
     fs3.writeFileSync(targetPath, j2, "utf-8");
   }
@@ -327923,12 +327934,14 @@ var ConfigManager = class {
     return providers;
   }
   writeRecoveredConfig(configPath) {
+    if (this.readOnly) return defaultConfig();
     const config = loadExampleConfig();
     fs3.mkdirSync(path3.dirname(configPath), { recursive: true });
     fs3.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
     return config;
   }
   backupConfig(configPath, reason) {
+    if (this.readOnly) return;
     try {
       if (!fs3.existsSync(configPath)) return;
       const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -328273,7 +328286,10 @@ function defaultConfig() {
     general: {
       tone: { _description: "Conversation style", _type: "choice", _values: ["strict_simple", "casual_friendly"], value: "strict_simple" },
       language: { _description: "Default language", _type: "choice", _values: ["en", "zh", "auto"], value: "auto" },
-      close_behavior: { _description: "Close behavior", _type: "choice", _values: ["minimize", "exit"], value: "minimize" },
+      // A first-run desktop window must have a deterministic close/exit
+      // contract. Users who explicitly choose minimize-to-tray keep that
+      // choice, but a fresh install must not hide the process on OS close.
+      close_behavior: { _description: "Close behavior", _type: "choice", _values: ["minimize", "exit"], value: "exit" },
       default_input: { _description: "Default input mode", _type: "choice", _values: ["guide", "next"], value: "guide" },
       auto_archive_on_close: { _description: "Auto archive on close", _type: "boolean", value: true }
     },
@@ -328612,6 +328628,38 @@ function providerAbortError(signal) {
   if (!error.name || error.name === "Error") error.name = "AbortError";
   return error;
 }
+function providerStreamTimeoutError(timeoutMs) {
+  const error = new Error("Stream read timeout");
+  error.name = "TimeoutError";
+  error.message = `Stream read timeout after ${timeoutMs}ms`;
+  return error;
+}
+async function readProviderStreamChunk(reader, signal, timeoutMs = 3e4) {
+  if (signal.aborted) throw providerAbortError(signal);
+  let timer;
+  let onAbort;
+  const abortPromise = new Promise((_3, reject) => {
+    onAbort = () => reject(providerAbortError(signal));
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  const timeoutPromise = new Promise((_3, reject) => {
+    timer = setTimeout(() => reject(providerStreamTimeoutError(timeoutMs)), timeoutMs);
+  });
+  try {
+    return await Promise.race([reader.read(), abortPromise, timeoutPromise]);
+  } catch (error) {
+    if (signal.aborted || error instanceof Error && error.name === "TimeoutError") {
+      try {
+        await reader.cancel(error);
+      } catch {
+      }
+    }
+    throw error;
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (onAbort) signal.removeEventListener("abort", onAbort);
+  }
+}
 function parseProviderSse(raw) {
   const events = [];
   for (const block of String(raw || "").replace(/\r\n/g, "\n").split(/\n\n+/)) {
@@ -328847,12 +328895,7 @@ var ChatCompletionsAdapter = class {
     let emittedTool = false;
     try {
       while (true) {
-        if (signal.aborted) throw providerAbortError(signal);
-        const readPromise = reader.read();
-        const timeoutPromise = new Promise(
-          (_3, reject) => setTimeout(() => reject(new Error("Stream read timeout")), 3e4)
-        );
-        const { done, value } = await Promise.race([readPromise, timeoutPromise]);
+        const { done, value } = await readProviderStreamChunk(reader, signal);
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
@@ -329090,8 +329133,7 @@ var ResponsesAdapter = class {
     let streamError = "";
     try {
       while (true) {
-        if (signal.aborted) throw providerAbortError(signal);
-        const { done, value } = await reader.read();
+        const { done, value } = await readProviderStreamChunk(reader, signal);
         if (done) break;
         buffer += decoder.decode(value, { stream: true }).replace(/\r\n/g, "\n");
         const blocks = buffer.split(/\n\n+/);
@@ -329301,6 +329343,16 @@ function createProviderAdapter(providerId, apiMode) {
 }
 
 // src/llm/provider.ts
+var DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS = 9e4;
+var 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");
@@ -329330,13 +329382,14 @@ function parseProviderSse2(raw) {
   return events;
 }
 var LLMProvider = class _LLMProvider {
-  constructor(name50, baseUrl, apiKey, explicitProtocol, openAIMode = "chat_stream", useProviderAdaptersV2 = false) {
+  constructor(name50, baseUrl, apiKey, explicitProtocol, openAIMode = "chat_stream", useProviderAdaptersV2 = false, requestTimeoutMs = DEFAULT_PROVIDER_REQUEST_TIMEOUT_MS) {
     this.name = name50;
     this.baseUrl = baseUrl;
     this.apiKey = apiKey;
     this.explicitProtocol = explicitProtocol;
     this.openAIMode = openAIMode;
     this.useProviderAdaptersV2 = useProviderAdaptersV2;
+    this.requestTimeoutMs = requestTimeoutMs;
   }
   name;
   baseUrl;
@@ -329344,8 +329397,25 @@ var LLMProvider = class _LLMProvider {
   explicitProtocol;
   openAIMode;
   useProviderAdaptersV2;
+  requestTimeoutMs;
   static nodeHttpTransport = null;
   static powershellTransport = null;
+  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((_3, 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) {
       case "low":
@@ -329447,6 +329517,7 @@ var LLMProvider = class _LLMProvider {
     };
   }
   async postJsonWithFetchFallback(url, headers, body, timeoutMs = 12e4, signal) {
+    const effectiveTimeout = this.effectiveRequestTimeout(timeoutMs);
     if (this.isPlainHttpLoopback(url)) {
       const pathname = (() => {
         try {
@@ -329456,7 +329527,7 @@ var LLMProvider = class _LLMProvider {
         }
       })();
       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,
@@ -329470,7 +329541,7 @@ var LLMProvider = class _LLMProvider {
     const forwardAbort = () => abort.abort(signal?.reason);
     if (signal?.aborted) 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",
@@ -329481,8 +329552,9 @@ var LLMProvider = class _LLMProvider {
       return response;
     } catch (e3) {
       if (signal?.aborted) throw abortFailure(signal);
+      if (abort.signal.aborted) throw abortFailure(abort.signal);
       if (!this.shouldUseNodeHttpFallback(e3)) throw e3;
-      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,
@@ -329496,14 +329568,16 @@ var LLMProvider = class _LLMProvider {
     }
   }
   async getJsonWithFetchFallback(url, headers, timeoutMs = 3e4) {
+    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 (e3) {
+      if (abort.signal.aborted) throw abortFailure(abort.signal);
       if (!this.shouldUseNodeHttpFallback(e3)) throw e3;
-      const fallback = await this.nodeHttpJson("GET", url, headers);
+      const fallback = await this.nodeHttpJson("GET", url, headers, "", void 0, effectiveTimeout);
       return {
         ok: fallback.status >= 200 && fallback.status < 300,
         status: fallback.status,
@@ -329516,14 +329590,16 @@ var LLMProvider = class _LLMProvider {
     }
   }
   shouldUseNodeHttpFallback(error) {
-    return error instanceof TypeError && /fetch failed/i.test(error.message) || error instanceof Error && /abort/i.test(error.name || error.message);
+    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;
       });
@@ -329568,8 +329644,8 @@ var LLMProvider = class _LLMProvider {
           else fail(new Error("Node HTTP response closed before completion"));
         });
       });
-      req.setTimeout(12e4, () => {
-        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));
@@ -329580,15 +329656,17 @@ var LLMProvider = class _LLMProvider {
       req.end();
     }).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((resolve16, reject) => {
       const headerJson = JSON.stringify(headers);
@@ -329617,7 +329695,7 @@ var LLMProvider = 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 / 1e3))} }`,
         'if ($method -eq "POST") { $params["Body"] = $bodyJson }',
         'if ($method -eq "POST") { $params["ContentType"] = "application/json; charset=utf-8" }',
         "$resp = Invoke-WebRequest @params",
@@ -329649,8 +329727,8 @@ var LLMProvider = class _LLMProvider {
       const timer = setTimeout(() => {
         child.kill();
         cleanup();
-        reject(new Error("PowerShell HTTP fallback timeout"));
-      }, 13e4);
+        reject(providerTimeoutError(effectiveTimeout));
+      }, effectiveTimeout + 5e3);
       child.stdout.setEncoding("utf8");
       child.stderr.setEncoding("utf8");
       child.stdout.on("data", (chunk) => {
@@ -330098,10 +330176,10 @@ ${responsePath}
     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) => {
@@ -330110,7 +330188,8 @@ ${responsePath}
         const forwardAbort = () => abort.abort(signal?.reason);
         if (signal?.aborted) forwardAbort();
         else signal?.addEventListener("abort", forwardAbort, { once: true });
-        const timer = setTimeout(() => abort.abort(), 12e4);
+        const effectiveTimeout = this.effectiveRequestTimeout(12e4);
+        const timer = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
         try {
           try {
             return await fetch(request.url, {
@@ -330121,6 +330200,7 @@ ${responsePath}
             });
           } 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"];
@@ -330128,7 +330208,7 @@ ${responsePath}
               request.url,
               fallbackHeaders,
               { ...request.body, stream: false },
-              12e4,
+              effectiveTimeout,
               signal
             );
             return this.toTransportResponse(fallback);
@@ -330238,7 +330318,8 @@ ${responsePath}
     const forwardAbort = () => abort.abort(signal?.reason);
     if (signal?.aborted) forwardAbort();
     else signal?.addEventListener("abort", forwardAbort, { once: true });
-    const timeout = setTimeout(() => abort.abort(), 12e4);
+    const effectiveTimeout = this.effectiveRequestTimeout(12e4);
+    const timeout = setTimeout(() => abort.abort(providerTimeoutError(effectiveTimeout)), effectiveTimeout);
     let reader = null;
     try {
       let response;
@@ -330250,9 +330331,10 @@ ${responsePath}
           signal: abort.signal
         });
       } catch (e3) {
+        if (signal?.aborted) throw abortFailure(signal);
+        if (abort.signal.aborted) throw abortFailure(abort.signal);
         if (!this.shouldUseNodeHttpFallback(e3)) throw e3;
         clearTimeout(timeout);
-        if (signal?.aborted) throw abortFailure(signal);
         yield* this.githubModelsChatNonStreaming(url, body, signal);
         return;
       }
@@ -330272,13 +330354,9 @@ ${responsePath}
       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(
-          (_3, reject) => setTimeout(() => reject(new Error("Stream read timeout")), 3e4)
-        );
-        const { done, value } = await Promise.race([readPromise, timeoutPromise]);
+        const { done, value } = await readProviderStreamChunk(reader, streamSignal);
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
@@ -337924,6 +338002,19 @@ var WorkspaceManager = class {
       this.saveState();
     }
   }
+  /**
+   * Re-read the registry and persisted current-workspace pointer after another
+   * Newmark entrypoint updates Work/*.json. This intentionally does not create
+   * a workspace: a refresh must reflect the shared on-disk state exactly.
+   */
+  reloadFromStorage() {
+    if (this.detached) return this.current;
+    this.scan();
+    this.validate();
+    this.current = null;
+    this.restoreCurrent();
+    return this.current;
+  }
   saveInternal() {
     if (this.detached) return;
     const p = path16.join(this.rootPath, "Work", "Local.json");
@@ -340014,17 +340105,35 @@ function normalizePublicProviderError(error, secrets = []) {
   }
   return raw.slice(0, 1200);
 }
+function throwIfKernelAborted(signal) {
+  if (!signal?.aborted) return;
+  const reason = signal.reason;
+  if (reason instanceof Error) {
+    reason.name = "AbortError";
+    throw reason;
+  }
+  const error = new Error(reason ? String(reason) : "Agent run aborted");
+  error.name = "AbortError";
+  throw error;
+}
 async function runAgentKernel(agent) {
   const stopContextTimer = performanceTimer("context_prepare", { conversationId: agent.activeConversationId });
+  const processSignal = agent.activeProcessSignal();
+  if (processSignal?.aborted) {
+    stopContextTimer();
+    throwIfKernelAborted(processSignal);
+  }
   if (!agent.engineModel()) {
+    const message = "No LLM configured. Add provider in Settings > Models.";
     agent.status = "error";
     agent.saveWorkspaceConversationState();
-    return [{ type: "text", text: "[Error] No LLM configured. Add provider in Settings > Models." }];
+    throw new Error(message);
   }
   const [{ Agent: NativeAgent }, KernelStreamCompat] = await Promise.all([
     Promise.resolve().then(() => (init_agentKernel(), agentKernel_exports)),
     Promise.resolve().then(() => (init_stream_types(), stream_types_exports))
   ]);
+  throwIfKernelAborted(processSignal);
   const toolProvisioning = new ToolProvisionSession([], []);
   let activeToolSurfaceIdentity = "";
   let activeToolSurfaceNotice = "";
@@ -340050,6 +340159,7 @@ async function runAgentKernel(agent) {
   const initialToolSurface = refreshToolSurface(true);
   const assembledContext = agent.assembleContextV2(initialToolSurface.systemPromptNotice);
   const systemPrompt = assembledContext.text;
+  throwIfKernelAborted(processSignal);
   let providerRequestCount = 0;
   let bootstrappedCompressionAt = agent.lastCompression?.at || "";
   stopContextTimer();
@@ -340070,6 +340180,24 @@ async function runAgentKernel(agent) {
   kernel2.state.tools = toKernelTools(agent, initialToolSurface.definitions, toolProvisioning);
   kernel2.state.messages = toKernelMessages(agent);
   agent.attachAgentKernelRuntime(kernel2);
+  let detachProcessAbort = () => {
+  };
+  if (processSignal) {
+    const abortKernel = () => kernel2.abort();
+    if (processSignal.aborted) {
+      kernel2.abort();
+    } else {
+      processSignal.addEventListener("abort", abortKernel, { once: true });
+      detachProcessAbort = () => processSignal.removeEventListener("abort", abortKernel);
+    }
+  }
+  try {
+    throwIfKernelAborted(processSignal);
+  } catch (error) {
+    detachProcessAbort();
+    agent.attachAgentKernelRuntime(null);
+    throw error;
+  }
   const tokens = [];
   const runOnce = async (promptMessages, appendPromptToAgentHistory) => {
     let lastAssistant = null;
@@ -340173,6 +340301,7 @@ async function runAgentKernel(agent) {
       else agent.pendingOptions = agent.pendingOptions.filter((question) => !isPlanExecutionQuestion(question));
     }
   } finally {
+    detachProcessAbort();
     agent.attachAgentKernelRuntime(null);
   }
   agent.status = "idle";
@@ -340339,20 +340468,18 @@ async function transformContext(agent, messages, signal) {
   const provider = agent.engineModel();
   if (!provider || !compressionModel) return messages;
   const newmarkMessages = publicHistoryFromKernelMessages(messages);
-  const beforeCompression = JSON.stringify(newmarkMessages);
   const compressionAt = agent.lastCompression?.at || "";
-  await agent.maybeCompress(newmarkMessages, provider, processSignal, compressionModel);
+  let compressed = await agent.maybeCompress(newmarkMessages, provider, processSignal, compressionModel);
   if (processSignal?.aborted) return messages;
-  const primaryCompressed = JSON.stringify(newmarkMessages) !== beforeCompression;
-  if (primaryCompressed && agent.estimateContextTokens(newmarkMessages) >= Math.floor(agent.contextWindow(compressionModel).maxTokens * 0.82)) {
-    await agent.maybeCompress(newmarkMessages, null, processSignal, compressionModel, true);
+  if (compressed && agent.estimateContextTokens(newmarkMessages) >= Math.floor(agent.contextWindow(compressionModel).maxTokens * 0.82)) {
+    compressed = await agent.maybeCompress(newmarkMessages, null, processSignal, compressionModel, true) || compressed;
   }
   const windowMax = agent.contextWindow(compressionModel).maxTokens;
   const conservativeTokens = agent.estimateContextTokens(newmarkMessages);
   if (conservativeTokens >= Math.floor(windowMax * 0.9) && !processSignal?.aborted) {
-    await agent.maybeCompress(newmarkMessages, null, processSignal, compressionModel, true);
+    compressed = await agent.maybeCompress(newmarkMessages, null, processSignal, compressionModel, true) || compressed;
   }
-  if (JSON.stringify(newmarkMessages) === beforeCompression) return messages;
+  if (!compressed) return messages;
   const durableMessages = toKernelMessagesFromHistory(newmarkMessages, agent);
   if (agent.lastCompression?.at && agent.lastCompression.at !== compressionAt) {
     agent.recordContextCompressionStep();
@@ -342243,9 +342370,11 @@ function key2(model) {
 }
 var FileModelValidationCache = class {
   filePath;
+  readOnly;
   records = /* @__PURE__ */ new Map();
-  constructor(rootPath) {
+  constructor(rootPath, options = {}) {
     this.filePath = path20.join(rootPath, "model-validation", "records.json");
+    this.readOnly = options.readOnly === true;
     this.load();
   }
   get(modelKey2) {
@@ -342254,10 +342383,12 @@ var FileModelValidationCache = class {
   }
   set(record) {
     this.records.set(record.modelKey || key2(record.model), JSON.parse(JSON.stringify(record)));
+    if (this.readOnly) return;
     this.save();
   }
   delete(modelKey2) {
     if (!this.records.delete(modelKey2)) return;
+    if (this.readOnly) return;
     this.save();
   }
   load() {
@@ -344133,7 +344264,7 @@ var Agent4 = class _Agent {
     this.subagentName = options.subagentName || "";
     this.subagentPrompt = options.subagentPrompt || "";
     this.linkedPlanAccess = options.linkedPlanAccess;
-    this.config = new ConfigManager(rootPath);
+    this.config = new ConfigManager(rootPath, { readOnly: options.readOnlyConfig === true });
     this.compressionHistoryArchive = new CompressionHistoryArchive(rootPath);
     this.contextV2 = new AgentContextManager(rootPath, this.config);
     this.agentRunService = this.config.contextFlag("agent_runtime_v2") ? new AgentRunService(path28.join(rootPath, ".newmark-context-v2")) : null;
@@ -344664,7 +344795,10 @@ var Agent4 = class _Agent {
     }
     const previousAuto = this.model === "auto" ? this.resolvedDeployment : null;
     const qualified = parseDeploymentSelectionValue2(requested);
-    const current = qualified ? this.config.findDeployment(qualified) : requested ? this.config.findModel(requested) : void 0;
+    const legacyQualified = requested.includes("/") ? this.config.allModels().filter(
+      (model2) => `${model2.provider_id}/${model2.name}` === requested || `${model2.provider}/${model2.name}` === requested
+    ) : [];
+    const current = qualified ? this.config.findDeployment(qualified) : legacyQualified.length === 1 ? legacyQualified[0] : requested ? this.config.findModel(requested) : void 0;
     this.model = current?.name || requested;
     this.fixedDeployment = current ? this.deploymentRef(current) : qualified;
     this.resolvedDeployment = null;
@@ -345781,7 +345915,7 @@ ${String(event.toolArgs || "")}`;
     this.saveWorkspaceConversationState(true);
     return true;
   }
-  finishConversationWorkRun(runId, status, endedAt = this.nowIso()) {
+  finishConversationWorkRun(runId, status, endedAt = this.nowIso(), errorMessage = "") {
     const run = this.workRuns.find((item) => item.runId === String(runId || ""));
     if (!run) return false;
     this.syncAgentRunTerminal(run.runId, status, endedAt);
@@ -345825,7 +345959,7 @@ ${String(event.toolArgs || "")}`;
     this.enforceGoalTerminalInvariant(status, goalAudit);
     this.emitWorkEvent({
       type: status === "completed" ? "done" : status === "error" ? "error" : "status",
-      content: status === "force_interrupted" ? "Force interrupted." : status === "interrupted" ? "Interrupted." : "Response complete.",
+      content: status === "error" ? String(errorMessage || "").trim() || "Agent run failed." : status === "force_interrupted" ? "Force interrupted." : status === "interrupted" ? "Interrupted." : "Response complete.",
       status,
       runId: run.runId,
       conversationId: run.target.conversationId,
@@ -345970,6 +346104,7 @@ ${String(event.toolArgs || "")}`;
     this.activeAgentKernelRuntime = runtime;
     this.awaitingAgentKernelRuntime = false;
     if (!runtime) return;
+    if (this.activeProcessAbortController?.signal.aborted) runtime.abort?.();
     const queued = this.pendingAgentKernelQueue.splice(0);
     for (const item of queued) {
       const accepted = this.forwardAgentKernelQueueMessage(item.content, item.queueMode, item.clientMessageId, item.runId, item.images, item.hiddenUserInput);
@@ -347131,6 +347266,25 @@ Review this persisted peer result and summarize or continue the parent task as n
     this.loadWorkspaceConversationState();
     return selected;
   }
+  refreshWorkspaceRegistryFromStorage() {
+    const before = JSON.stringify({
+      internal: this.workspace.internal,
+      external: this.workspace.external,
+      current: this.workspace.current
+    });
+    const selected = this.workspace.reloadFromStorage();
+    const after = JSON.stringify({
+      internal: this.workspace.internal,
+      external: this.workspace.external,
+      current: this.workspace.current
+    });
+    if (before === after) return selected;
+    if (selected) this.config.loadWorkspaceConfig(selected.path);
+    else this.config.clearWorkspaceOverrides();
+    this.workspaceConversations.clear();
+    this.loadWorkspaceConversationState();
+    return selected;
+  }
   setConversation(id) {
     const clean = this.safeConversationId(id || "default");
     if (this.workspaceConversationKey() === this.loadedWorkspaceConversationKey) {
@@ -348124,28 +348278,25 @@ ${summary}`, segment, "local-summarize", true);
     this.saveWorkspaceConversationState(true);
     return { text, hiddenUserInput: true, goalContinuation: true };
   }
-  writeSessionArchive(messages, mode, model) {
+  buildSessionArchive(messages, mode, model, archiveDir) {
     const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "").replace("T", "_").replace("Z", "");
-    const archiveDir = this.archiveDir();
-    fs25.mkdirSync(archiveDir, { recursive: true });
-    const filename = `session_${stamp}.md`;
-    const outPath = path28.join(archiveDir, filename);
-    let md = `# Newmark Session \u2014 ${stamp}
+    const filename = `session_${stamp}_${crypto14.randomUUID().slice(0, 8)}.md`;
+    let markdown = `# Newmark Session \u2014 ${stamp}
 
 `;
-    md += `**Mode**: ${mode}
+    markdown += `**Mode**: ${mode}
 **Model**: ${model}
 `;
-    md += `**Messages**: ${messages.length}
+    markdown += `**Messages**: ${messages.length}
 
 ---
 
 `;
-    if (this.goal) md += `**Goal**: ${this.goal.objective}
+    if (this.goal) markdown += `**Goal**: ${this.goal.objective}
 
 `;
     for (const msg of messages) {
-      md += `**[${msg.role}] ${msg.timestamp}**
+      markdown += `**[${msg.role}] ${msg.timestamp}**
 
 ${msg.content}
 
@@ -348154,13 +348305,35 @@ ${msg.content}
         const archived = archiveConversationImageAttachment(this.rootPath, archiveDir, attachment);
         if (!archived) continue;
         const alt = archived.name.replace(/[\]\r\n]/g, " ").trim() || "Submitted image";
-        md += `![${alt}](${archived.relativePath})
+        markdown += `![${alt}](${archived.relativePath})
 
 `;
       }
     }
-    fs25.writeFileSync(outPath, md, "utf-8");
-    return filename;
+    return { filename, markdown };
+  }
+  writeSessionArchive(messages, mode, model) {
+    const archiveDir = this.archiveDir();
+    fs25.mkdirSync(archiveDir, { recursive: true });
+    const archive = this.buildSessionArchive(messages, mode, model, archiveDir);
+    fs25.writeFileSync(path28.join(archiveDir, archive.filename), archive.markdown, "utf-8");
+    return archive.filename;
+  }
+  async writeSessionArchiveAsync(messages, mode, model, archiveDir = this.archiveDir()) {
+    const archive = this.buildSessionArchive(messages, mode, model, archiveDir);
+    await fs25.promises.mkdir(archiveDir, { recursive: true });
+    const outPath = path28.join(archiveDir, archive.filename);
+    const tempPath = `${outPath}.${process.pid}.${crypto14.randomUUID()}.tmp`;
+    try {
+      await fs25.promises.writeFile(tempPath, archive.markdown, "utf-8");
+      await fs25.promises.rename(tempPath, outPath);
+    } finally {
+      try {
+        await fs25.promises.unlink(tempPath);
+      } catch {
+      }
+    }
+    return archive.filename;
   }
   archiveSession() {
     return this.writeSessionArchive(this.chatMessages, this.modeName(), this.model);
@@ -348228,6 +348401,93 @@ ${msg.content}
     }
     return filename;
   }
+  /**
+   * Non-blocking archive writer used by the desktop IPC path. The conversation
+   * state merge remains synchronous and lock-protected, but the potentially
+   * large markdown payload and manifest use promise-based filesystem I/O so
+   * independent workspaces can archive in parallel without freezing Electron.
+   */
+  async archiveConversationAsync(conversationId) {
+    return await this.archiveConversationAsyncUnlocked(conversationId);
+  }
+  async archiveConversationAsyncUnlocked(conversationId) {
+    const ws = this.workspace.current;
+    if (!ws) return null;
+    const clean = this.safeConversationId(conversationId || "default");
+    const stateKey2 = this.workspaceConversationStateKey(clean);
+    if (!stateKey2) return null;
+    const memoryKey = `${ws.isInternal ? "internal" : "external"}:${path28.resolve(ws.path)}::conversation:${clean}`;
+    const archiveDir = path28.join(ws.path, "archive");
+    const workspacePrefix = this.workspaceConversationPrefix() || "";
+    const archiveMode = this.modeName();
+    const archiveModel = this.model;
+    const cachedStored = this.readStoredConversationState(ws);
+    const stored = JSON.parse(JSON.stringify(cachedStored || {}));
+    const persisted = stored.conversations?.[stateKey2];
+    if (persisted) this.normalizeConversationTree(persisted);
+    const memory = this.workspaceConversations.get(memoryKey);
+    const persistedMessagesAvailable = persisted?.chatMessages !== void 0;
+    const sourceMessages = persisted?.chatMessages ?? memory?.chatMessages ?? [];
+    const sourceHistory = persistedMessagesAvailable ? persisted?.history ?? [] : memory?.history ?? persisted?.history ?? [];
+    const messages = this.normalizeConversationChatMessages(sourceMessages, sourceHistory);
+    const filename = await this.writeSessionArchiveAsync(messages, archiveMode, archiveModel, archiveDir);
+    const archiveEntry = persisted ? JSON.parse(JSON.stringify(persisted)) : {
+      title: this.titleFromMessages(messages, clean),
+      chatMessages: messages,
+      history: sourceHistory,
+      plan: memory?.plan,
+      linkedPlan: memory?.linkedPlan,
+      subagentState: memory?.subagentState,
+      workRuns: memory?.workRuns,
+      continuations: memory?.continuations,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const manifest = {
+      version: 2,
+      kind: "newmark-conversation-archive",
+      archivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      conversationId: clean,
+      workspaceId: ws.id,
+      workspaceName: ws.name,
+      workspacePath: ws.path,
+      workspaceInternal: ws.isInternal,
+      statePrefix: workspacePrefix,
+      entry: this.conversationEntryForDisk(archiveEntry)
+    };
+    const manifestPath = this.archiveManifestPath(path28.join(archiveDir, filename));
+    const manifestTempPath = `${manifestPath}.${process.pid}.${crypto14.randomUUID()}.tmp`;
+    try {
+      await fs25.promises.writeFile(manifestTempPath, JSON.stringify(manifest, null, 2), "utf-8");
+      await fs25.promises.rename(manifestTempPath, manifestPath);
+    } finally {
+      try {
+        await fs25.promises.unlink(manifestTempPath);
+      } catch {
+      }
+    }
+    this.finalizeAsyncConversationArchive(clean, stateKey2, memoryKey, ws);
+    return filename;
+  }
+  finalizeAsyncConversationArchive(clean, stateKey2, memoryKey, ws) {
+    let nextActiveId = "";
+    this.mutateStoredConversationState(ws, (latest) => {
+      latest.conversations = latest.conversations || {};
+      delete latest.conversations[stateKey2];
+      const prefix = stateKey2.slice(0, Math.max(0, stateKey2.length - clean.length - 1)) + "-";
+      const remaining = Object.keys(latest.conversations).filter((key3) => !prefix || key3.startsWith(prefix)).map((key3) => key3.slice(prefix.length)).filter(Boolean);
+      const currentActiveId = this.safeConversationId(latest.activeConversationId || this.activeConversationId || "default");
+      if (clean === currentActiveId) latest.activeConversationId = remaining[0] || "default";
+      nextActiveId = latest.activeConversationId || remaining[0] || "default";
+      return latest;
+    });
+    this.workspaceConversations.delete(memoryKey);
+    const duplicateMemoryKey = `${ws.isInternal ? "internal" : "external"}:${path28.resolve(ws.path)}::conversation:${clean}`;
+    this.workspaceConversations.delete(duplicateMemoryKey);
+    if (clean === this.safeConversationId(this.activeConversationId || "default")) {
+      this.activeConversationId = nextActiveId || "default";
+      this.loadWorkspaceConversationState();
+    }
+  }
   listStoredConversationIds(stored) {
     const prefix = `${this.workspaceConversationPrefix() || ""}-`;
     return Object.keys(stored.conversations || {}).filter((key3) => !prefix || key3.startsWith(prefix)).map((key3) => key3.slice(prefix.length)).filter(Boolean);
@@ -348753,9 +349013,9 @@ ${msg.content}
     const provider = this.config.findProvider(providerId);
     return all.filter((m2) => m2.provider_id === (provider?.id || providerId));
   }
-  async validateModels(selectedNames) {
+  async validateModels(selectedNames, options = {}) {
     if (this.modelValidationPromise) return this.modelValidationPromise;
-    const validation = this.runModelValidation(selectedNames);
+    const validation = this.runModelValidation(selectedNames, options.persist !== false);
     this.modelValidationPromise = validation;
     try {
       return await validation;
@@ -348773,7 +349033,7 @@ ${msg.content}
       recentChecks: this.modelValidationProgress.recentChecks.map((item) => ({ ...item }))
     };
   }
-  async runModelValidation(selectedNames) {
+  async runModelValidation(selectedNames, persist = true) {
     const selectedModels = this.config.modelsForSelections(selectedNames);
     if (!selectedModels.length) {
       this.modelValidationProgress = {
@@ -348791,7 +349051,7 @@ ${msg.content}
     }
     const results = [];
     const catalogByProvider = /* @__PURE__ */ new Map();
-    const cache = new FileModelValidationCache(this.rootPath);
+    const cache = new FileModelValidationCache(this.rootPath, { readOnly: !persist });
     const checksPerModel = 11;
     let currentModel = "";
     let currentModelChecks = 0;
@@ -348923,7 +349183,7 @@ ${msg.content}
         completedModels: this.modelValidationProgress.completedModels + 1
       };
     }
-    this.config.save();
+    if (persist) this.config.save();
     this.modelValidationProgress = {
       ...this.modelValidationProgress,
       running: false,
@@ -349175,7 +349435,8 @@ ${String(input2.content || "").slice(0, 18e3)}`;
       const text = typeof input2 === "string" ? input2 : String(input2.text || "");
       const inputEnvelope = typeof input2 === "string" ? null : input2;
       const hiddenUserInput = inputEnvelope?.hiddenUserInput === true;
-      this.ensureUsableModelSelection();
+      const explicitFixedModel = this.model !== "" && this.model !== "auto";
+      if (!explicitFixedModel) this.ensureUsableModelSelection();
       const clientMessageId = String(inputEnvelope?.clientMessageId || "").trim();
       const inputRunId = String(inputEnvelope?.runId || this.activeWorkRunId || "").trim();
       const rawImages = typeof input2 === "string" ? [] : Array.isArray(input2.images) ? input2.images : [];
@@ -349263,7 +349524,13 @@ ${String(input2.content || "").slice(0, 18e3)}`;
         await this.evaluateAndSwitch(displayText, inputEnvelope?.routePolicy);
       }
       if (this.model && this.modelIsUnavailable(this.model)) {
+        const requestedModel = this.model;
         this.switchToFallbackModel();
+        if (this.modelIsUnavailable(this.model)) {
+          const message = `[Error] Model '${requestedModel || "unknown"}' is unavailable or not configured. Select a configured model or enable a valid provider before sending.`;
+          this.status = "error";
+          throw new Error(message);
+        }
       }
       if (this.engine === "opencode") {
         if (images.length) return [{ type: "text", text: "[Vision unavailable] The OpenCode engine does not accept Newmark image attachments." }];
@@ -350256,11 +350523,11 @@ Falling back to built-in engine.` }];
     }
   }
   async maybeCompress(msgs, provider, signal, compressionModel, force = false) {
-    if (signal?.aborted) return;
-    if (!this.config.getBool("context", "auto_compress")) return;
+    if (signal?.aborted) return false;
+    if (!this.config.getBool("context", "auto_compress")) return false;
     const total = msgs.reduce((sum, m2) => sum + (typeof m2.content === "string" ? m2.content.length : JSON.stringify(m2.content || "").length), 0);
     const budget = this.compressionBudget(msgs);
-    if (budget.estimatedTokens < budget.triggerTokens && !force) return;
+    if (budget.estimatedTokens < budget.triggerTokens && !force) return false;
     if (!force && this.lastCompression && String(msgs[0]?.content || "").includes(this.lastCompression.summary)) {
       const baselineChars = Math.max(0, Number(this.lastCompression.compressedChars || 0));
       const baselineTokens = Math.max(0, Number(this.lastCompression.compressedTokens || 0));
@@ -350268,16 +350535,16 @@ Falling back to built-in engine.` }];
       const tokenGrowth = baselineTokens ? Math.max(0, budget.estimatedTokens - baselineTokens) : Number.POSITIVE_INFINITY;
       const minCharGrowth = Math.max(12e3, Math.floor(baselineChars * 0.25));
       const minTokenGrowth = Math.max(1024, Math.floor(budget.triggerTokens * 0.2));
-      if (charGrowth < minCharGrowth && tokenGrowth < minTokenGrowth) return;
+      if (charGrowth < minCharGrowth && tokenGrowth < minTokenGrowth) return false;
     }
     const originalMessageCount = msgs.length;
     const configuredKeepLast = this.config.getNum("context", "keep_recent_messages") || 10;
-    if (msgs.length <= 1) return;
+    if (msgs.length <= 1) return false;
     const continuationAnchorTokens = this.estimateContextTokens([this.postCompressionContinuationMessage()]);
     const recentBudget = Math.max(64, budget.targetTokens - budget.summaryTokens - continuationAnchorTokens);
     const recent = this.recentContextSuffix(msgs, configuredKeepLast, recentBudget);
     const recentStart = Math.max(0, msgs.length - recent.length);
-    if (recentStart <= 0) return;
+    if (recentStart <= 0) return false;
     const middle = msgs.slice(0, recentStart);
     const currentInstruction = this.latestUserHistoryText(recent);
     const compression = await this.buildCompressionSummary(
@@ -350289,7 +350556,7 @@ Falling back to built-in engine.` }];
       compressionModel || this.activeModelName(),
       currentInstruction
     );
-    if (signal?.aborted) return;
+    if (signal?.aborted) return false;
     const compressed = [{
       role: "system",
       content: compression.summary
@@ -350314,6 +350581,7 @@ Falling back to built-in engine.` }];
     };
     this.pushCompressionCacheEntry(compression.summary, middle, compression.model, compression.fallback);
     this.persistCompressedHistory(compression.summary, recent.length, msgs);
+    return true;
   }
   async buildCompressionSummary(middle, totalChars, budget, provider, signal, compressionModel, currentInstruction = "") {
     const workspacePath = this.workspace.current?.path || this.rootPath;
@@ -351649,7 +351917,12 @@ var ConversationKernel = class {
         if (runtime.runId === runId && runtime.stopRequestedRunId === runId) {
           stopped = true;
         } else {
-          runtime.runner.finishConversationWorkRun(runId, "error");
+          runtime.runner.finishConversationWorkRun(
+            runId,
+            "error",
+            void 0,
+            error instanceof Error ? error.message : String(error)
+          );
           throw error;
         }
       } finally {