newmark-agent 0.5.11 → 0.5.13

package/dist/core/browserUse.d.ts

@@ -18,6 +18,13 @@ export declare function isPublicBrowserUseAttribute(input: string): boolean;
 export interface BrowserUseScope {
     owner: string;
     runtimeKey: string;
+    /**
+     * Selects the user-visible right-sidebar browser surface. `false` keeps the
+     * same Browser-Use protocol on a host-owned background page that is never
+     * attached to the renderer. Omission is normalized to `true` for backwards
+     * compatibility.
+     */
+    visible?: boolean;
 }
 export interface BrowserUseRequest extends BrowserUseScope {
     action: BrowserUseAction;

package/dist/core/browserUse.js

@@ -46,7 +46,17 @@ function hasControlCharacter(text) {
     return false;
 }
 function scopeKey(scope) {
-    return `${scope.runtimeKey}\u0000${scope.owner}`;
+    return `${scope.runtimeKey}\u0000${scope.owner}\u0000${browserUseVisible(scope.visible) ? 'visible' : 'background'}`;
+}
+function browserUseVisible(value) {
+    return typeof value === 'boolean' ? value : true;
+}
+function bindBrowserUseVisible(value) {
+    if (value === undefined)
+        return true;
+    if (typeof value !== 'boolean')
+        throw new TypeError('Browser-Use visible must be a boolean when provided.');
+    return value;
 }
 function abortReason(signal) {
     return signal.reason instanceof Error
@@ -154,6 +164,7 @@ function bindBrowserUseRequest(input, context) {
     const request = {
         owner: runtimeKey && actorId ? `browser-use:${runtimeKey}:actor:${actorId}` : '',
         runtimeKey,
+        visible: bindBrowserUseVisible(raw.visible),
         action: String(raw.action || '').trim().toLowerCase(),
     };
     if (raw.actionId !== undefined || raw.action_id !== undefined)
@@ -263,10 +274,11 @@ class BrowserUseEngine {
         const rawAction = String(input?.action || '').trim().toLowerCase();
         const action = (ACTIONS.has(rawAction) ? rawAction : 'observe');
         const actionId = cleanScopePart(input?.actionId) || `browser-use-${this.id()}`;
-        const normalized = { ...input, owner, runtimeKey, action, actionId };
+        const visible = browserUseVisible(input?.visible);
+        const normalized = { ...input, owner, runtimeKey, visible, action, actionId };
         if (!owner || !runtimeKey || !ACTIONS.has(rawAction))
             return await this.runNow(normalized, signal);
-        const session = this.ensureSession({ owner, runtimeKey });
+        const session = this.ensureSession({ owner, runtimeKey, visible });
         const cached = session.receipts.get(actionId);
         if (cached)
             return cached;
@@ -293,17 +305,18 @@ class BrowserUseEngine {
         throwIfBrowserUseAborted(signal);
         const owner = cleanScopePart(input?.owner);
         const runtimeKey = cleanScopePart(input?.runtimeKey);
+        const visible = browserUseVisible(input?.visible);
         const rawAction = String(input?.action || '').trim().toLowerCase();
         const action = (ACTIONS.has(rawAction) ? rawAction : 'observe');
         const actionId = cleanScopePart(input?.actionId) || `browser-use-${this.id()}`;
         const startedAt = this.now();
         if (!owner || !runtimeKey) {
-            return this.standaloneFailure({ owner, runtimeKey, action, actionId, startedAt }, 'invalid_scope', 'Browser-Use requires a non-empty owner and runtimeKey.');
+            return this.standaloneFailure({ owner, runtimeKey, visible, action, actionId, startedAt }, 'invalid_scope', 'Browser-Use requires a non-empty owner and runtimeKey.');
         }
         if (!ACTIONS.has(rawAction)) {
-            return this.standaloneFailure({ owner, runtimeKey, action, actionId, startedAt }, 'invalid_request', `Unsupported Browser-Use action: ${rawAction || '(missing)'}`);
+            return this.standaloneFailure({ owner, runtimeKey, visible, action, actionId, startedAt }, 'invalid_request', `Unsupported Browser-Use action: ${rawAction || '(missing)'}`);
         }
-        const scope = { owner, runtimeKey };
+        const scope = { owner, runtimeKey, visible };
         const session = this.ensureSession(scope);
         const cached = session.receipts.get(actionId);
         if (cached)
@@ -572,7 +585,10 @@ class BrowserUse {
         throwIfBrowserUseAborted(signal);
         if (bridged.ok && bridged.data && typeof bridged.data === 'object') {
             const receipt = bridged.data;
-            if (receipt.action && receipt.actionId && receipt.owner === request.owner && receipt.runtimeKey === request.runtimeKey)
+            if (receipt.action && receipt.actionId
+                && receipt.owner === request.owner
+                && receipt.runtimeKey === request.runtimeKey
+                && browserUseVisible(receipt.visible) === browserUseVisible(request.visible))
                 return receipt;
         }
         return this.unavailable(request, bridged.error ? 'backend_error' : 'backend_unavailable', bridged.error || 'Browser-Use backend is not connected. Start Newmark Desktop to use the built-in browser.');
@@ -585,6 +601,7 @@ class BrowserUse {
             actionId: cleanScopePart(request?.actionId) || `browser-use-${(0, crypto_1.randomUUID)()}`,
             owner: cleanScopePart(request?.owner),
             runtimeKey: cleanScopePart(request?.runtimeKey),
+            visible: browserUseVisible(request?.visible),
             sequence: 0,
             pageGeneration: Number.isInteger(request?.pageGeneration) ? Number(request.pageGeneration) : 0,
             startedAt: now,

package/dist/core/conversationKernel.d.ts

@@ -285,6 +285,10 @@ export declare class ConversationKernel {
     private settleCooperativeStop;
     private stopAutomaticContinuationAfterError;
     private run;
+    private automaticMessage;
+    private currentAssistantFingerprint;
+    private rememberAutomaticAssistantFingerprint;
+    private repeatedAutomaticAssistant;
     /**
      * Apply a model selection recorded while a Build block was running. The
      * in-flight block never switches mid-block; the switch takes effect the next

package/dist/core/conversationKernel.js

@@ -85,6 +85,11 @@ class ConversationKernel {
             ...(attachments?.length ? { attachments } : {}),
             ...(visible ? { visibleUserInput: visible } : {}),
             ...(visibleMode ? { visibleMode } : {}),
+            // A normal user follow-up must never inherit the identity metadata that
+            // was only needed while it lived in the runtime queue.  In particular,
+            // do not let a stale/forwarded hiddenUserInput flag classify it as an
+            // Agent-generated continuation when Agent.process persists the turn.
+            hiddenUserInput: message.hiddenUserInput === true && !message.clientMessageId,
         };
     }
     queueItems(target) {
@@ -718,7 +723,7 @@ class ConversationKernel {
         this.deferOutstandingGuides(runtime);
         const checkpointed = this.checkpoint(runtime.target).checkpointed;
         runtime.stopCheckpointed = checkpointed;
-        runtime.runner.abortActiveKernelRun();
+        runtime.runner.abortActiveKernelRun('user_stop');
         runtime.runner.emitWorkEvent({
             type: 'status',
             content: 'Stop requested. Saving progress and interrupting this conversation.',
@@ -874,6 +879,7 @@ class ConversationKernel {
     async run(runtime, message, options) {
         this.applyOptions(runtime.runner, options);
         let lastTokens = await this.runSingle(runtime, message);
+        this.rememberAutomaticAssistantFingerprint(runtime, message);
         if (runtime.stopRequestedRunId === runtime.runId) {
             this.mirrorHostIfTargetActive(runtime);
             return this.result(runtime, lastTokens);
@@ -904,6 +910,8 @@ class ConversationKernel {
                     }
                     if (batchGuides.length === 1) {
                         lastTokens = await this.runSingle(runtime, next.message, next.queueMode);
+                        if (this.repeatedAutomaticAssistant(runtime, next.message, next.queueMode))
+                            break;
                         continue;
                     }
                     const batchText = batchGuides.map((guide, index) => `Guide ${index + 1}: ${guide.text}`).join('\n');
@@ -913,9 +921,14 @@ class ConversationKernel {
                         batchGuides,
                     };
                     lastTokens = await this.runSingle(runtime, batchMessage, 'steer');
+                    if (this.repeatedAutomaticAssistant(runtime, batchMessage, 'steer'))
+                        break;
                 }
                 else {
-                    lastTokens = await this.runSingle(runtime, this.drainQueuedFollowUpMessage(next.message), next.queueMode);
+                    const drained = this.drainQueuedFollowUpMessage(next.message);
+                    lastTokens = await this.runSingle(runtime, drained, next.queueMode);
+                    if (this.repeatedAutomaticAssistant(runtime, drained, next.queueMode))
+                        break;
                 }
             }
             const rootMessage = runtime.runner.subagents.readRootInbox()[0];
@@ -956,6 +969,41 @@ class ConversationKernel {
         this.mirrorHostIfTargetActive(runtime);
         return this.result(runtime, lastTokens);
     }
+    automaticMessage(message, queueMode) {
+        return queueMode === 'steer'
+            || (typeof message !== 'string' && (message.hiddenUserInput === true || message.goalContinuation === true || !!message.batchGuides?.length));
+    }
+    currentAssistantFingerprint(runtime) {
+        const messages = runtime.runner.chatMessages || [];
+        const last = messages[messages.length - 1];
+        if (!last || last.role !== 'assistant')
+            return '';
+        return String(last.content || '').trim().replace(/\s+/g, ' ').toLowerCase().slice(0, 4000);
+    }
+    rememberAutomaticAssistantFingerprint(runtime, message, queueMode) {
+        if (this.automaticMessage(message, queueMode))
+            runtime.lastAutomaticAssistantFingerprint = this.currentAssistantFingerprint(runtime) || undefined;
+    }
+    repeatedAutomaticAssistant(runtime, message, queueMode) {
+        if (!this.automaticMessage(message, queueMode))
+            return false;
+        const fingerprint = this.currentAssistantFingerprint(runtime);
+        if (!fingerprint)
+            return false;
+        if (runtime.lastAutomaticAssistantFingerprint === fingerprint) {
+            runtime.pendingNextTurn = runtime.pendingNextTurn.filter(item => {
+                const automatic = item.queueMode === 'steer' || (typeof item.message !== 'string' && item.message.hiddenUserInput === true);
+                if (automatic)
+                    runtime.runner.consumeConversationContinuation({ content: typeof item.message === 'string' ? item.message : item.message.text, queueMode: item.queueMode, clientMessageId: typeof item.message === 'string' ? undefined : item.message.clientMessageId });
+                return !automatic;
+            });
+            runtime.runner.recordWorkStatus('Automatic continuation stopped after a repeated assistant response.');
+            this.emitQueueUpdate(runtime);
+            return true;
+        }
+        runtime.lastAutomaticAssistantFingerprint = fingerprint;
+        return false;
+    }
     /**
      * Apply a model selection recorded while a Build block was running. The
      * in-flight block never switches mid-block; the switch takes effect the next
@@ -999,7 +1047,20 @@ class ConversationKernel {
                 tokens = await Promise.race([
                     runtime.runner.process(message),
                     new Promise((_, reject) => {
-                        timeout = setTimeout(() => reject(new Error(`Process timeout (${Math.round(timeoutMs / 1000)}s)`)), timeoutMs);
+                        timeout = setTimeout(() => {
+                            // A timeout must cancel the provider/kernel operation as well as
+                            // reject the caller. Previously only the Promise.race rejected,
+                            // leaving the worker running in the background and making the
+                            // UI observe a later unexplained interruption.
+                            runtime.runner.abortActiveKernelRun(`process_timeout_${timeoutMs}ms`);
+                            runtime.runner.emitWorkEvent({
+                                type: 'error',
+                                content: `Process timeout (${Math.round(timeoutMs / 1000)}s); the run was aborted to prevent a stale worker from continuing.`,
+                                status: 'error',
+                                runId: runtime.runId,
+                            });
+                            reject(new Error(`Process timeout (${Math.round(timeoutMs / 1000)}s); run aborted and checkpointed`));
+                        }, timeoutMs);
                     }),
                 ]);
             }
@@ -1067,6 +1128,7 @@ class ConversationKernel {
             guideEnvelopes: new Map(),
             goalContinuationTimer: undefined,
             pendingContinuationRunId: undefined,
+            lastAutomaticAssistantFingerprint: undefined,
         };
         runner.setGoalContinuationGate(() => {
             this.queueState(runtime);

package/dist/core/displayImages.d.ts

@@ -1,4 +1,14 @@
 import type { DisplayImageAttachment } from './types';
+export interface WorkspaceImageObservation {
+    path: string;
+    name: string;
+    byteLength: number;
+    dataUrl: string;
+    mimeType: DisplayImageAttachment['mimeType'];
+    width: number;
+    height: number;
+}
+export declare function readWorkspaceImageForVision(workspacePath: string, requestedPath: string): WorkspaceImageObservation;
 export declare function persistWorkspaceDisplayImage(rootPath: string, workspacePath: string, requestedPath: string, caption?: string, createdAt?: string): DisplayImageAttachment;
 export declare function hydrateDisplayImage(rootPath: string, input: unknown): DisplayImageAttachment | undefined;
 export declare function durableDisplayImage(input: DisplayImageAttachment | undefined): DisplayImageAttachment | undefined;

package/dist/core/displayImages.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.readWorkspaceImageForVision = readWorkspaceImageForVision;
 exports.persistWorkspaceDisplayImage = persistWorkspaceDisplayImage;
 exports.hydrateDisplayImage = hydrateDisplayImage;
 exports.durableDisplayImage = durableDisplayImage;
@@ -78,6 +79,27 @@ function decodeFile(filePath) {
         throw new Error('Display image extension does not match its decoded content.');
     return { bytes, dataUrl, mimeType, width: decoded.width, height: decoded.height };
 }
+function readWorkspaceImageForVision(workspacePath, requestedPath) {
+    const workspace = fs.realpathSync(path.resolve(workspacePath));
+    const candidate = path.resolve(workspace, String(requestedPath || '').trim());
+    if (!inside(workspace, candidate))
+        throw new Error('Workspace images must stay inside the active workspace.');
+    if (!fs.existsSync(candidate) || !fs.statSync(candidate).isFile())
+        throw new Error(`Workspace image not found: ${requestedPath}`);
+    const realCandidate = fs.realpathSync(candidate);
+    if (!inside(workspace, realCandidate))
+        throw new Error('Workspace images must stay inside the active workspace.');
+    const decoded = decodeFile(realCandidate);
+    return {
+        path: path.relative(workspace, realCandidate).split(path.sep).join('/'),
+        name: path.basename(realCandidate),
+        byteLength: decoded.bytes.length,
+        dataUrl: decoded.dataUrl,
+        mimeType: decoded.mimeType,
+        width: decoded.width,
+        height: decoded.height,
+    };
+}
 function writeAsset(filePath, bytes, sha256) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     if (fs.existsSync(filePath)) {
@@ -105,14 +127,15 @@ function writeAsset(filePath, bytes, sha256) {
     }
 }
 function persistWorkspaceDisplayImage(rootPath, workspacePath, requestedPath, caption = '', createdAt = new Date().toISOString()) {
-    const workspace = fs.realpathSync(path.resolve(workspacePath));
-    const candidate = path.resolve(workspace, String(requestedPath || '').trim());
-    if (!fs.existsSync(candidate) || !fs.statSync(candidate).isFile())
-        throw new Error(`Display image not found: ${requestedPath}`);
-    const realCandidate = fs.realpathSync(candidate);
-    if (!inside(workspace, realCandidate))
-        throw new Error('Display images must stay inside the active workspace.');
-    const decoded = decodeFile(realCandidate);
+    const source = readWorkspaceImageForVision(workspacePath, requestedPath);
+    const realCandidate = path.resolve(fs.realpathSync(path.resolve(workspacePath)), ...source.path.split('/'));
+    const decoded = {
+        bytes: Buffer.from(source.dataUrl.slice(source.dataUrl.indexOf(',') + 1), 'base64'),
+        dataUrl: source.dataUrl,
+        mimeType: source.mimeType,
+        width: source.width,
+        height: source.height,
+    };
     const sha256 = crypto.createHash('sha256').update(decoded.bytes).digest('hex');
     writeAsset(absoluteAssetPath(rootPath, sha256, decoded.mimeType), decoded.bytes, sha256);
     return {

package/dist/core/electronBrowserUseHost.d.ts

@@ -5,6 +5,7 @@ export interface ElectronBrowserUseHostOptions {
     resolveContents(scope: BrowserUseScope, boundContentsId?: number): Promise<WebContents>;
     openExternal?(url: string): void | Promise<void>;
     guardSettleMs?: number;
+    releaseContents?(scope: BrowserUseScope, contents: WebContents): void;
 }
 /**
  * Electron-owned Browser-Use page host. All model-independent DOM programs live in
@@ -25,6 +26,9 @@ export declare class ElectronBrowserUseHost {
     private page;
     private activeEffects;
     private isRuntimeBound;
+    private bindingKey;
+    private bindingMatchesScope;
+    private releaseBinding;
     private installDownloadGuard;
 }
 //# sourceMappingURL=electronBrowserUseHost.d.ts.map

package/dist/core/electronBrowserUseHost.js

@@ -59,22 +59,31 @@ class ElectronBrowserUseHost {
         });
     }
     async resolve(scope) {
-        const boundId = this.runtimeBindings.get(scope.runtimeKey);
+        const bindingKey = this.bindingKey(scope);
+        const boundId = this.runtimeBindings.get(bindingKey);
         const contents = await this.options.resolveContents(scope, boundId);
         if (contents.isDestroyed())
             throw new Error('Built-in browser page is unavailable.');
         this.attach(contents);
-        this.runtimeBindings.set(scope.runtimeKey, contents.id);
+        this.runtimeBindings.set(bindingKey, contents.id);
         return this.page(contents);
     }
     clear(scope) {
-        if (scope)
-            this.runtimeBindings.delete(scope.runtimeKey);
-        else
+        if (!scope) {
+            for (const [bindingKey, contentsId] of this.runtimeBindings)
+                this.releaseBinding(bindingKey, contentsId);
             this.runtimeBindings.clear();
+            return;
+        }
+        for (const [bindingKey, contentsId] of this.runtimeBindings) {
+            if (!this.bindingMatchesScope(bindingKey, scope))
+                continue;
+            this.releaseBinding(bindingKey, contentsId, scope);
+            this.runtimeBindings.delete(bindingKey);
+        }
     }
     dispose() {
-        this.runtimeBindings.clear();
+        this.clear();
         for (const [browserSession, handler] of this.downloadHandlers) {
             browserSession.removeListener('will-download', handler);
         }
@@ -193,6 +202,23 @@ class ElectronBrowserUseHost {
         }
         return false;
     }
+    bindingKey(scope) {
+        return `${scope.runtimeKey}\u0000${scope.visible === false ? 'background' : 'visible'}`;
+    }
+    bindingMatchesScope(bindingKey, scope) {
+        const prefix = `${scope.runtimeKey}\u0000`;
+        return bindingKey.startsWith(prefix)
+            && (scope.visible === undefined || bindingKey === this.bindingKey({ ...scope, visible: scope.visible !== false }));
+    }
+    releaseBinding(bindingKey, contentsId, scope) {
+        const contents = this.pages.get(contentsId)?.contents;
+        if (!contents || contents.isDestroyed())
+            return;
+        const separator = bindingKey.lastIndexOf('\u0000');
+        const runtimeKey = separator >= 0 ? bindingKey.slice(0, separator) : bindingKey;
+        const visible = separator < 0 || bindingKey.slice(separator + 1) !== 'background';
+        this.options.releaseContents?.({ owner: scope?.owner || '', runtimeKey, visible }, contents);
+    }
     installDownloadGuard(browserSession) {
         if (this.downloadHandlers.has(browserSession))
             return;

package/dist/core/electronUtilityAgentClient.d.ts

@@ -73,6 +73,7 @@ export declare class ElectronUtilityAgentClient {
     private childRootIdentity;
     private sequence;
     private lastError;
+    private expectedExit;
     private restartQuarantine;
     constructor(root: string, hostScript: string, target: NormalizedConversationTarget, options?: ElectronUtilityAgentClientOptions);
     subscribe(listener: (event: AgentWorkEvent) => void): () => void;

package/dist/core/electronUtilityAgentClient.js

@@ -49,6 +49,8 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const electron_1 = require("electron");
 const child_process_1 = require("child_process");
+const runtimeDiagnostics_1 = require("./runtimeDiagnostics");
+const runtimeLifecycle_1 = require("./runtimeLifecycle");
 const conversationTarget_1 = require("./conversationTarget");
 // PowerShell startup can be slow on a cold or busy Windows host even though
 // the precompiled Toolhelp helper itself is healthy.
@@ -882,6 +884,7 @@ class ElectronUtilityAgentClient {
     childRootIdentity = null;
     sequence = 0;
     lastError = '';
+    expectedExit = false;
     // A failed force-stop means an old descendant may still own target-scoped
     // resources.  This is intentionally sticky for the lifetime of this client:
     // only rebuilding the Electron main-process runtime pool may clear it.
@@ -955,6 +958,11 @@ class ElectronUtilityAgentClient {
         const generation = ++this.childGeneration;
         this.readyGeneration = 0;
         this.lastError = '';
+        this.expectedExit = false;
+        (0, runtimeDiagnostics_1.appendRuntimeDiagnostic)(this.root, {
+            event: 'utility_runtime_started', runtimeKey: this.target.runtimeKey,
+            generation, pid: Number(child.pid || 0),
+        });
         child.on('message', message => this.handleMessage(child, generation, message));
         child.on('error', (_type, _location, report) => {
             if (this.child === child)
@@ -1078,6 +1086,7 @@ class ElectronUtilityAgentClient {
         const child = this.child;
         if (!child)
             return;
+        this.expectedExit = true;
         if (!this.restartQuarantine && this.readyGeneration === this.childGeneration) {
             try {
                 await this.request('shutdown', undefined, 2_000);
@@ -1337,7 +1346,13 @@ class ElectronUtilityAgentClient {
             return;
         let result;
         const controller = new AbortController();
-        this.hostToolRuns.set(request.requestId, { generation, controller });
+        const run = { generation, controller, tool: String(request.tool), startedAt: Date.now(), stage: 'received' };
+        this.hostToolRuns.set(request.requestId, run);
+        (0, runtimeDiagnostics_1.appendRuntimeDiagnostic)(this.root, {
+            event: 'utility_host_rpc_started', runtimeKey: this.target.runtimeKey,
+            generation, pid: Number(child.pid || 0), requestId: request.requestId,
+            tool: request.tool, stage: run.stage,
+        });
         const allowed = new Set(['browser_control', 'browser_use', 'screen_capture', 'computer_use', 'automation', 'terminal_takeover']);
         if (!allowed.has(request.tool)) {
             result = { requestId: request.requestId, ok: false, error: `Electron host tool is not allowed: ${String(request.tool)}` };
@@ -1350,13 +1365,26 @@ class ElectronUtilityAgentClient {
         }
         else {
             try {
+                const active = this.hostToolRuns.get(request.requestId);
+                if (active)
+                    active.stage = 'running';
                 result = { requestId: request.requestId, ok: true, result: await this.hostToolHandler(request, controller.signal) };
             }
             catch (error) {
                 result = { requestId: request.requestId, ok: false, error: error instanceof Error ? error.message : String(error) };
             }
         }
+        const active = this.hostToolRuns.get(request.requestId);
+        if (active)
+            active.stage = 'responding';
         this.hostToolRuns.delete(request.requestId);
+        (0, runtimeDiagnostics_1.appendRuntimeDiagnostic)(this.root, {
+            event: result.ok ? 'utility_host_rpc_completed' : 'utility_host_rpc_failed',
+            level: result.ok ? 'info' : 'warn', runtimeKey: this.target.runtimeKey,
+            generation, pid: Number(child.pid || 0), requestId: request.requestId,
+            tool: request.tool, stage: active?.stage || 'responding',
+            durationMs: Date.now() - run.startedAt, error: result.ok ? '' : result.error,
+        });
         if (controller.signal.aborted
             || this.restartQuarantine
             || this.invalidGenerations.has(generation)
@@ -1377,8 +1405,48 @@ class ElectronUtilityAgentClient {
     handleExit(child, code) {
         if (this.child !== child)
             return;
-        const error = new Error(`Electron utility runtime exited (${code}): ${this.lastError || 'no stderr'}`);
+        const expected = this.expectedExit || !!this.restartQuarantine;
+        const lastHostRun = [...this.hostToolRuns.entries()]
+            .filter(([, run]) => run.generation === this.childGeneration)
+            .sort((left, right) => right[1].startedAt - left[1].startedAt)[0];
+        const hostSuffix = lastHostRun
+            ? `; last host RPC ${lastHostRun[1].tool}/${lastHostRun[1].stage} (${Date.now() - lastHostRun[1].startedAt} ms)`
+            : '';
+        const error = new Error(`Electron utility runtime exited (${code}): ${this.lastError || 'no stderr'}${hostSuffix}`);
+        (0, runtimeDiagnostics_1.appendRuntimeDiagnostic)(this.root, {
+            event: expected ? 'utility_runtime_stopped' : 'utility_runtime_unexpected_exit',
+            level: expected ? 'info' : 'error', runtimeKey: this.target.runtimeKey,
+            generation: this.childGeneration, pid: Number(child.pid || 0), exitCode: code,
+            expected, requestId: lastHostRun?.[0], tool: lastHostRun?.[1].tool,
+            stage: lastHostRun?.[1].stage, durationMs: lastHostRun ? Date.now() - lastHostRun[1].startedAt : 0,
+            error: this.lastError || (expected ? '' : 'no stderr'),
+        });
+        (0, runtimeLifecycle_1.markRuntimeLifecycleExitedByPid)(this.root, 'utility', Number(child.pid || 0), {
+            unexpected: !expected, exitCode: code, error: this.lastError || '',
+        });
+        // Surface unexpected worker death as a target-scoped terminal error. A
+        // silent child exit used to leave the renderer with a generic interrupted
+        // state and no explanation of whether the provider, runtime, or process
+        // supervisor was responsible.
+        if (!expected && !this.restartQuarantine) {
+            const event = {
+                id: `utility-runtime-exit-${process.pid}-${Date.now()}`,
+                conversationId: this.target.conversationId,
+                type: 'error',
+                content: error.message,
+                mode: 'build',
+                model: '',
+                timestamp: new Date().toISOString(),
+                workspaceId: this.target.workspaceId,
+                workspaceKey: this.target.workspaceKey,
+                runtimeKey: this.target.runtimeKey,
+                status: 'error',
+            };
+            for (const listener of this.listeners)
+                listener(event);
+        }
         this.detachChild(child, error);
+        this.expectedExit = false;
     }
     detachChild(child, error) {
         if (this.child !== child)

package/dist/core/runtimeDiagnostics.d.ts

@@ -0,0 +1,18 @@
+export type RuntimeDiagnosticLevel = 'info' | 'warn' | 'error';
+export interface RuntimeDiagnosticEvent {
+    event: string;
+    level?: RuntimeDiagnosticLevel;
+    runtimeKey?: string;
+    generation?: number;
+    pid?: number;
+    requestId?: string;
+    tool?: string;
+    stage?: string;
+    durationMs?: number;
+    exitCode?: number | null;
+    expected?: boolean;
+    error?: string;
+}
+/** Append one bounded, path-free JSON event. Diagnostics must never break runtime work. */
+export declare function appendRuntimeDiagnostic(root: string, input: RuntimeDiagnosticEvent): void;
+//# sourceMappingURL=runtimeDiagnostics.d.ts.map

package/dist/core/runtimeDiagnostics.js

@@ -0,0 +1,89 @@
+"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.appendRuntimeDiagnostic = appendRuntimeDiagnostic;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto_1 = require("crypto");
+const MAX_LOG_BYTES = 2 * 1024 * 1024;
+function boundedText(value, limit = 800) {
+    return String(value || '')
+        .replace(/(?:[A-Za-z]:[\\/]|\\\\)[^\s"']+/g, '[local-path]')
+        .replace(/\b(?:sk|ghp|github_pat)-?[A-Za-z0-9_.-]{8,}\b/g, '[redacted]')
+        .replace(/(Authorization\s*:\s*Bearer\s+)[^\s,;]+/ig, '$1[redacted]')
+        .slice(-limit);
+}
+function runtimeCorrelation(runtimeKey) {
+    return runtimeKey
+        ? (0, crypto_1.createHash)('sha256').update(runtimeKey).digest('hex').slice(0, 16)
+        : '';
+}
+/** Append one bounded, path-free JSON event. Diagnostics must never break runtime work. */
+function appendRuntimeDiagnostic(root, input) {
+    try {
+        const directory = path.join(root, '.newmark-runtime');
+        const file = path.join(directory, 'runtime-events.jsonl');
+        fs.mkdirSync(directory, { recursive: true });
+        try {
+            if (fs.statSync(file).size > MAX_LOG_BYTES) {
+                const previous = `${file}.1`;
+                try {
+                    fs.unlinkSync(previous);
+                }
+                catch { }
+                fs.renameSync(file, previous);
+            }
+        }
+        catch { }
+        const record = {
+            at: new Date().toISOString(),
+            event: boundedText(input.event, 100),
+            level: input.level || 'info',
+            runtime: runtimeCorrelation(String(input.runtimeKey || '')),
+            generation: Math.max(0, Math.floor(Number(input.generation) || 0)),
+            pid: Math.max(0, Math.floor(Number(input.pid) || 0)),
+            requestId: boundedText(input.requestId, 160),
+            tool: boundedText(input.tool, 80),
+            stage: boundedText(input.stage, 80),
+            durationMs: Math.max(0, Math.floor(Number(input.durationMs) || 0)),
+            exitCode: input.exitCode === null ? null : Number.isFinite(Number(input.exitCode)) ? Number(input.exitCode) : undefined,
+            expected: input.expected,
+            error: boundedText(input.error),
+        };
+        fs.appendFileSync(file, `${JSON.stringify(record)}\n`, 'utf-8');
+    }
+    catch { }
+}
+//# sourceMappingURL=runtimeDiagnostics.js.map

package/dist/core/runtimeLifecycle.d.ts

@@ -6,7 +6,7 @@ export interface RuntimeLifecycleState {
     startedAt: string;
     previousOwnerAlive: boolean;
     unexpectedExit: boolean;
-    active: true;
+    active: boolean;
 }
 export declare function isRuntimeProcessAlive(pid: number): boolean;
 /** Prepare crash-recovery markers asynchronously after the startup shell is visible. */
@@ -21,5 +21,11 @@ export declare function prepareRuntimeLifecycle(root: string, role?: RuntimeLife
 export declare function beginRuntimeLifecycle(root: string, role?: RuntimeLifecycleRole): RuntimeLifecycleState;
 /** Mark only this owner clean; a hard kill leaves the active marker intact. */
 export declare function markRuntimeLifecycleClean(root: string, role?: RuntimeLifecycleRole): void;
+/** Parent-side fallback for a worker that died before it could clean its own marker. */
+export declare function markRuntimeLifecycleExitedByPid(root: string, role: RuntimeLifecycleRole, pid: number, input?: {
+    unexpected: boolean;
+    exitCode?: number | null;
+    error?: string;
+}): void;
 export declare function runtimeLifecycleState(root: string, role?: RuntimeLifecycleRole): RuntimeLifecycleState | null;
 //# sourceMappingURL=runtimeLifecycle.d.ts.map