@houwert/conductor 0.10.0 → 0.11.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/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/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");
@@ -79,6 +80,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,
@@ -454,6 +456,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@houwert/conductor",
-  "version": "0.10.0",
+  "version": "0.11.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.11.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.11.0
     requires:
       bins: [conductor]