monomind 1.10.33 → 1.10.35

package/.claude/helpers/intelligence.cjs

@@ -10,11 +10,12 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-const DATA_DIR = path.join(process.cwd(), '.monomind', 'data');
+const _CWD = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+const DATA_DIR = path.join(_CWD, '.monomind', 'data');
 const STORE_PATH = path.join(DATA_DIR, 'auto-memory-store.json');
 const RANKED_PATH = path.join(DATA_DIR, 'ranked-context.json');
 const PENDING_PATH = path.join(DATA_DIR, 'pending-insights.jsonl');
-const SESSION_DIR = path.join(process.cwd(), '.monomind', 'sessions');
+const SESSION_DIR = path.join(_CWD, '.monomind', 'sessions');
 const SESSION_FILE = path.join(SESSION_DIR, 'current.json');
 
 // ── Safety limits (fixes #1530, #1531) ─────────────────────────────────────

package/.claude/helpers/session.cjs

@@ -12,7 +12,8 @@ const platform = os.platform();
 const homeDir = os.homedir();
 
 function getDataDir() {
-  const localDir = path.join(process.cwd(), '.monomind', 'sessions');
+  const baseDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const localDir = path.join(baseDir, '.monomind', 'sessions');
   if (fs.existsSync(path.dirname(localDir))) {
     return localDir;
   }

package/.claude/skills/monomind/.monomind/registry.json

@@ -0,0 +1,6 @@
+{
+  "version": "1.0.0",
+  "generatedAt": "2026-05-17T17:12:24.935Z",
+  "totalAgents": 0,
+  "agents": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monomind",
-  "version": "1.10.33",
+  "version": "1.10.35",
   "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/browser.js

@@ -4,6 +4,8 @@ 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 { setupDialogAutoHandling } from './dialog.js';
 const DEFAULT_PORT = 9222;
 const LAUNCH_TIMEOUT = 10_000;
 const POLL_INTERVAL = 200;
@@ -112,6 +114,9 @@ export async function connectToTarget(port, targetId) {
         client.send('DOM.enable', {}, sessionId),
         client.send('Accessibility.enable', {}, sessionId),
     ]);
+    // Wire up auto-capture listeners so console/errors/dialogs work immediately
+    enableConsoleCapture(client, sessionId);
+    setupDialogAutoHandling(client, sessionId);
     return { client, target, sessionId };
 }
 export async function openUrl(client, sessionId, url) {
@@ -122,7 +127,7 @@ export async function waitForLoad(client, sessionId, condition = 'load', timeout
     if (condition === 'load' || condition === 'domcontentloaded') {
         const event = condition === 'load' ? 'Page.loadEventFired' : 'Page.domContentEventFired';
         await Promise.race([
-            client.once(event),
+            client.once(event, sessionId),
             sleep(timeout).then(() => { throw new Error(`Timeout waiting for ${condition}`); }),
         ]);
         return;
@@ -137,16 +142,23 @@ async function waitForNetworkIdle(client, sessionId, idleMs) {
     return new Promise((resolve) => {
         let pending = 0;
         let timer = null;
+        const settle = () => {
+            offReq();
+            offResp();
+            offFail();
+            resolve();
+        };
         const check = () => {
             if (pending === 0) {
                 if (timer)
                     clearTimeout(timer);
-                timer = setTimeout(resolve, idleMs);
+                timer = setTimeout(settle, idleMs);
             }
             else {
-                if (timer)
+                if (timer) {
                     clearTimeout(timer);
-                timer = null;
+                    timer = null;
+                }
             }
         };
         const offReq = client.on('Network.requestWillBeSent', (_, sid) => {
@@ -168,14 +180,6 @@ async function waitForNetworkIdle(client, sessionId, idleMs) {
             }
         });
         check();
-        // Cleanup after resolution
-        const originalResolve = resolve;
-        resolve = () => {
-            offReq();
-            offResp();
-            offFail();
-            originalResolve();
-        };
     });
 }
 export async function getCurrentUrl(client, sessionId) {

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

@@ -8,7 +8,7 @@ export declare class CdpClient {
     connect(wsUrl: string): Promise<void>;
     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): Promise<Record<string, unknown>>;
+    once(event: string, sessionId?: string): Promise<Record<string, unknown>>;
     close(): void;
     isConnected(): boolean;
 }

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

@@ -74,9 +74,11 @@ export class CdpClient {
         this.eventListeners.get(event).add(fn);
         return () => this.eventListeners.get(event)?.delete(fn);
     }
-    once(event) {
+    once(event, sessionId) {
         return new Promise((resolve) => {
-            const off = this.on(event, (params) => {
+            const off = this.on(event, (params, sid) => {
+                if (sessionId !== undefined && sid !== sessionId)
+                    return;
                 off();
                 resolve(params);
             });

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

@@ -12,6 +12,7 @@ export declare function findBySelector(client: CdpClient, sessionId: string, sel
 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>;
+export declare function findByPlaceholder(client: CdpClient, sessionId: string, refs: Map<string, ElementRef>, placeholder: string, options?: FindOptions): Promise<ElementRef | null>;
 export declare function findByTestId(client: CdpClient, sessionId: string, testId: string): Promise<string | null>;
 export declare function isVisible(client: CdpClient, sessionId: string, ref: ElementRef): Promise<boolean>;
 export declare function isEnabled(client: CdpClient, sessionId: string, ref: ElementRef): Promise<boolean>;

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

@@ -43,6 +43,18 @@ export async function findByText(client, sessionId, refs, text, options = {}) {
 export async function findByLabel(client, sessionId, refs, label, options = {}) {
     return findByText(client, sessionId, refs, label, options);
 }
+export async function findByPlaceholder(client, sessionId, refs, placeholder, options = {}) {
+    const lower = placeholder.toLowerCase();
+    const candidates = [...refs.values()].filter((r) => {
+        const desc = (r.description ?? '').toLowerCase();
+        return options.exact ? desc === lower : desc.includes(lower);
+    });
+    if (options.nth !== undefined)
+        return candidates[options.nth - 1] ?? null;
+    if (options.last)
+        return candidates[candidates.length - 1];
+    return candidates[0] ?? null;
+}
 export async function findByTestId(client, sessionId, testId) {
     const selectors = [
         `[data-testid="${testId}"]`,

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

@@ -0,0 +1,26 @@
+import type { CdpClient } from './cdp.js';
+interface HarRequest {
+    id: string;
+    url: string;
+    method: string;
+    status: number;
+    statusText: string;
+    mimeType: string;
+    requestHeaders: Record<string, string>;
+    responseHeaders: Record<string, string>;
+    startTime: number;
+    endTime: number;
+    size: number;
+    encodedSize: number;
+    fromCache: boolean;
+    responseBody?: string;
+}
+export declare function startHarRecording(client: CdpClient, sessionId: string): Promise<void>;
+export declare function stopHarRecording(client: CdpClient, sessionId: string, outputPath?: string, captureResponseBodies?: boolean): Promise<string>;
+export declare function getHarStatus(sessionId: string): {
+    recording: boolean;
+    requestCount: number;
+};
+export declare function getRequests(sessionId: string): Partial<HarRequest>[];
+export {};
+//# sourceMappingURL=har.d.ts.map

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

@@ -0,0 +1,130 @@
+import { writeFile } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+const _sessions = new Map();
+export async function startHarRecording(client, sessionId) {
+    if (_sessions.has(sessionId))
+        throw new Error('HAR recording already in progress');
+    const requests = new Map();
+    const startTime = Date.now();
+    const offReq = client.on('Network.requestWillBeSent', (params, sid) => {
+        if (sid !== sessionId)
+            return;
+        const p = params;
+        requests.set(p.requestId, {
+            id: p.requestId,
+            url: p.request.url,
+            method: p.request.method,
+            requestHeaders: p.request.headers,
+            startTime: p.timestamp * 1000,
+            fromCache: false,
+        });
+    });
+    const offResp = client.on('Network.responseReceived', (params, sid) => {
+        if (sid !== sessionId)
+            return;
+        const p = params;
+        const entry = requests.get(p.requestId);
+        if (entry) {
+            entry.status = p.response.status;
+            entry.statusText = p.response.statusText;
+            entry.mimeType = p.response.mimeType;
+            entry.responseHeaders = p.response.headers;
+            entry.fromCache = p.response.fromDiskCache || p.response.fromServiceWorker;
+            entry.endTime = p.timestamp * 1000;
+        }
+    });
+    const offFinished = client.on('Network.loadingFinished', (params, sid) => {
+        if (sid !== sessionId)
+            return;
+        const p = params;
+        const entry = requests.get(p.requestId);
+        if (entry) {
+            entry.encodedSize = p.encodedDataLength;
+            entry.endTime = p.timestamp * 1000;
+        }
+    });
+    _sessions.set(sessionId, { requests, offReq, offResp, offFinished, startTime });
+}
+export async function stopHarRecording(client, sessionId, outputPath, captureResponseBodies = false) {
+    const state = _sessions.get(sessionId);
+    if (!state)
+        throw new Error('No active HAR recording for this session');
+    state.offReq();
+    state.offResp();
+    state.offFinished();
+    // Optionally fetch response bodies
+    if (captureResponseBodies) {
+        for (const [reqId, entry] of state.requests.entries()) {
+            try {
+                const body = await client.send('Network.getResponseBody', { requestId: reqId }, sessionId);
+                entry.responseBody = body.base64Encoded
+                    ? Buffer.from(body.body, 'base64').toString('utf8')
+                    : body.body;
+                entry.size = entry.responseBody.length;
+            }
+            catch {
+                // body may not be available for cached/redirected responses
+            }
+        }
+    }
+    _sessions.delete(sessionId);
+    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));
+    return path;
+}
+export function getHarStatus(sessionId) {
+    const state = _sessions.get(sessionId);
+    return { recording: !!state, requestCount: state?.requests.size ?? 0 };
+}
+export function getRequests(sessionId) {
+    const state = _sessions.get(sessionId);
+    return state ? Array.from(state.requests.values()) : [];
+}
+function buildHar(entries, startTime) {
+    return {
+        log: {
+            version: '1.2',
+            creator: { name: 'monomind browse', version: '1.0.0' },
+            pages: [{
+                    startedDateTime: new Date(startTime).toISOString(),
+                    id: 'page_1',
+                    title: '',
+                    pageTimings: {},
+                }],
+            entries: entries.map((e) => ({
+                startedDateTime: new Date(e.startTime ?? startTime).toISOString(),
+                time: (e.endTime ?? e.startTime ?? startTime) - (e.startTime ?? startTime),
+                request: {
+                    method: e.method ?? 'GET',
+                    url: e.url ?? '',
+                    httpVersion: 'HTTP/1.1',
+                    cookies: [],
+                    headers: Object.entries(e.requestHeaders ?? {}).map(([name, value]) => ({ name, value })),
+                    queryString: [],
+                    headersSize: -1,
+                    bodySize: -1,
+                },
+                response: {
+                    status: e.status ?? 0,
+                    statusText: e.statusText ?? '',
+                    httpVersion: 'HTTP/1.1',
+                    cookies: [],
+                    headers: Object.entries(e.responseHeaders ?? {}).map(([name, value]) => ({ name, value })),
+                    content: {
+                        size: e.size ?? -1,
+                        mimeType: e.mimeType ?? 'application/octet-stream',
+                        text: e.responseBody,
+                    },
+                    redirectURL: '',
+                    headersSize: -1,
+                    bodySize: e.encodedSize ?? -1,
+                },
+                cache: {},
+                timings: { send: 0, wait: 0, receive: 0 },
+            })),
+        },
+    };
+}
+//# sourceMappingURL=har.js.map

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

@@ -15,4 +15,9 @@ export * from './find.js';
 export * from './pdf.js';
 export * from './emulation.js';
 export * from './batch.js';
+export * from './record.js';
+export * from './trace.js';
+export * from './profiler.js';
+export * from './vitals.js';
+export * from './har.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -15,4 +15,9 @@ export * from './find.js';
 export * from './pdf.js';
 export * from './emulation.js';
 export * from './batch.js';
+export * from './record.js';
+export * from './trace.js';
+export * from './profiler.js';
+export * from './vitals.js';
+export * from './har.js';
 //# sourceMappingURL=index.js.map

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

@@ -6,6 +6,21 @@ export declare function clearCookies(client: CdpClient, sessionId: string): Prom
 export declare function setExtraHeaders(client: CdpClient, sessionId: string, headers: Record<string, string>): Promise<void>;
 export declare function enableInterception(client: CdpClient, sessionId: string): Promise<void>;
 export declare function setupRoutes(client: CdpClient, sessionId: string, routes: NetworkRoute[]): Promise<void>;
+export declare function startRequestCapture(client: CdpClient, sessionId: string): void;
+export declare function stopRequestCapture(sessionId: string): void;
+export declare function getCapturedRequests(sessionId: string): {
+    url: string;
+    method: string;
+    status?: number;
+    mimeType?: string;
+    requestHeaders?: Record<string, string>;
+    responseHeaders?: Record<string, string>;
+    startTime: number;
+    endTime?: number;
+    encodedSize?: number;
+}[];
+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>;
 //# sourceMappingURL=network.d.ts.map

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

@@ -50,6 +50,60 @@ export async function setupRoutes(client, sessionId, routes) {
         }
     });
 }
+const _capturedRequests = new Map();
+const _captureListeners = new Map();
+export function startRequestCapture(client, sessionId) {
+    if (_capturedRequests.has(sessionId))
+        return;
+    const list = [];
+    _capturedRequests.set(sessionId, list);
+    const offReq = client.on('Network.requestWillBeSent', (params, sid) => {
+        if (sid !== sessionId)
+            return;
+        const p = params;
+        list.push({ url: p.request.url, method: p.request.method, requestHeaders: p.request.headers, startTime: p.timestamp * 1000 });
+    });
+    const offResp = client.on('Network.responseReceived', (params, sid) => {
+        if (sid !== sessionId)
+            return;
+        const p = params;
+        const entry = list.find((r) => r.url === p.response.url && !r.status);
+        if (entry) {
+            entry.status = p.response.status;
+            entry.mimeType = p.response.mimeType;
+            entry.responseHeaders = p.response.headers;
+            entry.endTime = p.timestamp * 1000;
+        }
+    });
+    const offFinished = client.on('Network.loadingFinished', (params, sid) => {
+        if (sid !== sessionId)
+            return;
+        const p = params;
+        const entry = list[list.length - 1];
+        if (entry) {
+            entry.encodedSize = p.encodedDataLength;
+            entry.endTime = p.timestamp * 1000;
+        }
+    });
+    _captureListeners.set(sessionId, [offReq, offResp, offFinished]);
+}
+export function stopRequestCapture(sessionId) {
+    const offs = _captureListeners.get(sessionId);
+    if (offs) {
+        for (const off of offs)
+            off();
+        _captureListeners.delete(sessionId);
+    }
+}
+export function getCapturedRequests(sessionId) {
+    return _capturedRequests.get(sessionId) ?? [];
+}
+export function clearCapturedRequests(sessionId) {
+    _capturedRequests.set(sessionId, []);
+}
+export async function disableInterception(client, sessionId) {
+    await client.send('Fetch.disable', {}, sessionId);
+}
 export async function getLocalStorage(client, sessionId) {
     const result = await client.send('Runtime.evaluate', {
         expression: 'JSON.stringify(Object.fromEntries(Object.entries(localStorage)))',

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

@@ -0,0 +1,10 @@
+import type { CdpClient } from './cdp.js';
+export interface ProfilerOptions {
+    path?: string;
+    samplingInterval?: number;
+}
+export declare function startCpuProfile(client: CdpClient, sessionId: string, options?: ProfilerOptions): Promise<void>;
+export declare function stopCpuProfile(client: CdpClient, sessionId: string, outputPath?: string): Promise<string>;
+export declare function isProfilingActive(sessionId: string): boolean;
+export declare function startHeapSnapshot(client: CdpClient, sessionId: string, outputPath?: string): Promise<string>;
+//# sourceMappingURL=profiler.d.ts.map

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

@@ -0,0 +1,55 @@
+import { writeFile } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+const _sessions = new Set();
+export async function startCpuProfile(client, sessionId, options = {}) {
+    if (_sessions.has(sessionId)) {
+        throw new Error('CPU profiler already running for this session');
+    }
+    await client.send('Profiler.enable', {}, sessionId);
+    if (options.samplingInterval !== undefined) {
+        await client.send('Profiler.setSamplingInterval', { interval: options.samplingInterval }, sessionId);
+    }
+    await client.send('Profiler.start', {}, sessionId);
+    _sessions.add(sessionId);
+}
+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);
+    const path = outputPath ?? join(tmpdir(), `monomind-profile-${Date.now()}.cpuprofile`);
+    await writeFile(path, JSON.stringify(result.profile));
+    return path;
+}
+export function isProfilingActive(sessionId) {
+    return _sessions.has(sessionId);
+}
+export async function startHeapSnapshot(client, sessionId, outputPath) {
+    await client.send('HeapProfiler.enable', {}, sessionId);
+    const chunks = [];
+    const off = client.on('HeapProfiler.addHeapSnapshotChunk', (params, sid) => {
+        if (sid !== sessionId)
+            return;
+        chunks.push(params.chunk);
+    });
+    await new Promise((resolve) => {
+        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(() => { });
+    });
+    off();
+    await client.send('HeapProfiler.disable', {}, sessionId);
+    const path = outputPath ?? join(tmpdir(), `monomind-heap-${Date.now()}.heapsnapshot`);
+    await writeFile(path, chunks.join(''));
+    return path;
+}
+//# sourceMappingURL=profiler.js.map

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

@@ -0,0 +1,21 @@
+import type { CdpClient } from './cdp.js';
+export interface RecordOptions {
+    path?: string;
+    format?: 'jpeg' | 'png' | 'webp';
+    quality?: number;
+    everyNthFrame?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+}
+export interface RecordingState {
+    frames: string[];
+    offScreencast: (() => void) | null;
+}
+export declare function startRecording(client: CdpClient, sessionId: string, options?: RecordOptions): Promise<void>;
+export declare function stopRecording(client: CdpClient, sessionId: string, outputPath?: string): Promise<string>;
+export declare function getRecordingStatus(sessionId: string): {
+    recording: boolean;
+    frames: number;
+};
+export declare function saveFrameAsPng(client: CdpClient, sessionId: string, frameIndex: number, outputPath: string): Promise<void>;
+//# sourceMappingURL=record.d.ts.map

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

@@ -0,0 +1,48 @@
+import { writeFile } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+const _sessions = new Map();
+export async function startRecording(client, sessionId, options = {}) {
+    if (_sessions.has(sessionId)) {
+        throw new Error('Recording already in progress for this session');
+    }
+    const state = { frames: [], offScreencast: null };
+    _sessions.set(sessionId, state);
+    state.offScreencast = client.on('Page.screencastFrame', async (params, sid) => {
+        if (sid !== sessionId)
+            return;
+        const { data, sessionId: frameSessionId } = params;
+        state.frames.push(data);
+        await client.send('Page.screencastFrameAck', { sessionId: frameSessionId }, sessionId).catch(() => { });
+    });
+    await client.send('Page.startScreencast', {
+        format: options.format ?? 'jpeg',
+        quality: options.quality ?? 80,
+        everyNthFrame: options.everyNthFrame ?? 1,
+        ...(options.maxWidth ? { maxWidth: options.maxWidth } : {}),
+        ...(options.maxHeight ? { maxHeight: options.maxHeight } : {}),
+    }, sessionId);
+}
+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);
+    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;
+}
+export function getRecordingStatus(sessionId) {
+    const state = _sessions.get(sessionId);
+    return { recording: !!state, frames: state?.frames.length ?? 0 };
+}
+export async function saveFrameAsPng(client, sessionId, frameIndex, outputPath) {
+    const state = _sessions.get(sessionId);
+    if (!state || frameIndex >= state.frames.length) {
+        throw new Error(`Frame ${frameIndex} not available`);
+    }
+    await writeFile(outputPath, Buffer.from(state.frames[frameIndex], 'base64'));
+}
+//# sourceMappingURL=record.js.map

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

@@ -1,8 +1,27 @@
 import { INTERACTIVE_ROLES } from './types.js';
 import { getCurrentUrl, getCurrentTitle } from './browser.js';
 export async function captureSnapshot(client, sessionId, options = {}) {
-    const { interactiveOnly = false, compact = false } = options;
-    const { nodes } = await client.send('Accessibility.getFullAXTree', {}, sessionId);
+    const { interactiveOnly = false, compact = false, maxDepth, selector } = options;
+    // If a selector scope is requested, resolve it to a backendDOMNodeId and use getPartialAXTree
+    let nodes;
+    if (selector) {
+        const nodeResult = await client.send('Runtime.evaluate', { expression: `document.querySelector(${JSON.stringify(selector)})?.getAttribute('data-ax-node-id') ?? null`, returnByValue: true }, sessionId);
+        // Use DOM.querySelector to find the backend node
+        const doc = await client.send('DOM.getDocument', {}, sessionId);
+        const found = await client.send('DOM.querySelector', { nodeId: doc.root.nodeId, selector }, sessionId).catch(() => ({ nodeId: 0 }));
+        if (found.nodeId) {
+            const partial = await client.send('Accessibility.getPartialAXTree', { nodeId: found.nodeId, fetchRelatives: true }, sessionId).catch(async () => client.send('Accessibility.getFullAXTree', {}, sessionId));
+            nodes = partial.nodes;
+        }
+        else {
+            const full = await client.send('Accessibility.getFullAXTree', {}, sessionId);
+            nodes = full.nodes;
+        }
+    }
+    else {
+        const full = await client.send('Accessibility.getFullAXTree', {}, sessionId);
+        nodes = full.nodes;
+    }
     const url = await getCurrentUrl(client, sessionId);
     const title = await getCurrentTitle(client, sessionId);
     const refs = new Map();
@@ -14,6 +33,8 @@ export async function captureSnapshot(client, sessionId, options = {}) {
     const processNode = (node, depth) => {
         if (node.ignored)
             return;
+        if (maxDepth !== undefined && depth > maxDepth)
+            return;
         const role = node.role?.value ?? 'generic';
         const name = node.name?.value ?? '';
         const description = node.description?.value;

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

@@ -0,0 +1,10 @@
+import type { CdpClient } from './cdp.js';
+export interface TraceOptions {
+    path?: string;
+    categories?: string[];
+    screenshots?: boolean;
+}
+export declare function startTrace(client: CdpClient, sessionId: string, options?: TraceOptions): Promise<void>;
+export declare function stopTrace(client: CdpClient, sessionId: string, outputPath?: string): Promise<string>;
+export declare function getTraceStatus(sessionId: string): boolean;
+//# sourceMappingURL=trace.d.ts.map