@forsion/tangu-computer-use 0.5.8

package/native/windows/bridge-rs/tests/protocol_tests.rs

@@ -0,0 +1,252 @@
+use serde_json::json;
+
+/// The protocol types under test are expected to be exported from the library crate.
+use windows_bridge::{protocol::PROTOCOL_VERSION, ErrorCode, ProtocolError, Request, Response};
+
+// ---------------------------------------------------------------------------
+// Request parsing
+// ---------------------------------------------------------------------------
+
+#[test]
+fn test_parse_valid_request() {
+    let raw = json!({
+        "protocolVersion": PROTOCOL_VERSION,
+        "id": "req-001",
+        "cmd": "checkPermissions",
+        "args": {}
+    });
+    let req: Request = serde_json::from_value(raw).expect("valid request");
+    assert_eq!(req.protocol_version, PROTOCOL_VERSION);
+    assert_eq!(req.id, "req-001");
+    assert_eq!(req.cmd, "checkPermissions");
+}
+
+#[test]
+fn test_parse_request_with_args() {
+    let raw = json!({
+        "protocolVersion": PROTOCOL_VERSION,
+        "id": "req-002",
+        "cmd": "listWindows",
+        "args": { "pid": 1234 }
+    });
+    let req: Request = serde_json::from_value(raw).expect("valid request with args");
+    assert_eq!(req.protocol_version, PROTOCOL_VERSION);
+    assert_eq!(req.id, "req-002");
+    assert_eq!(req.cmd, "listWindows");
+    assert!(req.args.is_object());
+    assert_eq!(req.args["pid"], 1234);
+}
+
+#[test]
+fn test_parse_request_missing_id() {
+    let raw = json!({
+        "protocolVersion": PROTOCOL_VERSION,
+        "cmd": "checkPermissions",
+        "args": {}
+    });
+    let result: Result<Request, _> = serde_json::from_value(raw);
+    assert!(result.is_err(), "missing id should be rejected");
+}
+
+#[test]
+fn test_parse_request_missing_cmd() {
+    let raw = json!({
+        "protocolVersion": PROTOCOL_VERSION,
+        "id": "req-003",
+        "args": {}
+    });
+    let result: Result<Request, _> = serde_json::from_value(raw);
+    assert!(result.is_err(), "missing cmd should be rejected");
+}
+
+#[test]
+fn test_parse_request_wrong_types() {
+    // id must be a string
+    let raw = json!({
+        "protocolVersion": PROTOCOL_VERSION,
+        "id": 42,
+        "cmd": "test",
+        "args": {}
+    });
+    let result: Result<Request, _> = serde_json::from_value(raw);
+    assert!(result.is_err(), "non-string id should be rejected");
+}
+
+// ---------------------------------------------------------------------------
+// Success response serialization
+// ---------------------------------------------------------------------------
+
+#[test]
+fn test_serialize_success_response() {
+    let resp = Response::ok("req-001", json!({ "ready": true }));
+    let json_str = serde_json::to_string(&resp).expect("serialize success");
+    let parsed: serde_json::Value = serde_json::from_str(&json_str).unwrap();
+
+    assert_eq!(parsed["protocolVersion"], PROTOCOL_VERSION);
+    assert_eq!(parsed["id"], "req-001");
+    assert_eq!(parsed["ok"], true);
+    assert_eq!(parsed["result"]["ready"], true);
+}
+
+#[test]
+fn test_serialize_success_with_null_result() {
+    let resp = Response::ok("req-002", json!(null));
+    let json_str = serde_json::to_string(&resp).expect("serialize success null");
+    let parsed: serde_json::Value = serde_json::from_str(&json_str).unwrap();
+
+    assert_eq!(parsed["protocolVersion"], PROTOCOL_VERSION);
+    assert_eq!(parsed["id"], "req-002");
+    assert_eq!(parsed["ok"], true);
+    assert_eq!(parsed["result"], serde_json::Value::Null);
+}
+
+// ---------------------------------------------------------------------------
+// Error response serialization
+// ---------------------------------------------------------------------------
+
+#[test]
+fn test_serialize_capability_deferred_error() {
+    let err = ProtocolError::new(
+        "Window ref-backed actions are deferred in PR #1. \
+         This PR supports window discovery, screenshots, state IDs, \
+         and read-only UIA element discovery.",
+        ErrorCode::CapabilityDeferred,
+    );
+    let resp = Response::err("req-003", err);
+    let json_str = serde_json::to_string(&resp).expect("serialize error");
+    let parsed: serde_json::Value = serde_json::from_str(&json_str).unwrap();
+
+    assert_eq!(parsed["protocolVersion"], PROTOCOL_VERSION);
+    assert_eq!(parsed["id"], "req-003");
+    assert_eq!(parsed["ok"], false);
+    assert_eq!(parsed["error"]["code"], "capability_deferred");
+    assert!(parsed["error"]["message"]
+        .as_str()
+        .unwrap()
+        .contains("deferred"));
+}
+
+#[test]
+fn test_serialize_unsupported_command_error() {
+    let err = ProtocolError::new("Unknown command 'fooBar'", ErrorCode::UnsupportedCommand);
+    let resp = Response::err("req-004", err);
+    let json_str = serde_json::to_string(&resp).expect("serialize error");
+    let parsed: serde_json::Value = serde_json::from_str(&json_str).unwrap();
+
+    assert_eq!(parsed["protocolVersion"], PROTOCOL_VERSION);
+    assert_eq!(parsed["id"], "req-004");
+    assert_eq!(parsed["ok"], false);
+    assert_eq!(parsed["error"]["code"], "unsupported_command");
+    assert_eq!(parsed["error"]["message"], "Unknown command 'fooBar'");
+}
+
+#[test]
+fn test_serialize_invalid_request_error() {
+    let err = ProtocolError::new(
+        "Request must be a valid JSON object with protocolVersion, id, and cmd",
+        ErrorCode::InvalidRequest,
+    );
+    let resp = Response::err("req-005", err);
+    let json_str = serde_json::to_string(&resp).expect("serialize error");
+    let parsed: serde_json::Value = serde_json::from_str(&json_str).unwrap();
+
+    assert_eq!(parsed["protocolVersion"], PROTOCOL_VERSION);
+    assert_eq!(parsed["id"], "req-005");
+    assert_eq!(parsed["ok"], false);
+    assert_eq!(parsed["error"]["code"], "invalid_request");
+}
+
+#[test]
+fn test_serialize_internal_error() {
+    let err = ProtocolError::new("Unexpected internal failure", ErrorCode::InternalError);
+    let resp = Response::err("req-006", err);
+    let json_str = serde_json::to_string(&resp).expect("serialize error");
+    let parsed: serde_json::Value = serde_json::from_str(&json_str).unwrap();
+
+    assert_eq!(parsed["protocolVersion"], PROTOCOL_VERSION);
+    assert_eq!(parsed["id"], "req-006");
+    assert_eq!(parsed["ok"], false);
+    assert_eq!(parsed["error"]["code"], "internal_error");
+}
+
+#[test]
+fn test_serialize_target_not_found_error() {
+    let err = ProtocolError::new("Window with id 42 not found", ErrorCode::TargetNotFound);
+    let resp = Response::err("req-007", err);
+    let json_str = serde_json::to_string(&resp).expect("serialize error");
+    let parsed: serde_json::Value = serde_json::from_str(&json_str).unwrap();
+
+    assert_eq!(parsed["protocolVersion"], PROTOCOL_VERSION);
+    assert_eq!(parsed["id"], "req-007");
+    assert_eq!(parsed["ok"], false);
+    assert_eq!(parsed["error"]["code"], "target_not_found");
+}
+
+// ---------------------------------------------------------------------------
+// ErrorCode Display
+// ---------------------------------------------------------------------------
+
+#[test]
+fn test_error_code_display() {
+    assert_eq!(
+        ErrorCode::CapabilityDeferred.to_string(),
+        "capability_deferred"
+    );
+    assert_eq!(
+        ErrorCode::UnsupportedCommand.to_string(),
+        "unsupported_command"
+    );
+    assert_eq!(ErrorCode::InvalidRequest.to_string(), "invalid_request");
+    assert_eq!(ErrorCode::TargetNotFound.to_string(), "target_not_found");
+    assert_eq!(ErrorCode::InternalError.to_string(), "internal_error");
+}
+
+// ---------------------------------------------------------------------------
+// Integration: round-trip request + response
+// ---------------------------------------------------------------------------
+
+#[test]
+fn test_round_trip_request_response() {
+    // Simulate: parse a request, produce a success response, serialize it
+    let raw = json!({
+        "protocolVersion": PROTOCOL_VERSION,
+        "id": "rt-001",
+        "cmd": "checkPermissions",
+        "args": {}
+    });
+    let req: Request = serde_json::from_value(raw).unwrap();
+    assert_eq!(req.cmd, "checkPermissions");
+
+    let resp = Response::ok(req.id.as_str(), json!({ "accessibility": false }));
+    let out = serde_json::to_string(&resp).unwrap();
+    let parsed: serde_json::Value = serde_json::from_str(&out).unwrap();
+    assert_eq!(parsed["protocolVersion"], PROTOCOL_VERSION);
+    assert_eq!(parsed["id"], "rt-001");
+    assert_eq!(parsed["ok"], true);
+    assert_eq!(parsed["result"]["accessibility"], false);
+}
+
+#[test]
+fn test_round_trip_request_error() {
+    // Simulate: parse request, produce an error response, serialize it
+    let raw = json!({
+        "protocolVersion": PROTOCOL_VERSION,
+        "id": "rt-002",
+        "cmd": "mouseClick",
+        "args": {}
+    });
+    let req: Request = serde_json::from_value(raw).unwrap();
+    assert_eq!(req.cmd, "mouseClick");
+
+    let err = ProtocolError::new(
+        "Windows ref-backed actions are deferred in PR #1",
+        ErrorCode::CapabilityDeferred,
+    );
+    let resp = Response::err(req.id.as_str(), err);
+    let out = serde_json::to_string(&resp).unwrap();
+    let parsed: serde_json::Value = serde_json::from_str(&out).unwrap();
+    assert_eq!(parsed["protocolVersion"], PROTOCOL_VERSION);
+    assert_eq!(parsed["id"], "rt-002");
+    assert_eq!(parsed["ok"], false);
+    assert_eq!(parsed["error"]["code"], "capability_deferred");
+}

package/native/windows/bridge-rs/tests/refs_tests.rs

@@ -0,0 +1,86 @@
+use windows_bridge::refs::{NativeHandle, RefStore};
+
+// ---------------------------------------------------------------------------
+// First ref assertions
+// ---------------------------------------------------------------------------
+
+#[test]
+fn test_first_window_ref_is_w1() {
+    let mut store = RefStore::new();
+    let wref = store.insert_window(NativeHandle::new(0x1234));
+    assert_eq!(wref.to_string(), "@w1");
+}
+
+#[test]
+fn test_first_element_ref_is_e1() {
+    let mut store = RefStore::new();
+    let eref = store.insert_element(NativeHandle::new(0x5678));
+    assert_eq!(eref.to_string(), "@e1");
+}
+
+// ---------------------------------------------------------------------------
+// Refs are state-scoped: independent stores reset counters
+// ---------------------------------------------------------------------------
+
+#[test]
+fn test_refs_are_state_scoped() {
+    let mut store1 = RefStore::new();
+    let mut store2 = RefStore::new();
+
+    let w1 = store1.insert_window(NativeHandle::new(1));
+    let e1 = store1.insert_element(NativeHandle::new(2));
+    let w2 = store2.insert_window(NativeHandle::new(3));
+    let e2 = store2.insert_element(NativeHandle::new(4));
+
+    assert_eq!(w1.to_string(), "@w1");
+    assert_eq!(e1.to_string(), "@e1");
+    // Second store starts fresh at 1
+    assert_eq!(w2.to_string(), "@w1");
+    assert_eq!(e2.to_string(), "@e1");
+}
+
+// ---------------------------------------------------------------------------
+// Monotonically increasing refs within the same store
+// ---------------------------------------------------------------------------
+
+#[test]
+fn test_window_refs_increment() {
+    let mut store = RefStore::new();
+    let w1 = store.insert_window(NativeHandle::new(10));
+    let w2 = store.insert_window(NativeHandle::new(20));
+    let w3 = store.insert_window(NativeHandle::new(30));
+
+    assert_eq!(w1.to_string(), "@w1");
+    assert_eq!(w2.to_string(), "@w2");
+    assert_eq!(w3.to_string(), "@w3");
+}
+
+#[test]
+fn test_element_refs_increment() {
+    let mut store = RefStore::new();
+    let e1 = store.insert_element(NativeHandle::new(100));
+    let e2 = store.insert_element(NativeHandle::new(200));
+
+    assert_eq!(e1.to_string(), "@e1");
+    assert_eq!(e2.to_string(), "@e2");
+}
+
+// ---------------------------------------------------------------------------
+// Retrieve stored native handles by ref
+// ---------------------------------------------------------------------------
+
+#[test]
+fn test_retrieve_window_handle() {
+    let mut store = RefStore::new();
+    let wref = store.insert_window(NativeHandle::new(0xABCD));
+    let retrieved = store.get_window(&wref);
+    assert_eq!(retrieved, Some(NativeHandle::new(0xABCD)));
+}
+
+#[test]
+fn test_retrieve_element_handle() {
+    let mut store = RefStore::new();
+    let eref = store.insert_element(NativeHandle::new(0xDEAD));
+    let retrieved = store.get_element(&eref);
+    assert_eq!(retrieved, Some(NativeHandle::new(0xDEAD)));
+}

package/native/windows/bridge-rs/tests/state_tests.rs

@@ -0,0 +1,33 @@
+use windows_bridge::state::StateId;
+
+// ---------------------------------------------------------------------------
+// Fresh state IDs
+// ---------------------------------------------------------------------------
+
+#[test]
+fn test_two_fresh_state_ids_differ() {
+    let id1 = StateId::fresh("session");
+    let id2 = StateId::fresh("session");
+    assert_ne!(id1, id2, "two fresh state IDs must differ");
+}
+
+#[test]
+fn test_fresh_state_id_contains_prefix() {
+    let id = StateId::fresh("test");
+    assert!(
+        id.starts_with("test-"),
+        "state ID should start with prefix followed by '-'"
+    );
+}
+
+#[test]
+fn test_fresh_ids_are_unique_across_calls() {
+    let mut ids = Vec::new();
+    for _ in 0..100 {
+        ids.push(StateId::fresh("batch"));
+    }
+    let mut sorted = ids.clone();
+    sorted.sort();
+    sorted.dedup();
+    assert_eq!(sorted.len(), ids.len(), "all 100 fresh IDs must be unique");
+}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@forsion/tangu-computer-use",
+  "version": "0.5.8",
+  "description": "Tangu engine plugin: let agents observe and control macOS, Windows, and Linux desktop apps. Fork of injaneity/pi-computer-use (MIT).",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Changan-Su/Tangu-Computer-Use.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "tangu-plugin",
+    "computer-use",
+    "macos",
+    "desktop-automation",
+    "accessibility"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "tangu-plugins",
+    "skills",
+    "manifest.json",
+    "icon.png",
+    "main.js",
+    "check.mjs",
+    "install.sh",
+    "CHANGELOG.md",
+    "UPSTREAM.md",
+    "tsconfig.json",
+    "src",
+    "types",
+    "scripts",
+    "prebuilt",
+    "native/macos",
+    "native/windows",
+    "native/linux/bridge-rs",
+    "LICENSE",
+    "LICENSE.upstream",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs && npm run typecheck",
+    "typecheck": "tsc --noEmit",
+    "check:no-foreground": "node scripts/no-foreground.check.mjs",
+    "check:helper-path": "node scripts/helper-path.check.mjs",
+    "check:highlight": "node scripts/highlight.check.mjs",
+    "check:permissions": "node scripts/permissions.check.mjs",
+    "check:plugin": "node check.mjs",
+    "check:platform": "node scripts/platform-contract.check.mjs",
+    "check:blindclick": "node scripts/blind-click.check.mjs",
+    "check:liveview": "node scripts/live-view.check.mjs",
+    "check": "npm run check:platform && npm run check:no-foreground && npm run check:helper-path && npm run check:highlight && npm run check:permissions && npm run check:plugin && npm run check:helper-refresh && npm run check:installer && npm run check:cli-exit",
+    "build:native": "node scripts/build-native.mjs",
+    "build:windows": "node scripts/build-native.mjs --platform windows",
+    "build:linux": "node scripts/build-native.mjs --platform linux",
+    "check:live": "npm run check:blindclick && npm run check:liveview && npm run check:overlay",
+    "check:overlay": "node scripts/overlay-visible.check.mjs",
+    "check:mini-foreground": "node scripts/mini-foreground.check.mjs",
+    "check:helper-refresh": "node scripts/helper-refresh.check.mjs",
+    "check:helper-signal": "node scripts/helper-signal.check.mjs",
+    "check:installer": "node scripts/keychain-free-install.check.mjs",
+    "check:cli-exit": "node scripts/cli-exit.check.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "esbuild": "^0.24.0",
+    "typescript": "^5.6.0"
+  }
+}

package/prebuilt/macos/arm64/tangu-computer-use.app.json

@@ -0,0 +1,10 @@
+{
+  "bundleId": "com.forsion.tangu-computer-use",
+  "version": "0.5.8",
+  "archiveSha256": "30aa8caad4f8a5425af2b72516b22e8947982ad42d7cb7eccc6a7bbebfb7c264",
+  "files": {
+    "Contents/MacOS/bridge": "e83fb3ee7bd4bbdcbe64876485602354c6881b5e7ee73306ef2fcdb716484063",
+    "Contents/Info.plist": "6089a47275854f04a74c57cd0f862de65781bfed323f9fba65e0768aa592518a",
+    "Contents/_CodeSignature/CodeResources": "6686de10a28a2fe11b36cbb86dcbacc827cfc4ea116b4dabf1845e5aee629e9b"
+  }
+}

package/prebuilt/macos/x64/tangu-computer-use.app.json

@@ -0,0 +1,10 @@
+{
+  "bundleId": "com.forsion.tangu-computer-use",
+  "version": "0.5.8",
+  "archiveSha256": "a8c677df28ee97c320d10319773662f4dad9c0f0d880c185291949837909c8be",
+  "files": {
+    "Contents/MacOS/bridge": "3e6f53eeec547db886b57b033e82ab9e9dc31164d0d613fbf60847243751255e",
+    "Contents/Info.plist": "6089a47275854f04a74c57cd0f862de65781bfed323f9fba65e0768aa592518a",
+    "Contents/_CodeSignature/CodeResources": "6686de10a28a2fe11b36cbb86dcbacc827cfc4ea116b4dabf1845e5aee629e9b"
+  }
+}

package/scripts/blind-click.check.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * 「后台盲点」的真机仪器 —— 证明**坐标点击不抢前台**,而且真的落下去了。
+ *
+ * 为什么必须有它:症状是"点了就跳前台、虚拟鼠标不出现",而这条路上有三段各自都会静默失败的东西
+ * (needsForeground 判定 → helper 的 AX 命中测试 → AXPress 到底打没打中)。纸面推理只能验证想到的
+ * 那一段。这个脚本一次把三段都钉住:
+ *
+ *   ① `performed.delivery === "ax"` —— 走的是 AX 按压,没发物理事件(所以不动真鼠标)
+ *   ② 前台 App 前后不变 —— 没抢焦点
+ *   ③ **计算器的显示值真的变了** —— 这一条最重要:前两条都能在"点击压根没生效"时照样成立。
+ *      没有 ③ 的话,"不抢前台"可以靠什么都不做来达成。
+ *
+ * 跑法:node scripts/blind-click.check.mjs
+ * 需要:macOS、helper 已装并授权(辅助功能 + 屏幕录制)。会短暂打开「计算器」,跑完关掉。
+ */
+import assert from 'node:assert/strict'
+import { connect } from 'node:net'
+import { homedir } from 'node:os'
+import { ensureDaemon, freshCalculator, killCalculator } from './calc-fixture.mjs'
+
+const SOCK = `${homedir()}/Library/Caches/tangu-computer-use/bridge.sock`
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+
+let seq = 0
+/** 一次请求一条连接 —— helper 的协议是一行 JSON 进、一行 JSON 出,不必维持长连。 */
+function ask(payload) {
+  return new Promise((resolve, reject) => {
+    const sock = connect(SOCK)
+    let buf = ''
+    const timer = setTimeout(() => { sock.destroy(); reject(new Error(`timeout: ${payload.cmd}`)) }, 20_000)
+    sock.on('error', (e) => { clearTimeout(timer); reject(e) })
+    sock.on('data', (d) => {
+      buf += d
+      const nl = buf.indexOf('\n')
+      if (nl < 0) return
+      clearTimeout(timer)
+      sock.end()
+      const msg = JSON.parse(buf.slice(0, nl))
+      if (!msg.ok) return reject(Object.assign(new Error(msg.error?.message || 'helper error'), { code: msg.error?.code }))
+      resolve(msg.result)
+    })
+    sock.write(`${JSON.stringify({ id: `bc_${++seq}`, ...payload })}\n`)
+  })
+}
+
+/** 前台是谁 —— 问 helper 自己(NSWorkspace),**别走 osascript**:System Events 要额外的
+ *  「自动化」授权,node 没有,只会 AppleEvent 超时(踩过)。 */
+const frontmostApp = async () => `${(await ask({ cmd: 'getFrontmost' })).appName}`
+
+/** 在 outline 里深度优先找第一个满足条件的节点。 */
+function findNode(node, pred) {
+  if (!node) return null
+  if (pred(node)) return node
+  for (const child of node.children || []) {
+    const hit = findNode(child, pred)
+    if (hit) return hit
+  }
+  return null
+}
+
+const diag = await ensureDaemon(ask)
+assert.equal(diag.protocolVersion, 11, `helper 协议应为 11,实测 ${diag.protocolVersion} —— 先重装 helper`)
+assert.ok(diag.accessibility, '需要「辅助功能」权限')
+
+try {
+  const before = await frontmostApp()
+  // 后台开一个全新的计算器(-g = 不抢前台);夹具会先等上一个仪器留下的实例真的退干净。
+  const { calc, win } = await freshCalculator(ask)
+
+  const look = await ask({ cmd: 'look', pid: calc.pid, windowId: win.windowId, includeImage: true })
+  // ⚠️outline 里的 rect 已经是**图像坐标**(不是屏幕坐标),act 的 x/y 要的正是它 —— 别再换算一遍。
+  assert.ok(
+    findNode(look.outline, (n) => n.role === 'AXButton' && (n.description === '5' || n.title === '5')),
+    '没在 outline 里找到数字键 5',
+  )
+
+  /** 计算器的读数:第一个有值的静态文本。数字前有个 LTR 标记,只留数字。 */
+  const displayIn = (outline) => String(findNode(outline, (n) => n.role === 'AXStaticText' && n.value)?.value ?? '').replace(/\D/g, '')
+  const digitAt = (n) => {
+    const node = findNode(look.outline, (x) => x.role === 'AXButton' && (x.description === n || x.title === n))
+    assert.ok(node, `没在 outline 里找到数字键 ${n}`)
+    // ⚠️outline 里的 rect 已经是**图像坐标**(不是屏幕坐标),act 的 x/y 要的正是它 —— 别再换算一遍。
+    return { x: node.rect.x + node.rect.w / 2, y: node.rect.y + node.rect.h / 2 }
+  }
+
+  /** 只给 x/y(**没有 ref**)—— 这正是 agent 看着截图"盲点"时走的那条路,也正是上游会直接判
+   *  needsForeground、跳去 HID 前台的那条路。policy/delivery 照 TS 层在这种情况下会发的值。 */
+  const blindClick = async (digit) => {
+    const p = digitAt(digit)
+    const act = await ask({
+      cmd: 'act',
+      lookId: look.lookId,
+      pid: calc.pid,
+      policy: 'foreground',
+      delivery: 'hid',
+      cursorOverlay: true,
+      action: 'click',
+      target: { x: p.x, y: p.y },
+      params: { button: 'left', clickCount: 1 },
+    })
+    await sleep(350)
+    const fresh = await ask({ cmd: 'look', pid: calc.pid, windowId: win.windowId, includeImage: false })
+    return { act, display: displayIn(fresh.outline) }
+  }
+
+  // 连点两个**不同**的数字:断言只看"最后一位是不是刚点的那个",与计算器的起始状态无关
+  // (上一轮跑剩的数字会留在屏上 —— 拿 before≠after 当判据会被这个坑掉)。
+  const five = await blindClick('5')
+  const seven = await blindClick('7')
+  const after = await frontmostApp()
+
+  console.log(`  performed = ${JSON.stringify(five.act.performed)}`)
+  console.log(`  前台: ${before} → ${after}`)
+  console.log(`  计算器显示: 点 5 → ${five.display} ｜ 点 7 → ${seven.display}`)
+
+  for (const [label, r] of [['5', five], ['7', seven]]) {
+    assert.equal(r.act.performed?.delivery, 'ax', `点 ${label}:坐标点击应走后台 AX 按压(delivery=ax),不是物理事件`)
+    assert.equal(r.act.performed?.grounding, 'hit_test', `点 ${label}:应经由 AX 命中测试落点`)
+  }
+  assert.equal(after, before, `点击不得夺取前台(${before} → ${after})`)
+  // ⚠️这两条是命门:上面三条在"点击压根没生效"时照样全绿 —— "不抢前台"可以靠什么都不做换来。
+  assert.ok(five.display.endsWith('5'), `点了 5,读数应以 5 结尾,实得 ${five.display}`)
+  assert.ok(seven.display.endsWith('7'), `点了 7,读数应以 7 结尾,实得 ${seven.display}`)
+  console.log('✅ 后台盲点:走 AX、不抢前台、且两次都真的点中了')
+} finally {
+  await killCalculator(ask).catch(() => {})
+}