newmark-agent 0.3.10 → 0.3.12

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

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

@@ -81,7 +81,10 @@ export declare class ConfigManager {
     rootPath: string;
     private config;
     private workspaceOverrides;
-    constructor(rootPath: string);
+    private readonly readOnly;
+    constructor(rootPath: string, options?: {
+        readOnly?: boolean;
+    });
     reload(): void;
     private load;
     get<T = unknown>(section: string, key: string): T | undefined;
@@ -153,7 +156,9 @@ export interface ModelValidationSummary {
         message: string;
     };
 }
-export declare function ensureRootConfig(rootPath: string): void;
+export declare function ensureRootConfig(rootPath: string, options?: {
+    readOnly?: boolean;
+}): void;
 export declare function inferProviderProtocol(name: string, baseUrl: string): ProviderProtocol;
 export declare function normalizeProviderProtocol(value: unknown, name: string, baseUrl: string): ProviderProtocol;
 export declare function defaultProviderBaseUrl(protocol: ProviderProtocol): string;

package/dist/core/config.js

@@ -64,8 +64,10 @@ class ConfigManager {
     rootPath;
     config;
     workspaceOverrides;
-    constructor(rootPath) {
+    readOnly;
+    constructor(rootPath, options = {}) {
         this.rootPath = rootPath;
+        this.readOnly = options.readOnly === true;
         this.workspaceOverrides = new Map();
         this.config = this.load();
     }
@@ -80,6 +82,8 @@ class ConfigManager {
                 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);
                 }
@@ -87,7 +91,8 @@ class ConfigManager {
                     // Provider ids are routing identities, so legacy/malformed catalogs must
                     // not wait for an unrelated settings save before becoming collision-safe.
                     try {
-                        fs.writeFileSync(cp, JSON.stringify(normalized, null, 2), 'utf-8');
+                        if (!this.readOnly)
+                            fs.writeFileSync(cp, JSON.stringify(normalized, null, 2), 'utf-8');
                     }
                     catch {
                         // A read-only root may still be used for this process. The normalized
@@ -97,6 +102,8 @@ class ConfigManager {
                 return normalized;
             }
             catch {
+                if (this.readOnly)
+                    return defaultConfig();
                 this.backupConfig(cp, 'invalid-json');
                 return this.writeRecoveredConfig(cp);
             }
@@ -146,10 +153,14 @@ class ConfigManager {
         this.config[section][key] = { value: normalizedValue };
     }
     save() {
+        if (this.readOnly)
+            return;
         const j = JSON.stringify(this.config, null, 2);
         fs.writeFileSync(path.join(this.rootPath, 'config.json'), j, 'utf-8');
     }
     saveTo(targetPath) {
+        if (this.readOnly)
+            return;
         const j = JSON.stringify(this.config, null, 2);
         fs.writeFileSync(targetPath, j, 'utf-8');
     }
@@ -393,12 +404,16 @@ class ConfigManager {
         return providers;
     }
     writeRecoveredConfig(configPath) {
+        if (this.readOnly)
+            return defaultConfig();
         const config = loadExampleConfig();
         fs.mkdirSync(path.dirname(configPath), { recursive: true });
         fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
         return config;
     }
     backupConfig(configPath, reason) {
+        if (this.readOnly)
+            return;
         try {
             if (!fs.existsSync(configPath))
                 return;
@@ -412,13 +427,13 @@ class ConfigManager {
     }
 }
 exports.ConfigManager = ConfigManager;
-function ensureRootConfig(rootPath) {
+function ensureRootConfig(rootPath, options = {}) {
     const configPath = path.join(rootPath, 'config.json');
     if (fs.existsSync(configPath)) {
-        new ConfigManager(rootPath);
+        new ConfigManager(rootPath, options);
         return;
     }
-    new ConfigManager(rootPath).save();
+    new ConfigManager(rootPath, options).save();
 }
 function normalizeConfigShape(raw, withDefaults) {
     const base = withDefaults ? defaultConfig() : {};
@@ -827,7 +842,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 },
         },

package/dist/core/conversationKernel.d.ts

@@ -212,6 +212,7 @@ export declare class ConversationKernel {
     private processTimeoutMs;
     private runtime;
     private scheduleGoalContinuation;
+    private schedulePendingRuntimeContinuation;
     private startGoalDrivenBuild;
     private createRunner;
     private enqueueRootInboxWake;

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) {
@@ -496,7 +499,7 @@ class ConversationKernel {
                     stopped = true;
                 }
                 else {
-                    runtime.runner.finishConversationWorkRun(runId, 'error');
+                    runtime.runner.finishConversationWorkRun(runId, 'error', undefined, error instanceof Error ? error.message : String(error));
                     throw error;
                 }
             }
@@ -507,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)
@@ -656,6 +665,7 @@ class ConversationKernel {
             guideReceipts: new Map(),
             guideEnvelopes: new Map(),
             goalContinuationTimer: undefined,
+            pendingContinuationRunId: undefined,
         };
         runner.setGoalContinuationGate(() => {
             this.queueState(runtime);
@@ -748,6 +758,34 @@ 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);

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;
 /**
@@ -109,6 +110,12 @@ class ElectronBrowserUseHost {
                 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();

package/dist/core/electronUtilityAgentClient.js

@@ -473,6 +473,70 @@ async function snapshotWindowsProcessTree(rootPid, timeoutMs = WINDOWS_TREE_SNAP
 function delay(ms) {
     return new Promise(resolve => setTimeout(resolve, Math.max(0, ms)));
 }
+function processRootIsAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * A graceful utility shutdown can make Electron's UtilityProcess.kill() return
+ * false before the child exit event is delivered.  On Windows the captured
+ * root creation identity lets us prove that the root and every owned
+ * descendant are gone without falling back to an unscoped PID kill.
+ */
+async function confirmWindowsUtilityProcessTreeStopped(pid, expectedRootCreationIdentity, options, ownerKey) {
+    if (process.platform !== 'win32' || !Number.isInteger(pid) || pid <= 0 || !/^\d+$/.test(expectedRootCreationIdentity))
+        return false;
+    const snapshotter = options.snapshot || snapshotWindowsProcessTree;
+    const deadline = Date.now() + Math.min(WINDOWS_TREE_FORCE_STOP_DEADLINE_MS, Math.max(1, Math.floor(options.forceStopDeadlineMs ?? WINDOWS_TREE_FORCE_STOP_DEADLINE_MS)));
+    const maxRescans = Math.max(2, Math.floor(options.maxRescans ?? WINDOWS_TREE_MAX_RESCANS));
+    const stableRequired = Math.max(2, Math.min(maxRescans, Math.floor(options.stableEmptyRescans ?? WINDOWS_TREE_STABLE_EMPTY_RESCANS)));
+    const syntheticRoot = {
+        pid,
+        parentPid: 0,
+        depth: 0,
+        creationIdentity: expectedRootCreationIdentity,
+    };
+    let stableEmpty = 0;
+    for (let scan = 0; scan < maxRescans; scan++) {
+        try {
+            if (scan > 0)
+                await withinWindowsTreeDeadline(delay(options.rescanDelayMs ?? WINDOWS_TREE_RESCAN_DELAY_MS), deadline, 'graceful-stop rescan delay');
+            const snapshot = await withinWindowsTreeDeadline(snapshotter(pid, remainingWindowsTreeBudget(deadline, options.rescanTimeoutMs ?? WINDOWS_TREE_RESCAN_TIMEOUT_MS, 'graceful-stop rescan', !options.snapshot), [pid], ownerKey), deadline, 'graceful-stop rescan');
+            const root = snapshot.entries.find(entry => entry.pid === pid);
+            if (root && root.creationIdentity !== expectedRootCreationIdentity)
+                return false;
+            if (!snapshot.entries.length) {
+                stableEmpty += 1;
+                if (stableEmpty >= stableRequired)
+                    return true;
+                continue;
+            }
+            // The root may have exited while a child was still observable through
+            // its parent PID. Add only the already-captured root identity so the
+            // normal identity/quiescence gate can safely terminate the survivor.
+            const captured = root
+                ? snapshot
+                : { rootPid: pid, entries: [syntheticRoot, ...snapshot.entries] };
+            await terminateCapturedWindowsProcessTree(captured, {
+                ...options,
+                helperOwnerKey: ownerKey,
+                forceStopDeadlineMs: Math.max(1, deadline - Date.now()),
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
 function remainingWindowsTreeBudget(deadline, capMs, label, reserveHelperClose = false) {
     const remaining = deadline - Date.now() - (reserveHelperClose ? WINDOWS_HELPER_CLOSE_GRACE_MS + 75 : 0);
     if (remaining < 100)
@@ -1014,6 +1078,20 @@ class ElectronUtilityAgentClient {
             if (exited && this.child === child)
                 this.detachChild(child, new Error('Electron utility runtime stopped'));
             else if (!exited) {
+                const rootIdentity = this.childRootIdentity;
+                if (!this.restartQuarantine
+                    && rootIdentity
+                    && rootIdentity.generation === this.childGeneration
+                    && rootIdentity.pid === Number(child.pid || 0)
+                    && rootIdentity.creationIdentity) {
+                    const helperOwnerKey = this.windowsHelperOwnerKey(rootIdentity.generation);
+                    const quiescent = await confirmWindowsUtilityProcessTreeStopped(rootIdentity.pid, rootIdentity.creationIdentity, { ...this.options.windowsProcessTree, helperOwnerKey }, helperOwnerKey);
+                    if (quiescent) {
+                        if (this.child === child)
+                            this.detachChild(child, new Error('Electron utility runtime stopped'));
+                        return;
+                    }
+                }
                 this.enterRestartQuarantine(failure);
                 // Retain the UtilityProcess object and surface the failure.  The pool
                 // must not evict the only identity-safe handle to a still-live child.
@@ -1071,8 +1149,12 @@ class ElectronUtilityAgentClient {
             // killing through it is identity-safe even when PID-tree discovery is
             // uncertain. Descendants remain unknown, hence quarantine is still
             // permanent and replacement remains forbidden.
-            const exited = await this.killChildHandleAndAwaitExit(child, 1_000);
-            if (exited && this.child === child)
+            const rootAlreadyGone = process.platform === 'win32' && !processRootIsAlive(pid);
+            const exited = await this.killChildHandleAndAwaitExit(child, 5_000);
+            // The root handle can outlive the OS process after a tree proof fails.
+            // Detach that dead root handle, but keep the sticky quarantine because
+            // the failed tree proof still leaves descendant ownership unknown.
+            if ((exited || rootAlreadyGone) && this.child === child)
                 this.detachChild(child, failure);
             throw failure;
         }

package/dist/core/electronUtilityRuntimePool.d.ts

@@ -55,6 +55,7 @@ export declare class ElectronUtilityRuntimePool {
     private restarting;
     private quarantined;
     private disposing;
+    private forceStopPromises;
     private capacityTail;
     private accessSequence;
     constructor(root: string, hostScript: string, createClient?: ElectronTargetRuntimeClientFactory, options?: ElectronUtilityRuntimePoolOptions);
@@ -86,6 +87,16 @@ export declare class ElectronUtilityRuntimePool {
     hasActiveWorkspace(target: ConversationRuntimeTarget): Promise<boolean>;
     stopWorkspace(target: ConversationRuntimeTarget): Promise<void>;
     stopTarget(target: ConversationRuntimeTarget): Promise<void>;
+    /**
+     * Immediately terminate a target runtime for destructive lifecycle actions.
+     * Archive is deliberately stronger than the user-facing two-click Stop
+     * contract: the target may be running, already stopping, or holding an
+     * active prompt lease. Give the kernel only the short checkpoint window
+     * owned by forceTerminateEntry, then hard-stop and evict the client so no
+     * delayed runtime event can keep the archived target resident.
+     */
+    forceStopTarget(target: ConversationRuntimeTarget): Promise<void>;
+    private forceStopTargetInternal;
     stopAll(): Promise<void>;
     private throwStopFailures;
     private stopEntry;