@houwert/conductor 0.10.0 → 0.12.0

package/README.md

@@ -71,7 +71,7 @@ Claude learns every available command, how to coordinate across devices, and how
 |---|---|
 | App lifecycle | `launch-app`, `stop-app`, `clear-state`, `uninstall-app`, `install-app`, `foreground-app`, `copy-app` |
 | Interaction | `tap-on`, `input-text`, `scroll`, `scroll-until-visible`, `swipe`, `press-key`, `erase-text`, `hide-keyboard` |
-| Inspection | `inspect`, `focused`, `take-screenshot`, `list-apps` |
+| Inspection | `inspect`, `focused`, `take-screenshot`, `capture-ui`, `list-apps` |
 | Assertions | `assert-visible`, `assert-not-visible` |
 | Navigation | `open-link`, `back` |
 | Flows | `run-flow`, `run-flow-inline`, `run-parallel` |

package/dist/commands/capture-ui.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.captureUI = captureUI;
+exports.HELP = `  capture-ui [--output <path>]         Capture screenshot + hierarchy + a11y snapshot (for Argus UI panel)`;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const runner_js_1 = require("../runner.js");
+const output_js_1 = require("../output.js");
+const ios_js_1 = require("../drivers/ios.js");
+const android_js_1 = require("../drivers/android.js");
+const web_js_1 = require("../drivers/web.js");
+const a11y_js_1 = require("../drivers/a11y.js");
+async function captureUI(outputPath, opts = {}, sessionName = 'default') {
+    try {
+        const driver = await (0, runner_js_1.getDriver)(sessionName);
+        const capturedAt = new Date().toISOString();
+        let platform;
+        let width = 0;
+        let height = 0;
+        let hierarchy;
+        let a11ySnapshot;
+        let screenshotBuf;
+        if (driver instanceof ios_js_1.IOSDriver) {
+            platform = driver.platform; // 'ios' | 'tvos'
+            const [info, vh, shot] = await Promise.all([
+                driver.deviceInfo(),
+                driver.viewHierarchy(false),
+                driver.screenshot(),
+            ]);
+            width = info.widthPoints;
+            height = info.heightPoints;
+            const built = (0, a11y_js_1.buildIOSA11y)(vh.axElement);
+            hierarchy = { axElement: built.hierarchy, depth: vh.depth };
+            a11ySnapshot = built.a11ySnapshot;
+            screenshotBuf = shot;
+        }
+        else if (driver instanceof web_js_1.WebDriver) {
+            platform = 'web';
+            const [info, vh, shot] = await Promise.all([
+                driver.deviceInfo(),
+                driver.viewHierarchy(),
+                driver.screenshot(),
+            ]);
+            width = info.widthPixels;
+            height = info.heightPixels;
+            const built = (0, a11y_js_1.buildWebA11y)(vh);
+            hierarchy = { ...vh, elements: built.hierarchy };
+            a11ySnapshot = built.a11ySnapshot;
+            screenshotBuf = shot;
+        }
+        else if (driver instanceof android_js_1.AndroidDriver) {
+            platform = 'android';
+            const [info, xml, shot] = await Promise.all([
+                driver.deviceInfo(),
+                driver.viewHierarchy(),
+                driver.screenshot(),
+            ]);
+            width = info.widthPixels;
+            height = info.heightPixels;
+            const built = (0, a11y_js_1.buildAndroidA11y)(xml);
+            hierarchy = { xml, elements: built.hierarchy };
+            a11ySnapshot = built.a11ySnapshot;
+            screenshotBuf = shot;
+        }
+        else {
+            throw new Error('Unknown driver type');
+        }
+        const bundle = {
+            version: 1,
+            capturedAt,
+            device: {
+                platform,
+                deviceId: sessionName,
+                width,
+                height,
+            },
+            screenshot: {
+                kind: 'composite',
+                encoding: 'png',
+                data: screenshotBuf.toString('base64'),
+            },
+            hierarchy,
+            a11ySnapshot,
+            capabilities: { perViewPixels: false, depthData: false },
+        };
+        const json = JSON.stringify(bundle);
+        if (outputPath) {
+            const resolved = path_1.default.resolve(outputPath);
+            await promises_1.default.writeFile(resolved, json);
+            if (opts.json) {
+                console.log(JSON.stringify({
+                    status: 'ok',
+                    path: resolved,
+                    bytes: Buffer.byteLength(json, 'utf-8'),
+                }));
+            }
+            else {
+                (0, output_js_1.printSuccess)(`capture-ui saved to ${resolved}`, opts);
+            }
+        }
+        else {
+            // Stdout: raw JSON bundle (no pretty-printing — screenshot is huge).
+            process.stdout.write(json);
+            if (!opts.json)
+                process.stdout.write('\n');
+        }
+        return 0;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        (0, output_js_1.printError)(`capture-ui — failed\n${msg}`, opts);
+        return 1;
+    }
+}

package/dist/commands/cheat-sheet.js

@@ -67,7 +67,8 @@ ASSERTIONS
 
 SCREENSHOTS & INSPECTION
   take-screenshot [--output <path>]          Take screenshot (default: ./screenshot-<ts>.png)
-  inspect                                   Print UI hierarchy
+  inspect [--dump]                          Print UI hierarchy (--dump: a11y-enriched JSON)
+  capture-ui [--output <path>]              Screenshot + hierarchy + a11y snapshot bundle (Argus)
 
 FLOW EXECUTION
   run-flow <file> [--device <id>]           Run a Maestro YAML flow file

package/dist/commands/inspect.js

@@ -9,6 +9,7 @@ const ios_js_1 = require("../drivers/ios.js");
 const android_js_1 = require("../drivers/android.js");
 const web_js_1 = require("../drivers/web.js");
 const element_resolver_js_1 = require("../drivers/element-resolver.js");
+const a11y_js_1 = require("../drivers/a11y.js");
 async function inspect(opts = {}, sessionName = 'default', inspectOpts = {}) {
     try {
         const driver = await (0, runner_js_1.getDriver)(sessionName);
@@ -16,13 +17,20 @@ async function inspect(opts = {}, sessionName = 'default', inspectOpts = {}) {
             let raw;
             if (driver instanceof ios_js_1.IOSDriver) {
                 const hierarchy = await driver.viewHierarchy(false);
-                raw = JSON.stringify(hierarchy, null, 2);
+                // Augment each node with a11y fields (traits, accessibilityOrder,
+                // isAccessibilityElement, announcement). All existing fields are preserved.
+                const built = (0, a11y_js_1.buildIOSA11y)(hierarchy.axElement);
+                raw = JSON.stringify({ axElement: built.hierarchy, depth: hierarchy.depth }, null, 2);
             }
             else if (driver instanceof web_js_1.WebDriver) {
-                raw = JSON.stringify(await driver.viewHierarchy(), null, 2);
+                const vh = await driver.viewHierarchy();
+                const built = (0, a11y_js_1.buildWebA11y)(vh);
+                raw = JSON.stringify({ ...vh, elements: built.hierarchy }, null, 2);
             }
             else if (driver instanceof android_js_1.AndroidDriver) {
-                raw = await driver.viewHierarchy();
+                const xml = await driver.viewHierarchy();
+                const built = (0, a11y_js_1.buildAndroidA11y)(xml);
+                raw = JSON.stringify(built.hierarchy, null, 2);
             }
             else {
                 throw new Error('Unknown driver type');

package/dist/commands/memory.js

@@ -0,0 +1,487 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.memory = memory;
+exports.HELP = `  memory [<appId>]                    Show device + app memory usage and object counts`;
+const runner_js_1 = require("../runner.js");
+const session_js_1 = require("../session.js");
+const output_js_1 = require("../output.js");
+const bootstrap_js_1 = require("../drivers/bootstrap.js");
+const ios_js_1 = require("../drivers/ios.js");
+const android_js_1 = require("../drivers/android.js");
+const web_js_1 = require("../drivers/web.js");
+async function resolveDeviceId(sessionName) {
+    if (sessionName !== 'default')
+        return sessionName;
+    const session = await (0, session_js_1.getSession)(sessionName);
+    return session.deviceId ?? (await (0, runner_js_1.detectFirstDevice)());
+}
+async function resolveAppId(explicit, sessionName) {
+    if (explicit)
+        return explicit;
+    const session = await (0, session_js_1.getSession)(sessionName);
+    if (session.appId)
+        return session.appId;
+    // Fall back to whatever's in the foreground.
+    try {
+        const driver = await (0, runner_js_1.getDriver)(sessionName);
+        if (driver instanceof android_js_1.AndroidDriver)
+            return await driver.getForegroundApp();
+        if (driver instanceof web_js_1.WebDriver)
+            return await driver.runningApp();
+        if (driver instanceof ios_js_1.IOSDriver)
+            return await driver.runningApp([]);
+    }
+    catch {
+        /* ignore */
+    }
+    return undefined;
+}
+// ── Android ───────────────────────────────────────────────────────────────────
+function parseAndroidMeminfo(out) {
+    const get = (key) => {
+        const m = out.match(new RegExp(`^${key}:\\s+(\\d+)\\s*kB`, 'm'));
+        return m ? Number(m[1]) * 1024 : undefined;
+    };
+    return {
+        totalBytes: get('MemTotal'),
+        availableBytes: get('MemAvailable'),
+        freeBytes: get('MemFree'),
+        cachedBytes: get('Cached'),
+        swapTotalBytes: get('SwapTotal'),
+        swapFreeBytes: get('SwapFree'),
+    };
+}
+function parseAndroidDumpsysMeminfo(out) {
+    const app = {};
+    const objects = {};
+    const pidMatch = out.match(/\*\* MEMINFO in pid (\d+)/);
+    const pid = pidMatch ? Number(pidMatch[1]) : undefined;
+    // App Summary block — most useful, single-line entries with KB values.
+    // e.g. "       Java Heap:    12345"
+    const summary = out.match(/App Summary[\s\S]*?(?:\n\s*\n|TOTAL:)/);
+    if (summary) {
+        const block = summary[0];
+        const grab = (label) => {
+            const m = block.match(new RegExp(`${label}:\\s+(\\d+)`));
+            return m ? Number(m[1]) * 1024 : undefined;
+        };
+        app.javaHeapBytes = grab('Java Heap');
+        app.nativeHeapBytes = grab('Native Heap');
+        app.codeBytes = grab('Code');
+        app.stackBytes = grab('Stack');
+        app.graphicsBytes = grab('Graphics');
+        app.privateOtherBytes = grab('Private Other');
+        app.systemBytes = grab('System');
+        const totalPss = block.match(/TOTAL PSS:\s+(\d+)/);
+        if (totalPss)
+            app.totalPssBytes = Number(totalPss[1]) * 1024;
+        const totalRss = block.match(/TOTAL RSS:\s+(\d+)/);
+        if (totalRss)
+            app.totalRssBytes = Number(totalRss[1]) * 1024;
+        const totalSwap = block.match(/TOTAL SWAP[^:]*:\s+(\d+)/);
+        if (totalSwap)
+            app['totalSwapBytes'] = Number(totalSwap[1]) * 1024;
+    }
+    // Fallback: TOTAL line in the main table — "TOTAL  12345  ..."
+    if (app.totalPssBytes === undefined) {
+        const total = out.match(/^\s*TOTAL\s+(\d+)/m);
+        if (total)
+            app.totalPssBytes = Number(total[1]) * 1024;
+    }
+    // Objects block:
+    //  Objects
+    //         Views:        3   ViewRootImpl:        1
+    //     AppContexts:        2     Activities:        1
+    //          Assets:        7  AssetManagers:        0
+    //   Local Binders:        5  Proxy Binders:       17
+    //   Parcel memory:        1     Parcel count:        4
+    //    Death Recipients:    0   OpenSSL Sockets:    0
+    //            WebViews:    0
+    const objSection = out.match(/Objects[\s\S]*?(?:\n\s*\n|SQL\s|DATABASES|$)/);
+    if (objSection) {
+        const text = objSection[0];
+        // Capture every "Label: number" pair (labels may have spaces).
+        const re = /([A-Za-z][A-Za-z _]*?):\s+(\d+)/g;
+        let m;
+        while ((m = re.exec(text)) !== null) {
+            const key = m[1].trim();
+            if (key === 'Objects')
+                continue;
+            objects[key] = Number(m[2]);
+        }
+    }
+    return { app, objects, pid };
+}
+async function collectAndroid(deviceId, appId) {
+    const report = { platform: 'android', deviceId, appId, notes: [] };
+    const meminfo = await (0, runner_js_1.spawnCommand)('adb', ['-s', deviceId, 'shell', 'cat', '/proc/meminfo']);
+    if (meminfo.success) {
+        const sys = parseAndroidMeminfo(meminfo.stdout);
+        report.system = {
+            ...sys,
+            usedBytes: sys.totalBytes !== undefined && sys.availableBytes !== undefined
+                ? sys.totalBytes - sys.availableBytes
+                : undefined,
+        };
+    }
+    else {
+        report.notes.push(`/proc/meminfo unavailable: ${meminfo.stderr.trim()}`);
+    }
+    if (appId) {
+        const dump = await (0, runner_js_1.spawnCommand)('adb', ['-s', deviceId, 'shell', 'dumpsys', 'meminfo', appId]);
+        if (dump.success && !dump.stdout.includes('No process found')) {
+            const { app, objects, pid } = parseAndroidDumpsysMeminfo(dump.stdout);
+            report.app = app;
+            report.objects = objects;
+            report.pid = pid;
+        }
+        else {
+            report.notes.push(`dumpsys meminfo ${appId} returned no data — app may not be running`);
+        }
+    }
+    if (report.notes.length === 0)
+        delete report.notes;
+    return report;
+}
+// ── iOS / tvOS ────────────────────────────────────────────────────────────────
+function parseVmStat(out) {
+    // vm_stat output uses "page size of 16384 bytes" and counts in pages.
+    const pageMatch = out.match(/page size of (\d+)/);
+    const pageSize = pageMatch ? Number(pageMatch[1]) : 4096;
+    const grab = (label) => {
+        const m = out.match(new RegExp(`${label}:\\s+(\\d+)`));
+        return m ? Number(m[1]) * pageSize : undefined;
+    };
+    const free = grab('Pages free');
+    const inactive = grab('Pages inactive');
+    const speculative = grab('Pages speculative');
+    const wired = grab('Pages wired down');
+    const active = grab('Pages active');
+    const compressed = grab('Pages occupied by compressor');
+    const total = [free, inactive, speculative, wired, active, compressed]
+        .filter((v) => v !== undefined)
+        .reduce((a, b) => a + b, 0);
+    const available = free !== undefined && inactive !== undefined && speculative !== undefined
+        ? free + inactive + speculative
+        : undefined;
+    return {
+        totalBytes: total > 0 ? total : undefined,
+        freeBytes: free,
+        availableBytes: available,
+    };
+}
+async function findIOSPid(deviceId, appId) {
+    // Inside-simulator PIDs == host PIDs for app processes.
+    const list = await (0, runner_js_1.spawnCommand)('xcrun', ['simctl', 'spawn', deviceId, 'launchctl', 'list']);
+    if (!list.success)
+        return undefined;
+    for (const line of list.stdout.split('\n')) {
+        if (!line.includes(appId))
+            continue;
+        const parts = line.trim().split(/\s+/);
+        const pid = Number(parts[0]);
+        if (Number.isFinite(pid) && pid > 0)
+            return pid;
+    }
+    return undefined;
+}
+function parseVmmapSummary(out) {
+    const regions = {};
+    const app = {};
+    // Lines look like: "MALLOC                          1.2G       234.5M  ..."
+    // We want the "RESIDENT" column (2nd numeric). The columns are whitespace-delimited.
+    // Easier: parse the per-region rows under "REGION TYPE" header.
+    const headerIdx = out.indexOf('REGION TYPE');
+    if (headerIdx === -1)
+        return { app, regions };
+    const body = out.slice(headerIdx);
+    const lines = body.split('\n').slice(1);
+    for (const raw of lines) {
+        const line = raw.trimEnd();
+        if (!line.trim())
+            continue;
+        if (line.startsWith('='))
+            break;
+        if (line.startsWith('TOTAL')) {
+            // "TOTAL                          5.2G       1.4G       950M  ..."
+            const m = line.match(/TOTAL\s+\S+\s+(\S+)/);
+            if (m)
+                app.totalRssBytes = humanToBytes(m[1]);
+            break;
+        }
+        // Region rows: name (may have spaces), virtual, resident, dirty, swap, ...
+        const m = line.match(/^(.+?)\s{2,}(\S+)\s+(\S+)/);
+        if (!m)
+            continue;
+        const name = m[1].trim();
+        const resident = humanToBytes(m[3]);
+        if (resident !== undefined)
+            regions[name] = resident;
+    }
+    // Roll up a few well-known regions into the canonical fields.
+    app.nativeHeapBytes = regions['MALLOC'] ?? regions['MALLOC_NANO'];
+    app.stackBytes = regions['Stack'];
+    return { app, regions };
+}
+function humanToBytes(s) {
+    // Matches "1.2G", "234.5M", "950K", "1024", "1.2GB" etc.
+    const m = s.match(/^([\d.]+)\s*([KMGT]?)B?$/i);
+    if (!m)
+        return undefined;
+    const n = parseFloat(m[1]);
+    if (Number.isNaN(n))
+        return undefined;
+    const mult = {
+        '': 1,
+        K: 1024,
+        M: 1024 ** 2,
+        G: 1024 ** 3,
+        T: 1024 ** 4,
+    };
+    return Math.round(n * (mult[m[2].toUpperCase()] ?? 1));
+}
+async function collectIOS(deviceId, platform, appId) {
+    const report = { platform, deviceId, appId, notes: [] };
+    // System-wide memory: vm_stat from inside the simulator (== host RAM).
+    const vm = await (0, runner_js_1.spawnCommand)('xcrun', ['simctl', 'spawn', deviceId, 'vm_stat']);
+    if (vm.success) {
+        const sys = parseVmStat(vm.stdout);
+        report.system = {
+            ...sys,
+            usedBytes: sys.totalBytes !== undefined && sys.availableBytes !== undefined
+                ? sys.totalBytes - sys.availableBytes
+                : undefined,
+        };
+        report.notes.push('System memory reflects host Mac RAM — simulators share the host memory pool.');
+    }
+    else {
+        report.notes.push(`vm_stat unavailable: ${vm.stderr.trim()}`);
+    }
+    if (!appId) {
+        if (report.notes.length === 0)
+            delete report.notes;
+        return report;
+    }
+    const pid = await findIOSPid(deviceId, appId);
+    if (!pid) {
+        report.notes.push(`No running process found for ${appId}.`);
+        if (report.notes.length === 0)
+            delete report.notes;
+        return report;
+    }
+    report.pid = pid;
+    // ps for RSS/VSZ — fast, always available.
+    const ps = await (0, runner_js_1.spawnCommand)('ps', ['-o', 'rss=,vsz=', '-p', String(pid)]);
+    if (ps.success) {
+        const m = ps.stdout.trim().match(/(\d+)\s+(\d+)/);
+        if (m) {
+            report.app = {
+                ...(report.app ?? {}),
+                // ps reports rss/vsz in KB on macOS.
+                totalRssBytes: Number(m[1]) * 1024,
+                vszBytes: Number(m[2]) * 1024,
+            };
+        }
+    }
+    // vmmap -summary for region breakdown — slower but provides categories.
+    const vmmap = await (0, runner_js_1.spawnCommand)('vmmap', ['-summary', String(pid)]);
+    if (vmmap.success) {
+        const { app, regions } = parseVmmapSummary(vmmap.stdout);
+        report.app = {
+            ...(report.app ?? {}),
+            ...Object.fromEntries(Object.entries(app).filter(([, v]) => v !== undefined)),
+            regions,
+        };
+    }
+    else {
+        report.notes.push('vmmap unavailable — run `sudo DevToolsSecurity --enable` if it errors.');
+    }
+    if (report.notes.length === 0)
+        delete report.notes;
+    return report;
+}
+// ── Web (Playwright via CDP) ──────────────────────────────────────────────────
+async function collectWeb(deviceId, sessionName) {
+    const report = { platform: 'web', deviceId, notes: [] };
+    let driver;
+    try {
+        const d = await (0, runner_js_1.getDriver)(sessionName);
+        if (!(d instanceof web_js_1.WebDriver)) {
+            report.notes.push('Expected web driver, got something else.');
+            return report;
+        }
+        driver = d;
+    }
+    catch (err) {
+        report.notes.push(`Could not attach to web driver: ${err instanceof Error ? err.message : String(err)}`);
+        return report;
+    }
+    const data = await driver.memory().catch((err) => {
+        report.notes.push(`Performance.getMetrics failed: ${err.message}`);
+        return null;
+    });
+    if (!data) {
+        if (report.notes.length === 0)
+            delete report.notes;
+        return report;
+    }
+    report.appId = data.url;
+    const m = data.metrics;
+    const pm = data.pageMemory;
+    report.app = {
+        // Heap totals — prefer page-context performance.memory (Chromium) over
+        // CDP's JSHeapUsedSize (which can lag). Both are JS heap only.
+        nativeHeapBytes: pm?.usedJSHeapSize ?? m['JSHeapUsedSize'],
+        codeBytes: m['JSHeapTotalSize'] ? m['JSHeapTotalSize'] - (m['JSHeapUsedSize'] ?? 0) : undefined,
+        // Roll the raw CDP metrics into `regions` so they're inspectable verbatim.
+        regions: { ...m },
+    };
+    if (pm) {
+        report.app.regions = {
+            ...report.app.regions,
+            'JS Heap Used': pm.usedJSHeapSize,
+            'JS Heap Total': pm.totalJSHeapSize,
+            'JS Heap Limit': pm.jsHeapSizeLimit,
+        };
+    }
+    // Object counts — direct CDP equivalents of Android's "Views/Activities/Binders".
+    const objectKeys = [
+        'Nodes',
+        'Documents',
+        'Frames',
+        'JSEventListeners',
+        'LayoutCount',
+        'RecalcStyleCount',
+    ];
+    const objects = {};
+    for (const k of objectKeys) {
+        if (m[k] !== undefined)
+            objects[k] = m[k];
+    }
+    if (Object.keys(objects).length > 0)
+        report.objects = objects;
+    report.notes.push('Web memory is per-page (Performance.getMetrics + performance.memory). Run-wide RSS for the browser process is not exposed via CDP.');
+    if (report.notes.length === 0)
+        delete report.notes;
+    return report;
+}
+// ── Formatting ────────────────────────────────────────────────────────────────
+function fmtBytes(n) {
+    if (n === undefined)
+        return '—';
+    if (n < 1024)
+        return `${n} B`;
+    const units = ['KB', 'MB', 'GB', 'TB'];
+    let v = n / 1024;
+    let i = 0;
+    while (v >= 1024 && i < units.length - 1) {
+        v /= 1024;
+        i++;
+    }
+    return `${v.toFixed(v >= 100 ? 0 : v >= 10 ? 1 : 2)} ${units[i]}`;
+}
+function formatReport(r) {
+    const lines = [];
+    lines.push(`Device:    ${r.deviceId} (${r.platform})`);
+    if (r.appId)
+        lines.push(`App:       ${r.appId}${r.pid ? ` (pid ${r.pid})` : ''}`);
+    if (r.system) {
+        lines.push('');
+        lines.push('System memory:');
+        const s = r.system;
+        if (s.totalBytes !== undefined)
+            lines.push(`  Total:      ${fmtBytes(s.totalBytes)}`);
+        if (s.usedBytes !== undefined)
+            lines.push(`  Used:       ${fmtBytes(s.usedBytes)}`);
+        if (s.availableBytes !== undefined)
+            lines.push(`  Available:  ${fmtBytes(s.availableBytes)}`);
+        if (s.freeBytes !== undefined)
+            lines.push(`  Free:       ${fmtBytes(s.freeBytes)}`);
+        if (s.cachedBytes !== undefined)
+            lines.push(`  Cached:     ${fmtBytes(s.cachedBytes)}`);
+        if (s.swapTotalBytes !== undefined)
+            lines.push(`  Swap:       ${fmtBytes((s.swapTotalBytes ?? 0) - (s.swapFreeBytes ?? 0))} / ${fmtBytes(s.swapTotalBytes)}`);
+    }
+    if (r.app) {
+        lines.push('');
+        lines.push('App memory:');
+        const a = r.app;
+        if (a.totalPssBytes !== undefined)
+            lines.push(`  PSS total:  ${fmtBytes(a.totalPssBytes)}`);
+        if (a.totalRssBytes !== undefined)
+            lines.push(`  RSS total:  ${fmtBytes(a.totalRssBytes)}`);
+        if (a.totalUssBytes !== undefined)
+            lines.push(`  USS total:  ${fmtBytes(a.totalUssBytes)}`);
+        if (a.vszBytes !== undefined)
+            lines.push(`  VSZ:        ${fmtBytes(a.vszBytes)}`);
+        if (a.javaHeapBytes !== undefined)
+            lines.push(`  Java heap:  ${fmtBytes(a.javaHeapBytes)}`);
+        if (a.nativeHeapBytes !== undefined)
+            lines.push(`  Native:     ${fmtBytes(a.nativeHeapBytes)}`);
+        if (a.codeBytes !== undefined)
+            lines.push(`  Code:       ${fmtBytes(a.codeBytes)}`);
+        if (a.stackBytes !== undefined)
+            lines.push(`  Stack:      ${fmtBytes(a.stackBytes)}`);
+        if (a.graphicsBytes !== undefined)
+            lines.push(`  Graphics:   ${fmtBytes(a.graphicsBytes)}`);
+        if (a.privateOtherBytes !== undefined)
+            lines.push(`  Private:    ${fmtBytes(a.privateOtherBytes)}`);
+        if (a.systemBytes !== undefined)
+            lines.push(`  System:     ${fmtBytes(a.systemBytes)}`);
+        if (a.regions && Object.keys(a.regions).length > 0) {
+            lines.push('');
+            lines.push('Top memory regions (resident):');
+            const entries = Object.entries(a.regions)
+                .filter(([, v]) => v > 0)
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 12);
+            for (const [name, bytes] of entries) {
+                lines.push(`  ${name.padEnd(28)} ${fmtBytes(bytes)}`);
+            }
+        }
+    }
+    if (r.objects && Object.keys(r.objects).length > 0) {
+        lines.push('');
+        lines.push('Object counts:');
+        const entries = Object.entries(r.objects).sort((a, b) => b[1] - a[1]);
+        for (const [name, count] of entries) {
+            lines.push(`  ${name.padEnd(20)} ${count}`);
+        }
+    }
+    if (r.notes && r.notes.length > 0) {
+        lines.push('');
+        for (const n of r.notes)
+            lines.push(`note: ${n}`);
+    }
+    return lines.join('\n');
+}
+// ── Entry point ───────────────────────────────────────────────────────────────
+async function memory(appIdArg, opts = {}, sessionName = 'default', _memOpts = {}) {
+    const deviceId = await resolveDeviceId(sessionName);
+    if (!deviceId) {
+        (0, output_js_1.printError)('No device found. Connect a device or start a simulator first.', opts);
+        return 1;
+    }
+    const platform = await (0, bootstrap_js_1.detectPlatform)(deviceId);
+    let report;
+    if (platform === 'web') {
+        report = await collectWeb(deviceId, sessionName);
+    }
+    else {
+        const appId = await resolveAppId(appIdArg, sessionName);
+        if (platform === 'android') {
+            report = await collectAndroid(deviceId, appId);
+        }
+        else {
+            report = await collectIOS(deviceId, platform, appId);
+        }
+    }
+    if (opts.json) {
+        (0, output_js_1.printData)({ status: 'ok', ...report }, opts);
+    }
+    else {
+        console.log(formatReport(report));
+    }
+    return 0;
+}

package/dist/daemon/web-server.js

@@ -839,6 +839,35 @@ async function handleRequest(req, res, dlog) {
                 jsonResponse(res, { isScreenStatic: snap1 === snap2 });
                 return;
             }
+            case '/memory': {
+                const p = await getPage(dlog);
+                const session = await p.context().newCDPSession(p);
+                try {
+                    await session.send('Performance.enable').catch(() => { });
+                    const perf = (await session.send('Performance.getMetrics'));
+                    const metricsMap = {};
+                    for (const m of perf.metrics)
+                        metricsMap[m.name] = m.value;
+                    // Chrome-only: performance.memory in the page context.
+                    const pageMemory = await p
+                        .evaluate(() => {
+                        const pm = performance.memory;
+                        return pm
+                            ? {
+                                usedJSHeapSize: pm.usedJSHeapSize,
+                                totalJSHeapSize: pm.totalJSHeapSize,
+                                jsHeapSizeLimit: pm.jsHeapSizeLimit,
+                            }
+                            : null;
+                    })
+                        .catch(() => null);
+                    jsonResponse(res, { metrics: metricsMap, pageMemory, url: p.url() });
+                }
+                finally {
+                    await session.detach().catch(() => { });
+                }
+                return;
+            }
             case '/consoleLogs': {
                 const since = parsedUrl.query['since'] ?? '';
                 const entries = since

package/dist/drivers/a11y.js

@@ -0,0 +1,416 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeIOSAnnouncement = composeIOSAnnouncement;
+exports.buildIOSA11y = buildIOSA11y;
+exports.composeAndroidAnnouncement = composeAndroidAnnouncement;
+exports.buildAndroidA11y = buildAndroidA11y;
+exports.composeWebAnnouncement = composeWebAnnouncement;
+exports.buildWebA11y = buildWebA11y;
+const element_resolver_js_1 = require("./element-resolver.js");
+// ── iOS ──────────────────────────────────────────────────────────────────────
+/** XCUIElementType raw values → trait/role strings. Incomplete by design: only
+ *  the element types that map to user-facing roles are listed; others fall back
+ *  to an empty traits array and an empty role string. */
+const IOS_TYPE_TO_TRAIT = {
+    3: 'application',
+    4: 'window',
+    8: 'image',
+    9: 'button',
+    23: 'adjustable',
+    40: 'switch',
+    48: 'staticText',
+    49: 'textField',
+    50: 'secureTextField',
+    54: 'link',
+    70: 'table',
+    73: 'picker',
+    74: 'pickerWheel',
+    75: 'cell',
+    90: 'stepper',
+    93: 'searchField',
+};
+function iosTraitsFor(node) {
+    const out = [];
+    const base = IOS_TYPE_TO_TRAIT[node.elementType];
+    if (base)
+        out.push(base);
+    if (node.selected)
+        out.push('selected');
+    if (!node.enabled)
+        out.push('disabled');
+    if (node.hasFocus)
+        out.push('focused');
+    return out;
+}
+function isIOSA11yElement(node) {
+    // VoiceOver considers an element "accessible" if it has a label or a known interactive type.
+    // AXElement doesn't expose isAccessibilityElement directly; this is a documented approximation.
+    const hasText = !!(node.label || node.title || node.value || node.placeholderValue);
+    const hasTrait = !!IOS_TYPE_TO_TRAIT[node.elementType];
+    const hasFrame = node.frame.Width > 0 && node.frame.Height > 0;
+    return hasFrame && (hasText || hasTrait);
+}
+/** iOS announcement: `[label], [traits], [value], [hint]` — commas between parts. */
+function composeIOSAnnouncement(label, traits, value, hint) {
+    const parts = [];
+    if (label)
+        parts.push(label);
+    const announceableTraits = traits.filter((t) => t !== 'staticText' && t !== 'window' && t !== 'application');
+    if (announceableTraits.length)
+        parts.push(announceableTraits.join(', '));
+    if (value && value !== label)
+        parts.push(value);
+    if (hint)
+        parts.push(hint);
+    return parts.join(', ');
+}
+function buildIOSA11y(root) {
+    const snapshot = [];
+    let order = 0;
+    function walk(node, path) {
+        const traits = iosTraitsFor(node);
+        const isA11y = isIOSA11yElement(node);
+        const label = node.label || node.title || '';
+        const value = node.value || node.placeholderValue || '';
+        const hint = node.hint || '';
+        const announcement = isA11y ? composeIOSAnnouncement(label, traits, value, hint) : '';
+        let accessibilityOrder = null;
+        if (isA11y) {
+            accessibilityOrder = order++;
+            snapshot.push({
+                nodeId: path,
+                order: accessibilityOrder,
+                frame: {
+                    x: node.frame.X,
+                    y: node.frame.Y,
+                    w: node.frame.Width,
+                    h: node.frame.Height,
+                },
+                label,
+                hint,
+                role: traits[0] ?? '',
+                traits,
+                announcement,
+                value,
+                state: {
+                    enabled: node.enabled,
+                    selected: node.selected,
+                    focused: node.hasFocus,
+                },
+            });
+        }
+        const children = (node.children ?? []).map((c, i) => walk(c, path === '' ? String(i) : `${path}.${i}`));
+        const enriched = {
+            ...node,
+            nodeId: path,
+            accessibilityOrder,
+            traits,
+            isAccessibilityElement: isA11y,
+            accessibilityIdentifier: node.identifier,
+            accessibilityLabel: label || undefined,
+            accessibilityHint: hint || undefined,
+            accessibilityValue: value || undefined,
+            announcement: announcement || undefined,
+            children: children.length ? children : undefined,
+        };
+        return enriched;
+    }
+    const hierarchy = walk(root, '0');
+    return { hierarchy, a11ySnapshot: snapshot };
+}
+// Android className → semantic role. Matches AccessibilityNodeInfoCompat defaults.
+const ANDROID_CLASS_ROLE = [
+    [/Button$/, 'button'],
+    [/ImageButton$/, 'button'],
+    [/EditText$/, 'textField'],
+    [/CheckBox$/, 'checkbox'],
+    [/Switch$/, 'switch'],
+    [/ToggleButton$/, 'switch'],
+    [/RadioButton$/, 'radio'],
+    [/Spinner$/, 'dropdown'],
+    [/SeekBar$/, 'adjustable'],
+    [/ProgressBar$/, 'progressIndicator'],
+    [/TextView$/, 'staticText'],
+    [/ImageView$/, 'image'],
+    [/WebView$/, 'webView'],
+];
+function androidRoleFor(className) {
+    for (const [re, role] of ANDROID_CLASS_ROLE) {
+        if (re.test(className))
+            return role;
+    }
+    return '';
+}
+/** Android announcement: `[contentDescription || text], [role], [state], [hint]`. */
+function composeAndroidAnnouncement(text, contentDescription, role, stateParts, hint) {
+    const parts = [];
+    const spoken = contentDescription || text;
+    if (spoken)
+        parts.push(spoken);
+    if (role)
+        parts.push(role);
+    if (stateParts.length)
+        parts.push(stateParts.join(', '));
+    if (hint)
+        parts.push(hint);
+    return parts.join(', ');
+}
+/**
+ * Parse Android XML while preserving nesting — parseAndroidHierarchy returns a flat list,
+ * but we need tree structure for stable nodeId paths. We re-walk the XML here with a small
+ * state machine (open-tag depth) to reconstruct parent/child relationships.
+ */
+function parseAndroidTree(xml) {
+    const flat = (0, element_resolver_js_1.parseAndroidHierarchy)(xml);
+    // Parent index per node, computed from ordered XML scan.
+    const openStack = [];
+    const parentOf = new Array(flat.length).fill(-1);
+    // Regex that walks open/close tags in order.
+    const tokenRe = /<node\b[^>]*?(\/?)>|<\/node>/g;
+    let idx = 0;
+    let m;
+    while ((m = tokenRe.exec(xml)) !== null) {
+        const tag = m[0];
+        if (tag === '</node>') {
+            openStack.pop();
+            continue;
+        }
+        const selfClosing = m[1] === '/';
+        // Does this node have a valid bounds? Only those appear in `flat`.
+        const boundsMatch = /\bbounds="(\[[^"]+\])"/.exec(tag);
+        const hasValidBounds = boundsMatch &&
+            /\[(\d+),(\d+)]\[(\d+),(\d+)]/.test(boundsMatch[1]) &&
+            (() => {
+                const [, x1, y1, x2, y2] = /\[(\d+),(\d+)]\[(\d+),(\d+)]/.exec(boundsMatch[1]);
+                return +x2 - +x1 > 0 && +y2 - +y1 > 0;
+            })();
+        if (hasValidBounds) {
+            parentOf[idx] = openStack.length ? openStack[openStack.length - 1] : -1;
+            if (!selfClosing)
+                openStack.push(idx);
+            idx++;
+        }
+        else if (!selfClosing) {
+            // Non-visible container: push a sentinel so close tags still pop correctly.
+            openStack.push(-1);
+        }
+    }
+    const childrenOf = new Map();
+    const roots = [];
+    parentOf.forEach((p, i) => {
+        if (p === -1)
+            roots.push(i);
+        else {
+            const arr = childrenOf.get(p) ?? [];
+            arr.push(i);
+            childrenOf.set(p, arr);
+        }
+    });
+    const result = flat.map((n) => ({
+        text: n.text,
+        resourceId: n.resourceId,
+        contentDesc: n.contentDesc,
+        className: n.className,
+        hintText: n.hintText,
+        bounds: n.bounds,
+        clickable: n.clickable,
+        focusable: n.focusable,
+        enabled: n.enabled,
+        checked: n.checked,
+        checkable: n.checkable,
+        focused: n.focused,
+        selected: n.selected,
+        visibleToUser: n.visibleToUser,
+    }));
+    result.childrenOf = childrenOf;
+    result.roots = roots;
+    return result;
+}
+function buildAndroidA11y(xml) {
+    const tree = parseAndroidTree(xml);
+    const snapshot = [];
+    const meta = new Array(tree.length);
+    const computeMeta = (rawIdx) => {
+        const n = tree[rawIdx];
+        const role = androidRoleFor(n.className);
+        const screenReaderFocusable = n.focusable && (!!n.text || !!n.contentDesc);
+        const importantForAccessibility = screenReaderFocusable ? 'yes' : 'auto';
+        const stateParts = [];
+        if (n.checkable)
+            stateParts.push(n.checked ? 'checked' : 'not checked');
+        if (n.selected)
+            stateParts.push('selected');
+        if (!n.enabled)
+            stateParts.push('disabled');
+        const announcement = composeAndroidAnnouncement(n.text, n.contentDesc, role, stateParts, n.hintText);
+        // importantForAccessibility is inferred as 'yes' or 'auto' here (uiautomator
+        // dumps omit 'no' nodes). The 'no' case is kept as a documented future extension.
+        const wouldAnnounce = n.visibleToUser && (!!n.text || !!n.contentDesc || screenReaderFocusable);
+        return {
+            role,
+            screenReaderFocusable,
+            importantForAccessibility,
+            announcement,
+            stateParts,
+            wouldAnnounce,
+            hasAnnouncedDescendant: false,
+        };
+    };
+    // Post-order pass to fill hasAnnouncedDescendant.
+    const postOrder = (rawIdx) => {
+        meta[rawIdx] = computeMeta(rawIdx);
+        let anyChild = false;
+        for (const c of tree.childrenOf.get(rawIdx) ?? []) {
+            const childHasAnnounced = postOrder(c);
+            if (childHasAnnounced || meta[c].wouldAnnounce)
+                anyChild = true;
+        }
+        meta[rawIdx].hasAnnouncedDescendant = anyChild;
+        return anyChild;
+    };
+    for (const r of tree.roots)
+        postOrder(r);
+    // Phase 2: pre-order walk to emit snapshot entries + build enriched tree.
+    let order = 0;
+    const walk = (rawIdx, path) => {
+        const n = tree[rawIdx];
+        const m = meta[rawIdx];
+        const inOrder = m.wouldAnnounce && !m.hasAnnouncedDescendant;
+        let accessibilityOrder = null;
+        if (inOrder) {
+            accessibilityOrder = order++;
+            snapshot.push({
+                nodeId: path,
+                order: accessibilityOrder,
+                frame: {
+                    x: n.bounds.x1,
+                    y: n.bounds.y1,
+                    w: n.bounds.x2 - n.bounds.x1,
+                    h: n.bounds.y2 - n.bounds.y1,
+                },
+                label: n.contentDesc || n.text,
+                hint: n.hintText,
+                role: m.role,
+                traits: m.role ? [m.role] : [],
+                announcement: m.announcement,
+                value: '',
+                state: {
+                    enabled: n.enabled,
+                    selected: n.selected,
+                    focused: n.focused,
+                    checked: n.checkable ? n.checked : undefined,
+                },
+            });
+        }
+        const childIndices = tree.childrenOf.get(rawIdx) ?? [];
+        const kids = childIndices.map((i, ci) => walk(i, `${path}.${ci}`));
+        return {
+            nodeId: path,
+            accessibilityOrder,
+            class: n.className,
+            resourceId: n.resourceId,
+            text: n.text,
+            contentDescription: n.contentDesc,
+            hintText: n.hintText,
+            roleDescription: m.role,
+            role: m.role,
+            importantForAccessibility: m.importantForAccessibility,
+            screenReaderFocusable: m.screenReaderFocusable,
+            bounds: n.bounds,
+            state: {
+                enabled: n.enabled,
+                selected: n.selected,
+                focused: n.focused,
+                checked: n.checkable ? n.checked : undefined,
+            },
+            announcement: m.announcement,
+            children: kids.length ? kids : undefined,
+        };
+    };
+    const hierarchy = tree.roots.map((r, i) => walk(r, String(i)));
+    return { hierarchy, a11ySnapshot: snapshot };
+}
+const WEB_FOCUSABLE_ROLES = new Set([
+    'button',
+    'link',
+    'textbox',
+    'searchbox',
+    'checkbox',
+    'radio',
+    'switch',
+    'slider',
+    'spinbutton',
+    'combobox',
+    'menuitem',
+    'menuitemcheckbox',
+    'menuitemradio',
+    'tab',
+    'option',
+]);
+function isWebFocusable(node) {
+    return WEB_FOCUSABLE_ROLES.has(node.role);
+}
+/** Web announcement: `[accessibleName], [role], [state]` — screen readers read role after name. */
+function composeWebAnnouncement(name, role, stateParts) {
+    const parts = [];
+    if (name)
+        parts.push(name);
+    if (role && role !== 'generic' && role !== 'none')
+        parts.push(role);
+    if (stateParts.length)
+        parts.push(stateParts.join(', '));
+    return parts.join(', ');
+}
+function buildWebA11y(hierarchy) {
+    const snapshot = [];
+    let order = 0;
+    function walk(nodes, basePath) {
+        return nodes.map((n, i) => {
+            const path = basePath === '' ? String(i) : `${basePath}.${i}`;
+            const focusable = isWebFocusable(n);
+            const stateParts = [];
+            if (n.checked)
+                stateParts.push('checked');
+            if (n.selected)
+                stateParts.push('selected');
+            if (!n.enabled)
+                stateParts.push('disabled');
+            const announcement = composeWebAnnouncement(n.name, n.role, stateParts);
+            const kids = n.children ? walk(n.children, path) : undefined;
+            let accessibilityOrder = null;
+            if (focusable && n.bounds && n.bounds.width > 0 && n.bounds.height > 0) {
+                accessibilityOrder = order++;
+                snapshot.push({
+                    nodeId: path,
+                    order: accessibilityOrder,
+                    frame: { x: n.bounds.x, y: n.bounds.y, w: n.bounds.width, h: n.bounds.height },
+                    label: n.name,
+                    hint: '',
+                    role: n.role,
+                    traits: n.role ? [n.role] : [],
+                    announcement,
+                    value: '',
+                    state: {
+                        enabled: n.enabled,
+                        selected: !!n.selected,
+                        focused: n.focused,
+                        checked: n.checked,
+                    },
+                });
+            }
+            const enriched = {
+                ...n,
+                nodeId: path,
+                accessibilityOrder,
+                accessibleName: n.name,
+                ariaLabel: n.name, // Playwright's `name` is the computed accessible name; alias it.
+                ariaDescription: '',
+                focusable,
+                announcement,
+                children: kids,
+            };
+            return enriched;
+        });
+    }
+    return { hierarchy: walk(hierarchy.elements, ''), a11ySnapshot: snapshot };
+}

package/dist/drivers/web.js

@@ -136,6 +136,9 @@ class WebDriver {
         const result = await this.get('runningApp');
         return result.runningAppBundleId;
     }
+    async memory() {
+        return this.get('memory');
+    }
     async eraseAllText(count = 50) {
         await this.post('eraseText', { count });
     }

package/dist/index.js

@@ -18,6 +18,7 @@ const scroll_js_1 = require("./commands/scroll.js");
 const swipe_js_1 = require("./commands/swipe.js");
 const assert_visible_js_1 = require("./commands/assert-visible.js");
 const screenshot_js_1 = require("./commands/screenshot.js");
+const capture_ui_js_1 = require("./commands/capture-ui.js");
 const inspect_js_1 = require("./commands/inspect.js");
 const focused_js_1 = require("./commands/focused.js");
 const run_flow_js_1 = require("./commands/run-flow.js");
@@ -45,6 +46,7 @@ const start_device_js_1 = require("./commands/start-device.js");
 const stop_device_js_1 = require("./commands/stop-device.js");
 const delete_device_js_1 = require("./commands/delete-device.js");
 const logs_js_1 = require("./commands/logs.js");
+const memory_js_1 = require("./commands/memory.js");
 const device_picker_js_1 = require("./device-picker.js");
 const update_check_js_1 = require("./update-check.js");
 const pkg_root_js_1 = require("./pkg-root.js");
@@ -79,6 +81,7 @@ const COMMAND_HELP = {
     'set-location': set_location_js_1.HELP,
     'set-orientation': set_orientation_js_1.HELP,
     'take-screenshot': screenshot_js_1.HELP,
+    'capture-ui': capture_ui_js_1.HELP,
     inspect: inspect_js_1.HELP,
     focused: focused_js_1.HELP,
     'run-flow': run_flow_js_1.HELP,
@@ -94,6 +97,7 @@ const COMMAND_HELP = {
     'device-pool': device_pool_js_1.HELP,
     'run-parallel': run_parallel_js_1.HELP,
     logs: logs_js_1.HELP,
+    memory: memory_js_1.HELP,
 };
 const OPTIONS_HELP = `Options:
   --device <id>     Target device ID (also keys the session and daemon)
@@ -454,6 +458,11 @@ async function main() {
             exitCode = await (0, screenshot_js_1.screenshot)(outPath, opts, sessionName);
             break;
         }
+        case 'capture-ui': {
+            const outPath = argv['output'];
+            exitCode = await (0, capture_ui_js_1.captureUI)(outPath, opts, sessionName);
+            break;
+        }
         case 'inspect':
             exitCode = await (0, inspect_js_1.inspect)(opts, sessionName, { dump: argv['dump'] });
             break;
@@ -475,6 +484,11 @@ async function main() {
                 duration: argv['duration'] !== undefined ? Number(argv['duration']) : undefined,
             });
             break;
+        case 'memory': {
+            const appId = rest[0];
+            exitCode = await (0, memory_js_1.memory)(appId, opts, sessionName);
+            break;
+        }
         case 'run-flow': {
             const file = rest[0] ?? '';
             const rawEnv = argv['env'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@houwert/conductor",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "CLI tool for mobile app interactions — optimized for AI agents",
   "license": "MIT",
   "repository": {

package/skills/conductor/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: conductor
-version: 0.10.0
+version: 0.12.0
 description: "Token-efficient CLI for mobile UI testing (iOS simulator + Android emulator), designed for AI agents"
 metadata.openclaw:
   category: service
@@ -410,8 +410,54 @@ The hierarchy shows each element's type, text, and accessibility ID (resourceId
 
 ```bash
 conductor inspect
+conductor inspect --dump            # full hierarchy as JSON with a11y fields
 ```
 
+`--dump` emits a11y-enriched JSON on all platforms. Each node carries
+`accessibilityOrder` (0-based screen-reader nav index, or `null`), `traits` / `role`,
+`nodeId` (stable per-capture path), and platform-specific fields:
+`isAccessibilityElement` + `accessibilityLabel/Hint/Value` on iOS,
+`contentDescription` + `screenReaderFocusable` + `importantForAccessibility` on Android,
+`accessibleName` + `focusable` on web. Existing fields (`label`, `frame`, `identifier`,
+`text`, `resource-id`, `bounds`, ...) are preserved.
+
+---
+
+### `capture-ui`
+
+Bundle everything Argus needs for a single UI inspection: screenshot (PNG base64) +
+full UI hierarchy (with a11y fields) + flat accessibility-order snapshot in one JSON
+document. Intended primarily for programmatic consumers (Argus UI panel); humans
+should prefer `inspect` + `take-screenshot`.
+
+```bash
+conductor capture-ui                            # prints bundle as JSON to stdout
+conductor capture-ui --output /tmp/capture.json # writes bundle to file
+```
+
+Output shape:
+
+```json
+{
+  "version": 1,
+  "capturedAt": "2026-04-22T12:34:56.000Z",
+  "device": { "platform": "ios", "deviceId": "...", "width": 390, "height": 844 },
+  "screenshot": { "kind": "composite", "encoding": "png", "data": "<base64>" },
+  "hierarchy": { /* platform-native hierarchy with a11y fields on each node */ },
+  "a11ySnapshot": [
+    { "nodeId": "0.2.1", "order": 0, "frame": {"x":0,"y":0,"w":80,"h":44},
+      "label": "Sign in", "hint": "", "role": "button", "traits": ["button"],
+      "announcement": "Sign in, button", "value": "",
+      "state": {"enabled": true, "selected": false, "focused": false} }
+  ],
+  "capabilities": { "perViewPixels": false, "depthData": false }
+}
+```
+
+`nodeId` is a stable per-capture path (dot-joined child indices) so Argus can
+correlate flat snapshot entries back to hierarchy nodes. `capabilities.perViewPixels`
+is `false` in v1; per-view pixel rendering is a future phase.
+
 ---
 
 ### `logs`

package/skills/skills.yaml

@@ -3,6 +3,6 @@ skills:
     path: conductor/SKILL.md
     description: "Token-efficient CLI for mobile UI testing, designed for AI agents"
     category: service
-    version: 0.10.0
+    version: 0.12.0
     requires:
       bins: [conductor]