newmark-agent 0.5.12 → 0.5.13

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/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,12 +1405,30 @@ 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 (code !== 0 && !this.restartQuarantine) {
+        if (!expected && !this.restartQuarantine) {
             const event = {
                 id: `utility-runtime-exit-${process.pid}-${Date.now()}`,
                 conversationId: this.target.conversationId,
@@ -1400,6 +1446,7 @@ class ElectronUtilityAgentClient {
                 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

package/dist/core/runtimeLifecycle.js

@@ -37,6 +37,7 @@ exports.isRuntimeProcessAlive = isRuntimeProcessAlive;
 exports.prepareRuntimeLifecycle = prepareRuntimeLifecycle;
 exports.beginRuntimeLifecycle = beginRuntimeLifecycle;
 exports.markRuntimeLifecycleClean = markRuntimeLifecycleClean;
+exports.markRuntimeLifecycleExitedByPid = markRuntimeLifecycleExitedByPid;
 exports.runtimeLifecycleState = runtimeLifecycleState;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -189,6 +190,34 @@ function markRuntimeLifecycleClean(root, role = 'main') {
         }
     }
 }
+/** Parent-side fallback for a worker that died before it could clean its own marker. */
+function markRuntimeLifecycleExitedByPid(root, role, pid, input = { unexpected: true }) {
+    const directory = path.join(root, '.newmark-runtime');
+    let files = [];
+    try {
+        files = fs.readdirSync(directory).filter(file => file.startsWith(`lifecycle-${role}-`) && file.endsWith('.json'));
+    }
+    catch {
+        return;
+    }
+    for (const name of files) {
+        const file = path.join(directory, name);
+        const state = readState(file);
+        if (!state || Number(state.pid) !== Math.floor(Number(pid) || 0) || state.active !== true)
+            continue;
+        try {
+            writeState(root, role, {
+                ...state,
+                active: false,
+                unexpectedExit: input.unexpected,
+                exitedAt: new Date().toISOString(),
+                exitCode: input.exitCode,
+                error: String(input.error || '').slice(-800),
+            });
+        }
+        catch { }
+    }
+}
 function runtimeLifecycleState(root, role = 'main') {
     return processStates.get(stateKey(root, role)) || null;
 }

package/dist/core/searchMcpPool.d.ts

@@ -0,0 +1,80 @@
+export type SearchMcpTransport = 'stdio' | 'streamable_http' | 'sse' | 'template';
+export interface SearchMcpEndpoint {
+    id: string;
+    name: string;
+    enabled: boolean;
+    priority: number;
+    transport: SearchMcpTransport;
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+    tool?: string;
+    argument?: string;
+    timeoutMs?: number;
+    notes?: string;
+}
+export interface SearchMcpPoolConfig {
+    version: 1;
+    endpoints: SearchMcpEndpoint[];
+}
+export interface PublicSearchMcpEndpoint extends Omit<SearchMcpEndpoint, 'env' | 'headers' | 'command' | 'args' | 'cwd'> {
+    envKeys: string[];
+    headerKeys: string[];
+    url?: string;
+}
+export interface SearchMcpAttempt {
+    id: string;
+    name: string;
+    status: 'success' | 'empty' | 'error' | 'unconfigured';
+    durationMs: number;
+    error?: string;
+}
+export interface SearchMcpPoolResult {
+    invocationId: string;
+    checkedAt: string;
+    ok: boolean;
+    provider?: string;
+    text?: string;
+    attempts: SearchMcpAttempt[];
+}
+export interface SearchMcpPoolDependencies {
+    callEndpoint?: (endpoint: SearchMcpEndpoint, query: string, signal?: AbortSignal) => Promise<string>;
+    now?: () => number;
+}
+export declare const MAX_SEARCH_MCP_RESULT_CHARS = 60000;
+/**
+ * Public protocol catalog. Only endpoints with evidence-backed launch metadata are runnable by default.
+ * The remaining requested implementations are exposed as disabled templates until a distributor/user
+ * supplies a concrete stdio command or Streamable HTTP/SSE URL in search-mcp.json.
+ */
+export declare const DEFAULT_SEARCH_MCP_MANIFEST: SearchMcpEndpoint[];
+export declare function loadSearchMcpManifest(root: string): SearchMcpEndpoint[];
+export declare function publicSearchMcpManifest(root: string): PublicSearchMcpEndpoint[];
+export declare function redactSearchMcpLocalPaths(value: string, additionalRoots?: string[]): string;
+export declare function chooseSearchTool(tools: Array<{
+    name: string;
+    description?: string;
+    inputSchema?: {
+        type?: string;
+        properties?: Record<string, {
+            type?: string;
+        }>;
+        required?: string[];
+        additionalProperties?: boolean;
+    };
+}>, preferred?: string): {
+    name: string;
+    argument: string;
+} | undefined;
+export declare class SearchMcpPool {
+    private readonly root;
+    private readonly callEndpoint;
+    private readonly now;
+    constructor(root: string, dependencies?: SearchMcpPoolDependencies);
+    manifest(): SearchMcpEndpoint[];
+    search(query: string, signal?: AbortSignal): Promise<SearchMcpPoolResult>;
+}
+//# sourceMappingURL=searchMcpPool.d.ts.map