newmark-agent 0.3.10 → 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");
@@ -335773,10 +335851,102 @@ function browserVisualFallback(runtimeKey, observationId) {
   return browserFallbacks.get(key(runtimeKey, observationId)) || null;
 }
 
+// src/core/computerUseSession.ts
+var COMPUTER_USE_OCCUPIED_MARKER = "computerUse occupied";
+var COMPUTER_USE_LOCK_TTL_MS = 10 * 60 * 1e3;
+var ComputerUseSessionRegistry = class {
+  constructor(ttlMs = COMPUTER_USE_LOCK_TTL_MS) {
+    this.ttlMs = ttlMs;
+  }
+  ttlMs;
+  enabledByRuntime = /* @__PURE__ */ new Map();
+  activeLease = null;
+  authorize(action, scope, dryRun = false) {
+    const normalizedAction = String(action || "").trim().toLowerCase();
+    const runtimeKey = String(scope.runtimeKey || "").trim() || "conversation:default";
+    const now2 = Date.now();
+    this.clearExpired(now2);
+    if (this.activeLease && this.activeLease.runtimeKey !== runtimeKey) {
+      return this.occupiedError(normalizedAction, scope.ownerLabel, this.activeLease.ownerLabel);
+    }
+    if (normalizedAction === "takeover_stop") return null;
+    const enabled = this.enabledByRuntime.get(runtimeKey) !== false;
+    const readOnly = normalizedAction === "observe" || normalizedAction === "app_list" || normalizedAction === "app_observe" || normalizedAction === "wait";
+    if (!enabled && !readOnly && !dryRun && normalizedAction !== "takeover_start") {
+      return JSON.stringify({
+        ok: false,
+        action: normalizedAction,
+        error: `ComputerUse is disabled for ${scope.ownerLabel}. Enable ComputerUse for this conversation before sending desktop operations.`,
+        computer_use_enabled: false,
+        requested_owner: scope.ownerLabel
+      }, null, 2);
+    }
+    if (normalizedAction === "takeover_start") this.enabledByRuntime.set(runtimeKey, true);
+    if (!this.activeLease) {
+      this.activeLease = { ...scope, runtimeKey, updatedAt: now2 };
+    } else {
+      this.activeLease.updatedAt = now2;
+    }
+    return null;
+  }
+  complete(action, scope) {
+    const normalizedAction = String(action || "").trim().toLowerCase();
+    const runtimeKey = String(scope.runtimeKey || "").trim() || "conversation:default";
+    if (normalizedAction === "takeover_stop") {
+      if (!this.activeLease || this.activeLease.runtimeKey === runtimeKey) this.activeLease = null;
+      this.enabledByRuntime.set(runtimeKey, false);
+      return;
+    }
+    if (this.activeLease?.runtimeKey === runtimeKey) this.activeLease.updatedAt = Date.now();
+  }
+  setEnabled(scope, enabled) {
+    const runtimeKey = String(scope.runtimeKey || "").trim() || "conversation:default";
+    this.clearExpired();
+    if (this.activeLease && this.activeLease.runtimeKey !== runtimeKey) {
+      return { ok: false, error: this.occupiedError("toggle", scope.ownerLabel, this.activeLease.ownerLabel), state: this.state(runtimeKey) };
+    }
+    this.enabledByRuntime.set(runtimeKey, enabled !== false);
+    if (enabled === false && this.activeLease?.runtimeKey === runtimeKey) this.activeLease = null;
+    return { ok: true, state: this.state(runtimeKey) };
+  }
+  state(runtimeKey) {
+    const key3 = String(runtimeKey || "").trim() || "conversation:default";
+    this.clearExpired();
+    const lease = this.activeLease;
+    return {
+      runtimeKey: key3,
+      enabled: this.enabledByRuntime.get(key3) !== false,
+      occupied: !!lease,
+      ...lease ? { ownerLabel: lease.ownerLabel, updatedAt: lease.updatedAt } : {}
+    };
+  }
+  cancelTarget(runtimeKey) {
+    const key3 = String(runtimeKey || "").trim();
+    if (!key3) return false;
+    const hadActiveLease = this.activeLease?.runtimeKey === key3;
+    if (hadActiveLease) this.activeLease = null;
+    this.enabledByRuntime.set(key3, false);
+    return hadActiveLease;
+  }
+  clearExpired(now2 = Date.now()) {
+    if (this.activeLease && now2 - this.activeLease.updatedAt > this.ttlMs) {
+      this.activeLease = null;
+    }
+  }
+  occupiedError(action, requestedOwner, activeOwner) {
+    return JSON.stringify({
+      ok: false,
+      action,
+      error: `${COMPUTER_USE_OCCUPIED_MARKER}: ComputerUse is already active in ${activeOwner}. Stop it with computer_use takeover_stop or wait before another conversation takes control.`,
+      lock_owner: activeOwner,
+      requested_owner: requestedOwner
+    }, null, 2);
+  }
+};
+var defaultComputerUseSessionRegistry = new ComputerUseSessionRegistry();
+
 // src/tools/index.ts
 var globSync = require_index_min().sync;
-var computerUseLock = null;
-var COMPUTER_USE_LOCK_TTL_MS = 10 * 60 * 1e3;
 function normalizeComputerUseAction(action) {
   return String(action || "").trim().toLowerCase();
 }
@@ -335861,49 +336031,24 @@ async function abortableToolDelay(durationMs, signal) {
     if (signal?.aborted) abort();
   });
 }
-function clearStaleComputerUseLock(now2 = Date.now()) {
-  if (computerUseLock && now2 - computerUseLock.updatedAt > COMPUTER_USE_LOCK_TTL_MS) {
-    computerUseLock = null;
-  }
-}
-function computerUseLockError(action, owner) {
-  return JSON.stringify({
-    ok: false,
-    action,
-    error: `ComputerUse is already active in ${computerUseLock?.owner || "another conversation"}. Stop it with computer_use takeover_stop or wait before using ComputerUse from another conversation.`,
-    lock_owner: computerUseLock?.owner || "",
-    requested_owner: owner
-  }, null, 2);
-}
-function acquireComputerUseLock(action, owner, wsPath) {
-  const now2 = Date.now();
-  clearStaleComputerUseLock(now2);
-  if (computerUseLock && computerUseLock.owner !== owner) {
-    return computerUseLockError(action, owner);
-  }
-  computerUseLock = {
-    owner,
-    workspacePath: path15.resolve(wsPath || process.cwd()),
-    acquiredAt: computerUseLock?.owner === owner ? computerUseLock.acquiredAt : now2,
-    updatedAt: now2
+function computerUseSessionScope(context, wsPath, owner) {
+  return {
+    runtimeKey: browserUseScope(context, wsPath).runtimeKey,
+    ownerLabel: owner,
+    workspacePath: path15.resolve(wsPath || process.cwd())
   };
-  return null;
 }
-function releaseComputerUseLock(action, owner) {
-  clearStaleComputerUseLock();
-  if (computerUseLock && computerUseLock.owner !== owner) {
-    return computerUseLockError(action, owner);
-  }
-  if (computerUseLock?.owner === owner) computerUseLock = null;
-  return null;
+function acquireComputerUseLock(action, owner, wsPath, context = {}, dryRun = false) {
+  return defaultComputerUseSessionRegistry.authorize(action, computerUseSessionScope(context, wsPath, owner), dryRun);
 }
-function assertComputerUseLockOwner(action, owner) {
-  clearStaleComputerUseLock();
-  if (computerUseLock && computerUseLock.owner !== owner) {
-    return computerUseLockError(action, owner);
-  }
+function releaseComputerUseLock(action, owner, context = {}, wsPath = context.workspacePath || "") {
+  const scope = computerUseSessionScope(context, wsPath, owner);
+  defaultComputerUseSessionRegistry.complete(action, scope);
   return null;
 }
+function assertComputerUseLockOwner(action, owner, context = {}, wsPath = context.workspacePath || "") {
+  return defaultComputerUseSessionRegistry.authorize(action, computerUseSessionScope(context, wsPath, owner));
+}
 var ToolExecutor = class {
   constructor(root2, config, ssh, workspace) {
     this.config = config;
@@ -336454,7 +336599,7 @@ var ToolExecutor = class {
         case "computer_use": {
           const action = normalizeComputerUseAction(g2("action"));
           const owner = `${computerUseOwner(context, wsPath)}:${String(context.actorId || "root")}`;
-          const lockGuard = action === "takeover_stop" ? assertComputerUseLockOwner(action, owner) : acquireComputerUseLock(action, owner, wsPath);
+          const lockGuard = action === "takeover_stop" ? assertComputerUseLockOwner(action, owner, context, wsPath) : acquireComputerUseLock(action, owner, wsPath, context, args.dry_run === true);
           if (lockGuard) return lockGuard;
           if (process.env.NEWMARK_WSL_DISTRO) {
             try {
@@ -336468,7 +336613,7 @@ var ToolExecutor = class {
               }, 12e4, context.signal);
               return typeof result === "string" ? result : JSON.stringify(result);
             } finally {
-              if (action === "takeover_stop") releaseComputerUseLock(action, owner);
+              if (action === "takeover_stop") releaseComputerUseLock(action, owner, context, wsPath);
             }
           }
           if (process.env.NEWMARK_ISOLATED_RUNTIME === "1") {
@@ -336485,7 +336630,7 @@ var ToolExecutor = class {
               const result = await requestUtilityHostTool("computer_use", args, trustedComputerUseContext, 12e4, context.signal);
               return typeof result === "string" ? result : JSON.stringify(result);
             } finally {
-              if (action === "takeover_stop") releaseComputerUseLock(action, owner);
+              if (action === "takeover_stop") releaseComputerUseLock(action, owner, context, wsPath);
             }
           }
           const output = await runComputerUse({
@@ -336526,7 +336671,7 @@ var ToolExecutor = class {
               durationMs: Number(step.duration_ms || 0)
             })) : void 0
           });
-          if (action === "takeover_stop") releaseComputerUseLock(action, owner);
+          if (action === "takeover_stop") releaseComputerUseLock(action, owner, context, wsPath);
           return output;
         }
         case "terminal_takeover": {
@@ -337007,9 +337152,17 @@ ${snippet ? clean(snippet[1]) : ""}`.trim());
     }
   }
   async browserRun(request, signal, context = {}, workspacePath = this.root) {
+    const scope = browserUseScope(context, workspacePath);
+    const scopedRequest = {
+      ...request,
+      target: {
+        workspaceId: context.workspaceId || terminalTakeoverWorkspaceId(workspacePath),
+        conversationId: context.conversationId || "default",
+        runtimeKey: scope.runtimeKey
+      }
+    };
     if (process.env.NEWMARK_WSL_DISTRO) {
-      const scope = browserUseScope(context, workspacePath);
-      const result2 = await requestWindowsHostTool("browser_control", request, {
+      const result2 = await requestWindowsHostTool("browser_control", scopedRequest, {
         conversationId: context.conversationId || process.env.NEWMARK_CONVERSATION_ID || "default",
         workspaceId: process.env.NEWMARK_WORKSPACE_ID || context.workspaceId || terminalTakeoverWorkspaceId(workspacePath),
         actorId: context.actorId || ROOT_TERMINAL_ACTOR_ID,
@@ -337019,10 +337172,10 @@ ${snippet ? clean(snippet[1]) : ""}`.trim());
       return this.formatBrowserResult(result2);
     }
     if (process.env.NEWMARK_ISOLATED_RUNTIME === "1") {
-      const result2 = await requestUtilityHostTool("browser_control", request, void 0, 3e4, signal);
+      const result2 = await requestUtilityHostTool("browser_control", scopedRequest, void 0, 3e4, signal);
       return this.formatBrowserResult(result2);
     }
-    const result = await BrowserControl.run(request, signal);
+    const result = await BrowserControl.run(scopedRequest, signal);
     return this.formatBrowserResult(result);
   }
   formatBrowserResult(result) {
@@ -337849,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");
@@ -339900,6 +340066,10 @@ var ProviderRunError = class extends Error {
 function kernelTurnFailed(agent, turn) {
   return turn.stopReason === "error" || agent.isLlmErrorText(turn.text);
 }
+function providerTurnIsEmpty(turn) {
+  return /provider returned an empty response/i.test(`${turn.errorMessage}
+${turn.text}`);
+}
 function removeTrailingFailedAssistant(agent, messages) {
   const last = messages[messages.length - 1];
   if (last?.role !== "assistant") return;
@@ -339935,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 = "";
@@ -339971,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();
@@ -339991,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;
@@ -340011,10 +340218,13 @@ async function runAgentKernel(agent) {
       }
       await kernel2.prompt(promptMessages);
       const assistant = lastAssistant;
+      const text = assistant ? KernelMessageText(assistant) : "";
+      const hasToolCall = !!assistant?.content?.some((content) => content.type === "toolCall");
+      const emptyResponse = !assistant || !text.trim() && !hasToolCall && String(assistant?.stopReason || "") !== "aborted";
       return {
-        text: assistant ? KernelMessageText(assistant) : "",
+        text: emptyResponse ? "[Error] Provider returned an empty response." : text,
         stopReason: String(assistant?.stopReason || ""),
-        errorMessage: String(assistant?.errorMessage || "")
+        errorMessage: String(assistant?.errorMessage || (emptyResponse ? "Provider returned an empty response." : ""))
       };
     } finally {
       unsubscribe();
@@ -340049,6 +340259,16 @@ async function runAgentKernel(agent) {
     if (modelBeforeKernelRun && modelBeforeKernelRun !== agent.model && !tokens.some((t3) => t3.text?.includes("[Model fallback]"))) {
       tokens.unshift({ type: "text", text: `[Model fallback] ${modelBeforeKernelRun} unavailable; switched to ${agent.model}.` });
     }
+    let emptyResponseRetries = 0;
+    while (providerTurnIsEmpty(lastTurn) && emptyResponseRetries < 2) {
+      removeTrailingFailedAssistant(agent, kernel2.state.messages);
+      emptyResponseRetries += 1;
+      const notice = `[Model retry] Provider returned an empty response; retrying the same deployment (${emptyResponseRetries}/2).`;
+      tokens.push({ type: "text", text: notice });
+      agent.recordWorkStatus(notice);
+      await agent.waitForPlannedRouteRetry();
+      lastTurn = await runWithCompressionResume([], false);
+    }
     let routeRetries = 0;
     while (kernelTurnFailed(agent, lastTurn) && routeRetries < 2) {
       const previous = agent.switchToFallbackModel(lastTurn.errorMessage || lastTurn.text);
@@ -340081,6 +340301,7 @@ async function runAgentKernel(agent) {
       else agent.pendingOptions = agent.pendingOptions.filter((question) => !isPlanExecutionQuestion(question));
     }
   } finally {
+    detachProcessAbort();
     agent.attachAgentKernelRuntime(null);
   }
   agent.status = "idle";
@@ -340247,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();
@@ -342151,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) {
@@ -342162,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() {
@@ -344041,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;
@@ -344572,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;
@@ -345689,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);
@@ -345733,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,
@@ -345878,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);
@@ -347039,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) {
@@ -348032,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}
 
@@ -348062,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);
@@ -348136,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);
@@ -348661,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;
@@ -348681,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 = {
@@ -348699,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;
@@ -348831,7 +349183,7 @@ ${msg.content}
         completedModels: this.modelValidationProgress.completedModels + 1
       };
     }
-    this.config.save();
+    if (persist) this.config.save();
     this.modelValidationProgress = {
       ...this.modelValidationProgress,
       running: false,
@@ -349083,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 : [];
@@ -349171,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." }];
@@ -350164,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));
@@ -350176,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(
@@ -350197,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
@@ -350222,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;
@@ -351079,8 +351439,26 @@ var GoalStateImpl = class {
     return s3;
   }
   checkComplete(response) {
-    const lower = response.toLowerCase();
-    return lower.includes("goal complete") || lower.includes("objective achieved") || lower.includes("task finished") || lower.includes("all done") || lower.includes("goal accomplished");
+    const lines = String(response || "").replace(/\r\n?/g, "\n").split("\n");
+    const completionMarkers = "(?:goal\\s+complete|objective\\s+achieved|task\\s+finished|all\\s+done|goal\\s+accomplished)";
+    const explicitLinePatterns = [
+      new RegExp(`^\\s*(?:[*#_~\\-]+\\s*)*(?:\\[\\s*)?${completionMarkers}(?:\\s*\\])?(?=\\s|[!.,:;]|$)`, "i"),
+      /^\s*(?:[*#_~\-]+\s*)*(?:i|we)\s+(?:have\s+)?(?:now\s+)?(?:fully\s+)?(?:completed|finished|achieved|accomplished)\s+(?:the\s+)?(?:goal|objective|task)\b/i,
+      /^\s*(?:[*#_~\-]+\s*)*(?:the\s+)?(?:goal|objective|task)\s+(?:is|was)\s+(?:now\s+)?(?:complete|achieved|finished|accomplished)\b/i
+    ];
+    const completionContext = new RegExp(completionMarkers, "i");
+    const deferredBefore = new RegExp(`\\b(?:must|will|should|would|can|could)\\s+(?:still\\s+)?(?:contain(?:s|ed)?|include(?:s|d)?|say|state|use|write|appear)\\b.{0,180}${completionMarkers}`, "i");
+    const negatedBefore = new RegExp(`\\b(?:not|isn't|is not|never|don't|do not|won't|will not)\\b.{0,180}${completionMarkers}`, "i");
+    const pendingBefore = new RegExp(`\\b(?:one\\s+step\\s+remains|still\\s+required|one\\s+more\\s+(?:step|call|turn)|not\\s+(?:the\\s+)?final)\\b.{0,180}${completionMarkers}`, "i");
+    const deferredAfter = new RegExp(`${completionMarkers}.{0,180}\\b(?:not\\s+(?:the\\s+)?final|not\\s+yet|one\\s+more\\s+model\\s+call|next\\s+(?:call|step)|not\\s+done)\\b`, "i");
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index];
+      if (!explicitLinePatterns.some((pattern) => pattern.test(line))) continue;
+      const context = lines.slice(Math.max(0, index - 2), Math.min(lines.length, index + 3)).join(" ");
+      if (completionContext.test(context) && (deferredBefore.test(context) || negatedBefore.test(context) || pendingBefore.test(context) || deferredAfter.test(context))) continue;
+      return true;
+    }
+    return false;
   }
 };
 
@@ -351277,6 +351655,7 @@ var ConversationKernel = class {
       runtime.runner.recordGuideReceipt(deferred2);
       this.emitQueueUpdate(runtime);
       this.activateAcceptedGoal(runtime, envelope.goalObjective);
+      this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
       return deferred2;
     }
     if (runtime.guideAcceptanceClosedRunId === runtime.runId) {
@@ -351308,6 +351687,7 @@ var ConversationKernel = class {
         createdAt: deferred2.createdAt
       }]);
       this.activateAcceptedGoal(runtime, envelope.goalObjective);
+      this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
       return deferred2;
     }
     const queued = runtime.runner.queueActiveKernelMessage(safeEnvelope.text, "steer", clientMessageId, runtime.runId, safeEnvelope.images);
@@ -351338,6 +351718,7 @@ var ConversationKernel = class {
       createdAt: deferred.createdAt
     }]);
     this.activateAcceptedGoal(runtime, envelope.goalObjective);
+    this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
     return deferred;
   }
   checkpoint(target) {
@@ -351536,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 {
@@ -351545,6 +351931,8 @@ var ConversationKernel = class {
           if (runtime.stopRequestedRunId === runId) {
             stopped = true;
             this.settleCooperativeStop(runtime, runId);
+          } else if (runtime.pendingNextTurn.length > 0) {
+            this.schedulePendingRuntimeContinuation(runtime, runId);
           }
         }
       }
@@ -351679,7 +352067,8 @@ Review this persisted peer result and summarize or continue the parent task as n
       guideAcceptanceClosedRunId: "",
       guideReceipts: /* @__PURE__ */ new Map(),
       guideEnvelopes: /* @__PURE__ */ new Map(),
-      goalContinuationTimer: void 0
+      goalContinuationTimer: void 0,
+      pendingContinuationRunId: void 0
     };
     runner.setGoalContinuationGate(() => {
       this.queueState(runtime);
@@ -351751,6 +352140,28 @@ Review this persisted peer result and summarize or continue the parent task as n
       });
     }, 250);
   }
+  schedulePendingRuntimeContinuation(runtime, runId) {
+    if (runtime.pendingContinuationRunId === runId) return;
+    runtime.pendingContinuationRunId = runId;
+    const active = runtime.activePromise;
+    if (active) {
+      const continueAfterSettlement = () => {
+        runtime.pendingContinuationRunId = void 0;
+        this.schedulePendingRuntimeContinuation(runtime, runId);
+      };
+      void active.then(continueAfterSettlement, continueAfterSettlement);
+      return;
+    }
+    setImmediate(() => {
+      runtime.pendingContinuationRunId = void 0;
+      if (runtime.runId !== runId || runtime.activePromise || runtime.stopRequestedRunId === runId) return;
+      const next = runtime.pendingNextTurn.shift();
+      if (!next) return;
+      const message = typeof next.message === "string" ? { text: next.message, runId } : { ...next.message, runId: next.message.runId || runId };
+      void this.prompt(message, runtime.target, runtime.options, next.queueMode).catch(() => {
+      });
+    });
+  }
   startGoalDrivenBuild(runtime) {
     if (runtime.goalContinuationTimer) {
       clearTimeout(runtime.goalContinuationTimer);