deadbyte-mcp 0.15.74 → 0.15.76

package/RELEASE.json

@@ -1,22 +1,22 @@
 {
   "schema": "deadbyte.release.v1",
   "name": "deadbyte-mcp",
-  "version": "0.15.74",
-  "train": "R194",
-  "label": "R194 npm authenticated publication hardening with R193 owner UAC baseline",
+  "version": "0.15.76",
+  "train": "R207",
+  "label": "R207 protected owner-enrollment IO recovery",
   "protocol_revision": "2026-07-28",
   "parent": {
-    "version": "0.15.72",
-    "release_id": "v0.15.72-0a5d9436e06e2d9e",
-    "manifest_sha256": "0a5d9436e06e2d9e7cf9179417465955d8ca5ba88655b13dd019190243c1cc90",
-    "generation_manifest_sha256": "aec7b998306a3bbbcc59088648e7bc46ca7e203d749d4550b5b5f372032f92b0",
+    "version": "0.15.75",
+    "release_id": "v0.15.75-9039fff265696091",
+    "manifest_sha256": "9039fff265696091f9217ba4f19526c6c74a967f9ff48b75ac6e340b5f431248",
+    "generation_manifest_sha256": "83a212e01173c73f78cff2a6d26e6f3f50f476a8c0ea3cbbf592a466071909e9",
     "activation_status": "PRODUCTION_ACTIVE"
   },
   "runtime_predecessor": {
-    "version": "0.15.72",
-    "release_id": "v0.15.72-0a5d9436e06e2d9e",
-    "manifest_sha256": "0a5d9436e06e2d9e7cf9179417465955d8ca5ba88655b13dd019190243c1cc90",
-    "generation_manifest_sha256": "aec7b998306a3bbbcc59088648e7bc46ca7e203d749d4550b5b5f372032f92b0"
+    "version": "0.15.75",
+    "release_id": "v0.15.75-9039fff265696091",
+    "manifest_sha256": "9039fff265696091f9217ba4f19526c6c74a967f9ff48b75ac6e340b5f431248",
+    "generation_manifest_sha256": "83a212e01173c73f78cff2a6d26e6f3f50f476a8c0ea3cbbf592a466071909e9"
   },
   "r190_foreground_recovery": {
     "status": "PREPUBLISH_VERIFIED",
@@ -36,13 +36,13 @@
     "authority_scope_delta": 0
   },
   "source_predecessor": {
-    "version": "0.15.73",
-    "train": "R193",
-    "source_path": "D:\\Projects\\deadbyte-mcp\\testing\\r193-final-closure\\closure.json",
-    "release_status": "FROZEN_R193_RELEASE_READY_NOT_PUBLISHED",
-    "manifest_status": "FROZEN_R193_CLOSURE_VERIFIED",
-    "manifest_sha256": "e0b3f8b333f1c1260a97b178d1a8beff5742355296a9fe7daba378612604a3bd",
-    "tarball_sha256": "13c3dd23a535609aa53173b328c7d9299d5dcada684f3253a88af6a4b300c534"
+    "version": "0.15.75",
+    "train": "R206",
+    "source_path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.75-r206-release-closure",
+    "release_status": "RELEASED",
+    "manifest_status": "R206_MANIFEST_VERIFIED",
+    "manifest_sha256": "9039fff265696091f9217ba4f19526c6c74a967f9ff48b75ac6e340b5f431248",
+    "tarball_sha256": "c2ebb079e7725f3a2f2c7d8f98ef42059e94e51f402d99c1825f46e020237ee9"
   },
   "consolidation": {
     "frontend_status_vocabulary": true,
@@ -671,5 +671,56 @@
     "limited_runtime_migration": "NOT_RUN",
     "npm_publish": "NOT_RUN",
     "production_activation": "NOT_RUN"
+  },
+  "r195": {
+    "status": "BEHAVIOR_GREEN_RELEASE_GATES_PENDING",
+    "scope": "CANONICAL_PROTECTED_OWNER_OBSERVATION",
+    "development_policy_root": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.75-r195-owner-enrollment-live",
+    "source_predecessor_version": "0.15.74",
+    "source_predecessor_manifest_sha256": "e84bf4eed16e9443fbd0bf9f0f562e26b01db778647aefcc8b12fd7f48636b47",
+    "source_predecessor_tarball_sha256": "5da436a3f8068107e74caf6da58ff1e211d4a62f94266853136b601762f36f0c",
+    "public_tool_delta": 0,
+    "authority_scope_delta": 0,
+    "owner_enrollment": "PENDING_OWNER_GESTURE_AFTER_ACTIVATION",
+    "npm_publish": "NOT_RUN",
+    "production_activation": "NOT_RUN"
+  },
+  "r206": {
+    "status": "BEHAVIOR_GREEN_FINAL_GATES_PENDING",
+    "scope": "EVIDENCE_BOUND_CANDIDATE_SELECTION_RELEASE_CLOSURE",
+    "development_policy_root": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.75-r206-release-closure",
+    "source_predecessor_train": "R205",
+    "source_predecessor_manifest_sha256": "166eebde18d53a9ec46f738383c289733f9cd37918b3572b7515d1ab9b122c92",
+    "runtime_predecessor_release_id": "v0.15.74-e84bf4eed16e9443",
+    "selector_release_authority": false,
+    "public_tool_delta": 0,
+    "authority_scope_delta": 0,
+    "deferred_unverified": [
+      "REMOTE_TWO_MACHINE_E2E",
+      "NATIVE_UIA_APPLICATION_EFFECT",
+      "BOUNDED_CDP_HARNESS2",
+      "REA_WINDOWS_209_TOOL_PARITY"
+    ],
+    "owner_enrollment": "PENDING_SEPARATE_POST_ACTIVATION_OWNER_GESTURE",
+    "npm_publish": "NOT_RUN",
+    "production_activation": "NOT_RUN"
+  },
+  "r207": {
+    "status": "BEHAVIOR_GREEN_FINAL_GATES_PENDING",
+    "scope": "PROTECTED_OWNER_ENROLLMENT_IO_RECOVERY",
+    "development_policy_root": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.76-r207-owner-enrollment-fix",
+    "source_predecessor_train": "R206",
+    "source_predecessor_manifest_sha256": "9039fff265696091f9217ba4f19526c6c74a967f9ff48b75ac6e340b5f431248",
+    "runtime_predecessor_release_id": "v0.15.75-9039fff265696091",
+    "owner_consent_directory_initialization": "FAIL_CLOSED_CONTAINED_NON_REPARSE",
+    "supervisor_ledger_utf8_bom": "ACCEPT_ONE_LEADING_BOM_ONLY",
+    "owner_private_key_access": false,
+    "r70_weakened": false,
+    "r89_weakened": false,
+    "public_tool_delta": 0,
+    "authority_scope_delta": 0,
+    "owner_enrollment": "PENDING_OWNER_GESTURE_AFTER_ACTIVATION",
+    "npm_publish": "NOT_RUN",
+    "production_activation": "NOT_RUN"
   }
 }

package/SBOM.cdx.json

@@ -1,13 +1,13 @@
 {
   "bomFormat": "CycloneDX",
   "specVersion": "1.6",
-  "serialNumber": "urn:cdx:deadbyte-mcp:r194:0.15.74",
+  "serialNumber": "urn:cdx:deadbyte-mcp:r207:0.15.76",
   "version": 1,
   "metadata": {
     "component": {
       "type": "application",
       "name": "deadbyte-mcp",
-      "version": "0.15.74"
+      "version": "0.15.76"
     }
   },
   "components": [

package/TEST-MATRIX.json

@@ -1,7 +1,7 @@
 {
   "schema": "deadbyte.test-matrix.v1",
-  "version": "0.15.74",
-  "train": "R194",
+  "version": "0.15.76",
+  "train": "R207",
   "primary_platform": "win32-x64",
   "reference": {
     "package": "@wonderwhy-er/desktop-commander",
@@ -10,6 +10,36 @@
     "schemas_sha256": "f342345e34e48769dabaefe1b932f09d41e2e207b422f7794a15ee50ffa8f140"
   },
   "required": [
+    {
+      "id": "r207-owner-enrollment-io",
+      "command": "node --test --test-concurrency=1 test/r207-owner-enrollment-io.test.mjs test/r193-owner-uac-broker.test.mjs test/r193-owner-uac-entrypoint.test.mjs",
+      "expected": "Protected owner request creates only its contained non-reparse state directory and the broker accepts exactly one UTF-8 BOM without weakening proof checks"
+    },
+    {
+      "id": "r207-release-identity",
+      "command": "node --test --test-concurrency=1 test/r207-release-contract.test.mjs",
+      "expected": "R206 source and active 0.15.75 runtime predecessors remain distinct; public tool and authority surfaces are unchanged"
+    },
+    {
+      "id": "r206-independent-candidate-evidence",
+      "command": "node --test --test-concurrency=1 test/r206-candidate-evidence.test.mjs",
+      "expected": "Every decision-bearing correctness and benchmark receipt is independently verified and the selector remains unable to authorize release"
+    },
+    {
+      "id": "r206-release-identity",
+      "command": "node --test --test-concurrency=1 test/r206-release-contract.test.mjs",
+      "expected": "R205 source and active 0.15.74 runtime predecessors remain distinct; public tool and authority surfaces are unchanged"
+    },
+    {
+      "id": "r206-protected-full-and-package",
+      "command": "powershell -NoProfile -ExecutionPolicy Bypass -File scripts/gate-windows-r206.ps1 -Stage all",
+      "expected": "Exact final manifest passes R89 protected focused/full regression and package verify-only with every skip classified"
+    },
+    {
+      "id": "r195-canonical-protected-owner-observation",
+      "command": "node --test test/r195-canonical-owner-observation.test.mjs",
+      "expected": "Protected owner request and broker observe the exact active controller through the canonical verified launcher"
+    },
     {
       "id": "r191-trusted-successor-epoch-root",
       "command": "run R191 protected 0.15.71 ACL and full Windows regression",

package/bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deadbyte-chatgpt-bridge",
-  "version": "0.15.74",
+  "version": "0.15.76",
   "private": true,
   "type": "module",
   "engines": {

package/controller/deadbyte-process-policy.json

@@ -1,15 +1,15 @@
 {
   "schema": "deadbyte.process-policy.v1",
   "enabled": true,
-  "grant_file": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.74-r194-npm-auth-recovery\\controller\\runtime\\process-grant.json",
-  "state_dir": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.74-r194-npm-auth-recovery\\controller\\runtime\\process-state",
+  "grant_file": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.76-r207-owner-enrollment-fix\\controller\\runtime\\process-grant.json",
+  "state_dir": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.76-r207-owner-enrollment-fix\\controller\\runtime\\process-state",
   "native_host": {
-    "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.74-r194-npm-auth-recovery\\bin\\deadbyte-process-host.exe",
+    "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.76-r207-owner-enrollment-fix\\bin\\deadbyte-process-host.exe",
     "sha256": "daf9cfb371bee88cafbf5597eaa507fec504dbe0b0ddd40d0c3c2e02817f49e4"
   },
   "roots": {
     "core": {
-      "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.74-r194-npm-auth-recovery",
+      "path": "D:\\Projects\\deadbyte-mcp\\development\\deadbyte-mcp-0.15.76-r207-owner-enrollment-fix",
       "deny_paths": [
         "node_modules",
         "controller/runtime",

package/docs/R184-package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "deadbyte-mcp",
-  "version": "0.15.74",
+  "version": "0.15.76",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "deadbyte-mcp",
-      "version": "0.15.74",
+      "version": "0.15.76",
       "bundleDependencies": [
         "@modelcontextprotocol/server",
         "@modelcontextprotocol/client",
@@ -28,8 +28,6 @@
     },
     "node_modules/@modelcontextprotocol/client": {
       "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/client/-/client-2.3.1.tgz",
-      "integrity": "sha512-mIGZXpHsjnZ6lD+gD/WCMpR5k8yVQQ8nNFH1N0Srf7AvnwTUMYD6pvTY8ng2+He5FfV7YMZLmrjL7cLa/cc3dQ==",
       "inBundle": true,
       "license": "Apache-2.0",
       "dependencies": {
@@ -47,8 +45,6 @@
     },
     "node_modules/@modelcontextprotocol/core": {
       "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/core/-/core-2.3.1.tgz",
-      "integrity": "sha512-laVmIhPGpWi7rG9q+0UigblRN0Hws/Yjlb6qLFtVqryXVLkc4h+yN8z731POD2LnAGQlFe7/tXhUm7Bi0YB91g==",
       "inBundle": true,
       "license": "Apache-2.0",
       "dependencies": {
@@ -60,8 +56,6 @@
     },
     "node_modules/@modelcontextprotocol/server": {
       "version": "2.3.1",
-      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/server/-/server-2.3.1.tgz",
-      "integrity": "sha512-e59MfWuSssj6DoQ96JCTqdW1AXT5/XtnTl0WWd6MU1Ka434fFUGGosCLJbGNySDhHGvxQWoRWK137FXYFkYNWw==",
       "inBundle": true,
       "license": "Apache-2.0",
       "dependencies": {

package/native/deadbyte-desktop-uia-r199.cpp

@@ -0,0 +1,345 @@
+#include <windows.h>
+#include <UIAutomation.h>
+#include <cstdio>
+#include <cstdint>
+#include <cstdlib>
+#include <cerrno>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <cwctype>
+#include <oleauto.h>
+
+static constexpr size_t kMaxRequest = 8192;
+static constexpr int kMaxVisited = 2048;
+static constexpr int kMaxResultsHard = 16;
+
+struct Match {
+    LONG left{};
+    LONG top{};
+    LONG width{};
+    LONG height{};
+    int controlType{};
+    bool enabled{};
+    bool offscreen{};
+    std::vector<LONG> runtimeId;
+};
+
+struct Request {
+    HWND expectedHwnd{};
+    DWORD expectedPid{};
+    std::string kind;
+    int maxResults{8};
+    std::string queryUtf8;
+};
+
+static void fail(const char* message, int code = 2) {
+    std::fprintf(stderr, "deadbyte-desktop-uia: %s\n", message);
+    std::exit(code);
+}
+
+static bool parseUnsigned(const std::string& text, unsigned long long& out, int base = 10) {
+    if (text.empty()) return false;
+    char* end = nullptr;
+    errno = 0;
+    const auto v = std::strtoull(text.c_str(), &end, base);
+    if (errno != 0 || end == text.c_str() || *end != '\0') return false;
+    out = v;
+    return true;
+}
+
+static std::vector<std::string> readHeaderLines(const std::string& bytes, size_t count, size_t& offset) {
+    std::vector<std::string> lines;
+    offset = 0;
+    for (size_t i = 0; i < count; ++i) {
+        const auto pos = bytes.find('\n', offset);
+        if (pos == std::string::npos) fail("request header truncated");
+        std::string line = bytes.substr(offset, pos - offset);
+        if (!line.empty() && line.back() == '\r') line.pop_back();
+        lines.push_back(line);
+        offset = pos + 1;
+    }
+    return lines;
+}
+
+static std::string field(const std::string& line, const char* key) {
+    const std::string prefix = std::string(key) + "=";
+    if (line.rfind(prefix, 0) != 0) fail("request field order/name invalid");
+    return line.substr(prefix.size());
+}
+
+static Request readRequest() {
+    std::string bytes;
+    bytes.resize(kMaxRequest + 1);
+    const size_t got = std::fread(bytes.data(), 1, bytes.size(), stdin);
+    if (std::ferror(stdin)) fail("stdin read failed");
+    if (got > kMaxRequest) fail("request exceeds bound");
+    bytes.resize(got);
+
+    size_t offset = 0;
+    const auto lines = readHeaderLines(bytes, 6, offset);
+    if (lines[0] != "DEADBYTE_DESKTOP_UIA_V1") fail("request magic invalid");
+
+    Request r;
+    const auto hwndText = field(lines[1], "expected_hwnd");
+    const auto pidText = field(lines[2], "expected_pid");
+    r.kind = field(lines[3], "query_kind");
+    const auto maxText = field(lines[4], "max_results");
+    const auto queryBytesText = field(lines[5], "query_bytes");
+
+    unsigned long long hwndValue = 0, pidValue = 0, maxValue = 0, queryBytes = 0;
+    std::string h = hwndText;
+    if (h.rfind("0x", 0) == 0 || h.rfind("0X", 0) == 0) h = h.substr(2);
+    if (!parseUnsigned(h, hwndValue, 16) || hwndValue == 0) fail("expected_hwnd invalid");
+    if (!parseUnsigned(pidText, pidValue) || pidValue == 0 || pidValue > 0x7fffffffULL) fail("expected_pid invalid");
+    if (!parseUnsigned(maxText, maxValue) || maxValue < 1 || maxValue > kMaxResultsHard) fail("max_results invalid");
+    if (!parseUnsigned(queryBytesText, queryBytes) || queryBytes > 512) fail("query_bytes invalid");
+    if (offset + queryBytes != bytes.size()) fail("query payload length mismatch");
+
+    r.expectedHwnd = reinterpret_cast<HWND>(static_cast<uintptr_t>(hwndValue));
+    r.expectedPid = static_cast<DWORD>(pidValue);
+    r.maxResults = static_cast<int>(maxValue);
+    r.queryUtf8.assign(bytes.data() + offset, static_cast<size_t>(queryBytes));
+
+    const bool needsQuery = r.kind != "root";
+    if (needsQuery && r.queryUtf8.empty()) fail("query required");
+    if (!needsQuery && !r.queryUtf8.empty()) fail("root query must be empty");
+    if (r.kind != "root" && r.kind != "name_exact" && r.kind != "name_contains" &&
+        r.kind != "automation_id_exact" && r.kind != "control_type") fail("query_kind invalid");
+    return r;
+}
+
+static std::wstring utf8ToWide(const std::string& input) {
+    if (input.empty()) return {};
+    const int n = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, input.data(),
+        static_cast<int>(input.size()), nullptr, 0);
+    if (n <= 0) fail("query UTF-8 invalid");
+    std::wstring out(static_cast<size_t>(n), L'\0');
+    if (MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, input.data(),
+        static_cast<int>(input.size()), out.data(), n) != n) fail("query UTF-8 conversion failed");
+    return out;
+}
+
+static std::wstring lower(std::wstring s) {
+    std::transform(s.begin(), s.end(), s.begin(), [](wchar_t c) { return static_cast<wchar_t>(std::towlower(c)); });
+    return s;
+}
+
+static int controlTypeFromQuery(const std::string& q) {
+    struct Pair { const char* name; int id; };
+    static const Pair map[] = {
+        {"button", UIA_ButtonControlTypeId}, {"checkbox", UIA_CheckBoxControlTypeId},
+        {"combobox", UIA_ComboBoxControlTypeId}, {"edit", UIA_EditControlTypeId},
+        {"hyperlink", UIA_HyperlinkControlTypeId}, {"list", UIA_ListControlTypeId},
+        {"listitem", UIA_ListItemControlTypeId}, {"menu", UIA_MenuControlTypeId},
+        {"menuitem", UIA_MenuItemControlTypeId}, {"radio", UIA_RadioButtonControlTypeId},
+        {"tab", UIA_TabControlTypeId}, {"tabitem", UIA_TabItemControlTypeId},
+        {"text", UIA_TextControlTypeId}, {"toolbar", UIA_ToolBarControlTypeId},
+        {"tree", UIA_TreeControlTypeId}, {"treeitem", UIA_TreeItemControlTypeId},
+        {"document", UIA_DocumentControlTypeId}, {"window", UIA_WindowControlTypeId},
+        {"pane", UIA_PaneControlTypeId}, {"group", UIA_GroupControlTypeId}
+    };
+    for (const auto& item : map) if (q == item.name) return item.id;
+    return 0;
+}
+
+static bool matches(IUIAutomationElement* e, const Request& r, const std::wstring& queryWide, int queryControlType) {
+    if (r.kind == "root") return true;
+    if (r.kind == "control_type") {
+        CONTROLTYPEID type = 0;
+        return SUCCEEDED(e->get_CurrentControlType(&type)) && type == queryControlType;
+    }
+
+    BSTR raw = nullptr;
+    HRESULT hr = E_FAIL;
+    if (r.kind == "automation_id_exact") hr = e->get_CurrentAutomationId(&raw);
+    else hr = e->get_CurrentName(&raw);
+    if (FAILED(hr) || raw == nullptr) {
+        if (raw) SysFreeString(raw);
+        return false;
+    }
+    std::wstring value(raw, SysStringLen(raw));
+    SysFreeString(raw);
+    value = lower(std::move(value));
+    const auto query = lower(queryWide);
+    if (r.kind == "name_contains") return value.find(query) != std::wstring::npos;
+    return value == query;
+}
+
+// RuntimeId is an ephemeral bounded value, not a long-lived COM reference.
+static bool readRuntimeId(IUIAutomationElement* e, std::vector<LONG>& out) {
+    SAFEARRAY* ids = nullptr;
+    const HRESULT identityStatus = e->GetRuntimeId(&ids);
+    if (FAILED(identityStatus) || !ids) {
+        if (ids) SafeArrayDestroy(ids);
+        return false;
+    }
+    const UINT dims = SafeArrayGetDim(ids);
+    LONG low = 0, high = -1;
+    const bool boundsOk = dims == 1 &&
+        SUCCEEDED(SafeArrayGetLBound(ids, 1, &low)) &&
+        SUCCEEDED(SafeArrayGetUBound(ids, 1, &high));
+    const long long count = boundsOk ? static_cast<long long>(high) -
+        static_cast<long long>(low) + 1 : 0;
+    if (!boundsOk || count < 1 || count > 64) {
+        SafeArrayDestroy(ids); return false;
+    }
+    std::vector<LONG> candidate;
+    candidate.reserve(static_cast<size_t>(count));
+    for (long long j = 0; j < count; ++j) {
+        LONG i = static_cast<LONG>(static_cast<long long>(low) + j);
+        LONG value = 0;
+        if (FAILED(SafeArrayGetElement(ids, &i, &value))) {
+            SafeArrayDestroy(ids); return false;
+        }
+        candidate.push_back(value);
+    }
+    SafeArrayDestroy(ids);
+    out = std::move(candidate);
+    return true;
+}
+static bool captureMatch(IUIAutomationElement* e, Match& out) {
+    RECT rc{};
+    if (FAILED(e->get_CurrentBoundingRectangle(&rc))) return false;
+    if (rc.right <= rc.left || rc.bottom <= rc.top) return false;
+    BOOL offscreen = TRUE, enabled = FALSE;
+    e->get_CurrentIsOffscreen(&offscreen);
+    e->get_CurrentIsEnabled(&enabled);
+    if (offscreen) return false;
+    CONTROLTYPEID type = 0;
+    e->get_CurrentControlType(&type);
+    out.left = rc.left; out.top = rc.top;
+    out.width = rc.right - rc.left; out.height = rc.bottom - rc.top;
+    out.controlType = type; out.enabled = enabled != FALSE; out.offscreen = offscreen != FALSE;
+    return readRuntimeId(e, out.runtimeId);
+}
+
+static void walk(IUIAutomationTreeWalker* walker, IUIAutomationElement* parent, const Request& req,
+    const std::wstring& queryWide, int queryControlType, int depth, int& visited,
+    bool& truncated, std::vector<Match>& matchesOut) {
+    if (depth > 64 || visited >= kMaxVisited || static_cast<int>(matchesOut.size()) >= req.maxResults) return;
+    IUIAutomationElement* child = nullptr;
+    if (FAILED(walker->GetFirstChildElement(parent, &child)) || child == nullptr) return;
+    while (child != nullptr) {
+        ++visited;
+        if (visited >= kMaxVisited) truncated = true;
+        if (matches(child, req, queryWide, queryControlType)) {
+            Match m;
+            if (captureMatch(child, m)) matchesOut.push_back(m);
+        }
+        if (!truncated && static_cast<int>(matchesOut.size()) < req.maxResults) {
+            walk(walker, child, req, queryWide, queryControlType, depth + 1, visited, truncated, matchesOut);
+        }
+        IUIAutomationElement* next = nullptr;
+        walker->GetNextSiblingElement(child, &next);
+        child->Release();
+        child = next;
+        if (truncated || static_cast<int>(matchesOut.size()) >= req.maxResults) {
+            if (child) child->Release();
+            break;
+        }
+    }
+}
+
+static unsigned long long hwndNumber(HWND h) {
+    return static_cast<unsigned long long>(reinterpret_cast<uintptr_t>(h));
+}
+
+static int runSelftest() {
+    if (controlTypeFromQuery("button") != UIA_ButtonControlTypeId) return 2;
+    std::printf("{\"schema\":\"deadbyte.desktop-uia-selftest.v1\",\"status\":\"passed\"}\n");
+    return 0;
+}
+
+int wmain(int argc, wchar_t** argv) {
+    if (argc == 2 && std::wstring(argv[1]) == L"--selftest") return runSelftest();
+    const Request req = readRequest();
+
+    HWND fg = GetForegroundWindow();
+    DWORD pid = 0;
+    if (fg) GetWindowThreadProcessId(fg, &pid);
+    if (fg != req.expectedHwnd || pid != req.expectedPid) fail("foreground window identity changed", 3);
+
+    const HRESULT init = CoInitializeEx(nullptr, COINIT_MULTITHREADED);
+    if (FAILED(init) && init != RPC_E_CHANGED_MODE) fail("CoInitializeEx failed", 4);
+    const bool uninit = SUCCEEDED(init);
+
+    IUIAutomation* automation = nullptr;
+    HRESULT hr = CoCreateInstance(CLSID_CUIAutomation, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&automation));
+    if (FAILED(hr) || !automation) {
+        if (uninit) CoUninitialize();
+        fail("CUIAutomation creation failed", 5);
+    }
+
+    IUIAutomationElement* root = nullptr;
+    hr = automation->ElementFromHandle(fg, &root);
+    if (FAILED(hr) || !root) {
+        automation->Release(); if (uninit) CoUninitialize();
+        fail("ElementFromHandle failed", 6);
+    }
+
+    std::vector<Match> found;
+    int visited = 0;
+    bool truncated = false;
+    const std::wstring queryWide = utf8ToWide(req.queryUtf8);
+    const int queryControlType = req.kind == "control_type" ? controlTypeFromQuery(req.queryUtf8) : 0;
+    if (req.kind == "control_type" && queryControlType == 0) {
+        root->Release(); automation->Release(); if (uninit) CoUninitialize();
+        fail("unsupported control_type query", 7);
+    }
+
+    if (req.kind == "root") {
+        ++visited;
+        RECT wr{};
+        if (GetWindowRect(fg, &wr)) {
+            const LONG vx = GetSystemMetrics(SM_XVIRTUALSCREEN);
+            const LONG vy = GetSystemMetrics(SM_YVIRTUALSCREEN);
+            const LONG vr = vx + GetSystemMetrics(SM_CXVIRTUALSCREEN);
+            const LONG vb = vy + GetSystemMetrics(SM_CYVIRTUALSCREEN);
+            const LONG left = (std::max)(wr.left, vx);
+            const LONG top = (std::max)(wr.top, vy);
+            const LONG right = (std::min)(wr.right, vr);
+            const LONG bottom = (std::min)(wr.bottom, vb);
+            if (right > left && bottom > top && IsWindowVisible(fg)) {
+                Match m;
+                m.left = left; m.top = top; m.width = right - left; m.height = bottom - top;
+                m.controlType = UIA_WindowControlTypeId;
+                m.enabled = IsWindowEnabled(fg) != FALSE;
+                m.offscreen = false;
+                found.push_back(m);
+            }
+        }
+    } else {
+        IUIAutomationTreeWalker* walker = nullptr;
+        hr = automation->get_ControlViewWalker(&walker);
+        if (FAILED(hr) || !walker) {
+            root->Release(); automation->Release(); if (uninit) CoUninitialize();
+            fail("ControlViewWalker unavailable", 8);
+        }
+        walk(walker, root, req, queryWide, queryControlType, 0, visited, truncated, found);
+        walker->Release();
+    }
+
+    std::printf("{\"schema\":\"deadbyte.desktop-uia-ground.v1\",\"foreground_hwnd\":\"0x%llx\",\"foreground_pid\":%lu,"
+                "\"query_kind\":\"%s\",\"visited\":%d,\"truncated\":%s,\"matches\":[",
+        hwndNumber(fg), static_cast<unsigned long>(pid), req.kind.c_str(), visited, truncated ? "true" : "false");
+    for (size_t i = 0; i < found.size(); ++i) {
+        if (i) std::printf(",");
+        const auto& m = found[i];
+        std::printf("{\"left\":%ld,\"top\":%ld,\"width\":%ld,\"height\":%ld,\"control_type\":%d,"
+                    "\"enabled\":%s,\"offscreen\":%s,\"runtime_id\":[",
+            m.left, m.top, m.width, m.height, m.controlType,
+            m.enabled ? "true" : "false", m.offscreen ? "true" : "false");
+        for (size_t j = 0; j < m.runtimeId.size(); ++j) {
+            if (j) std::printf(",");
+            std::printf("%ld", m.runtimeId[j]);
+        }
+        std::printf("]}");
+    }
+    std::printf("]}\n");
+
+    root->Release();
+    automation->Release();
+    if (uninit) CoUninitialize();
+    return 0;
+}