monomind 1.10.37 → 1.10.38

package/.claude/helpers/utils/telemetry.cjs

@@ -129,6 +129,7 @@ function _recordDecisionMarkers(promptText) {
   if (!matches || matches.length === 0) return;
   try {
     var f = path.join(CWD, '.monomind', 'decisions.jsonl');
+    fs.mkdirSync(path.dirname(f), { recursive: true });
     var entry = JSON.stringify({ ts: Date.now(), excerpts: matches.slice(0, 3), prompt: promptText.slice(0, 400) });
     fs.appendFileSync(f, entry + '\n');
   } catch (e) {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.10.37",
+  "version": "1.10.38",
   "description": "Monomind - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration",
   "main": "dist/index.js",
   "type": "module",

package/packages/@monomind/cli/dist/src/browser/actions.d.ts

@@ -4,6 +4,7 @@ export declare function clickElement(client: CdpClient, sessionId: string, ref:
 export declare function clickPoint(client: CdpClient, sessionId: string, x: number, y: number, options?: ClickOptions): Promise<void>;
 export declare function fillElement(client: CdpClient, sessionId: string, ref: ElementRef, value: string): Promise<void>;
 export declare function typeText(client: CdpClient, sessionId: string, text: string): Promise<void>;
+export declare function pressKeyCombo(client: CdpClient, sessionId: string, key: string, modifiers: number): Promise<void>;
 export declare function pressKey(client: CdpClient, sessionId: string, key: string): Promise<void>;
 export declare function scrollElement(client: CdpClient, sessionId: string, direction: 'up' | 'down' | 'left' | 'right', amount?: number, ref?: ElementRef): Promise<void>;
 export declare function hoverElement(client: CdpClient, sessionId: string, ref: ElementRef): Promise<void>;

package/packages/@monomind/cli/dist/src/browser/actions.js

@@ -20,10 +20,11 @@ export async function clickPoint(client, sessionId, x, y, options = {}) {
     const button = options.button ?? 'left';
     const clickCount = options.clickCount ?? 1;
     const modifiers = options.modifiers ?? 0;
-    const shared = { x, y, button, modifiers, clickCount };
+    const shared = { x, y, button, modifiers };
     for (let i = 0; i < clickCount; i++) {
-        await client.send('Input.dispatchMouseEvent', { ...shared, type: 'mousePressed', buttons: 1 }, sessionId);
-        await client.send('Input.dispatchMouseEvent', { ...shared, type: 'mouseReleased', buttons: 0 }, sessionId);
+        const count = i + 1;
+        await client.send('Input.dispatchMouseEvent', { ...shared, type: 'mousePressed', buttons: 1, clickCount: count }, sessionId);
+        await client.send('Input.dispatchMouseEvent', { ...shared, type: 'mouseReleased', buttons: 0, clickCount: count }, sessionId);
     }
 }
 export async function fillElement(client, sessionId, ref, value) {
@@ -56,6 +57,12 @@ export async function fillElement(client, sessionId, ref, value) {
 export async function typeText(client, sessionId, text) {
     await client.send('Input.insertText', { text }, sessionId);
 }
+export async function pressKeyCombo(client, sessionId, key, modifiers) {
+    const { text: _text, ...keyInfo } = resolveKey(key);
+    // rawKeyDown prevents Chrome from inserting the character text; only the shortcut fires
+    await client.send('Input.dispatchKeyEvent', { type: 'rawKeyDown', ...keyInfo, modifiers }, sessionId);
+    await client.send('Input.dispatchKeyEvent', { type: 'keyUp', ...keyInfo, modifiers }, sessionId);
+}
 export async function pressKey(client, sessionId, key) {
     const keyInfo = resolveKey(key);
     await client.send('Input.dispatchKeyEvent', {
@@ -93,9 +100,9 @@ function resolveKey(key) {
     };
     if (keyMap[key])
         return keyMap[key];
-    // Single printable character
+    // Single printable character — windowsVirtualKeyCode required for rawKeyDown shortcut dispatch
     if (key.length === 1) {
-        return { key, code: `Key${key.toUpperCase()}`, text: key };
+        return { key, code: `Key${key.toUpperCase()}`, text: key, windowsVirtualKeyCode: key.toUpperCase().charCodeAt(0) };
     }
     return { key, code: key };
 }

package/packages/@monomind/cli/dist/src/browser/batch.d.ts

@@ -2,12 +2,6 @@ export interface BatchCommand {
     command: string;
     args: string[];
 }
-export type BatchResult = {
-    command: string;
-    success: boolean;
-    output?: string;
-    error?: string;
-};
 export declare function parseBatchCommands(input: string[]): Promise<BatchCommand[]>;
 export declare function parseBatchJson(json: string): Promise<BatchCommand[]>;
 //# sourceMappingURL=batch.d.ts.map

package/packages/@monomind/cli/dist/src/browser/browser.js

@@ -4,7 +4,7 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 import { CdpClient, fetchTargets, fetchNewTarget } from './cdp.js';
 import { CHROME_EXECUTABLES } from './types.js';
-import { enableConsoleCapture } from './console-log.js';
+import { enableConsoleCapture, setupConsoleCapture } from './console-log.js';
 import { setupDialogAutoHandling } from './dialog.js';
 const DEFAULT_PORT = 9222;
 const LAUNCH_TIMEOUT = 10_000;
@@ -115,7 +115,8 @@ export async function connectToTarget(port, targetId) {
         client.send('Accessibility.enable', {}, sessionId),
     ]);
     // Wire up auto-capture listeners so console/errors/dialogs work immediately
-    enableConsoleCapture(client, sessionId);
+    setupConsoleCapture(client, sessionId);
+    await enableConsoleCapture(client, sessionId);
     setupDialogAutoHandling(client, sessionId);
     return { client, target, sessionId };
 }
@@ -126,38 +127,54 @@ export async function openUrl(client, sessionId, url) {
 export async function waitForLoad(client, sessionId, condition = 'load', timeout = 30_000) {
     if (condition === 'load' || condition === 'domcontentloaded') {
         const event = condition === 'load' ? 'Page.loadEventFired' : 'Page.domContentEventFired';
-        await Promise.race([
-            client.once(event, sessionId),
-            sleep(timeout).then(() => { throw new Error(`Timeout waiting for ${condition}`); }),
-        ]);
+        const [eventPromise, cancelOnce] = client.onceWithOff(event, sessionId);
+        let timedOut = false;
+        const timeoutPromise = sleep(timeout).then(() => { timedOut = true; });
+        try {
+            await Promise.race([eventPromise, timeoutPromise]);
+            if (timedOut)
+                throw new Error(`Timeout waiting for ${condition}`);
+        }
+        finally {
+            cancelOnce();
+        }
         return;
     }
     // networkidle: no network requests for 500ms
-    await Promise.race([
-        waitForNetworkIdle(client, sessionId, 500),
-        sleep(timeout).then(() => { throw new Error('Timeout waiting for networkidle'); }),
-    ]);
+    await waitForNetworkIdle(client, sessionId, 500, timeout);
 }
-async function waitForNetworkIdle(client, sessionId, idleMs) {
-    return new Promise((resolve) => {
+async function waitForNetworkIdle(client, sessionId, idleMs, timeout) {
+    return new Promise((resolve, reject) => {
         let pending = 0;
-        let timer = null;
-        const settle = () => {
+        let idleTimer = null;
+        const killTimer = setTimeout(() => {
+            cleanup();
+            reject(new Error('Timeout waiting for networkidle'));
+        }, timeout);
+        const cleanup = () => {
+            if (idleTimer) {
+                clearTimeout(idleTimer);
+                idleTimer = null;
+            }
+            clearTimeout(killTimer);
             offReq();
             offResp();
             offFail();
+        };
+        const settle = () => {
+            cleanup();
             resolve();
         };
         const check = () => {
             if (pending === 0) {
-                if (timer)
-                    clearTimeout(timer);
-                timer = setTimeout(settle, idleMs);
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+                idleTimer = setTimeout(settle, idleMs);
             }
             else {
-                if (timer) {
-                    clearTimeout(timer);
-                    timer = null;
+                if (idleTimer) {
+                    clearTimeout(idleTimer);
+                    idleTimer = null;
                 }
             }
         };

package/packages/@monomind/cli/dist/src/browser/cdp.d.ts

@@ -9,6 +9,7 @@ export declare class CdpClient {
     send<T = Record<string, unknown>>(method: string, params?: Record<string, unknown>, sessionId?: string): Promise<T>;
     on(event: string, fn: (params: Record<string, unknown>, sessionId?: string) => void): () => void;
     once(event: string, sessionId?: string): Promise<Record<string, unknown>>;
+    onceWithOff(event: string, sessionId?: string): [Promise<Record<string, unknown>>, () => void];
     close(): void;
     isConnected(): boolean;
 }

package/packages/@monomind/cli/dist/src/browser/cdp.js

@@ -39,8 +39,12 @@ export class CdpClient {
                     else if (msg.method) {
                         const listeners = this.eventListeners.get(msg.method);
                         if (listeners) {
-                            for (const fn of listeners)
-                                fn(msg.params ?? {}, msg.sessionId);
+                            for (const fn of listeners) {
+                                try {
+                                    fn(msg.params ?? {}, msg.sessionId);
+                                }
+                                catch { /* isolate per-listener errors */ }
+                            }
                         }
                     }
                 }
@@ -75,14 +79,20 @@ export class CdpClient {
         return () => this.eventListeners.get(event)?.delete(fn);
     }
     once(event, sessionId) {
-        return new Promise((resolve) => {
-            const off = this.on(event, (params, sid) => {
+        const [promise] = this.onceWithOff(event, sessionId);
+        return promise;
+    }
+    onceWithOff(event, sessionId) {
+        let off = () => { };
+        const promise = new Promise((resolve) => {
+            off = this.on(event, (params, sid) => {
                 if (sessionId !== undefined && sid !== sessionId)
                     return;
                 off();
                 resolve(params);
             });
         });
+        return [promise, () => off()];
     }
     close() {
         this.ws?.close();

package/packages/@monomind/cli/dist/src/browser/console-log.d.ts

@@ -15,8 +15,8 @@ export interface PageError {
 }
 export declare function setupConsoleCapture(client: CdpClient, sessionId: string): void;
 export declare function enableConsoleCapture(client: CdpClient, sessionId: string): Promise<void>;
-export declare function getConsoleMessages(): ConsoleMessage[];
-export declare function clearConsoleMessages(): void;
-export declare function getPageErrors(): PageError[];
-export declare function clearPageErrors(): void;
+export declare function getConsoleMessages(sessionId?: string): ConsoleMessage[];
+export declare function clearConsoleMessages(sessionId?: string): void;
+export declare function getPageErrors(sessionId?: string): PageError[];
+export declare function clearPageErrors(sessionId?: string): void;
 //# sourceMappingURL=console-log.d.ts.map

package/packages/@monomind/cli/dist/src/browser/console-log.js

@@ -1,22 +1,41 @@
-let consoleMessages = [];
-let pageErrors = [];
+const _consoleMessages = new Map();
+const _pageErrors = new Map();
+const _consoleListeners = new Map();
+function messagesFor(sessionId) {
+    if (!_consoleMessages.has(sessionId))
+        _consoleMessages.set(sessionId, []);
+    return _consoleMessages.get(sessionId);
+}
+function errorsFor(sessionId) {
+    if (!_pageErrors.has(sessionId))
+        _pageErrors.set(sessionId, []);
+    return _pageErrors.get(sessionId);
+}
 export function setupConsoleCapture(client, sessionId) {
-    client.on('Runtime.consoleAPICalled', (params, sid) => {
+    // Remove stale listeners from any prior connection on this sessionId
+    const prevOffs = _consoleListeners.get(sessionId);
+    if (prevOffs) {
+        for (const off of prevOffs)
+            off();
+    }
+    _consoleMessages.set(sessionId, []);
+    _pageErrors.set(sessionId, []);
+    const off1 = client.on('Runtime.consoleAPICalled', (params, sid) => {
         if (sid !== sessionId)
             return;
         const args = params.args ?? [];
         const text = args.map((a) => a.description ?? String(a.value ?? '')).join(' ');
-        consoleMessages.push({
+        messagesFor(sessionId).push({
             type: params.type ?? 'log',
             text,
             timestamp: Date.now(),
         });
     });
-    client.on('Log.entryAdded', (params, sid) => {
+    const off2 = client.on('Log.entryAdded', (params, sid) => {
         if (sid !== sessionId)
             return;
         const entry = params.entry;
-        consoleMessages.push({
+        messagesFor(sessionId).push({
             type: entry.level ?? 'log',
             text: entry.text ?? '',
             timestamp: Date.now(),
@@ -24,11 +43,11 @@ export function setupConsoleCapture(client, sessionId) {
             lineNumber: entry.lineNumber,
         });
     });
-    client.on('Runtime.exceptionThrown', (params, sid) => {
+    const off3 = client.on('Runtime.exceptionThrown', (params, sid) => {
         if (sid !== sessionId)
             return;
         const detail = params.exceptionDetails;
-        pageErrors.push({
+        errorsFor(sessionId).push({
             text: detail.text ?? 'Unknown error',
             url: detail.url,
             lineNumber: detail.lineNumber,
@@ -36,20 +55,34 @@ export function setupConsoleCapture(client, sessionId) {
             timestamp: Date.now(),
         });
     });
+    _consoleListeners.set(sessionId, [off1, off2, off3]);
 }
 export async function enableConsoleCapture(client, sessionId) {
     await client.send('Log.enable', {}, sessionId);
 }
-export function getConsoleMessages() {
-    return [...consoleMessages];
+export function getConsoleMessages(sessionId) {
+    if (sessionId)
+        return [...(messagesFor(sessionId))];
+    // Fallback: return all messages across all sessions (legacy callers)
+    return [..._consoleMessages.values()].flat();
 }
-export function clearConsoleMessages() {
-    consoleMessages = [];
+export function clearConsoleMessages(sessionId) {
+    if (sessionId) {
+        _consoleMessages.set(sessionId, []);
+        return;
+    }
+    _consoleMessages.clear();
 }
-export function getPageErrors() {
-    return [...pageErrors];
+export function getPageErrors(sessionId) {
+    if (sessionId)
+        return [...(errorsFor(sessionId))];
+    return [..._pageErrors.values()].flat();
 }
-export function clearPageErrors() {
-    pageErrors = [];
+export function clearPageErrors(sessionId) {
+    if (sessionId) {
+        _pageErrors.set(sessionId, []);
+        return;
+    }
+    _pageErrors.clear();
 }
 //# sourceMappingURL=console-log.js.map

package/packages/@monomind/cli/dist/src/browser/dialog.d.ts

@@ -5,7 +5,8 @@ export interface DialogInfo {
     defaultPrompt?: string;
 }
 export declare function setupDialogAutoHandling(client: CdpClient, sessionId: string, autoAccept?: boolean): void;
+export declare function teardownDialogHandling(sessionId: string): void;
 export declare function acceptDialog(client: CdpClient, sessionId: string, text?: string): Promise<void>;
 export declare function dismissDialog(client: CdpClient, sessionId: string): Promise<void>;
-export declare function getDialogStatus(): DialogInfo | null;
+export declare function getDialogStatus(sessionId: string): DialogInfo | null;
 //# sourceMappingURL=dialog.d.ts.map

package/packages/@monomind/cli/dist/src/browser/dialog.js

@@ -1,6 +1,10 @@
-let pendingDialog = null;
+const _pendingDialogs = new Map();
+const _dialogListeners = new Map();
 export function setupDialogAutoHandling(client, sessionId, autoAccept = true) {
-    client.on('Page.javascriptDialogOpening', async (params, sid) => {
+    if (_pendingDialogs.has(sessionId))
+        return;
+    _pendingDialogs.set(sessionId, null);
+    const off1 = client.on('Page.javascriptDialogOpening', async (params, sid) => {
         if (sid !== sessionId)
             return;
         const info = {
@@ -8,29 +12,39 @@ export function setupDialogAutoHandling(client, sessionId, autoAccept = true) {
             message: params.message,
             defaultPrompt: params.defaultPrompt,
         };
-        pendingDialog = info;
+        _pendingDialogs.set(sessionId, info);
         if (autoAccept && (info.type === 'alert' || info.type === 'beforeunload')) {
             await client.send('Page.handleJavaScriptDialog', { accept: true }, sessionId);
-            pendingDialog = null;
+            _pendingDialogs.set(sessionId, null);
         }
     });
-    client.on('Page.javascriptDialogClosed', (_, sid) => {
+    const off2 = client.on('Page.javascriptDialogClosed', (_, sid) => {
         if (sid === sessionId)
-            pendingDialog = null;
+            _pendingDialogs.set(sessionId, null);
     });
+    _dialogListeners.set(sessionId, [off1, off2]);
+}
+export function teardownDialogHandling(sessionId) {
+    const offs = _dialogListeners.get(sessionId);
+    if (offs) {
+        for (const off of offs)
+            off();
+        _dialogListeners.delete(sessionId);
+    }
+    _pendingDialogs.delete(sessionId);
 }
 export async function acceptDialog(client, sessionId, text) {
     await client.send('Page.handleJavaScriptDialog', {
         accept: true,
         promptText: text,
     }, sessionId);
-    pendingDialog = null;
+    _pendingDialogs.set(sessionId, null);
 }
 export async function dismissDialog(client, sessionId) {
     await client.send('Page.handleJavaScriptDialog', { accept: false }, sessionId);
-    pendingDialog = null;
+    _pendingDialogs.set(sessionId, null);
 }
-export function getDialogStatus() {
-    return pendingDialog;
+export function getDialogStatus(sessionId) {
+    return _pendingDialogs.get(sessionId) ?? null;
 }
 //# sourceMappingURL=dialog.js.map

package/packages/@monomind/cli/dist/src/browser/find.d.ts

@@ -8,7 +8,7 @@ export interface FindOptions {
     first?: boolean;
     last?: boolean;
 }
-export declare function findBySelector(client: CdpClient, sessionId: string, selector: string, options?: FindOptions): Promise<string | null>;
+export declare function findBySelector(client: CdpClient, sessionId: string, refs: Map<string, ElementRef>, selector: string, options?: FindOptions): Promise<ElementRef | null>;
 export declare function findByRole(client: CdpClient, sessionId: string, refs: Map<string, ElementRef>, role: string, options?: FindOptions): Promise<ElementRef | null>;
 export declare function findByText(client: CdpClient, sessionId: string, refs: Map<string, ElementRef>, text: string, options?: FindOptions): Promise<ElementRef | null>;
 export declare function findByLabel(client: CdpClient, sessionId: string, refs: Map<string, ElementRef>, label: string, options?: FindOptions): Promise<ElementRef | null>;

package/packages/@monomind/cli/dist/src/browser/find.js

@@ -1,17 +1,36 @@
 import { evaluateJs } from './actions.js';
 import { getObjectIdForRef } from './snapshot.js';
-export async function findBySelector(client, sessionId, selector, options = {}) {
-    let expr;
-    if (options.nth !== undefined) {
-        expr = `document.querySelectorAll(${JSON.stringify(selector)})[${options.nth - 1}]?.outerHTML ?? null`;
+export async function findBySelector(client, sessionId, refs, selector, options = {}) {
+    try {
+        const doc = await client.send('DOM.getDocument', {}, sessionId);
+        let targetNodeId;
+        if (options.nth !== undefined || options.last) {
+            const result = await client.send('DOM.querySelectorAll', { nodeId: doc.root.nodeId, selector }, sessionId);
+            const nodeIds = result.nodeIds ?? [];
+            if (nodeIds.length === 0)
+                return null;
+            targetNodeId = options.last ? nodeIds[nodeIds.length - 1] : (nodeIds[(options.nth ?? 1) - 1] ?? 0);
+        }
+        else {
+            const result = await client.send('DOM.querySelector', { nodeId: doc.root.nodeId, selector }, sessionId);
+            targetNodeId = result.nodeId ?? 0;
+        }
+        if (!targetNodeId)
+            return null;
+        const desc = await client.send('DOM.describeNode', { nodeId: targetNodeId }, sessionId);
+        const backendDOMNodeId = desc.node?.backendNodeId;
+        if (!backendDOMNodeId)
+            return null;
+        // Return existing ref from snapshot if this node is already indexed
+        const existing = [...refs.values()].find((r) => r.backendDOMNodeId === backendDOMNodeId);
+        if (existing)
+            return existing;
+        // Synthetic ref for elements not represented in the AX tree
+        return { ref: `sel-${backendDOMNodeId}`, role: 'generic', name: selector, nodeId: targetNodeId, backendDOMNodeId };
     }
-    else if (options.last) {
-        expr = `Array.from(document.querySelectorAll(${JSON.stringify(selector)})).at(-1)?.outerHTML ?? null`;
-    }
-    else {
-        expr = `document.querySelector(${JSON.stringify(selector)})?.outerHTML ?? null`;
+    catch {
+        return null;
     }
-    return evaluateJs(client, sessionId, expr);
 }
 export async function findByRole(client, sessionId, refs, role, options = {}) {
     const lowerRole = role.toLowerCase();

package/packages/@monomind/cli/dist/src/browser/har.js

@@ -51,7 +51,7 @@ export async function startHarRecording(client, sessionId) {
             entry.endTime = cdpToWall(p.timestamp);
         }
     });
-    _sessions.set(sessionId, { requests, offReq, offResp, offFinished, startTime, startWallMs, refCdpTs });
+    _sessions.set(sessionId, { requests, offReq, offResp, offFinished, startTime, startWallMs });
 }
 export async function stopHarRecording(client, sessionId, outputPath, captureResponseBodies = false) {
     const state = _sessions.get(sessionId);
@@ -68,14 +68,14 @@ export async function stopHarRecording(client, sessionId, outputPath, captureRes
                 entry.responseBody = body.base64Encoded
                     ? Buffer.from(body.body, 'base64').toString('utf8')
                     : body.body;
-                entry.size = entry.responseBody.length;
+                entry.size = entry.responseBody?.length ?? 0;
             }
             catch {
                 // body may not be available for cached/redirected responses
             }
         }
     }
-    _sessions.delete(sessionId);
+    _sessions.delete(sessionId); // always runs — response body loop errors are caught per-entry
     const har = buildHar(Array.from(state.requests.values()), state.startTime);
     const path = outputPath ?? join(tmpdir(), `monomind-har-${Date.now()}.har`);
     await writeFile(path, JSON.stringify(har, null, 2));

package/packages/@monomind/cli/dist/src/browser/network.d.ts

@@ -24,4 +24,6 @@ export declare function clearCapturedRequests(sessionId: string): void;
 export declare function disableInterception(client: CdpClient, sessionId: string): Promise<void>;
 export declare function getLocalStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>>;
 export declare function setLocalStorage(client: CdpClient, sessionId: string, data: Record<string, string>): Promise<void>;
+export declare function getSessionStorage(client: CdpClient, sessionId: string): Promise<Record<string, string>>;
+export declare function setSessionStorage(client: CdpClient, sessionId: string, data: Record<string, string>): Promise<void>;
 //# sourceMappingURL=network.d.ts.map

package/packages/@monomind/cli/dist/src/browser/network.js

@@ -16,39 +16,55 @@ export async function enableInterception(client, sessionId) {
         patterns: [{ requestStage: 'Request' }],
     }, sessionId);
 }
+const _routeListeners = new Map();
 export async function setupRoutes(client, sessionId, routes) {
-    if (routes.length === 0)
+    // Remove previous route listener for this session before registering a new one
+    const prevOff = _routeListeners.get(sessionId);
+    if (prevOff) {
+        prevOff();
+        _routeListeners.delete(sessionId);
+    }
+    if (routes.length === 0) {
+        await client.send('Fetch.disable', {}, sessionId);
         return;
+    }
     await client.send('Fetch.enable', {
         patterns: routes.map((r) => ({ urlPattern: globToFetchPattern(r.pattern), requestStage: 'Request' })),
     }, sessionId);
-    client.on('Fetch.requestPaused', async (params, sid) => {
+    const off = client.on('Fetch.requestPaused', async (params, sid) => {
         if (sid !== sessionId)
             return;
         const { requestId, request } = params;
-        const matchedRoute = routes.find((r) => globToRegex(r.pattern).test(request.url));
-        if (!matchedRoute) {
-            await client.send('Fetch.continueRequest', { requestId }, sessionId);
-            return;
-        }
-        switch (matchedRoute.action) {
-            case 'abort':
-                await client.send('Fetch.failRequest', { requestId, errorReason: 'Failed' }, sessionId);
-                break;
-            case 'fulfill':
-                await client.send('Fetch.fulfillRequest', {
-                    requestId,
-                    responseCode: matchedRoute.response?.status ?? 200,
-                    responseHeaders: Object.entries(matchedRoute.response?.headers ?? {}).map(([name, value]) => ({ name, value })),
-                    body: matchedRoute.response?.body ? Buffer.from(matchedRoute.response.body).toString('base64') : '',
-                }, sessionId);
-                break;
-            case 'continue':
-            default:
+        try {
+            const matchedRoute = routes.find((r) => globToRegex(r.pattern).test(request.url));
+            if (!matchedRoute) {
                 await client.send('Fetch.continueRequest', { requestId }, sessionId);
-                break;
+                return;
+            }
+            switch (matchedRoute.action) {
+                case 'abort':
+                    await client.send('Fetch.failRequest', { requestId, errorReason: 'Failed' }, sessionId);
+                    break;
+                case 'fulfill':
+                    await client.send('Fetch.fulfillRequest', {
+                        requestId,
+                        responseCode: matchedRoute.response?.status ?? 200,
+                        responseHeaders: Object.entries(matchedRoute.response?.headers ?? {}).map(([name, value]) => ({ name, value })),
+                        body: matchedRoute.response?.body ? Buffer.from(matchedRoute.response.body).toString('base64') : '',
+                    }, sessionId);
+                    break;
+                case 'continue':
+                default:
+                    await client.send('Fetch.continueRequest', { requestId }, sessionId);
+                    break;
+            }
+        }
+        catch {
+            // Best-effort: resume the request so it doesn't hang in Chrome
+            await client.send('Fetch.continueRequest', { requestId }, sessionId).catch(() => { });
         }
     });
+    _routeListeners.set(sessionId, off);
 }
 const _capturedRequests = new Map();
 const _captureListeners = new Map();
@@ -103,6 +119,11 @@ export function clearCapturedRequests(sessionId) {
     _capturedRequests.set(sessionId, []);
 }
 export async function disableInterception(client, sessionId) {
+    const prevOff = _routeListeners.get(sessionId);
+    if (prevOff) {
+        prevOff();
+        _routeListeners.delete(sessionId);
+    }
     await client.send('Fetch.disable', {}, sessionId);
 }
 export async function getLocalStorage(client, sessionId) {
@@ -121,7 +142,27 @@ export async function setLocalStorage(client, sessionId, data) {
     const script = Object.entries(data)
         .map(([k, v]) => `localStorage.setItem(${JSON.stringify(k)}, ${JSON.stringify(v)})`)
         .join('; ');
-    await client.send('Runtime.evaluate', { expression: script }, sessionId);
+    if (script)
+        await client.send('Runtime.evaluate', { expression: script }, sessionId);
+}
+export async function getSessionStorage(client, sessionId) {
+    const result = await client.send('Runtime.evaluate', {
+        expression: 'JSON.stringify(Object.fromEntries(Object.entries(sessionStorage)))',
+        returnByValue: true,
+    }, sessionId);
+    try {
+        return JSON.parse(result.result?.value ?? '{}');
+    }
+    catch {
+        return {};
+    }
+}
+export async function setSessionStorage(client, sessionId, data) {
+    const script = Object.entries(data)
+        .map(([k, v]) => `sessionStorage.setItem(${JSON.stringify(k)}, ${JSON.stringify(v)})`)
+        .join('; ');
+    if (script)
+        await client.send('Runtime.evaluate', { expression: script }, sessionId);
 }
 function globToRegex(pattern) {
     const escaped = pattern

package/packages/@monomind/cli/dist/src/browser/profiler.js

@@ -17,9 +17,15 @@ export async function stopCpuProfile(client, sessionId, outputPath) {
     if (!_sessions.has(sessionId)) {
         throw new Error('No active CPU profiler for this session');
     }
-    const result = await client.send('Profiler.stop', {}, sessionId);
-    await client.send('Profiler.disable', {}, sessionId);
-    _sessions.delete(sessionId);
+    let result;
+    try {
+        result = await client.send('Profiler.stop', {}, sessionId);
+    }
+    finally {
+        _sessions.delete(sessionId);
+    }
+    // Disable after capturing the profile so a disable failure doesn't discard valid data
+    await client.send('Profiler.disable', {}, sessionId).catch(() => { });
     const path = outputPath ?? join(tmpdir(), `monomind-profile-${Date.now()}.cpuprofile`);
     await writeFile(path, JSON.stringify(result.profile));
     return path;
@@ -35,19 +41,23 @@ export async function startHeapSnapshot(client, sessionId, outputPath) {
             return;
         chunks.push(params.chunk);
     });
-    await new Promise((resolve, reject) => {
-        const off2 = client.on('HeapProfiler.reportHeapSnapshotProgress', (params, sid) => {
-            if (sid !== sessionId)
-                return;
-            if (params.finished) {
-                off2();
-                resolve();
-            }
+    try {
+        await new Promise((resolve, reject) => {
+            const off2 = client.on('HeapProfiler.reportHeapSnapshotProgress', (params, sid) => {
+                if (sid !== sessionId)
+                    return;
+                if (params.finished) {
+                    off2();
+                    resolve();
+                }
+            });
+            client.send('HeapProfiler.takeHeapSnapshot', { reportProgress: true }, sessionId)
+                .catch((err) => { off2(); reject(err); });
         });
-        client.send('HeapProfiler.takeHeapSnapshot', { reportProgress: true }, sessionId)
-            .catch((err) => { off2(); reject(err); });
-    });
-    off();
+    }
+    finally {
+        off();
+    }
     await client.send('HeapProfiler.disable', {}, sessionId);
     const path = outputPath ?? join(tmpdir(), `monomind-heap-${Date.now()}.heapsnapshot`);
     await writeFile(path, chunks.join(''));

package/packages/@monomind/cli/dist/src/browser/record.js

@@ -34,9 +34,13 @@ export async function stopRecording(client, sessionId, outputPath) {
     const state = _sessions.get(sessionId);
     if (!state)
         throw new Error('No active recording for this session');
-    await client.send('Page.stopScreencast', {}, sessionId);
-    state.offScreencast?.();
-    _sessions.delete(sessionId);
+    try {
+        await client.send('Page.stopScreencast', {}, sessionId);
+    }
+    finally {
+        state.offScreencast?.();
+        _sessions.delete(sessionId);
+    }
     const path = outputPath ?? join(tmpdir(), `monomind-screencast-${Date.now()}.frames.json`);
     await writeFile(path, JSON.stringify({ frameCount: state.frames.length, frames: state.frames }));
     return path;

package/packages/@monomind/cli/dist/src/browser/session.js

@@ -2,13 +2,14 @@ import { readFile, writeFile, mkdir } from 'fs/promises';
 import { existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import { getCookies, setCookies, getLocalStorage, setLocalStorage } from './network.js';
+import { getCookies, setCookies, getLocalStorage, setLocalStorage, getSessionStorage, setSessionStorage } from './network.js';
 const SESSION_DIR = join(homedir(), '.monomind', 'browser-sessions');
 export async function saveSession(client, sessionId, targetId, name, url, title) {
     await mkdir(SESSION_DIR, { recursive: true });
     const cookies = await getCookies(client, sessionId);
     const localStorage = await getLocalStorage(client, sessionId);
-    const state = { targetId, sessionId, url, title, cookies, localStorage };
+    const sessionStorage = await getSessionStorage(client, sessionId);
+    const state = { targetId, sessionId, url, title, cookies, localStorage, sessionStorage };
     const filePath = join(SESSION_DIR, `${name}.json`);
     await writeFile(filePath, JSON.stringify(state, null, 2));
     return filePath;
@@ -20,24 +21,27 @@ export async function loadSession(client, sessionId, name) {
     const raw = await readFile(filePath, 'utf8');
     const state = JSON.parse(raw);
     await setCookies(client, sessionId, state.cookies);
-    if (state.localStorage) {
+    if (state.localStorage)
         await setLocalStorage(client, sessionId, state.localStorage);
-    }
+    if (state.sessionStorage)
+        await setSessionStorage(client, sessionId, state.sessionStorage);
     return state;
 }
 export async function saveStateFile(client, sessionId, targetId, filePath, url, title) {
     const cookies = await getCookies(client, sessionId);
     const localStorage = await getLocalStorage(client, sessionId);
-    const state = { targetId, sessionId, url, title, cookies, localStorage };
+    const sessionStorage = await getSessionStorage(client, sessionId);
+    const state = { targetId, sessionId, url, title, cookies, localStorage, sessionStorage };
     await writeFile(filePath, JSON.stringify(state, null, 2));
 }
 export async function loadStateFile(client, sessionId, filePath) {
     const raw = await readFile(filePath, 'utf8');
     const state = JSON.parse(raw);
     await setCookies(client, sessionId, state.cookies);
-    if (state.localStorage) {
+    if (state.localStorage)
         await setLocalStorage(client, sessionId, state.localStorage);
-    }
+    if (state.sessionStorage)
+        await setSessionStorage(client, sessionId, state.sessionStorage);
     return state;
 }
 export async function listSessions() {

package/packages/@monomind/cli/dist/src/browser/trace.js

@@ -30,28 +30,43 @@ export async function startTrace(client, sessionId, options = {}) {
     const cats = [...(options.categories ?? DEFAULT_CATEGORIES)];
     if (options.screenshots)
         cats.push('disabled-by-default-devtools.screenshot');
-    await client.send('Tracing.start', {
-        traceConfig: {
-            includedCategories: cats.filter((c) => !c.startsWith('-')),
-            excludedCategories: cats.filter((c) => c.startsWith('-')).map((c) => c.slice(1)),
-        },
-    }, sessionId);
+    try {
+        await client.send('Tracing.start', {
+            traceConfig: {
+                includedCategories: cats.filter((c) => !c.startsWith('-')),
+                excludedCategories: cats.filter((c) => c.startsWith('-')).map((c) => c.slice(1)),
+            },
+        }, sessionId);
+    }
+    catch (err) {
+        offData();
+        _sessions.delete(sessionId);
+        throw err;
+    }
 }
 export async function stopTrace(client, sessionId, outputPath) {
     const state = _sessions.get(sessionId);
     if (!state)
         throw new Error('No active trace for this session');
-    await new Promise((resolve) => {
-        const off = client.on('Tracing.tracingComplete', (_params, sid) => {
-            if (sid !== sessionId)
-                return;
-            off();
-            resolve();
-        });
-        client.send('Tracing.end', {}, sessionId).catch(() => { });
-    });
-    state.offData();
-    _sessions.delete(sessionId);
+    try {
+        const [completePromise, cancelOnce] = client.onceWithOff('Tracing.tracingComplete', sessionId);
+        let timedOut = false;
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => { timedOut = true; cancelOnce(); reject(new Error('Timeout waiting for Tracing.tracingComplete')); }, 30_000));
+        try {
+            await client.send('Tracing.end', {}, sessionId);
+            await Promise.race([completePromise, timeoutPromise]);
+        }
+        catch (err) {
+            cancelOnce();
+            throw err;
+        }
+        if (timedOut)
+            throw new Error('Timeout waiting for Tracing.tracingComplete');
+    }
+    finally {
+        state.offData();
+        _sessions.delete(sessionId);
+    }
     const trace = {
         traceEvents: state.events,
         metadata: { 'clock-offset-since-epoch': Date.now() },

package/packages/@monomind/cli/dist/src/browser/wait.js

@@ -30,33 +30,47 @@ async function waitForLoad(client, sessionId, condition, timeout) {
         return;
     }
     const event = condition === 'load' ? 'Page.loadEventFired' : 'Page.domContentEventFired';
-    await Promise.race([
-        client.once(event, sessionId),
-        sleep(timeout).then(() => { throw new Error(`Timeout waiting for ${condition}`); }),
-    ]);
+    const [eventPromise, cancelOnce] = client.onceWithOff(event, sessionId);
+    let timedOut = false;
+    const timeoutPromise = sleep(timeout).then(() => { timedOut = true; });
+    try {
+        await Promise.race([eventPromise, timeoutPromise]);
+        if (timedOut)
+            throw new Error(`Timeout waiting for ${condition}`);
+    }
+    finally {
+        cancelOnce();
+    }
 }
 async function waitForNetworkIdle(client, sessionId, idleMs, timeout) {
     return new Promise((resolve, reject) => {
         let pending = 0;
-        let timer = null;
-        const killTimer = setTimeout(() => reject(new Error('Timeout waiting for networkidle')), timeout);
-        const settle = () => {
+        let idleTimer = null;
+        const cleanup = () => {
+            if (idleTimer) {
+                clearTimeout(idleTimer);
+                idleTimer = null;
+            }
             clearTimeout(killTimer);
             offReq();
             offResp();
             offFail();
-            resolve();
         };
+        const killTimer = setTimeout(() => {
+            cleanup();
+            reject(new Error('Timeout waiting for networkidle'));
+        }, timeout);
+        const settle = () => { cleanup(); resolve(); };
         const check = () => {
             if (pending === 0) {
-                if (timer)
-                    clearTimeout(timer);
-                timer = setTimeout(settle, idleMs);
+                if (idleTimer)
+                    clearTimeout(idleTimer);
+                idleTimer = setTimeout(settle, idleMs);
             }
             else {
-                if (timer) {
-                    clearTimeout(timer);
-                    timer = null;
+                if (idleTimer) {
+                    clearTimeout(idleTimer);
+                    idleTimer = null;
                 }
             }
         };

package/packages/@monomind/cli/dist/src/commands/browse.js

@@ -994,12 +994,12 @@ const clipboardCommand = {
                 break;
             }
             case 'copy':
-                await browser.pressKey(client, sessionId, 'c');
-                output.printSuccess('Copy sent (Ctrl+C equivalent)');
+                await browser.pressKeyCombo(client, sessionId, 'c', 2); // Ctrl modifier
+                output.printSuccess('Copy sent');
                 break;
             case 'paste':
-                await browser.pressKey(client, sessionId, 'v');
-                output.printSuccess('Paste sent (Ctrl+V equivalent)');
+                await browser.pressKeyCombo(client, sessionId, 'v', 2); // Ctrl modifier
+                output.printSuccess('Paste sent');
                 break;
             default:
                 throw new Error('Usage: monomind browse clipboard read|write|copy|paste');
@@ -1026,7 +1026,7 @@ const dialogCommand = {
                 output.printSuccess('Dialog dismissed');
                 break;
             case 'status': {
-                const info = browser.getDialogStatus();
+                const info = browser.getDialogStatus(sessionId);
                 if (info) {
                     print(`Dialog open: type=${info.type} message="${info.message}"`);
                 }
@@ -1354,15 +1354,9 @@ const findCommand = {
             case 'placeholder':
                 ref = await browser.findByPlaceholder(client, sessionId, _refs, value, opts);
                 break;
-            case 'selector': {
-                const html = await browser.findBySelector(client, sessionId, value, opts);
-                if (!html) {
-                    output.printWarning(`selector not found: ${value}`);
-                    return { success: false };
-                }
-                output.printSuccess(`Found: ${value}`);
-                return { success: true, data: { html } };
-            }
+            case 'selector':
+                ref = await browser.findBySelector(client, sessionId, _refs, value, opts);
+                break;
             case 'testid': {
                 const sel = await browser.findByTestId(client, sessionId, value);
                 if (!sel) {

package/packages/@monomind/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.10.37",
+  "version": "1.10.38",
   "type": "module",
   "description": "Monomind CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory for Claude Code",
   "main": "dist/src/index.js",