newmark-agent 0.3.10 → 0.3.11

package/dist/cli-help.d.ts

@@ -0,0 +1,2 @@
+export declare function newmarkHelpText(version: string): string;
+//# sourceMappingURL=cli-help.d.ts.map

package/dist/cli-help.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newmarkHelpText = newmarkHelpText;
+const cli_commands_1 = require("./cli-commands");
+function newmarkHelpText(version) {
+    return [
+        `Newmark Agent ${version}`,
+        '',
+        'Usage:',
+        '  Newmark Agent.exe [--gui|--TUI|--cli] [--root <dir>]',
+        '  Newmark.exe <command> ...',
+        '  Newmark.exe flow <workflow-name> [start-pc] [--input "text"] [--root <dir>]',
+        '  Newmark.exe edit <file.txt|.json|.tex|.md>',
+        '',
+        (0, cli_commands_1.cliCommandUsage)(),
+        '',
+        'Flags:',
+        '  --help, -h     Show this help and exit.',
+        '  --version, -v  Show the installed version and exit.',
+    ].join('\n');
+}
+//# sourceMappingURL=cli-help.js.map

package/dist/conversation-utility-host.bundle.cjs

@@ -335769,10 +335769,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();
 }
@@ -335857,49 +335949,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;
@@ -336450,7 +336517,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 {
@@ -336464,7 +336531,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") {
@@ -336481,7 +336548,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({
@@ -336522,7 +336589,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": {
@@ -337003,9 +337070,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,
@@ -337015,10 +337090,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) {
@@ -339896,6 +339971,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;
@@ -340007,10 +340086,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();
@@ -340045,6 +340127,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);
@@ -351075,8 +351167,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;
   }
 };
 
@@ -351273,6 +351383,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) {
@@ -351304,6 +351415,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);
@@ -351334,6 +351446,7 @@ var ConversationKernel = class {
       createdAt: deferred.createdAt
     }]);
     this.activateAcceptedGoal(runtime, envelope.goalObjective);
+    this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
     return deferred;
   }
   checkpoint(target) {
@@ -351541,6 +351654,8 @@ var ConversationKernel = class {
           if (runtime.stopRequestedRunId === runId) {
             stopped = true;
             this.settleCooperativeStop(runtime, runId);
+          } else if (runtime.pendingNextTurn.length > 0) {
+            this.schedulePendingRuntimeContinuation(runtime, runId);
           }
         }
       }
@@ -351675,7 +351790,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);
@@ -351747,6 +351863,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);

package/dist/core/agent.js

@@ -8045,10 +8045,28 @@ class GoalStateImpl {
         return s;
     }
     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;
     }
 }
 //# sourceMappingURL=agent.js.map

package/dist/core/agentKernelRunner.js

@@ -205,6 +205,9 @@ class ProviderRunError 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}\n${turn.text}`);
+}
 function removeTrailingFailedAssistant(agent, messages) {
     const last = messages[messages.length - 1];
     if (last?.role !== 'assistant')
@@ -338,10 +341,14 @@ async function runAgentKernel(agent) {
             }
             await kernel.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 {
@@ -380,6 +387,16 @@ async function runAgentKernel(agent) {
         if (modelBeforeKernelRun && modelBeforeKernelRun !== agent.model && !tokens.some(t => t.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, kernel.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);

package/dist/core/browserControl.d.ts

@@ -1,6 +1,14 @@
 export type BrowserControlAction = 'open' | 'snapshot' | 'click' | 'type' | 'eval' | 'back' | 'forward' | 'reload' | 'cdp' | 'use';
+/** Renderer/host routing identity. Browser controls must never fall back to the
+ * currently focused conversation when a caller has a concrete target. */
+export interface BrowserControlTarget {
+    workspaceId?: string;
+    conversationId?: string;
+    runtimeKey?: string;
+}
 export interface BrowserControlRequest {
     action: BrowserControlAction;
+    target?: BrowserControlTarget;
     url?: string;
     selector?: string;
     text?: string;

package/dist/core/browserUsePageAdapter.d.ts

@@ -22,6 +22,8 @@ export interface BrowserUseHostPage {
     }>;
     evaluateFixed<T>(script: string, signal?: AbortSignal): Promise<T>;
     clickAt(x: number, y: number, signal?: AbortSignal): Promise<void>;
+    /** Optional deterministic DOM click for embedded guests where native input can be dropped while the host tab is settling. */
+    clickElement?(token: string, signal?: AbortSignal): Promise<void>;
     replaceFocusedText(text: string, signal?: AbortSignal): Promise<void>;
     pressKey(key: string, signal?: AbortSignal): Promise<void>;
     navigate(url: string, signal?: AbortSignal): Promise<void>;
@@ -46,6 +48,7 @@ export type BrowserUseHostPageResolver = (scope: BrowserUseScope) => Promise<Bro
 export declare function browserUseObservationScript(maxChars: number, maxRefs: number): string;
 export declare function browserUseProbeScript(token: string, scrollIntoView?: boolean): string;
 export declare function browserUseFocusScript(token: string): string;
+export declare function browserUseClickScript(token: string): string;
 export declare function browserUseSelectScript(token: string, value: string): string;
 export declare function browserUseScrollScript(token: string | undefined, deltaX: number, deltaY: number): string;
 export declare function browserUseExtractScript(token: string | undefined, attribute: string | undefined, maxChars: number): string;

package/dist/core/browserUsePageAdapter.js

@@ -4,6 +4,7 @@ exports.NativeBrowserUsePageAdapter = void 0;
 exports.browserUseObservationScript = browserUseObservationScript;
 exports.browserUseProbeScript = browserUseProbeScript;
 exports.browserUseFocusScript = browserUseFocusScript;
+exports.browserUseClickScript = browserUseClickScript;
 exports.browserUseSelectScript = browserUseSelectScript;
 exports.browserUseScrollScript = browserUseScrollScript;
 exports.browserUseExtractScript = browserUseExtractScript;
@@ -186,6 +187,17 @@ function browserUseProbeScript(token, scrollIntoView = false) {
 function browserUseFocusScript(token) {
     return `(() => { const el = document.querySelector(${json(token)}); if (!el) return false; if (typeof el.scrollIntoView === 'function') el.scrollIntoView({ block: 'center', inline: 'nearest', behavior: 'auto' }); el.focus({ preventScroll: true }); return document.activeElement === el || el.contains(document.activeElement); })()`;
 }
+function browserUseClickScript(token) {
+    return `(() => {
+    const el = document.querySelector(${json(token)});
+    if (!el) return { clicked: false, error: 'ref_not_found' };
+    if (typeof el.scrollIntoView === 'function') el.scrollIntoView({ block: 'center', inline: 'nearest', behavior: 'auto' });
+    if (typeof el.focus === 'function') el.focus({ preventScroll: true });
+    if (typeof el.click !== 'function') return { clicked: false, error: 'not_clickable' };
+    el.click();
+    return { clicked: true, tag: String(el.localName || 'element').toLowerCase() };
+  })()`;
+}
 function browserUseSelectScript(token, value) {
     return `(() => {
     const el = document.querySelector(${json(token)});
@@ -299,8 +311,13 @@ class NativeBrowserUsePageAdapter {
                         throw error;
                     }
                     if (request.action === 'click') {
-                        const rect = probe.rect;
-                        await page.clickAt(rect.x + rect.width / 2, rect.y + rect.height / 2, signal);
+                        if (page.clickElement) {
+                            await page.clickElement(request.element.token, signal);
+                        }
+                        else {
+                            const rect = probe.rect;
+                            await page.clickAt(rect.x + rect.width / 2, rect.y + rect.height / 2, signal);
+                        }
                         await page.waitForReady(signal);
                         return { clicked: true };
                     }

package/dist/core/computerUseSession.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Process-wide Computer-Use session state.
+ *
+ * The state is keyed by conversation runtime, not by Build/run id. A Build may finish
+ * or be interrupted/replaced while the conversation keeps its
+ * Computer-Use switch and lease. Only an explicit stop/toggle-off or runtime
+ * teardown releases it.
+ */
+export interface ComputerUseSessionScope {
+    runtimeKey: string;
+    ownerLabel: string;
+    workspacePath?: string;
+}
+export interface ComputerUseSessionState {
+    runtimeKey: string;
+    enabled: boolean;
+    occupied: boolean;
+    ownerLabel?: string;
+    updatedAt?: number;
+}
+export declare const COMPUTER_USE_OCCUPIED_MARKER = "computerUse occupied";
+export declare const COMPUTER_USE_LOCK_TTL_MS: number;
+export declare class ComputerUseSessionRegistry {
+    private readonly ttlMs;
+    private readonly enabledByRuntime;
+    private activeLease;
+    constructor(ttlMs?: number);
+    authorize(action: string, scope: ComputerUseSessionScope, dryRun?: boolean): string | null;
+    complete(action: string, scope: ComputerUseSessionScope): void;
+    setEnabled(scope: ComputerUseSessionScope, enabled: boolean): {
+        ok: true;
+        state: ComputerUseSessionState;
+    } | {
+        ok: false;
+        error: string;
+        state: ComputerUseSessionState;
+    };
+    state(runtimeKey: string): ComputerUseSessionState;
+    cancelTarget(runtimeKey: string): boolean;
+    private clearExpired;
+    private occupiedError;
+}
+export declare const defaultComputerUseSessionRegistry: ComputerUseSessionRegistry;
+//# sourceMappingURL=computerUseSession.d.ts.map