monomind 1.10.34 → 1.10.35

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.34",
+  "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/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

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

@@ -0,0 +1,72 @@
+import { writeFile } from 'fs/promises';
+import { join } from 'path';
+import { tmpdir } from 'os';
+const DEFAULT_CATEGORIES = [
+    '-*',
+    'devtools.timeline',
+    'v8.execute',
+    'disabled-by-default-devtools.timeline',
+    'disabled-by-default-devtools.timeline.frame',
+    'toplevel',
+    'blink.console',
+    'blink.user_timing',
+    'latencyInfo',
+    'disabled-by-default-devtools.timeline.stack',
+];
+const _sessions = new Map();
+export async function startTrace(client, sessionId, options = {}) {
+    if (_sessions.has(sessionId)) {
+        throw new Error('Trace already in progress for this session');
+    }
+    const events = [];
+    const offData = client.on('Tracing.dataCollected', (params, sid) => {
+        if (sid !== sessionId)
+            return;
+        const value = params.value;
+        if (Array.isArray(value))
+            events.push(...value);
+    });
+    const offComplete = client.on('Tracing.tracingComplete', (_params, sid) => {
+        if (sid !== sessionId)
+            return;
+        // Will be resolved by stopTrace
+    });
+    _sessions.set(sessionId, { events, offData, offComplete });
+    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);
+}
+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();
+    state.offComplete();
+    _sessions.delete(sessionId);
+    const trace = {
+        traceEvents: state.events,
+        metadata: { 'clock-offset-since-epoch': Date.now() },
+    };
+    const path = outputPath ?? join(tmpdir(), `monomind-trace-${Date.now()}.json`);
+    await writeFile(path, JSON.stringify(trace));
+    return path;
+}
+export function getTraceStatus(sessionId) {
+    return _sessions.has(sessionId);
+}
+//# sourceMappingURL=trace.js.map

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

@@ -41,6 +41,7 @@ export interface SnapshotOptions {
     interactiveOnly?: boolean;
     compact?: boolean;
     maxDepth?: number;
+    selector?: string;
 }
 export interface SnapshotResult {
     text: string;

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

@@ -0,0 +1,15 @@
+import type { CdpClient } from './cdp.js';
+export interface WebVitals {
+    lcp?: number;
+    fcp?: number;
+    cls?: number;
+    ttfb?: number;
+    inp?: number;
+    domInteractive?: number;
+    domContentLoaded?: number;
+    loadTime?: number;
+    resources?: number;
+}
+export declare function collectVitals(client: CdpClient, sessionId: string, waitMs?: number): Promise<WebVitals>;
+export declare function formatVitals(vitals: WebVitals): string;
+//# sourceMappingURL=vitals.d.ts.map

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

@@ -0,0 +1,116 @@
+import { evaluateJs } from './actions.js';
+export async function collectVitals(client, sessionId, waitMs = 2000) {
+    // Inject PerformanceObserver collectors and wait for data
+    const script = `
+    new Promise((resolve) => {
+      const vitals = {};
+
+      // Navigation timing
+      const nav = performance.getEntriesByType('navigation')[0];
+      if (nav) {
+        vitals.ttfb = nav.responseStart - nav.requestStart;
+        vitals.domInteractive = nav.domInteractive;
+        vitals.domContentLoaded = nav.domContentLoadedEventEnd;
+        vitals.loadTime = nav.loadEventEnd;
+        vitals.resources = performance.getEntriesByType('resource').length;
+      }
+
+      // FCP via paint entries
+      const paintEntries = performance.getEntriesByType('paint');
+      const fcp = paintEntries.find(e => e.name === 'first-contentful-paint');
+      if (fcp) vitals.fcp = fcp.startTime;
+
+      // LCP
+      let lcpValue = 0;
+      let lcpObs;
+      try {
+        lcpObs = new PerformanceObserver((list) => {
+          const entries = list.getEntries();
+          if (entries.length > 0) {
+            lcpValue = entries[entries.length - 1].startTime;
+            vitals.lcp = lcpValue;
+          }
+        });
+        lcpObs.observe({ type: 'largest-contentful-paint', buffered: true });
+      } catch(e) {}
+
+      // CLS
+      let clsValue = 0;
+      let clsObs;
+      try {
+        clsObs = new PerformanceObserver((list) => {
+          for (const entry of list.getEntries()) {
+            if (!(entry as any).hadRecentInput) {
+              clsValue += (entry as any).value;
+            }
+          }
+          vitals.cls = clsValue;
+        });
+        clsObs.observe({ type: 'layout-shift', buffered: true });
+      } catch(e) {}
+
+      // INP
+      let inpValue = 0;
+      let inpObs;
+      try {
+        inpObs = new PerformanceObserver((list) => {
+          for (const entry of list.getEntries()) {
+            if ((entry as any).duration > inpValue) {
+              inpValue = (entry as any).duration;
+              vitals.inp = inpValue;
+            }
+          }
+        });
+        inpObs.observe({ type: 'event', buffered: true, durationThreshold: 40 });
+      } catch(e) {}
+
+      setTimeout(() => {
+        try { lcpObs?.disconnect(); } catch(e) {}
+        try { clsObs?.disconnect(); } catch(e) {}
+        try { inpObs?.disconnect(); } catch(e) {}
+        resolve(vitals);
+      }, ${waitMs});
+    })
+  `;
+    const result = await evaluateJs(client, sessionId, script);
+    return (result ?? {});
+}
+export function formatVitals(vitals) {
+    const lines = [];
+    const ms = (v) => v !== undefined ? `${Math.round(v)}ms` : 'n/a';
+    const score = (metric, v) => {
+        if (v === undefined)
+            return '';
+        if (metric === 'lcp')
+            return v < 2500 ? ' ✓ good' : v < 4000 ? ' ~ needs improvement' : ' ✗ poor';
+        if (metric === 'fcp')
+            return v < 1800 ? ' ✓ good' : v < 3000 ? ' ~ needs improvement' : ' ✗ poor';
+        if (metric === 'cls')
+            return v < 0.1 ? ' ✓ good' : v < 0.25 ? ' ~ needs improvement' : ' ✗ poor';
+        if (metric === 'inp')
+            return v < 200 ? ' ✓ good' : v < 500 ? ' ~ needs improvement' : ' ✗ poor';
+        if (metric === 'ttfb')
+            return v < 800 ? ' ✓ good' : v < 1800 ? ' ~ needs improvement' : ' ✗ poor';
+        return '';
+    };
+    if (vitals.lcp !== undefined)
+        lines.push(`  LCP  (Largest Contentful Paint):  ${ms(vitals.lcp)}${score('lcp', vitals.lcp)}`);
+    if (vitals.fcp !== undefined)
+        lines.push(`  FCP  (First Contentful Paint):     ${ms(vitals.fcp)}${score('fcp', vitals.fcp)}`);
+    if (vitals.cls !== undefined)
+        lines.push(`  CLS  (Cumulative Layout Shift):    ${vitals.cls?.toFixed(4)}${score('cls', vitals.cls)}`);
+    if (vitals.inp !== undefined)
+        lines.push(`  INP  (Interaction to Next Paint):  ${ms(vitals.inp)}${score('inp', vitals.inp)}`);
+    if (vitals.ttfb !== undefined)
+        lines.push(`  TTFB (Time to First Byte):         ${ms(vitals.ttfb)}${score('ttfb', vitals.ttfb)}`);
+    if (vitals.domInteractive !== undefined)
+        lines.push(`  DOM Interactive:                   ${ms(vitals.domInteractive)}`);
+    if (vitals.domContentLoaded !== undefined)
+        lines.push(`  DOMContentLoaded:                  ${ms(vitals.domContentLoaded)}`);
+    if (vitals.loadTime !== undefined)
+        lines.push(`  Load:                              ${ms(vitals.loadTime)}`);
+    if (vitals.resources !== undefined)
+        lines.push(`  Resources loaded:                  ${vitals.resources}`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=vitals.js.map

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

@@ -71,6 +71,8 @@ const snapshotCommand = {
         { name: 'interactive', short: 'i', type: 'boolean', description: 'Interactive elements only (93% token reduction)', default: false },
         { name: 'compact', short: 'c', type: 'boolean', description: 'Compact output format', default: false },
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+        { name: 'depth', short: 'd', type: 'number', description: 'Max depth of AX tree to show' },
+        { name: 'selector', short: 's', type: 'string', description: 'Scope snapshot to a CSS selector' },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
@@ -78,6 +80,8 @@ const snapshotCommand = {
         const result = await browser.captureSnapshot(client, sessionId, {
             interactiveOnly: ctx.flags.interactive,
             compact: ctx.flags.compact,
+            maxDepth: ctx.flags.depth,
+            selector: ctx.flags.selector,
         });
         _refs = result.refs;
         if (ctx.flags.json) {
@@ -158,8 +162,10 @@ const waitCommand = {
     options: [
         { name: 'url', type: 'string', description: 'Wait for URL matching glob pattern' },
         { name: 'text', type: 'string', description: 'Wait for text to appear in page' },
+        { name: 'not-text', type: 'string', description: 'Wait for text to disappear from page' },
         { name: 'selector', type: 'string', description: 'Wait for CSS selector to appear' },
         { name: 'load', type: 'string', description: 'Wait for load event: load|networkidle|domcontentloaded' },
+        { name: 'fn', type: 'string', description: 'Wait until JS expression returns truthy' },
         { name: 'ms', type: 'number', description: 'Wait N milliseconds' },
         { name: 'timeout', short: 't', type: 'number', description: 'Timeout in ms', default: 30000 },
     ],
@@ -171,6 +177,36 @@ const waitCommand = {
             output.printSuccess(`Waited ${ctx.flags.ms}ms`);
             return { success: true };
         }
+        if (ctx.flags.fn) {
+            const expr = ctx.flags.fn;
+            const timeout = ctx.flags.timeout ?? 30000;
+            const interval = 200;
+            const deadline = Date.now() + timeout;
+            while (Date.now() < deadline) {
+                const result = await browser.evaluateJs(client, sessionId, expr);
+                if (result) {
+                    output.printSuccess('Wait function returned truthy');
+                    return { success: true };
+                }
+                await new Promise((r) => setTimeout(r, interval));
+            }
+            throw new Error(`Timeout waiting for --fn: ${expr}`);
+        }
+        if (ctx.flags['not-text']) {
+            const target = ctx.flags['not-text'];
+            const timeout = ctx.flags.timeout ?? 30000;
+            const interval = 200;
+            const deadline = Date.now() + timeout;
+            while (Date.now() < deadline) {
+                const text = await browser.evaluateJs(client, sessionId, 'document.body.innerText');
+                if (!text.includes(target)) {
+                    output.printSuccess('Text disappeared');
+                    return { success: true };
+                }
+                await new Promise((r) => setTimeout(r, interval));
+            }
+            throw new Error(`Timeout waiting for text to disappear: "${target}"`);
+        }
         await browser.waitFor(client, sessionId, {
             url: ctx.flags.url,
             text: ctx.flags.text,
@@ -211,7 +247,7 @@ const screenshotCommand = {
 };
 const getCommand = {
     name: 'get',
-    description: 'Get page info. Usage: monomind browse get url|title|text|html [@ref]',
+    description: 'Get page info. Usage: monomind browse get url|title|text|html|value|attr|count|box|styles [@ref] [attrName]',
     options: [
         { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
     ],
@@ -220,7 +256,7 @@ const getCommand = {
         const browser = await getBrowser();
         const what = ctx.args[0];
         if (!what)
-            throw new Error('Usage: monomind browse get url|title|text|html');
+            throw new Error('Usage: monomind browse get url|title|text|html|value|attr|count|box|styles');
         let value;
         switch (what) {
             case 'url':
@@ -254,14 +290,92 @@ const getCommand = {
             case 'html':
                 value = (await browser.evaluateJs(client, sessionId, 'document.documentElement.outerHTML'));
                 break;
+            case 'value': {
+                const refArg = ctx.args[1];
+                if (!refArg)
+                    throw new Error('Usage: monomind browse get value @ref');
+                const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+                const ref = _refs.get(refKey);
+                if (!ref)
+                    throw new Error(`Ref @${refKey} not found`);
+                const objectId = await browser.getObjectIdForRef(client, sessionId, ref);
+                if (!objectId)
+                    throw new Error('Element not in DOM');
+                const r = await client.send('Runtime.callFunctionOn', {
+                    functionDeclaration: 'function() { return this.value ?? null; }',
+                    objectId, returnByValue: true,
+                }, sessionId);
+                value = r.result?.value ?? null;
+                break;
+            }
+            case 'attr': {
+                const refArg = ctx.args[1];
+                const attrName = ctx.args[2];
+                if (!refArg || !attrName)
+                    throw new Error('Usage: monomind browse get attr @ref <attrName>');
+                const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+                const ref = _refs.get(refKey);
+                if (!ref)
+                    throw new Error(`Ref @${refKey} not found`);
+                const objectId = await browser.getObjectIdForRef(client, sessionId, ref);
+                if (!objectId)
+                    throw new Error('Element not in DOM');
+                const r = await client.send('Runtime.callFunctionOn', {
+                    functionDeclaration: `function() { return this.getAttribute(${JSON.stringify(attrName)}); }`,
+                    objectId, returnByValue: true,
+                }, sessionId);
+                value = r.result?.value ?? null;
+                break;
+            }
+            case 'count': {
+                const selector = ctx.args[1];
+                if (!selector)
+                    throw new Error('Usage: monomind browse get count <cssSelector>');
+                value = await browser.evaluateJs(client, sessionId, `document.querySelectorAll(${JSON.stringify(selector)}).length`);
+                break;
+            }
+            case 'box': {
+                const refArg = ctx.args[1];
+                if (!refArg)
+                    throw new Error('Usage: monomind browse get box @ref');
+                const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+                const ref = _refs.get(refKey);
+                if (!ref)
+                    throw new Error(`Ref @${refKey} not found`);
+                value = await browser.getElementBox(client, sessionId, ref);
+                break;
+            }
+            case 'styles': {
+                const refArg = ctx.args[1];
+                if (!refArg)
+                    throw new Error('Usage: monomind browse get styles @ref');
+                const refKey = refArg.startsWith('@') ? refArg.slice(1) : refArg;
+                const ref = _refs.get(refKey);
+                if (!ref)
+                    throw new Error(`Ref @${refKey} not found`);
+                const objectId = await browser.getObjectIdForRef(client, sessionId, ref);
+                if (!objectId)
+                    throw new Error('Element not in DOM');
+                const r = await client.send('Runtime.callFunctionOn', {
+                    functionDeclaration: 'function() { const s = window.getComputedStyle(this); return JSON.stringify(Object.fromEntries([...s].map(k => [k, s.getPropertyValue(k)]))); }',
+                    objectId, returnByValue: true,
+                }, sessionId);
+                try {
+                    value = JSON.parse(r.result?.value ?? '{}');
+                }
+                catch {
+                    value = {};
+                }
+                break;
+            }
             default:
-                throw new Error(`Unknown: ${what}. Use: url|title|text|html`);
+                throw new Error(`Unknown: ${what}. Use: url|title|text|html|value|attr|count|box|styles`);
         }
         if (ctx.flags.json) {
             print(JSON.stringify({ data: { [what]: value } }));
         }
         else {
-            print(value);
+            print(typeof value === 'object' ? JSON.stringify(value, null, 2) : String(value ?? ''));
         }
         return { success: true, data: { [what]: value } };
     },
@@ -329,10 +443,13 @@ const setCommand = {
             case 'viewport': {
                 const width = parseInt(ctx.args[1], 10);
                 const height = parseInt(ctx.args[2], 10);
+                const dpr = parseFloat(ctx.args[3]) || undefined;
                 if (isNaN(width) || isNaN(height))
-                    throw new Error('Usage: set viewport <width> <height>');
-                await browser.setViewport(client, sessionId, width, height);
-                output.printSuccess(`Viewport set to ${width}x${height}`);
+                    throw new Error('Usage: set viewport <width> <height> [dpr]');
+                await client.send('Emulation.setDeviceMetricsOverride', {
+                    width, height, deviceScaleFactor: dpr ?? 1, mobile: false,
+                }, sessionId);
+                output.printSuccess(`Viewport set to ${width}x${height}${dpr ? ` @${dpr}x` : ''}`);
                 break;
             }
             case 'device': {
@@ -442,8 +559,27 @@ const stateCommand = {
                 output.printSuccess(`State loaded from ${target}`);
                 return { success: true };
             }
+            case 'show': {
+                const { client: c, sessionId: sid } = await ensureConnected(_port);
+                const url = await browser.getCurrentUrl(c, sid);
+                const title = await browser.getCurrentTitle(c, sid);
+                const cookies = await browser.getCookies(c, sid);
+                const ls = await browser.getAllLocalStorage(c, sid);
+                const info = { url, title, cookies: cookies.length, localStorage: Object.keys(ls).length, refs: _refs.size };
+                print(JSON.stringify(info, null, 2));
+                return { success: true, data: info };
+            }
+            case 'clear': {
+                const { client: c, sessionId: sid } = await ensureConnected(_port);
+                await browser.clearCookies(c, sid);
+                await browser.clearLocalStorage(c, sid);
+                await browser.clearSessionStorage(c, sid);
+                _refs = new Map();
+                output.printSuccess('Browser state cleared (cookies, localStorage, sessionStorage, refs)');
+                return { success: true };
+            }
             default:
-                throw new Error(`Unknown action: ${action}. Use: save|load|list`);
+                throw new Error(`Unknown action: ${action}. Use: save|load|list|show|clear`);
         }
     },
 };
@@ -456,13 +592,14 @@ const networkCommand = {
         { name: 'fulfill', type: 'string', description: 'JSON response body' },
         { name: 'status', type: 'number', description: 'HTTP status for fulfill', default: 200 },
         { name: 'headers', type: 'string', description: 'JSON headers object' },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
     ],
     action: async (ctx) => {
         const { client, sessionId } = await ensureConnected(_port);
         const browser = await getBrowser();
         const action = ctx.args[0];
         if (!action)
-            throw new Error('Usage: monomind browse network route|cookies|headers');
+            throw new Error('Usage: monomind browse network route|unroute|cookies|headers|requests');
         switch (action) {
             case 'route': {
                 const pattern = ctx.flags.pattern;
@@ -481,6 +618,10 @@ const networkCommand = {
                 output.printSuccess(`Network route set: ${pattern}`);
                 break;
             }
+            case 'unroute':
+                await browser.disableInterception(client, sessionId);
+                output.printSuccess('Network interception disabled');
+                break;
             case 'cookies': {
                 const cookies = await browser.getCookies(client, sessionId);
                 print(JSON.stringify(cookies, null, 2));
@@ -494,8 +635,38 @@ const networkCommand = {
                 output.printSuccess('Extra headers set');
                 break;
             }
+            case 'capture': {
+                const subAction = ctx.args[1] ?? 'start';
+                if (subAction === 'start') {
+                    browser.startRequestCapture(client, sessionId);
+                    output.printSuccess('Request capture started');
+                }
+                else if (subAction === 'stop') {
+                    browser.stopRequestCapture(sessionId);
+                    output.printSuccess('Request capture stopped');
+                }
+                else if (subAction === 'clear') {
+                    browser.clearCapturedRequests(sessionId);
+                    output.printSuccess('Captured requests cleared');
+                }
+                break;
+            }
+            case 'requests': {
+                const reqs = browser.getCapturedRequests(sessionId);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: reqs }));
+                else {
+                    if (reqs.length === 0) {
+                        output.printInfo('No captured requests. Run: network capture start');
+                    }
+                    else
+                        for (const r of reqs)
+                            print(`  ${r.method ?? 'GET'} ${r.status ?? '-'} ${r.url}`);
+                }
+                return { success: true, data: { requests: reqs } };
+            }
             default:
-                throw new Error(`Unknown: ${action}. Use: route|cookies|headers`);
+                throw new Error(`Unknown: ${action}. Use: route|unroute|cookies|headers|capture|requests`);
         }
         return { success: true };
     },
@@ -1148,7 +1319,7 @@ const isCommand = {
 };
 const findCommand = {
     name: 'find',
-    description: 'Find elements by semantic locators. Usage: monomind browse find role|text|label|testid <value> [action]',
+    description: 'Find elements by semantic locators. Usage: monomind browse find role|text|label|placeholder|testid|selector <value> [action]',
     options: [
         { name: 'name', type: 'string', description: 'Filter by accessible name' },
         { name: 'exact', type: 'boolean', description: 'Require exact match', default: false },
@@ -1162,7 +1333,7 @@ const findCommand = {
         const value = ctx.args[1];
         const action = ctx.args[2];
         if (!locator || !value)
-            throw new Error('Usage: monomind browse find role|text|label|testid <value> [action]');
+            throw new Error('Usage: monomind browse find role|text|label|placeholder|testid|selector <value> [action]');
         const opts = {
             name: ctx.flags.name,
             exact: ctx.flags.exact,
@@ -1180,6 +1351,18 @@ const findCommand = {
             case 'label':
                 ref = await browser.findByLabel(client, sessionId, _refs, value, opts);
                 break;
+            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 'testid': {
                 const sel = await browser.findByTestId(client, sessionId, value);
                 if (!sel) {
@@ -1190,7 +1373,7 @@ const findCommand = {
                 return { success: true, data: { selector: sel } };
             }
             default:
-                throw new Error(`Unknown locator: ${locator}. Use: role|text|label|testid`);
+                throw new Error(`Unknown locator: ${locator}. Use: role|text|label|placeholder|testid|selector`);
         }
         if (!ref) {
             output.printWarning(`No element found: ${locator}="${value}"`);
@@ -1361,6 +1544,218 @@ const removeinitscriptCommand = {
         return { success: true };
     },
 };
+const connectCommand = {
+    name: 'connect',
+    description: 'Connect to existing Chrome instance. Usage: monomind browse connect [--port 9222] [--target <id>]',
+    options: [
+        { name: 'port', short: 'p', type: 'number', description: 'CDP port', default: 9222 },
+        { name: 'target', type: 'string', description: 'Target ID to attach to' },
+    ],
+    action: async (ctx) => {
+        const port = ctx.flags.port ?? 9222;
+        const browser = await getBrowser();
+        const conn = await browser.connectToTarget(port, ctx.flags.target);
+        _client = conn.client;
+        _sessionId = conn.sessionId;
+        _targetId = conn.target.id;
+        _port = port;
+        _refs = new Map();
+        const url = await browser.getCurrentUrl(_client, _sessionId);
+        const title = await browser.getCurrentTitle(_client, _sessionId);
+        output.printSuccess(`Connected: ${title} (${url})`);
+        return { success: true, data: { targetId: _targetId, url, title } };
+    },
+};
+const recordCommand = {
+    name: 'record',
+    description: 'Screen recording. Usage: monomind browse record start|stop|status [path]',
+    options: [
+        { name: 'format', type: 'string', description: 'jpeg|png', default: 'jpeg' },
+        { name: 'quality', type: 'number', description: 'Quality 0-100', default: 80 },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const action = ctx.args[0];
+        if (!action)
+            throw new Error('Usage: monomind browse record start|stop|status');
+        switch (action) {
+            case 'start':
+                await browser.startRecording(client, sessionId, {
+                    format: ctx.flags.format,
+                    quality: ctx.flags.quality,
+                });
+                output.printSuccess('Recording started');
+                return { success: true };
+            case 'stop': {
+                const path = await browser.stopRecording(client, sessionId, ctx.args[1]);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: { path } }));
+                else
+                    output.printSuccess(`Recording saved: ${path}`);
+                return { success: true, data: { path } };
+            }
+            case 'status': {
+                const status = browser.getRecordingStatus(sessionId);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: status }));
+                else
+                    print(`Recording: ${status.recording} | Frames: ${status.frames}`);
+                return { success: true, data: status };
+            }
+            default:
+                throw new Error('Usage: monomind browse record start|stop|status [path]');
+        }
+    },
+};
+const traceCommand = {
+    name: 'trace',
+    description: 'CDP performance trace. Usage: monomind browse trace start|stop [path]',
+    options: [
+        { name: 'screenshots', type: 'boolean', description: 'Include screenshots', default: false },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const action = ctx.args[0];
+        if (!action)
+            throw new Error('Usage: monomind browse trace start|stop [path]');
+        switch (action) {
+            case 'start':
+                await browser.startTrace(client, sessionId, { screenshots: ctx.flags.screenshots });
+                output.printSuccess('Trace started');
+                return { success: true };
+            case 'stop': {
+                const path = await browser.stopTrace(client, sessionId, ctx.args[1]);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: { path } }));
+                else
+                    output.printSuccess(`Trace saved: ${path}`);
+                return { success: true, data: { path } };
+            }
+            case 'status':
+                print(browser.getTraceStatus(sessionId) ? 'Tracing active' : 'Not tracing');
+                return { success: true };
+            default:
+                throw new Error('Usage: monomind browse trace start|stop|status [path]');
+        }
+    },
+};
+const profilerCommand = {
+    name: 'profiler',
+    description: 'CPU profiler. Usage: monomind browse profiler start|stop|heap [path]',
+    options: [
+        { name: 'interval', type: 'number', description: 'Sampling interval µs', default: 1000 },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const action = ctx.args[0];
+        if (!action)
+            throw new Error('Usage: monomind browse profiler start|stop|heap [path]');
+        switch (action) {
+            case 'start':
+                await browser.startCpuProfile(client, sessionId, { samplingInterval: ctx.flags.interval });
+                output.printSuccess('CPU profiler started');
+                return { success: true };
+            case 'stop': {
+                const path = await browser.stopCpuProfile(client, sessionId, ctx.args[1]);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: { path } }));
+                else
+                    output.printSuccess(`Profile saved: ${path}`);
+                return { success: true, data: { path } };
+            }
+            case 'heap': {
+                const path = await browser.startHeapSnapshot(client, sessionId, ctx.args[1]);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: { path } }));
+                else
+                    output.printSuccess(`Heap snapshot saved: ${path}`);
+                return { success: true, data: { path } };
+            }
+            default:
+                throw new Error('Usage: monomind browse profiler start|stop|heap [path]');
+        }
+    },
+};
+const vitalsCommand = {
+    name: 'vitals',
+    description: 'Collect Core Web Vitals. Usage: monomind browse vitals [--wait 2000]',
+    options: [
+        { name: 'wait', type: 'number', description: 'Wait ms for observers', default: 2000 },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const vitals = await browser.collectVitals(client, sessionId, ctx.flags.wait);
+        if (ctx.flags.json) {
+            print(JSON.stringify({ data: vitals }));
+        }
+        else {
+            print(browser.formatVitals(vitals));
+        }
+        return { success: true, data: vitals };
+    },
+};
+const harCommand = {
+    name: 'har',
+    description: 'HAR network recording. Usage: monomind browse har start|stop|status [path]',
+    options: [
+        { name: 'bodies', type: 'boolean', description: 'Capture response bodies', default: false },
+        { name: 'json', type: 'boolean', description: 'Output as JSON', default: false },
+    ],
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const action = ctx.args[0];
+        if (!action)
+            throw new Error('Usage: monomind browse har start|stop|status [path]');
+        switch (action) {
+            case 'start':
+                await browser.startHarRecording(client, sessionId);
+                output.printSuccess('HAR recording started');
+                return { success: true };
+            case 'stop': {
+                const path = await browser.stopHarRecording(client, sessionId, ctx.args[1], ctx.flags.bodies);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: { path } }));
+                else
+                    output.printSuccess(`HAR saved: ${path}`);
+                return { success: true, data: { path } };
+            }
+            case 'status': {
+                const status = browser.getHarStatus(sessionId);
+                if (ctx.flags.json)
+                    print(JSON.stringify({ data: status }));
+                else
+                    print(`Recording: ${status.recording} | Requests: ${status.requestCount}`);
+                return { success: true, data: status };
+            }
+            default:
+                throw new Error('Usage: monomind browse har start|stop|status [path]');
+        }
+    },
+};
+const resizeCommand = {
+    name: 'resize',
+    description: 'Resize browser window. Usage: monomind browse resize <width> <height>',
+    action: async (ctx) => {
+        const { client, sessionId } = await ensureConnected(_port);
+        const browser = await getBrowser();
+        const width = parseInt(ctx.args[0], 10);
+        const height = parseInt(ctx.args[1], 10);
+        if (isNaN(width) || isNaN(height))
+            throw new Error('Usage: monomind browse resize <width> <height>');
+        await browser.setViewport(client, sessionId, width, height);
+        output.printSuccess(`Resized to ${width}x${height}`);
+        return { success: true, data: { width, height } };
+    },
+};
 // ---------------------------------------------------------------------------
 // Root browse command
 // ---------------------------------------------------------------------------
@@ -1412,6 +1807,13 @@ const browseCommand = {
         batchCommand,
         addinitscriptCommand,
         removeinitscriptCommand,
+        connectCommand,
+        recordCommand,
+        traceCommand,
+        profilerCommand,
+        vitalsCommand,
+        harCommand,
+        resizeCommand,
         closeCommand,
     ],
     options: [

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

@@ -1,6 +1,6 @@
 {
   "name": "@monoes/monomindcli",
-  "version": "1.10.34",
+  "version": "1.10.35",
   "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",