dsh-codex-style-computer-use 1.3.1 → 2.1.0

package/README.zh.md

@@ -1,29 +1,54 @@
 # Codex 风格 Computer Use
 
-**更接近 Codex 的电脑操控体验，带到 DeepSeek Harness。**
+**全市场最精准的 Windows 桌面操控，也是单个任务成本最低的。**
 
-你描述目标，AI 看屏幕、找控件、点鼠标、敲键盘，再检查结果。让原生 Windows 应用里的工作，也能在对话中完成。
+你描述目标，AI 读准控件身份、按真实控件执行、回读结果——一段已知流程一轮模型往返就跑完，而不是每个动作各花一轮。
 
-[English](README.md) | 中文 · [安装](#在-dsh-market-安装和更新) · [版本记录](CHANGELOG.md)
+[English](README.md) | 中文 | [Français](README.fr.md) | [Deutsch](README.de.md) | [Español](README.es.md) | [Português](README.pt.md) | [العربية](README.ar.md) | [Русский](README.ru.md) | [فارسی](README.fa.md) · [安装](#在-dsh-market-安装和更新) · [版本记录](CHANGELOG.md) · [2.0.0 变更](docs/RELEASE-2.0.0.md)
 
 ![Codex 风格 Windows 桌面操控：观察、操作、验证](docs/images/01-codex-style.png)
 
-- **看得准，也点得动。** 截图、控件树与编号定位配合使用，支持点击、输入、拖拽、滚动和窗口操作。
-- **你接手，AI 等待，再接着做。** 1.3.0 提供 1.5 秒操作预告；非实际操控期间正常使用电脑，交回后重新观察并接续原任务。
-- **更少往返，更省 Token。** 控件增量观察、区域与降采样截图，加上连续动作批量执行，减少重复观察和模型往返。
+## 为什么它更准
+
+- **认身份，不猜坐标。** UI Automation 给出真实控件树与精确 `AutomationId`，动作可以走控件自身的 UI Automation 模式，而不是盲点坐标。
+- **标记先校验，再执行。** 默认情况下，编号标记在派发输入前按窗口身份与采样像素校验，过期标记会被拒绝，不会点错位置。动画邻居导致像素签名失效时，`uiaOnly` 用窗口句柄与几何固定身份，派发时的遮挡检查仍然生效。
+- **查询有边界。** UIA 查询默认深度 6、120 节点、1200 毫秒软预算；深度超过 6 或节点超过 300 时必须提供已测量的 `anchor`，不会悄悄扫错区域。
+- **看不见就读字。** `computer_ocr` 返回绝对屏幕像素的行与词框，零 UIA 应用也能按名字定位。
+
+## 为什么它更省
+
+- **一段已知流程只花一轮往返。** 一次 `computer_batch` 串行执行整串动作、遇错即停，只花一轮模型往返，而不是每个动作各花一轮。
+- **只回增量。** 把上一次观察 ID 作为 `since` 传回，只拿到新增、变化、删除与顺序，而不是整棵树重发。
+- **2.0.0 默认精简回执。** 动作后的文字回执通常最多再加 6 KiB；需要细节时仍可用 `feedback: full`。
+- **证据不进对话。** 完整点查证据可留在有界本地缓存（内存 4 MiB、磁盘 32 MiB、64 条、24 小时过期），按需读取。
+- **本地的事留在本地。** UIA、屏幕 OCR 与像素校验都在预置原生 worker 里完成，不额外产生每一步的视觉账单。
+
+## 它不会抢走你的桌面
+
+- **会等你。** 操作前 1 秒提示（3 分钟内再次操作 0.1 秒）后即时交出桌面；你操作完，AI 重新观察并续接原任务。
+- **刹车能传进模型。** `Ctrl+Esc` 暂停、`Ctrl+Alt+R` 恢复、`Ctrl+Alt+Q` 退出，停止事件被推入正在运行的会话。默认保留操作审批，密码框默认拒绝。
+- **做不到的会说出来。** 检测到 Windows 安全桌面（UAC 或锁屏）会报告并在结束后自动续接，而不是盲目重试。
 
 ![人工接管与续接：先提醒、可接管、再继续](docs/images/02-handoff.png)
 
 ![Token 效率：聚焦观察、合并操作、回读验证](docs/images/03-token-efficiency.png)
 
-上图为 **1.3.0 功能示意**。实际 Token 用量取决于任务、模型和观察方式。默认保留操作审批；明确暂停、取消和退出始终有效。
+上图为 1.3.0 引入的交互模型；2.0.0 的风筝光标、有界查询与精简回执见上。实际 Token 用量取决于任务、模型和观察方式。默认保留操作审批；明确暂停、取消和退出始终有效。
+
+**安装即用。** 19 个桌面工具，原生组件随包提供，无需 SDK 或安装时编译。支持 Windows、Node.js ≥ 22 和系统自带的 .NET Framework 4.x。独立社区插件；Codex 用于说明交互风格。
+
+## 2.0.0 新特性
 
-**安装即用。** 18 个桌面工具，原生组件随包提供，无需 SDK 或安装时编译。支持 Windows、Node.js ≥ 22 和系统自带的 .NET Framework 4.x。独立社区插件；Codex 用于说明交互风格。
+- **默认精简回执**——动作后的文字回执通常最多再加 6 KiB；需要细节可用 `feedback: full`，不需要可用 `feedback: none`。
+- **有界、带锚点的 UIA 查询**——默认深度 6、120 节点、1200 毫秒软预算；深度超过 6 或节点超过 300 的查询必须提供已测量的 `anchor`。
+- **证据按需读取**——内存 4 MiB + 磁盘 32 MiB、64 条记录、24 小时过期；磁盘失败回退到有界内存。
+- **自适应操作预告**——首次 1 秒，3 分钟滚动窗口内再次操作 0.1 秒；倾斜的风筝标记点击点。
+- **加固的输入路径**——窗口管理快捷键守卫、worker 背压/恢复、过期目标检查与取消清理。
 
 <details>
 <summary>当前版本与兼容性</summary>
 
-**1.3.1** 是 npm `latest` 频道的当前版本：`dsh-codex-style-computer-use@1.3.1`。新增 worker 侧 OCR（逐词坐标）、可定位变化与识别光标闪烁的等待、UAC/锁屏感知与自动续接、以及绕过 IME 的剪贴板文本通道。更新已加载的旧版本后，按宿主提示重启。详见 [1.3.1](docs/RELEASE-1.3.1.md) 与 [GitHub Releases](https://github.com/ltmroberthk915/dsh-computer-use/releases)。
+**2.0.0** 为本次大版本，先发布至 npm `next`，通过仓库规定的 24 小时成熟期后再升稳定频道。详见 [2.0.0 变更与迁移](docs/RELEASE-2.0.0.md)，稳定版以 registry 标签为准。
 
 1.3.1 可直接从屏幕读字定位控件，察觉 Windows 安全桌面并在其结束后自动续接；所有颜色共用同一条按 DPI 换算的边缘光环，呼吸谷值保持可见。1.3.0 起工具用完可主动释放，聊天继续；正常收尾自动退出。
 
@@ -33,6 +58,12 @@
 
 ## 它能做什么
 
+2.0.0在 AI 操作和保留现场时使用小巧的蓝色风筝光标：倾斜的尖端就是点击位置，文本、缩放等提示收在风筝中央。呼吸状态表示仍需保持页面与鼠标位置；放开现场后恢复应用原来的鼠标。Windows 鼠标主题保持原样。
+
+2.0.0进一步收紧 UIA 查询范围，并默认精简动作后的文字反馈；视觉模型仍保留原有图片检查。调用可用 `feedback: compact|full|none`，点击可用 `verificationRegion: "x,y,w,h"` 指定真正的结果区域。正常精简反馈在原动作回执之外最多增加 6 KiB 文字。完整点查证据可留在有容量与期限限制的本地缓存，按需读快照。磁盘失败先回退有界内存；如果无法保留可回读的快照，则直接完整返回已有证据，此时不受精简文字预算限制，不重复查询或操作。
+
+带过滤条件的 UIA 查询必须指定 `hwnd`，默认深度 6、最多 120 节点和 1200 毫秒软预算。深度大于 6 或节点上限大于 300 时，须提供该窗口内已测量的 `anchor:"x,y"`；精确 `id` 也不豁免。单次提供器调用可能超过软预算，部分结果不能证明目标不存在或唯一。窗口管理快捷键后，先用 `computer_state {windows:true}` 查看窗口，再成功激活目标并重新观察，随后才能继续键盘输入。
+
 - **观察** —— 窗口列表、截图（区域 / JPEG / PNG / 降采样）、可点元素的 Set-of-Marks 编号图，
   以及带精确 `AutomationId` 的 UI Automation 树。
 - **操作** —— 点击、移动、拖拽、滚动、选中文本区间、键入、按键，并可走控件**自身的 UI
@@ -42,14 +73,13 @@
 - **能传到模型的人为刹车** —— 停止事件被推入正在运行的会话，agent 当场知道自己被打断，
   而不是等到下一轮才发现。
 
-工具读的是桌面，不读你的文件。插件自己只写三处：worker 二进制
-（`%LOCALAPPDATA%\dsh-computer-use\worker\`）、审计日志与截图（`$DSH_HOME/data/computer-use/`）。
+工具观察桌面，不遍历用户文档。插件管理原生组件（`%LOCALAPPDATA%\dsh-computer-use\worker\`），以及 `$DSH_HOME/data/computer-use/` 下的审计日志、截图和自有 `observation-cache` 有界缓存。`computer_ctrl {action:"clear_cache"}` 只清理本 Agent 的观察缓存，不删除截图、附件或用户文档。
 
 ## 在 dsh-market 安装和更新
 
 在市场搜索 **computer-use** 或 **Codex-style**，认准仓库 **ltmroberthk915/dsh-computer-use**、npm 包 **dsh-codex-style-computer-use**（维护者 **ltmroberthk**），点击**安装**。以后通过市场的**更新**或**全部更新**获取正式频道版本。两份原生组件都已随包提供，无需 PowerShell 7、SDK 或构建白名单。
 
-也可在 **设置 → 插件 → 添加插件** 输入 **`dsh-codex-style-computer-use`**，安装当前正式频道；要体验本页展示的 1.3.0，输入 **`dsh-codex-style-computer-use@1.3.0`**。这里填 npm 包名即可。宿主可能对新版本设置等待期，以界面提示为准。首次新增 bundle 可在支持的宿主中热加载；确认工具与 skill 已出现即可使用。替换已经加载的版本、客户端界面未刷新或界面提示 **restart-required / 需要重启** 时，从托盘完整退出 DSH 并重新打开。
+也可在 **设置 → 插件 → 添加插件** 输入 **`dsh-codex-style-computer-use`**，安装当前正式频道；要体验本页描述的 2.0.0，输入 **`dsh-codex-style-computer-use@2.0.0`**。这里填 npm 包名即可。宿主可能对新版本设置等待期，以界面提示为准。首次新增 bundle 可在支持的宿主中热加载；确认工具与 skill 已出现即可使用。替换已经加载的版本、客户端界面未刷新或界面提示 **restart-required / 需要重启** 时，从托盘完整退出 DSH 并重新打开。
 
 ### 发布未满 24 小时
 
@@ -108,9 +138,9 @@ $CuDshInstall = Join-Path $env:LOCALAPPDATA 'Programs\DeepSeek Harness'
 
 ## 1.1 的按需控制
 
-- **按 Agent 加载：**未激活时暴露 `computer_use_activate`、`computer_ctrl`、`computer_ask`。成功读取 computer-use skill、确认规程或调用激活入口后，该 Agent 获得原有 18 个工具，加入口共 19 个。其他 Agent 和子 Agent 独立启用，支持原生调用和 Node `run_code`。激活本身不启动控制，也不释放人为刹车。
+- **按 Agent 加载：**未激活时暴露 `computer_use_activate`、`computer_ctrl`、`computer_ask`。成功读取 computer-use skill、确认规程或调用激活入口后，该 Agent 获得 19 个桌面工具，加入口共 20 个。其他 Agent 和子 Agent 独立启用，支持原生调用和 Node `run_code`。激活本身不启动控制，也不释放人为刹车。
 - **已观察的 UIA 目标：**指定窗口和 name/id 的聚焦查询默认生成 target 句柄。控件重建时，显式 `rebind:true` 才允许在同一窗口内进行唯一身份或语义匹配。上下文变化、歧义、扫描不完整时拒绝动作。宽查询需 `targets:true` 才生成恢复句柄，避免普通观察承担额外开销。
-- **增量观察：**重复相同查询并传入上一 observation 的 `since`，返回新增、变化、删除及顺序信息。每 Agent 保留最近 64 份完整快照，`snapshot` 可取回确切的历史结果。缺少基线、范围变化、证据不完整或增量更大时自动回退全量。
+- **增量观察：**重复相同查询并传入上一 observation 的 `since`，返回新增、变化、删除及顺序信息。快照按 Agent 隔离，每个 store 总计最多索引 64 份观察、在内存保留 4 MiB JSON。`snapshot` 可取回仍保留的历史结果，`offset` 和 `limit` 可分页读取数组。缺少基线、范围变化、证据不完整或增量更大时自动回退全量。
 
 保留的是提供器实际返回的完整字段，沿用原有提供器限制；历史快照不代替动作后的新验证。缓存上限和恢复边界见[详细协议](skills/computer-use/references/progressive-control.md)。
 
@@ -119,7 +149,7 @@ $CuDshInstall = Join-Path $env:LOCALAPPDATA 'Programs\DeepSeek Harness'
 | 分组 | 工具 |
 |---|---|
 | 激活 | `computer_use_activate` |
-| 观察 | `computer_state` `computer_shot` `computer_marks` `computer_uia` |
+| 观察 | `computer_state` `computer_shot` `computer_ocr` `computer_marks` `computer_uia` |
 | 操作 | `computer_click` `computer_move` `computer_drag` `computer_scroll` `computer_select` `computer_key` `computer_type` `computer_uia_act` `computer_window` `computer_clip` |
 | 流程 | `computer_wait` `computer_batch` |
 | 元 | `computer_ask` `computer_ctrl` |
@@ -157,7 +187,9 @@ ID**：派发输入前会核对窗口身份与采样像素，因此过期的 mar
 | 键 | 默认 | 含义 |
 |---|---:|---|
 | `automationMode` | `standard` | 审批模式（见上） |
-| `progressiveTools` | `true` | 按 Agent 激活；设为 `false` 可保留原有 18 个全局工具 |
+| `progressiveTools` | `true` | 按 Agent 激活；设为 `false` 全局暴露 19 个桌面工具 |
+| `actionFeedback` | `true` | 直接动作及批处理后自动观察 |
+| `actionFeedbackDetail` | `compact` | `compact`、`full` 或 `none`；单次调用的 `feedback` 可覆盖默认值；无法缓存时完整内联返回证据 |
 | `dryRun` | `false` | 只模拟操作并记录 |
 | `maxActionsPerMinute` | `60` | 核心层操作限速 |
 | `annotateMarks` | `true` | 在截图上绘制 Set-of-Marks 方框 |
@@ -169,9 +201,23 @@ ID**：派发输入前会核对窗口身份与采样像素，因此过期的 mar
 `mcp/` 是建立在同一核心之上的零依赖 MCP stdio 服务，供只讲 MCP、不讲 Cordis 的客户端使用：
 
 ```sh
+# 已发布包（2.0.1 起可用），无需克隆仓库
+npx -y dsh-codex-style-computer-use
+
+# 从仓库检出运行
 node mcp/src/index.js
 ```
 
+该入口随根包发布，运行时报告根包版本；默认只能观察桌面。启动它的宿主在负责桌面操作授权时，
+可以设置 `DSH_CU_ALLOW_INPUT=1`。模型调用工具不能开启输入：兼容工具 `cu_approve` 只说明授权来源，
+不会授予同意。DSH 的 `automationMode` 属于 Cordis 入口，不是 MCP 的审批服务。
+`DSH_CU_DRY_RUN=1` 只模拟已由宿主启用的输入。
+
+两个入口共享按键规范化、批次失败与接管后续行语义，以及图像坐标换算。MCP 保留截图时间、光标、
+稳定性和区域元数据，只附最后一张 PNG/JPEG，不把图像字节重复塞进 JSON。`cu_hold` / `cu_free`
+用于操作间保护或放开现场，`cu_release` 结束桌面周期；`cu_drag` 支持 `expectCursor` 与 `hwnd` 校验。
+MCP 工具范围较小，DSH 的人类提问和宿主生命周期集成仍由 Cordis 入口提供。
+
 ## 开发
 
 发布者检查默认查询 npm 官方源。若本地无法访问，可用 `CU_REGISTRY` 为只读的 `check` 命令指定镜像；JSON 输出会注明 `registry` 和 `authoritative`。PowerShell 示例（只影响当前终端）：
@@ -195,6 +241,10 @@ node build/verify-tools-schema.mjs                                   # 工具 sc
 工具定义走真实的 `@deepseek-ai/dsh-tools` DSL 编译，因此 schema 写错会在这里失败，
 而不是在宿主重启时把整棵插件树带崩。部分守卫会编译原生 worker，仅 Windows 可跑。
 
+发版前先跑 `npm run verify:package`：它校验打包身份、预编译 helper 的哈希，以及每一个 `bin`
+条目（目标文件存在、带 node shebang）。它刻意不是发布钩子——本包不带任何生命周期脚本——
+所以请在 `npm publish` 之前自己手动执行一次。
+
 ## 许可
 
 MIT —— 见 [LICENSE](LICENSE)。

package/icon.svg

@@ -13,10 +13,14 @@
       <stop offset=".5" stop-color="#38BDF8"/>
       <stop offset="1" stop-color="#A78BFA"/>
     </linearGradient>
-    <radialGradient id="glow" cx="18.2" cy="19.4" r="7.6" gradientUnits="userSpaceOnUse">
-      <stop stop-color="#38BDF8" stop-opacity=".32"/>
+    <radialGradient id="glow" cx="17.4" cy="16.8" r="7.4" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#38BDF8" stop-opacity=".30"/>
       <stop offset="1" stop-color="#38BDF8" stop-opacity="0"/>
     </radialGradient>
+    <linearGradient id="kite" x1="14.1" y1="10.6" x2="19.9" y2="23.0" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#55ADFF"/>
+      <stop offset="1" stop-color="#163A99"/>
+    </linearGradient>
   </defs>
   <rect width="32" height="32" rx="7.5" fill="url(#tile)"/>
   <rect width="32" height="32" rx="7.5" fill="url(#halo)"/>
@@ -24,6 +28,18 @@
   <path d="M5.6 10.1 H26.4" stroke="url(#rail)" stroke-width="1.05" stroke-opacity=".5"/>
   <circle cx="8.5" cy="8" r=".9" fill="#5EEAD4"/>
   <circle cx="11.2" cy="8" r=".9" fill="#A78BFA" fill-opacity=".85"/>
-  <circle cx="18.2" cy="19.4" r="7.6" fill="url(#glow)"/>
-  <path d="M15.6 12.4 L15.6 21.2 L17.8 19 L19.3 22.4 L20.8 21.7 L19.3 18.5 L22.3 18.5 Z" fill="#F8FAFC" stroke="#070B14" stroke-width=".85" stroke-linejoin="round"/>
+  <circle cx="17.4" cy="16.8" r="7.4" fill="url(#glow)"/>
+
+  <!-- mouse-line tail of the agent kite pointer -->
+  <path d="M19.87 22.96 C 19.2 25.3, 16.4 24.1, 14.6 26.3" stroke="#3B82F6" stroke-opacity=".92" stroke-width=".74" stroke-linecap="round" fill="none"/>
+
+  <!-- tilted kite pointer, simplified from the runtime KitePointerPainter -->
+  <polygon points="14.13,10.64 22.07,14.43 19.87,22.96 11.93,19.17"
+           fill="none" stroke="#3684FF" stroke-opacity=".35" stroke-width="1.5" stroke-linejoin="round"/>
+  <polygon points="14.13,10.64 22.07,14.43 19.87,22.96 11.93,19.17" fill="url(#kite)"/>
+  <polygon points="14.13,10.64 22.07,14.43 17.00,16.80" fill="#A9E0FF" fill-opacity=".30"/>
+  <polygon points="17.00,16.80 22.07,14.43 19.87,22.96" fill="#06184F" fill-opacity=".28"/>
+  <polygon points="14.13,10.64 22.07,14.43 19.87,22.96 11.93,19.17"
+           fill="none" stroke="#CFEFFF" stroke-opacity=".95" stroke-width=".33" stroke-linejoin="round"/>
+  <line x1="14.13" y1="10.64" x2="19.87" y2="22.96" stroke="#D5F2FF" stroke-opacity=".30" stroke-width=".25"/>
 </svg>

package/lib/audit.js

@@ -28,3 +28,10 @@ export function appendAudit (dataDir, rec) {
     appendFileSync(join(dataDir.root, 'audit.jsonl'), JSON.stringify(rec) + '\n')
   } catch { /* audit must never break the action */ }
 }
+
+export function installAudit (cu, dataDir) {
+  const events = ['action', 'action:settled', 'handoff-wait']
+  const write = record => appendAudit(dataDir, record)
+  for (const event of events) cu.on(event, write)
+  return () => { for (const event of events) cu.off(event, write) }
+}

package/lib/batch.js

@@ -1,32 +1,21 @@
 // Serial execution and observation selection; no desktop or lifecycle side effects here.
 import { handoffResult } from './continuation.js'
-const reads = new Set(['computer_state', 'computer_uia', 'computer_marks', 'computer_shot', 'computer_wait'])
-const isRead = (step) => reads.has(step?.tool) || (step?.tool === 'computer_clip' && step.args?.text === undefined)
-const isReadback = (step) => ['computer_state', 'computer_uia', 'computer_marks', 'computer_shot'].includes(step.tool) ||
-  (step.tool === 'computer_clip' && step.args?.text === undefined)
-
-export function actionRefusal (step, result) {
-  if (result?.ok === false || result?.success === false) return result.error || 'action reported failure'
-  if (step.tool === 'computer_window' && (step.args?.op || 'activate') === 'activate' && result?.activated !== true) {
-    return 'target window activation was not confirmed; subsequent actions were not dispatched'
-  }
-  if (step.tool === 'computer_ctrl' && step.args?.action === 'recover' && result?.recovered !== true) return result.reason || 'temporary pause recovery refused'
-  if (step.tool === 'computer_ctrl' && step.args?.action === 'release' && !result?.released && !result?.alreadyReleased) return result.reason || 'cycle release refused'
-  return null
-}
+import { actionRefusal, actionError, isReadStep as isRead, isReadbackStep as isReadback, endsBatch } from './tool-contract.js'
+export { actionRefusal } from './tool-contract.js'
 
 export async function runBatch ({ steps, handlers, signal, stopped, screenshot, shot = 'auto', exec, assertOwnership }) {
   if (!Array.isArray(steps) || !['auto', 'always', 'never'].includes(shot)) throw new Error('invalid batch actions or shot mode')
   const actions = []
   let failed = false
   let continuation = null
+  let endedBy = null
   for (const step of steps) {
     const name = step?.tool
     if (failed || signal?.aborted) {
       actions.push({ tool: name || '', ok: false, outcome: 'not-dispatched',
         ...(continuation && !signal?.aborted
           ? { status: 'deferred', message: 'Resume this unfinished step after fresh target evidence; the original task must continue.' }
-          : { error: signal?.aborted ? 'cancelled' : 'earlier action failed' }) })
+          : { error: signal?.aborted ? 'cancelled' : endedBy ? 'batch ended by control action' : 'earlier action failed' }) })
       failed = true
       continue
     }
@@ -38,22 +27,28 @@ export async function runBatch ({ steps, handlers, signal, stopped, screenshot,
       const result = await fn(step.args || {}, exec)
       const refusal = actionRefusal(step, result)
       actions.push({ tool: name, ok: !refusal, result, ...(refusal ? { error: refusal } : {}) })
-      failed = !!refusal || (!stoppedBefore && stopped()) ||
-        (name === 'computer_ctrl' && ['stop', 'exit', 'release'].includes(step.args?.action))
+      if (result?.taskStatus === 'continuing' && result.continuation?.required && !signal?.aborted && !stopped()) {
+        const nestedPath = result.continuation.resumeActionPath || [result.continuation.resumeFromActionIndex]
+        continuation = { ...result.continuation, resumeFromActionIndex: actions.length - 1,
+          resumeActionPath: [actions.length - 1, ...nestedPath.filter(Number.isInteger)] }
+      }
+      if (endsBatch(step)) endedBy = { tool: name, action: step.args?.action || name.replace(/^cu_/, '') }
+      else if (result?.endedBy) endedBy = result.endedBy
+      failed = !!refusal || !!continuation || (!stoppedBefore && stopped()) || !!endedBy
     } catch (error) {
       const checkpoint = !signal?.aborted && !stopped() ? handoffResult(error) : null
       if (checkpoint) {
         continuation = { ...checkpoint.continuation, resumeFromActionIndex: actions.length }
         actions.push({ tool: name, ...checkpoint, continuation })
       } else {
-        actions.push({ tool: name, ok: false, error: String(error.message || error),
-          code: error.code || 'action-error', outcome: error.outcome || 'unknown' })
+        actions.push({ tool: name, ...actionError(error) })
       }
       failed = true
     }
   }
   const needsShot = shot === 'always' || (shot === 'auto' && steps.some(s => !isRead(s)) && !isReadback(steps.at(-1) || {}))
   const result = { actions, attachedShot: null }
+  if (endedBy) result.endedBy = endedBy
   if (continuation) Object.assign(result, {
     status: 'continuation-required', taskStatus: 'continuing', transient: true, continuation,
   })

package/lib/bin/attention-worker.exe.json

@@ -3,5 +3,5 @@
   "platform": "win32",
   "architecture": "x64",
   "sourceSha256": "6e17308fc1cb0de1ece6f3164866b6de03ecdf74a42a6e78c0a8e6d02912c3bf",
-  "binarySha256": "f39e79148d0f1c8fa527f55607eb4e7440e82c3ab5b33162bde773528418fe5a"
+  "binarySha256": "ad99b350925f8b373a93b80ee73b2632d23f8f6e8bab913a2a83becfa7b016af"
 }

package/lib/compact-feedback.js

@@ -0,0 +1,175 @@
+// Small post-action evidence, shared by host/MCP adapters. Never dispatches input,
+// retries a read, inventories a UIA tree, or changes the original action receipt.
+export const COMPACT_FEEDBACK_BYTES = 6144
+export const COMPACT_OBSERVATION_MS = 6000
+export const COMPACT_POINT_MS = 5000
+
+const finite = value => typeof value === 'number' && Number.isFinite(value)
+const bytes = value => Buffer.byteLength(JSON.stringify(value), 'utf8')
+const rectKeys = ['x', 'y', 'width', 'height']
+const windowKeys = ['hwnd', 'pid', 'process', 'title', 'class', 'active', 'minimized']
+const elementKeys = ['name', 'role', 'controlType', 'automationId', 'className', 'value', 'text', 'enabled', 'isEnabled', 'offscreen', 'isOffscreen', 'editable', 'focused', 'hasKeyboardFocus', 'selected', 'checked', 'toggleState', 'expanded', 'expandCollapseState', 'hwnd', 'pid']
+
+function point (value) {
+  if (typeof value === 'string') {
+    const parts = value.trim().split(/[,\s]+/)
+    if (parts.length !== 2 || parts.some(p => !p)) return null
+    value = { x: Number(parts[0]), y: Number(parts[1]) }
+  }
+  return value && finite(value.x) && finite(value.y) ? { x: Math.round(value.x), y: Math.round(value.y) } : null
+}
+export function feedbackRegion (value) {
+  if (typeof value === 'string') {
+    const parts = value.trim().split(/[,\s]+/)
+    if (parts.length !== 4 || parts.some(p => !p)) return null
+    value = Object.fromEntries(rectKeys.map((k, i) => [k, Number(parts[i])]))
+  }
+  if (!value || !rectKeys.every(k => finite(value[k])) || value.width <= 0 || value.height <= 0) return null
+  return Object.fromEntries(rectKeys.map(k => [k, value[k]]))
+}
+
+// A native default verification crop is NOT authorization to narrow vision.
+// Only an explicitly requested region changes the automatic image viewport.
+export function feedbackViewport (args = {}, receipt = {}) {
+  args ||= {}; receipt ||= {}
+  const requested = (receipt.verificationSource === 'requested-region' ? feedbackRegion(receipt.verificationRegion) : null) ||
+    feedbackRegion(args.verificationRegion)
+  if (requested) return { region: rectKeys.map(k => requested[k]).join(','),
+    point: { x: Math.floor(requested.x + requested.width / 2), y: Math.floor(requested.y + requested.height / 2) }, source: 'requested-region' }
+  const actual = point(receipt)
+  if (actual) return { point: actual, source: 'action-receipt' }
+  const target = point(args.to) || point(args.at)
+  if (target) return { point: { x: target.x + (finite(args.dx) ? args.dx : 0), y: target.y + (finite(args.dy) ? args.dy : 0) }, source: 'requested-point' }
+  return { source: 'no-point' }
+}
+
+function clipped (value, limit, cuts, path) {
+  const text = String(value), raw = Buffer.from(text, 'utf8')
+  if (raw.length <= limit) return text
+  let end = limit - 3
+  while (end > 0 && (raw[end] & 0xc0) === 0x80) end--
+  cuts.push(path)
+  return raw.subarray(0, end).toString('utf8') + '…'
+}
+function brief (value, keys, cuts, path, limit = 768) {
+  if (!value || typeof value !== 'object') return null
+  const result = {}
+  for (const key of keys) {
+    const item = value[key]
+    if (typeof item === 'string') result[key] = clipped(item, limit, cuts, path + '.' + key)
+    else if (typeof item === 'boolean' || finite(item) || item === null) result[key] = item
+  }
+  const rect = feedbackRegion(value.rect || value.bounds)
+  if (rect) result.rect = rect
+  return result
+}
+
+// Budget applies to the ADDED observation envelope, never to an input receipt.
+// Whole fields are omitted if needed; a truncated field is never silently complete.
+export function limitCompactFeedback (envelope, maxBytes = COMPACT_FEEDBACK_BYTES) {
+  const limit = Number.isInteger(maxBytes) && maxBytes >= 1024 ? Math.min(maxBytes, COMPACT_FEEDBACK_BYTES) : COMPACT_FEEDBACK_BYTES
+  const result = JSON.parse(JSON.stringify(envelope))
+  const omitted = []
+  const existing = result.observation?.truncatedFields || []
+  const budget = result.budget = { maxBytes: limit, returnedBytes: 0, truncated: existing.length > 0, omittedFields: omitted }
+  const fit = () => {
+    // returnedBytes is part of its own JSON; stabilize decimal width.
+    for (let i = 0; i < 4; i++) budget.returnedBytes = bytes(result)
+    return budget.returnedBytes <= limit
+  }
+  if (fit()) return result
+  for (const field of ['ancestors', 'focused', 'element', 'receiver', 'window', 'contextFromAction']) {
+    if (result.observation && Object.hasOwn(result.observation, field)) {
+      delete result.observation[field]; omitted.push('observation.' + field); budget.truncated = true
+      if (fit()) return result
+    }
+  }
+  // Unknown adapter metadata is not allowed to evade the byte contract. Retain
+  // the truth that this observation could not fit, rather than cut JSON or paths.
+  result.observation = { scope: 'compact', incomplete: true, reason: 'observation exceeded compact byte budget; request feedback full for complete readback' }
+  omitted.push('observation'); budget.truncated = true
+  if (result.feedback) result.feedback = { kind: result.feedback.kind, detail: 'compact', reason: 'bounded post-action observation' }
+  if (!fit()) {
+    for (const key of Object.keys(result)) if (!['observation', 'feedback', 'verification', 'budget'].includes(key)) delete result[key]
+    if (typeof result.verification === 'string') result.verification = clipped(result.verification, 512, omitted, 'verification')
+    fit()
+  }
+  return result
+}
+
+export async function collectCompactState (cu, { args = {}, receipt = {}, checkAllowed = () => {}, archive, now = Date.now } = {}) {
+  args ||= {}; receipt ||= {}
+  const began = now(), deadline = began + COMPACT_OBSERVATION_MS, cuts = [], failures = []
+  const observation = { scope: 'local-post-action', ts: began, elementAvailable: false }
+  const raw = { scope: 'local-post-action', ts: began }
+  let viewport = feedbackViewport(args, receipt), calls = 0
+  const read = async (op, params, cap) => {
+    checkAllowed()
+    const remaining = Math.floor(deadline - now())
+    if (remaining <= 0) throw new Error('compact observation time budget exhausted')
+    calls++
+    return cu.call(op, params, Math.min(cap, remaining))
+  }
+  if (!viewport.point) {
+    try {
+      raw.cursor = await read('cursor', {}, 1000)
+      const current = point(raw.cursor)
+      if (current) viewport = { point: current, source: 'current-cursor' }
+      else failures.push({ channel: 'cursor', error: 'cursor position unavailable' })
+    } catch (error) { failures.push({ channel: 'cursor', error: clipped(error.message || error, 320, cuts, 'errors.cursor') }) }
+  }
+  if (viewport.point) {
+    observation.point = { ...viewport.point, source: viewport.source }
+    raw.point = observation.point
+    if (viewport.source === 'action-receipt' || viewport.source === 'current-cursor') observation.cursor = { ...viewport.point, source: viewport.source }
+    try {
+      const probe = await read('uiaFromPoint', viewport.point, COMPACT_POINT_MS)
+      raw.probe = probe
+      observation.window = brief(probe.root, windowKeys, cuts, 'window', 320)
+      observation.receiver = brief(probe.receives, windowKeys, cuts, 'receiver', 320)
+      observation.element = brief(probe.element, elementKeys, cuts, 'element')
+      observation.focused = brief(probe.focused, elementKeys, cuts, 'focused', 320)
+      if (typeof probe.typingWouldReach === 'boolean') observation.typingWouldReach = probe.typingWouldReach
+      const ancestors = probe.ancestors || probe.element?.ancestors || []
+      observation.ancestors = Array.isArray(ancestors) ? ancestors.slice(0, 3).map((a, i) => brief(a, elementKeys, cuts, `ancestors.${i}`, 160)) : []
+      if (Array.isArray(ancestors) && ancestors.length > 3) cuts.push('ancestors')
+      observation.elementAvailable = !!probe.element
+      if (!probe.element) failures.push({ channel: 'uiaFromPoint', error: 'no UIA element at this point; absence does not prove task failure' })
+    } catch (error) { failures.push({ channel: 'uiaFromPoint', error: clipped(error.message || error, 320, cuts, 'errors.uiaFromPoint') }) }
+  }
+  if (!viewport.point) observation.reason = 'No action, witness-region or current-cursor point was available; no UIA tree was read.'
+  if (receipt.receiver || receipt.focus || receipt.cursor) observation.contextFromAction = {
+    source: 'action-receipt, not an independent post-action read',
+    receiver: brief(receipt.receiver, windowKeys, cuts, 'context.receiver', 160),
+    focus: brief(receipt.focus, windowKeys, cuts, 'context.focus', 160),
+    cursor: point(receipt.cursor),
+  }
+  if (failures.length) observation.errors = failures
+  if (archive && (raw.probe || raw.cursor)) {
+    try {
+      const archived = await archive({ ...raw, ...(failures.length ? { errors: failures } : {}) })
+      const snapshot = typeof archived === 'string' ? archived : archived?.snapshot || archived?.observation
+      if (typeof snapshot === 'string' && /^O[\w-]{1,127}$/.test(snapshot)) observation.snapshot = snapshot
+      const cache = archived?.cache || archived?.archive
+      if (cache && (cache.status === 'memory-only' || cache.reason || cache.fallback)) {
+        observation.cache = brief(cache, ['status', 'reason', 'fallback'], cuts, 'cache', 160)
+      }
+      if (!observation.snapshot) {
+        // Once neither disk nor memory retains the evidence, truncation would
+        // make the omitted fields irretrievable. Return the existing raw value
+        // inline without another probe, input replay, clone or disk attempt.
+        observation.cache = { status: 'uncached', reason: cache?.reason || 'cache-unavailable', fallback: 'inline' }
+        observation.inlineEvidence = raw
+      }
+    } catch (error) {
+      observation.archiveError = clipped(error.message || error, 240, cuts, 'archiveError')
+      observation.cache = { status: 'uncached', reason: 'cache-unavailable', fallback: 'inline' }
+      observation.inlineEvidence = raw
+    }
+  }
+  if (cuts.length) observation.truncatedFields = [...new Set(cuts)]
+  observation.reads = calls
+  observation.elapsedMs = Math.max(0, now() - began)
+  observation.limitations = 'A local point/focus read may miss remote or visual changes. It does not verify the task effect; use explicit UIA/visual or application readback when needed.'
+  return observation
+}

package/lib/continuation.js

@@ -1,6 +1,6 @@
 // Temporary ownership handoff is a task checkpoint, not a failed/cancelled task.
 export function handoffResult (error) {
-  if (error?.code !== 'HUMAN_REOBSERVE' || !error.continuation?.required) return null
+  if (!['HUMAN_REOBSERVE', 'WORKER_REOBSERVE'].includes(error?.code) || !error.continuation?.required) return null
   return {
     ok: false,
     status: 'continuation-required',

package/lib/core/bin/dsh-computer-use-worker.exe.json

@@ -2,6 +2,6 @@
   "format": 1,
   "platform": "win32",
   "architecture": "x64",
-  "sourceSha256": "8427a18e1f161959043f638cab821e701714f3d83138911dc9c4fb2cbeb152bf",
-  "binarySha256": "0e9212f628ebd73655de1235b3e7bb4ce176c4b60da16c336f2ebae7397084a2"
+  "sourceSha256": "b448b6a665147bde3698471c0a36897188fd26688338a919b45ac2d96b175a95",
+  "binarySha256": "f8042acb806f07240ee5ba70eda3b235fc8f7e668318cc44e29b889a82b0b647"
 }