newmark-agent 0.3.8 → 0.3.11

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);
@@ -401,7 +418,7 @@ async function runAgentKernel(agent) {
             throw new ProviderRunError(normalizePublicProviderError(lastTurn.errorMessage || lastTurn.text, [agent.activeModelConfig()?.api_key]));
         }
         const lastAssistant = lastTurn.text;
-        if (agent.mode === 'goal' && agent.goal && agent.goal.checkComplete(lastAssistant)) {
+        if (agent.mode === 'goal' && agent.goal && !agent.goal.paused && agent.goal.checkComplete(lastAssistant)) {
             agent.markGoalComplete();
             if (!tokens.some(token => token.type === 'text' && /goal complete/i.test(token.text || ''))) {
                 tokens.push({ type: 'text', text: '\n[Goal Complete]' });

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/compressionHistoryArchive.d.ts

@@ -0,0 +1,28 @@
+export interface ArchivedCompressionEntry {
+    id: string;
+    at: string;
+    summary: string;
+    messages: Array<Record<string, unknown>>;
+    foldedEntries: number;
+    foldedChars: number;
+    model: string;
+    fallback: boolean;
+}
+/**
+ * Append-only cold storage for folded context segments evicted from the small
+ * in-state hot cache. The archive is never injected into a model request;
+ * callers must explicitly search/read/restore one bounded segment.
+ */
+export declare class CompressionHistoryArchive {
+    private readonly rootPath;
+    constructor(rootPath: string);
+    private file;
+    private append;
+    archive(scopeKey: string, entry: ArchivedCompressionEntry): void;
+    markRestored(scopeKey: string, id: string): void;
+    /** Replays the append-only ledger and returns only currently restorable entries. */
+    activeEntries(scopeKey: string): ArchivedCompressionEntry[];
+    /** Includes restored/tombstoned ids so a restart never reuses an archive id. */
+    maxNumericId(scopeKey: string): number;
+}
+//# sourceMappingURL=compressionHistoryArchive.d.ts.map

package/dist/core/compressionHistoryArchive.js

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionHistoryArchive = void 0;
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Append-only cold storage for folded context segments evicted from the small
+ * in-state hot cache. The archive is never injected into a model request;
+ * callers must explicitly search/read/restore one bounded segment.
+ */
+class CompressionHistoryArchive {
+    rootPath;
+    constructor(rootPath) {
+        this.rootPath = rootPath;
+    }
+    file(scopeKey) {
+        const digest = crypto.createHash('sha256').update(scopeKey).digest('hex');
+        return path.join(this.rootPath, '.newmark-context-v2', 'compression-history', `${digest}.jsonl`);
+    }
+    append(scopeKey, event) {
+        const file = this.file(scopeKey);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.appendFileSync(file, `${JSON.stringify(event)}\n`, 'utf-8');
+    }
+    archive(scopeKey, entry) {
+        this.append(scopeKey, {
+            version: 1,
+            type: 'fold',
+            at: new Date().toISOString(),
+            entry: { ...entry, messages: entry.messages.map(message => ({ ...message })) },
+        });
+    }
+    markRestored(scopeKey, id) {
+        this.append(scopeKey, { version: 1, type: 'restore', at: new Date().toISOString(), id });
+    }
+    /** Replays the append-only ledger and returns only currently restorable entries. */
+    activeEntries(scopeKey) {
+        const file = this.file(scopeKey);
+        if (!fs.existsSync(file))
+            return [];
+        const active = new Map();
+        const lines = fs.readFileSync(file, 'utf-8').split(/\r?\n/);
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                if (event.version !== 1)
+                    continue;
+                if (event.type === 'restore') {
+                    active.delete(String(event.id || ''));
+                    continue;
+                }
+                if (event.type !== 'fold' || !event.entry || typeof event.entry !== 'object')
+                    continue;
+                const candidate = event.entry;
+                if (!candidate.id || !Array.isArray(candidate.messages) || typeof candidate.summary !== 'string')
+                    continue;
+                active.set(candidate.id, {
+                    ...candidate,
+                    messages: candidate.messages.map(message => ({ ...message })),
+                    foldedEntries: Math.max(0, Number(candidate.foldedEntries) || candidate.messages.length),
+                    foldedChars: Math.max(0, Number(candidate.foldedChars) || 0),
+                    model: String(candidate.model || 'unknown'),
+                    fallback: Boolean(candidate.fallback),
+                });
+            }
+            catch {
+                // A partial/corrupt line must not hide earlier valid append-only events.
+            }
+        }
+        return [...active.values()];
+    }
+    /** Includes restored/tombstoned ids so a restart never reuses an archive id. */
+    maxNumericId(scopeKey) {
+        const file = this.file(scopeKey);
+        if (!fs.existsSync(file))
+            return 0;
+        let max = 0;
+        for (const line of fs.readFileSync(file, 'utf-8').split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                const entry = event.entry && typeof event.entry === 'object' ? event.entry : null;
+                const id = String(entry?.id || event.id || '');
+                max = Math.max(max, Number(id.replace(/^ctx-cache-/, '')) || 0);
+            }
+            catch {
+                // Ignore only the malformed line; valid earlier ids remain authoritative.
+            }
+        }
+        return max;
+    }
+}
+exports.CompressionHistoryArchive = CompressionHistoryArchive;
+//# sourceMappingURL=compressionHistoryArchive.js.map

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

package/dist/core/computerUseSession.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultComputerUseSessionRegistry = exports.ComputerUseSessionRegistry = exports.COMPUTER_USE_LOCK_TTL_MS = exports.COMPUTER_USE_OCCUPIED_MARKER = void 0;
+exports.COMPUTER_USE_OCCUPIED_MARKER = 'computerUse occupied';
+exports.COMPUTER_USE_LOCK_TTL_MS = 10 * 60 * 1000;
+class ComputerUseSessionRegistry {
+    ttlMs;
+    enabledByRuntime = new Map();
+    activeLease = null;
+    constructor(ttlMs = exports.COMPUTER_USE_LOCK_TTL_MS) {
+        this.ttlMs = ttlMs;
+    }
+    authorize(action, scope, dryRun = false) {
+        const normalizedAction = String(action || '').trim().toLowerCase();
+        const runtimeKey = String(scope.runtimeKey || '').trim() || 'conversation:default';
+        const now = Date.now();
+        this.clearExpired(now);
+        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: now };
+        }
+        else {
+            this.activeLease.updatedAt = now;
+        }
+        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 key = String(runtimeKey || '').trim() || 'conversation:default';
+        this.clearExpired();
+        const lease = this.activeLease;
+        return {
+            runtimeKey: key,
+            enabled: this.enabledByRuntime.get(key) !== false,
+            occupied: !!lease,
+            ...(lease ? { ownerLabel: lease.ownerLabel, updatedAt: lease.updatedAt } : {}),
+        };
+    }
+    cancelTarget(runtimeKey) {
+        const key = String(runtimeKey || '').trim();
+        if (!key)
+            return false;
+        const hadActiveLease = this.activeLease?.runtimeKey === key;
+        if (hadActiveLease)
+            this.activeLease = null;
+        this.enabledByRuntime.set(key, false);
+        return hadActiveLease;
+    }
+    clearExpired(now = Date.now()) {
+        if (this.activeLease && now - this.activeLease.updatedAt > this.ttlMs) {
+            this.activeLease = null;
+        }
+    }
+    occupiedError(action, requestedOwner, activeOwner) {
+        return JSON.stringify({
+            ok: false,
+            action,
+            error: `${exports.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);
+    }
+}
+exports.ComputerUseSessionRegistry = ComputerUseSessionRegistry;
+exports.defaultComputerUseSessionRegistry = new ComputerUseSessionRegistry();
+//# sourceMappingURL=computerUseSession.js.map

package/dist/core/config.js

@@ -913,6 +913,7 @@ function defaultConfig() {
             keep_recent_messages: { _description: "Keep recent messages", _type: "integer", value: 10 },
             preserve_recent_messages: { _description: "dev-0.3.8 protected recent-message zone for context_history_manage (0 disables)", _type: "integer", value: 5 },
             compression_cache_max: { _description: "dev-0.3.8 max folded-segment cache entries retained for restore/search", _type: "integer", value: 8 },
+            compression_archive_enabled: { _description: "dev-0.3.9 append-only cold archive for folded segments evicted from the hot cache", _type: "boolean", value: true },
             structured_context_v2: { _description: "dev-0.3.0 structured context v2 (orchestrator + fixed order + snapshot)", _type: "boolean", value: true },
             build_history_persistence: { _description: "dev-0.3.0 append-only Build History persistence", _type: "boolean", value: true },
             branch_log_v2: { _description: "dev-0.3.0 branch long-log v2 (epoch summaries)", _type: "boolean", value: true },

package/dist/core/conversationKernel.d.ts

@@ -198,7 +198,7 @@ export declare class ConversationKernel {
     setWorkRunExpanded(target: ConversationTargetInput, runId: string, expanded: boolean): boolean;
     setInputMode(target: ConversationTargetInput, mode: string): 'guide' | 'next';
     setMode(target: ConversationTargetInput, mode: AgentMode): AgentMode;
-    toggleGoalPause(target: ConversationTargetInput): boolean;
+    toggleGoalPause(target: ConversationTargetInput): Promise<boolean>;
     clearGoal(target: ConversationTargetInput): boolean;
     updateSetting(section: string, key: string, value: unknown): void;
     runtimeState(target: ConversationTargetInput): ConversationRuntimeState | null;
@@ -212,6 +212,8 @@ export declare class ConversationKernel {
     private processTimeoutMs;
     private runtime;
     private scheduleGoalContinuation;
+    private schedulePendingRuntimeContinuation;
+    private startGoalDrivenBuild;
     private createRunner;
     private enqueueRootInboxWake;
     private applyOptions;

package/dist/core/conversationKernel.js

@@ -217,6 +217,7 @@ class ConversationKernel {
             runtime.runner.recordGuideReceipt(deferred);
             this.emitQueueUpdate(runtime);
             this.activateAcceptedGoal(runtime, envelope.goalObjective);
+            this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
             return deferred;
         }
         if (runtime.guideAcceptanceClosedRunId === runtime.runId) {
@@ -248,6 +249,7 @@ class ConversationKernel {
                     createdAt: deferred.createdAt,
                 }]);
             this.activateAcceptedGoal(runtime, envelope.goalObjective);
+            this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
             return deferred;
         }
         const queued = runtime.runner.queueActiveKernelMessage(safeEnvelope.text, 'steer', clientMessageId, runtime.runId, safeEnvelope.images);
@@ -278,6 +280,7 @@ class ConversationKernel {
                 createdAt: deferred.createdAt,
             }]);
         this.activateAcceptedGoal(runtime, envelope.goalObjective);
+        this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
         return deferred;
     }
     checkpoint(target) {
@@ -333,11 +336,26 @@ class ConversationKernel {
             runtime.options.mode = mode;
         return runner.mode;
     }
-    toggleGoalPause(target) {
+    async toggleGoalPause(target) {
         const normalized = this.normalizeTarget(target);
-        const runtime = this.findRuntime(normalized);
-        const runner = runtime?.runner || this.createRunner(normalized);
-        return runner.toggleGoalPause();
+        let runtime = this.findRuntime(normalized);
+        if (!runtime) {
+            const runner = this.createRunner(normalized);
+            runtime = this.runtime(normalized, {
+                mode: runner.mode,
+                model: runner.model,
+                intelligence: runner.intelligence,
+                inputMode: runner.inputMode,
+                engine: runner.engine,
+            }, runner);
+        }
+        const wasPaused = runtime.runner.isGoalPaused();
+        const hadGoal = !!runtime.runner.goal;
+        const paused = runtime.runner.toggleGoalPause();
+        if (hadGoal && wasPaused && !paused)
+            this.startGoalDrivenBuild(runtime);
+        this.mirrorHostIfTargetActive(runtime);
+        return paused;
     }
     clearGoal(target) {
         const normalized = this.normalizeTarget(target);
@@ -401,6 +419,7 @@ class ConversationKernel {
         }
         runtime.stopRequestedRunId = runtime.runId;
         runtime.forceStopArmedRunId = runtime.runId;
+        runtime.runner.pauseGoalForUserInterrupt();
         this.retainUnconsumedKernelMessages(runtime);
         this.deferOutstandingGuides(runtime);
         const checkpointed = this.checkpoint(runtime.target).checkpointed;
@@ -491,6 +510,12 @@ class ConversationKernel {
                         stopped = true;
                         this.settleCooperativeStop(runtime, runId);
                     }
+                    else if (runtime.pendingNextTurn.length > 0) {
+                        // A renderer/IPC Guide can arrive after the final-drain barrier's
+                        // last check but before this promise settles. Do not leave the
+                        // deferred continuation queued on an idle runtime.
+                        this.schedulePendingRuntimeContinuation(runtime, runId);
+                    }
                 }
             }
             if (!stopped && runtime.runId === runId)
@@ -610,7 +635,7 @@ class ConversationKernel {
             return 0;
         return Math.max(1000, Math.floor(raw));
     }
-    runtime(target, options) {
+    runtime(target, options, runnerOverride) {
         const existing = this.findRuntime(target);
         if (existing) {
             this.ensureRuntimeMetadata(existing, target);
@@ -618,7 +643,7 @@ class ConversationKernel {
             return existing;
         }
         const id = target.conversationId;
-        const runner = this.createRunner(target);
+        const runner = runnerOverride || this.createRunner(target);
         runner.setAutomationManager(this.automation);
         this.applyOptions(runner, options);
         const runtime = {
@@ -640,6 +665,7 @@ class ConversationKernel {
             guideReceipts: new Map(),
             guideEnvelopes: new Map(),
             goalContinuationTimer: undefined,
+            pendingContinuationRunId: undefined,
         };
         runner.setGoalContinuationGate(() => {
             this.queueState(runtime);
@@ -732,8 +758,51 @@ class ConversationKernel {
             });
         }, 250);
     }
+    schedulePendingRuntimeContinuation(runtime, runId) {
+        if (runtime.pendingContinuationRunId === runId)
+            return;
+        runtime.pendingContinuationRunId = runId;
+        const active = runtime.activePromise;
+        if (active) {
+            const continueAfterSettlement = () => {
+                runtime.pendingContinuationRunId = undefined;
+                this.schedulePendingRuntimeContinuation(runtime, runId);
+            };
+            void active.then(continueAfterSettlement, continueAfterSettlement);
+            return;
+        }
+        setImmediate(() => {
+            runtime.pendingContinuationRunId = undefined;
+            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(() => {
+                // Agent.process and the work-run finalizer already publish the error.
+            });
+        });
+    }
+    startGoalDrivenBuild(runtime) {
+        if (runtime.goalContinuationTimer) {
+            clearTimeout(runtime.goalContinuationTimer);
+            runtime.goalContinuationTimer = undefined;
+        }
+        const message = runtime.runner.claimGoalContinuationMessage({ force: true });
+        if (!message)
+            return;
+        void this.prompt(message, runtime.target, { ...runtime.options, mode: 'goal' }, 'followUp').catch(() => {
+            // Agent.process records and publishes the Build error.
+        });
+    }
     createRunner(target) {
-        const runner = this.lifecycle.createRunner?.(target) || new agent_1.Agent(this.root, { actorId: this.host.runtimeActorId });
+        const runner = this.lifecycle.createRunner?.(target) || new agent_1.Agent(this.root, {
+            actorId: this.host.runtimeActorId,
+            runtimeLifecycleRole: this.host.runtimeLifecycleRole,
+        });
         if (target.workspace) {
             runner.workspace.current = {
                 id: target.workspace.id,

package/dist/core/electronBrowserUseHost.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ElectronBrowserUseHost = void 0;
+const browserUsePageAdapter_1 = require("./browserUsePageAdapter");
 const SAFE_NAVIGATION = /^(?:https?:|about:blank|newmark-preview:)/i;
 const BROWSER_USE_WORLD_ID = 999;
 /**
@@ -94,12 +95,27 @@ class ElectronBrowserUseHost {
             evaluateFixed: async (script, signal) => await raceWithAbort(contents.executeJavaScriptInIsolatedWorld(BROWSER_USE_WORLD_ID, [{ code: script }], true), signal),
             clickAt: async (x, y, signal) => {
                 throwIfAborted(signal);
+                // A webview guest can retain the DOM focus while its embedder is still
+                // committing a workspace/tab transition. Focus both sides and yield
+                // between native input events so Chromium receives a real click rather
+                // than a synchronously queued sequence that can be dropped by the guest.
+                contents.hostWebContents?.focus();
                 contents.focus();
+                await abortableDelay(10, signal);
                 const point = { x: Math.max(0, Math.round(x)), y: Math.max(0, Math.round(y)) };
                 contents.sendInputEvent({ type: 'mouseMove', ...point });
+                await abortableDelay(10, signal);
                 contents.sendInputEvent({ type: 'mouseDown', button: 'left', clickCount: 1, ...point });
+                await abortableDelay(10, signal);
                 contents.sendInputEvent({ type: 'mouseUp', button: 'left', clickCount: 1, ...point });
+                await abortableDelay(10, signal);
             },
+            clickElement: contents.getType() === 'webview' ? async (token, signal) => {
+                throwIfAborted(signal);
+                const result = await raceWithAbort(contents.executeJavaScriptInIsolatedWorld(BROWSER_USE_WORLD_ID, [{ code: (0, browserUsePageAdapter_1.browserUseClickScript)(token) }], true), signal);
+                if (!result?.clicked)
+                    throw new Error(result?.error || 'Unable to click the observed Browser-Use element.');
+            } : undefined,
             replaceFocusedText: async (text, signal) => {
                 throwIfAborted(signal);
                 contents.focus();