@entrorove/skill 0.1.33 → 0.1.35

package/CAPABILITY-MAP.md

@@ -1,5 +1,36 @@
 # 能力对账图（WP-02 / AC-20）
 
+## 2026-10-13 接入：协作观测、原生规划与任务通知
+
+| 能力 | 正常公开入口 | 已执行验证与边界 |
+| --- | --- | --- |
+| 协作状态 | `local peer-status` | 原签名授权和原协调绑定；等待、活动、过期、跨任务拒绝；只读查询不写日志、不发写入权限 |
+| Aimlock 规划 | `native aimlock brain-plan/brain-check/brain-validate/brain-status` | 原账号计划入库，检查范围与依赖；重启后按原 request 恢复，跨账号及自造计划拒绝；只认证规划，不认证业务交付 |
+| 八域直接调用 | `native <domain> <operation>` | 真实 discovery → schema 校验 → 单次原生调用 → 原回执核验；八域帮助和状态观察遵循服务端合同，不要求不存在的评价 |
+| IDE 系统通知 | `notifications configure/status/test` | 默认关闭；账号绑定、状态去重、凭据变更失效；仅真实结果、失败与需要确认事件；不推送推广 |
+| 网页与手机通知 | 登录后的任务通知按钮 | 同一加密 Web Push 协议，账号与设备隔离；真实任务事务队列、持久重试、失效注销与到期清理；手机可见投递仍需设备本人授权与验收 |
+| 失败后接续 | `scope-connect` 返回 `nextInput`；`feedback <requestId> [generation]` | 范围门禁使用同一排序路径集；新执行保存新一代回执，原失败回执不可改，默认只读最新一代 |
+
+本地公开 schema 已增加到 **101 项**（原 100 项加 `peer-status`）。Aimlock 运行时由 7.0.44 更新为 **7.0.45**，公开操作由 20 项增加到 24 项；其余七域的运行时版本保持原值。下方历史表保留原对账日期与当时验收边界，不表示当前仍缺上述入口。发布件与生产部署需独立核验，不能从仓库测试推断。
+
+## 2026-10-12 基线：八域 IDE 调用链
+
+逐项对照旧版八个技能的已安装说明、入口和服务实现，本次补回以下共同保证。后面的 AC-20～24 保留其历史基线与当时测试边界。
+
+| 旧版保证 | 当前入口与行为 |
+| --- | --- |
+| 每个任务选择云端／本地，原生确认不可用时仍须展示问题 | `cloud-task` 返回 Confirm Protocol 和 `chatFallback`；确认才提交，退出保留原任务并采用本地方案 |
+| 实际进度必须进入 IDE | `cloud-watch` 订阅本人任务 SSE，输出独立 IDE 事件；调用方必须把公开消息和摘要展示到对话进度 |
+| 执行提示与推广可见 | `智能执行中，请勿关闭！` 与服务端选中的真实推广独立输出；保留推广 HTTPS 链接，按事件 ID 去重 |
+| 断线恢复原任务 | `cloud-watch` 带原 `taskId/afterId` 只读续接；`status` 与 `feedback` 查询原请求，不重发业务 POST |
+| 服务端自动评价，无第二次评价写入 | 调用完成事务保存本人原 request 的评价与结果摘要；CLI 校验回执。旧式适配器使用幂等持久化并在同一 HTTP 响应返回 |
+| 未验证不可记好评 | intake、模型摘要、reported、不完整证据无评分；阻断、失败、P0/P1 不产生好评；发现和状态查询不生成新评价 |
+| 实际 IDE 与原调用绑定 | `ENTROROVE_IDE` 或宿主检测写入原调用标签；每个 OS 用户继续复用受限凭据存储 |
+| 最新官方技能说明生效 | 新调用使用 `npx --yes --prefer-online @entrorove/skill@latest`；安装更新后重新读取 managed `SKILL.md` |
+| 调用次数与沙箱次数分开 | 普通调用与旧式 UUID 记录技能用量；`cloud-task` 才创建沙箱。所有查询和评价按账号权限过滤 |
+
+自动技术评价是私有调用记录。公开用户评价仍须使用本人原话、真实评分和明确公开同意。原生系统通知与手机推送已按 2026-10-13 的公开入口接入；通知权限由用户开启。确认继续遵循 IDE 的明确问题与答案。思考详情只展示服务端公开的规划摘要。
+
 本表把旧八域的远端公开操作与当前本地执行器分开统计。旧版 `SKILL.md` 只规定入口、状态和边界，没有逐域列出操作名；远端操作名采用随包锁定的 v2 runtime catalog 交叉核对，本地操作名直接来自 `local-contracts.mjs` 的 `LOCAL_OPERATION_SCHEMAS`。两个分母不能合并。
 
 ## 边界
@@ -25,16 +56,16 @@ Entrorove 只治理通过技能入口执行的动作：路径、通行证、快
 
 | 域 | 旧 runtime 公开操作 | 当前映射 | 语义边界 |
 | --- | --- | --- | --- |
-| aimlock | `capabilities`, `help`, `intake`, `classify`, `scope-contract`, `skill-route`, `propose-nodes`, `accept-nodes`, `snapshot-plan`, `mutate-gate`, `continuity-check`, `interrupt`, `keep-alive`, `delivery-doc`, `validate-json`, `snapshot-verify`, `run-status`, `chain-plan`, `chain-status`, `feedback` | discovery、任务路由、快照、门控、状态、取消和交付证据 | `brain-plan/check/validate/status` 没有 aimlock 公开入口，见 AC-24 |
+| aimlock | `capabilities`, `help`, `intake`, `classify`, `scope-contract`, `skill-route`, `propose-nodes`, `accept-nodes`, `snapshot-plan`, `mutate-gate`, `continuity-check`, `interrupt`, `keep-alive`, `delivery-doc`, `validate-json`, `snapshot-verify`, `run-status`, `chain-plan`, `chain-status`, `feedback` | discovery、任务路由、快照、门控、状态、取消和交付证据 | 新增 `brain-plan/check/validate/status` 已接入 Aimlock 7.0.45，见上方最新接入表 |
 | blueprint | `capabilities`, `help`, `intake`, `validate`, `compile-inline`, `acceptance-report` | `blueprint` runtime；验收证据由调用方提供，不能自升 `verified` | `acceptance-report` 不是自报绿灯 |
 | calctool | `capabilities`, `help`, `intake`, `validate`, `compile-inline` | `calctool` runtime；公式执行和 final-gate 在本地 Decimal 层 | `research` 是 pipeline 内部阶段，不是独立公开操作 |
 | swarm | `capabilities`, `help`, `intake`, `org-chart`, `blueprint-bridge`, `dispatch`, `claim`, `report`, `accept`, `swarm-status`, `traffic-light`, `security-check`, `validate-json`, `heartbeat`, `reclaim` | 服务端路由、租约和 `reported`/`verified` 状态 | 本地 peer/coordinate 是统一本地层，不能冒充旧 swarm 远端 |
 | validator | `capabilities`, `help`, `intake`, `plan`, `validate-structure`, `security-scan`, `compliance-audit`, `functional-verify`, `verdict`；local-runner：`sandbox-run`, `fuzz-input`, `perf-benchmark`, `intrusive-test` | pure validator 与受控 runner 分开 | 生产验证需独立回执；`verdict` 不能把 reported 变绿 |
 | mergeguard | `capabilities`, `help`, `intake`, `resolve-propose`, `ruleguard-scan`, `ruleguard-compile`；local-runner：`branch-create`, `branch-list`, `branch-switch`, `diff-report`, `preflight`, `merge-verified`, `rollback`, `ledger-query` | pure mergeguard 与本地合并闸门分开 | 虚拟分支不会创建 Git 分支/worktree |
 | archguard | `capabilities`, `help`, `intake`, `contract-create`, `contract-get`, `contract-update`, `template-list`, `checkpoint`, `rules-scan`, `complexity-report`, `drift-status`, `ledger-query` | `archguard-*` 本地合同、快照、范围和账本 | 本地写入仍受路径和基线绑定 |
-| confirm-protocol | `capabilities`, `help`, `interaction-request`, `interaction-answer`, `chat-render`, `memory-set`, `memory-list`, `memory-clear`, `batch-request`, `audit-query` | 纯协议操作 | IDE/native/mobile 通知不是本地层能力；高风险交互默认不批准、不记忆、不批量 |
+| confirm-protocol | `capabilities`, `help`, `interaction-request`, `interaction-answer`, `chat-render`, `memory-set`, `memory-list`, `memory-clear`, `batch-request`, `audit-query` | 纯协议操作 | 通知由独立账号与设备适配层接入；高风险交互默认不批准、不记忆、不批量 |
 
-## 本地基线（当前 `LOCAL_OPERATION_SCHEMAS` 100 项）
+## 本地历史基线（2026-10-07，`LOCAL_OPERATION_SCHEMAS` 100 项）
 
 `scope-connect <absolute repositoryRoot>` 是 CLI 编排入口，不改变这 100 项本地操作。它串联远端 `scope-runner-prepare/register/challenge/attest` 与已有真实快照、签名检查，为原账号与任务提交范围证据；不授予执行证据签名或写入权限。全部远端操作以实时 discovery 为准。
 
@@ -67,11 +98,11 @@ Entrorove 只治理通过技能入口执行的动作：路径、通行证、快
 
 | 疑点 | 结论 | 证据与理由 |
 | --- | --- | --- |
-| `peer-status` | **缺失（开单）** | `statusLocalPeer17` 只在 `local-autocoord17-controller.mjs` 内部存在，未进入 `local-cli.mjs`/公开 schema；内部函数不算交付能力。 |
+| `peer-status` | **已接入并验证** | 公开 schema/CLI 经 `local-peer-status.mjs` 查询原授权；`peer-status-public.test.mjs` 与 `item17-autocoord-behavior.test.mjs` 通过。 |
 | `interrupt` | **已实现（仓库）** | `assets/aimlock-runtime-v7.0.44.mjs` operation catalog 与 policy 均有；发布件需 clean-install 后复测。 |
 | `delivery-doc` | **已实现（仓库）** | 同一 aimlock runtime/source 有 operation、schema、entry；发布面保持未验证。 |
 | calctool `research` | **有意不独立公开（理由）** | `calctool-runtime-v7.0.43.mjs` 将其作为 pipeline 内部 partition kind；它没有独立请求合同，拆成公开 operation 会重复 intake/验证边界。若需求改为独立调用，再开变更。 |
-| aimlock 自有 `brain plan/check/validate/status` | **缺失（开单）** | 现有 `brain-*` 只在 calctool contract/runtime；aimlock 只有 chain/run-status，没有书面迁移或归属合同。 |
+| aimlock 自有 `brain plan/check/validate/status` | **已接入并验证** | Aimlock 7.0.45 的四个公开操作、原计划持久化与账号隔离已由真实 HTTP 和重启回归验证；规划不授予执行或交付认证。 |
 
 ## 发布与校验边界
 

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.35 — 2026-10-13
+
+- 新增协作状态查询、Aimlock 专用规划与八域原生调用；接入账号和设备隔离的任务通知，修复失败接续的评价回执冲突，并完善范围门禁接续。
+- Add read-only peer status, Aimlock planning and native invocation across eight domains; support account/device-bound task notifications, preserve feedback receipts across authorized retries, and correct scope-gate continuation.
+
+## 0.1.34 — 2026-10-12
+
+- 完善 IDE 云端规划选择、实时执行进度与独立推广提示；服务端自动评价绑定原调用并返回可核验回执，支持只读恢复；修复 UUID 调用用量统计，保持账号隔离及沙箱／调用计数分离。
+- Improve IDE cloud planning choices, live execution progress and separate promotion notices. Bind automatic server evaluations to their original invocations with verifiable receipts and read-only recovery; correct UUID invocation usage while keeping accounts and skill/sandbox counters separate.
+
 ## 0.1.33 — 2026-10-12
 
 - 补齐账号与任务隔离的本地签名器和真实快照接入，解析实际别名及类型声明；动态依赖仅进入受限规划，保留独立写入核验。

package/SKILL.md

@@ -5,7 +5,7 @@ description: An engineering skill that understands a task, chooses a fitting wor
 
 # entrorove · 熵巡
 
-Version: 0.1.33.
+Version: 0.1.35.
 
 Read the user's goal and repository instructions first. Preserve the original task through planning, execution and verification. Use the workflow only where it helps; a small, low-risk edit can proceed directly. Never claim a reported step is a verified result.
 
@@ -23,11 +23,23 @@ On first use or after a material agreement revision, the CLI returns a Confirm P
 
 ## Work with a task
 
+### IDE display and cloud planning entry
+
+For a task using this skill's cloud planning, first run `npx --yes --prefer-online @entrorove/skill@latest cloud-task` with `{"goal":"<the user's actual goal>","ideTaskId":"<the current IDE task ID, when available>"}` on stdin. Render the returned choice with the host's question tool or native UI. If no native adapter exists, show `interaction.chatFallback` in the conversation and collect its answer. Tool output alone is not a displayed question. Offer **确认** and **退出，采用本地方案**. Exit or an explicit cancellation continues the original task locally; it must not stop the task or change account preferences. An unanswered question does not authorize cloud consumption. Reuse a prior explicit choice for this same task rather than asking again.
+
+With `sandboxChoice: "use"` (or the protocol callback's `answer: "use"`), retain the real returned task ID and immediately run the returned `nextAction`, `cloud-watch`. It subscribes to that account's authoritative SSE stream, returns newline-delimited `entrorove.ide-event/1.0` events, then one `entrorove.cloud-watch/1.0` result. **Mirror each new event's public `message` and optional `detail` into visible IDE progress/commentary.** Deduplicate by task ID and event ID, including events repeated in the final result. The same rule applies to normal invocation `ideMessages` and notice events. A JSON field or collapsed command log does not satisfy this display requirement. Show `智能执行中，请勿关闭！` and the selected promotion on separate lines; preserve the promotion's actual HTTPS link. Use only the server's selected promotion; do not insert a local test advertisement.
+
+Display the actual entering, allocation, thinking, public output and exit events as they arrive. Do not generate model reasoning, invent intermediate events or replace `reported` with verified completion. The public model summary is the planning output available to show. `云端沙箱输出完毕` means the current planning response has arrived; inspect its real task/verification status before dependent execution. Exit here closes the progress subscription and does not cancel the persisted task.
+
+When a bounded watch returns `nextAction`, continue it with the returned `afterId`; reconnect only with GET and that cursor. Never repeat cloud-task POST to recover progress. For an available planning result, query `status <feedback.requestId>` to obtain the original accepted flow and required next step, then continue that flow. Do not create a second `start` for the same cloud goal. If the task is still running but no events arrive, say so and keep reading its real status. Missing credentials, blocked entitlement, expiry and stream errors must be visible.
+
+Set `ENTROROVE_IDE` to the actual host name (for example `Codex`, `Cursor` or `Claude Code`) when host detection is unavailable. It carries only the IDE label; credentials remain in the restricted store. Use the latest official package with `--prefer-online` for new invocations, and reread the managed `SKILL.md` after installation reports an update. Recovering an uncertain request remains a read-only query of its original ID.
+
 Send JSON on standard input to `npx @entrorove/skill invoke`. Before every execution call, discover `operation: "capabilities"` with `{}` and validate input against the returned operation schema. The CLI performs remote discovery automatically; local adapters discover the installed contract before execution. Discovery failure stops execution. Adapters that expose the four-step task route can call `task-describe`, `message-route`, `message-accept` and `task-resume` in order; `start` remains the one-call workflow equivalent. Then start with `operation: "start"` and an `input.task` containing the goal, work type, risk, difficulty and observed scope facts. Work types are `implementation`, `documentation`, `calculation`, `merge`, `review`, `decision` and `diagnosis`. Assess facts from the real task and repository; do not invent certainty. entrorove chooses the workflow. A small task may return `decision: "direct"`, meaning the IDE should do the work without another service call. The public envelope is `entrorove.skill.request/2.0`; `requestId` is the SHA-256 digest of `operation + canonical(input)`. Version 1.0 remains accepted for older callers.
 
 `start` creates a normal durable skill flow. It does not create a cloud-sandbox task or contribute to cloud-sandbox usage. To create a real cloud-sandbox task, call `operation: "cloud-task"` with `input.goal`; the CLI returns a Confirm Protocol choice interaction before any cloud request. Continue the same request with `sandboxChoice: "use"` or `sandboxChoice: "local"`. `use` calls the authenticated `/api/cloud-task` endpoint and returns the real `taskId`; `local` skips only this task. The server is authoritative for account entitlement and the account-wide sandbox preference: a disabled or unavailable account returns `blocked` and creates no task. A `needs-input`, `blocked` or `failed` result is not a successful dispatch and must be shown to the user.
 
-After dispatch, query the real task without resending it with the CLI-only `operation: "cloud-status"` and `input.taskId`, or `npx @entrorove/skill cloud-status` with the same JSON. This special CLI route reads the authoritative task list and usage endpoints; it is not part of the `/api/skill/invoke` capability map. The read-only result includes the current task status, public title/summary, and recorded model usage when available. A missing task is reported explicitly; it is never treated as completed. This is the skill-side status and usage check for cloud tasks; the web dock may additionally subscribe to its event stream.
+After dispatch, use `cloud-watch` for live IDE progress and `cloud-status` for a read-only snapshot with `input.taskId`. Both are CLI-only routes, also accepted by `invoke`; they do not pass through `/api/skill/invoke`. Status includes public title/summary, actual model usage and the stored automatic evaluation when available. A missing task is explicit and never treated as completed. The IDE and website consume the same account-bound event stream.
 
 ### Per-task cloud sandbox choice
 
@@ -41,11 +53,15 @@ For `workType: "merge"`, include `baselineRef` with the concrete branch, tag, co
 
 The v2 capability map is recorded in [`CAPABILITY-MAP.md`](CAPABILITY-MAP.md). It maps every legacy domain and operation to its v2 equivalent, narrower semantics, or an explicitly documented uncovered area; adapters must not silently substitute an uncovered operation.
 
+For an explicit domain operation, use `npx @entrorove/skill native <domain> <operation>` with its input object on stdin. The supported domains are `aimlock`, `blueprint`, `calctool`, `swarm`, `validator`, `mergeguard`, `archguard` and `confirm-protocol`. This public adapter discovers that domain's actual server schema, validates the input, invokes the registered operation once, and verifies any required automatic feedback. Discovery, help and status observations follow the server's published feedback contract. A failed gate or unknown outcome must never be replaced with another executor or reported as local success; fix the original cause and recover the original request through its read-only status.
+
+Aimlock exposes `brain-plan`, `brain-check`, `brain-validate` and `brain-status`. Create a plan with the actual goal, scope `contract`, `requirements` and ordered `steps`; retain its returned `requestId` and `plan.digest`. Subsequent operations take only that original `planRequestId` (plus `paths` for `brain-check`); the server loads the authenticated account's stored plan. Never submit a reconstructed plan or another account's request. Planning validation checks scope, requirements and dependencies; it grants no mutation authority and never certifies business delivery.
+
 For a returned `flowId`, continue with `{"operation":"continue","input":{"flowId":"<returned ID>","operation":"<next operation>","payload":{}}}`. Fill `payload` with the next operation's required input. Keep the same task and evidence in the IDE. For later work, `input.task.phase` may be `plan`, `coordinate`, `architecture`, `verify`, `merge` or `decision`; it remains the same skill entry point. Never treat an unknown request outcome as permission to retry a paid or mutating action; query the original request ID when the workflow supports it.
 
 The v2 progress sequence is durable and ordered: the first runtime step reports `intake`, then the applicability `gate` is recorded and verified, then the selected contract or plan steps run. Every step can be `pending`, `running`, `reported`, `verified`, `blocked` or `failed`; only a completed verdict with trusted evidence is green.
 
-When intake returns `workflow-gate`, connect the current repository before invoking that gate: run `npx @entrorove/skill scope-connect <absolute repositoryRoot>` with JSON `{"flowId":"<original flowId>","paths":["<existing source file>"]}` on stdin. Use the concrete existing source files in the task's scope; new files belong in the later plan's declared artifacts. The adapter enrolls an OS-private Ed25519 scope signer for this accepted account and task, answers a server challenge, copies and verifies real source files, and submits the signed facts. It sends hashes and scope metadata rather than source contents or the private key. Enrollment grants scope inspection only; execution evidence and write passes retain their separate authority checks. An operator-configured signer cannot be replaced. After a successful connection, invoke the original `workflow-gate` with the same paths. Refresh an expired snapshot by reconnecting the same flow and path set. Show an explicit blocked result; query the original request ID after an unknown transport outcome before considering another attempt.
+When intake returns `workflow-gate`, connect the current repository before invoking that gate: run `npx @entrorove/skill scope-connect <absolute repositoryRoot>` with JSON `{"flowId":"<original flowId>","paths":["<existing source file>"]}` on stdin. Use the concrete existing source files in the task's scope; new files belong in the later plan's declared artifacts. The adapter enrolls an OS-private Ed25519 scope signer for this accepted account and task, answers a server challenge, copies and verifies real source files, and submits the signed facts. It sends hashes and scope metadata rather than source contents or the private key. Enrollment grants scope inspection only; execution evidence and write passes retain their separate authority checks. An operator-configured signer cannot be replaced. After a successful connection, use the returned `nextInput` for `continue`, or explicitly send `payload: {"targetFiles":["<same existing source file>"]}` to the original `workflow-gate`. The connector uses `paths`; the gate uses `targetFiles`. Refresh an expired snapshot by reconnecting the same flow and path set. Show an explicit blocked result; query the original request ID after an unknown transport outcome before considering another attempt.
 
 Scope inspection resolves aliases from actual `tsconfig.json` or `jsconfig.json`, including relative `extends`. For plugin source compiled by a host project whose config is outside the source's ancestors, include `importContexts: [{"sourcePrefix":"<plugin source directory>","configPath":"<actual host tsconfig.json>"}]` in `scope-connect` input. Inspect the real build configuration first; never invent an alias or mark an unresolved import as external. These context paths remain inside the repository, their hashes enter the signed facts, and the local task binding freezes them.
 
@@ -59,6 +75,22 @@ The local execution layer is available through `npx @entrorove/skill local <oper
 
 Local CLI failures use the machine-readable `entrorove.local-error/1.0` envelope `{schemaVersion,status,code,disposition,message}` on stderr. `status` is `failed` for invalid input or computation errors and `blocked` for missing mutation, lease, snapshot or handoff authority. Formula `add` and `mul` require at least one argument; `div`, `safeDivide` and `percentOf` reject a zero denominator with `DIV_ZERO`. The formula engine declares `round` as half-away-from-zero with two decimal places by default; an engine may declare another `decimalPlaces` value from 0 through 28 in its `roundingPolicy`.
 
+### Read-only peer status
+
+`local peer-status` observes the original signed worker grant, task and lease, or the registered coordination task/agent/chain/intent binding. It reports only that worker's active, waiting or expired state, own blocked/ready paths and own checkpoint requests. Queries do not issue leases, change ownership, write a coordination journal or grant permission to write. Use `local capabilities` for the exact supported input variants.
+
+### Optional task notifications
+
+System notifications are disabled until this account explicitly enables them. `npx @entrorove/skill notifications configure` accepts only `{"enabled":true}` or `{"enabled":false}` on stdin; `notifications status` observes the account's setting and `notifications test` submits a generic test only when enabled. macOS and Linux use their existing notification service. Real IDE events notify output availability, verification, failure or required confirmation, deduplicated by original task/request and state. Promotion and keep-alive messages remain visible in the IDE and never trigger system notifications. Changing the stored account credential disables the previous account's notification setting. OS acceptance does not prove that permission allows a visible notification.
+
+The website's signed-in bell control enables encrypted Web Push for the current account and device. Desktop browsers and supported phones use this same push protocol; iPhone requires a Home Screen web app. Ask permission only through the user's enable action. Logout clears the browser binding and subscription. Messages contain only generic task status, with no prompts, credentials, model output or promotion. Delivery retries keep the original event and device binding; expired endpoints and temporary tasks are cleaned up automatically. Never describe an unsupported platform or failed delivery as a successful notification.
+
+### Automatic invocation evaluation and optional user reviews
+
+Every completed or failed execution call receives a server-generated `feedback` receipt bound to the original account, request hash and result digest. Durable calls commit this evaluation in the same transaction as the result; legacy adapters return an idempotent receipt with the same HTTP response. The CLI verifies the original identity and evaluation digest. Preserve `receiptId`, `requestId` and `evaluation.digest`; never generate a score or comment locally. Display the returned evaluation acknowledgement in IDE progress, deduplicated by receipt ID. Read the saved receipt with `npx @entrorove/skill feedback <original requestId>` after a connection loss; this is GET only and never repeats execution or submits another evaluation. An authorized retry before side effects keeps the original request but gets a new server execution generation and immutable receipt. Default feedback reads the latest generation; `feedback <original requestId> <generation>` reads a preserved earlier receipt. Never overwrite a failed receipt or use it as the current retry result. Discovery/status queries create no evaluations.
+
+Only server-verified progress or a validated pure operation earns a positive automatic evaluation. Reported steps, intake, model summaries and incomplete evidence remain `pending` with no score. Blocked/failed results and P0/P1 findings cannot become positive. These are private technical evaluations; they do not create a public user review or masquerade as the user's words. If a server advertising this extension returns no valid receipt, show the missing receipt and query its original ID. Do not silently claim that evaluation was reported.
+
 When the user gives an actual evaluation after using the skill, offer to publish that feedback. Only after they explicitly agree to public display under the current notice, send their unchanged words, IDE name and 1–5 rating as JSON on standard input to `npx @entrorove/skill review`, including `invocationRequestId` from their actual successful call, `publicConsent: true` and `noticeVersion: "2026-10-07.1"`. The same account must own that successful call within the last 30 days; a recorded usage event, failed call or unknown result does not qualify. Three public reviews per account per day share one server quota across API replicas. Public output exposes only IDE, rating, original text and time, never account or invocation identity. Never invent, rewrite or infer a review from task completion. The website reads accepted reviews directly from entrorove's independent database.
 
 Feedback command example (replace the request ID with the original successful invocation ID, and use only the user’s actual words after explicit public consent):

package/automatic-feedback-client.mjs

@@ -0,0 +1,45 @@
+import { createHash } from 'node:crypto';
+import { parseTransportResponse, requestTransport, trustedOrigin } from './remote-transport.mjs';
+
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(',')}]`;
+  if (value && typeof value === 'object') return `{${Object.keys(value).sort().map(key => `${JSON.stringify(key)}:${canonical(value[key])}`).join(',')}}`;
+  return JSON.stringify(value);
+}
+function digest(value) { return createHash('sha256').update(canonical(value)).digest('hex'); }
+export function verifyAutomaticFeedback(feedback, requestId, requestHash) {
+  const evaluation = feedback?.evaluation;
+  if (!feedback || feedback.schemaVersion !== 'entrorove.automatic-feedback/1.0' || feedback.stored !== true
+    || !/^[0-9a-f-]{36}$/i.test(feedback.receiptId) || feedback.requestId !== requestId
+    || !/^[a-f0-9]{64}$/.test(feedback.requestHash) || requestHash && feedback.requestHash !== requestHash
+    || !/^[a-f0-9]{64}$/.test(feedback.resultDigest) || feedback.generation !== undefined
+      && (!Number.isSafeInteger(feedback.generation) || feedback.generation < 1) || !evaluation
+    || evaluation.schemaVersion !== 'entrorove.automatic-evaluation/1.0' || evaluation.requestId !== requestId
+    || !['good','bad','pending'].includes(evaluation.disposition)
+    || !['passed','failed','incomplete'].includes(evaluation.validation)
+    || !Number.isSafeInteger(evaluation.durationMs) || evaluation.durationMs < 0
+    || !['findingCount','p0Count','p1Count'].every(key => Number.isSafeInteger(evaluation[key]) && evaluation[key] >= 0)
+    || typeof evaluation.comment !== 'string' || !evaluation.comment.trim()) {
+    throw new Error(`Invalid automatic feedback receipt; query feedback ${requestId} without repeating the invocation`);
+  }
+  const { digest: checksum,...core } = evaluation;
+  if (digest(core) !== checksum || !['succeeded','reported','blocked','failed','incomplete'].includes(evaluation.status)
+    || evaluation.findingCount < evaluation.p0Count + evaluation.p1Count
+    || evaluation.disposition === 'pending' && (evaluation.score !== null || evaluation.validation !== 'incomplete')
+    || evaluation.disposition === 'good' && (evaluation.status !== 'succeeded' || evaluation.validation !== 'passed' || evaluation.p0Count || evaluation.p1Count)
+    || evaluation.disposition === 'bad' && evaluation.validation !== 'failed'
+    || evaluation.disposition !== 'pending' && (!Number.isInteger(evaluation.score) || evaluation.score < 0 || evaluation.score > 100)) {
+    throw new Error('Automatic feedback digest or validation state is inconsistent');
+  }
+  return feedback;
+}
+export async function queryAutomaticFeedback(requestId, dependencies, generation) {
+  if (typeof requestId !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(requestId)) throw new Error('feedback requires its original request ID');
+  const token = await dependencies.readCredential(dependencies.home);
+  if (generation !== undefined && (!/^[1-9][0-9]{0,14}$/.test(generation) || !Number.isSafeInteger(Number(generation)))) throw new Error('Invalid original execution generation');
+  const response = await requestTransport(trustedOrigin(dependencies.apiOrigin()),`/api/skill/feedback/${requestId}${generation === undefined ? '' : `?generation=${generation}`}`,
+    { headers: { authorization: `Bearer ${token}` } });
+  const result = parseTransportResponse(response,'automatic feedback');
+  if (!response.ok) throw new Error(`Automatic feedback unavailable: HTTP ${response.status}; requestId=${requestId}`);
+  return verifyAutomaticFeedback(result.feedback,requestId);
+}

package/cli.mjs

@@ -8,12 +8,16 @@ import { fileURLToPath } from 'node:url';
 import { compareVersions } from './version.mjs';
 import { credentialPath, readCredential, writeCredential } from './local-credential.mjs';
 import { runLocal } from './local-cli.mjs';
+import { runNative } from './native-client.mjs';
+import { configureNativeNotifications, notificationSettings, sendNativeNotification } from './native-notification.mjs';
 import { runTaskMessageCli } from './task-message-cli.mjs';
 import { runScopeConnect } from './scope-runner-client.mjs';
 import { apiUrl, buildInvocation, invokeRemote, queryFlows, queryStatus } from './remote-client.mjs';
 const packageDir = path.dirname(fileURLToPath(import.meta.url));
 import { buildReview, submitSkillFeedback, feedbackNoticeVersion } from './review-client.mjs';
 import { queryCloudTask, runCloudTask as dispatchCloudTask } from './cloud-task-client.mjs';
+import { watchCloudTask } from './cloud-watch-client.mjs';
+import { queryAutomaticFeedback } from './automatic-feedback-client.mjs';
 const markerName = '.entrorove-managed.json';
 const installFiles = ['SKILL.md', 'CAPABILITY-MAP.md', 'AGREEMENT.md', 'manifest.json'];
 const markerSchema = 'entrorove.managed-install/1.0';
@@ -396,6 +400,13 @@ export async function runCloudStatus(input, dependencies = remoteDependencies())
   if (['blocked', 'failed', 'missing'].includes(result.status)) process.exitCode = 2;
   return result;
 }
+export async function runCloudWatch(input, dependencies = remoteDependencies()) {
+  const result = await watchCloudTask(input,{ ...dependencies,
+    onIdeEvent: event => process.stdout.write(`${JSON.stringify(event)}\n`) });
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+  if (['blocked','failed','missing'].includes(result.status) || ['blocked','failed'].includes(result.taskStatus)) process.exitCode = 2;
+  return result;
+}
 
 async function invoke(data) {
   if (data?.operation === 'cloud-task') {
@@ -404,6 +415,7 @@ async function invoke(data) {
   if (data?.operation === 'cloud-status') {
     return runCloudStatus(data.input, remoteDependencies());
   }
+  if (data?.operation === 'cloud-watch') return runCloudWatch(data.input);
   return invokeRemote(data, remoteDependencies());
 }
 
@@ -430,6 +442,14 @@ async function main() {
     process.stdout.write(JSON.stringify({ accepted, version: agreementVersion }) + '\n');
   } else if (command === 'invoke' && args.length === 0) {
     await invoke(await stdinJson());
+  } else if (command === 'native' && args.length === 2) {
+    await runNative(args[0], args[1], await stdinJson(), remoteDependencies());
+  } else if (command === 'notifications' && args.length === 1) {
+    const result = args[0] === 'configure' ? await configureNativeNotifications(await stdinJson())
+      : args[0] === 'status' ? await notificationSettings()
+        : args[0] === 'test' && (await notificationSettings()).enabled ? await sendNativeNotification('test') : null;
+    if (!result) throw new Error('Use notifications configure|status|test; enable this account before sending a test');
+    process.stdout.write(`${JSON.stringify(result)}\n`);
   } else if (command === 'scope-connect' && args.length === 1) {
     const result = await runScopeConnect(args[0], await stdinJson(), remoteDependencies());
     process.stdout.write(`${JSON.stringify(result)}\n`);
@@ -440,6 +460,10 @@ async function main() {
     await runCloudTask(await stdinJson());
   } else if (command === 'cloud-status' && args.length === 0) {
     await runCloudStatus(await stdinJson());
+  } else if (command === 'cloud-watch' && args.length === 0) {
+    await runCloudWatch(await stdinJson());
+  } else if (command === 'feedback' && [1,2].includes(args.length)) {
+    process.stdout.write(`${JSON.stringify(await queryAutomaticFeedback(args[0],remoteDependencies(),args[1]))}\n`);
   } else if (command === 'review' && args.length === 0) {
     await submitReview(await stdinJson());
   } else if (command === 'status' && args.length === 1) {
@@ -461,7 +485,7 @@ async function main() {
   } else if (command === 'local') {
     await runLocal(args);
   } else {
-    throw new Error('Usage: entrorove install | configure | agreement | invoke | scope-connect <repositoryRoot> | host-message [adapterModulePath] | cloud-task | cloud-status | status <requestId> | flows | review | local (JSON on stdin)');
+    throw new Error('Usage: entrorove install | configure | agreement | invoke | native <domain> <operation> | notifications configure|status|test | scope-connect <repositoryRoot> | host-message [adapterModulePath] | cloud-task | cloud-watch | cloud-status | feedback <requestId> [generation] | status <requestId> | flows | review | local (JSON on stdin)');
   }
 }
 if (process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))) {

package/cloud-event-stream.mjs

@@ -0,0 +1,27 @@
+export async function consumeCloudStream(body, onFrame) {
+  if (!body) throw new Error('Cloud event response has no stream');
+  const reader = body.getReader(), decoder = new TextDecoder('utf-8',{ fatal: true });
+  let pending = '', size = 0;
+  try {
+    while (true) {
+      const { value,done } = await reader.read();
+      if (value) size += value.byteLength;
+      if (size > 16_777_216) throw new Error('Cloud event stream exceeded its bounded read');
+      pending += decoder.decode(value,{ stream: !done });
+      let match;
+      while ((match = /\r?\n\r?\n/u.exec(pending))) {
+        const frame = pending.slice(0,match.index); pending = pending.slice(match.index + match[0].length);
+        if (frame.length > 262144) throw new Error('Cloud event frame exceeded its bounded read');
+        let event = 'message', id, data = [];
+        for (const line of frame.split(/\r?\n/u)) {
+          if (line.startsWith('event:')) event = line.slice(6).trim();
+          else if (line.startsWith('id:')) id = line.slice(3).trim();
+          else if (line.startsWith('data:')) data.push(line.slice(5).replace(/^ /u,''));
+        }
+        if (data.length && await onFrame({ event,id,data: JSON.parse(data.join('\n')) }) === false) return;
+      }
+      if (pending.length > 262144) throw new Error('Cloud event frame exceeded its bounded read');
+      if (done) { if (pending.trim()) throw new Error('Cloud event response ended with an incomplete frame'); return; }
+    }
+  } finally { await reader.cancel().catch(() => undefined); reader.releaseLock(); }
+}

package/cloud-task-client.mjs

@@ -1,6 +1,8 @@
 import { createHash } from 'node:crypto';
 import { appendInvocation } from './local-invocations.mjs';
 import { parseTransportResponse, requestTransport, trustedOrigin } from './remote-transport.mjs';
+import { displayIdeEvent, ideClientHeaders } from './ide-presentation.mjs';
+import { verifyAutomaticFeedback } from './automatic-feedback-client.mjs';
 
 const CLOUD_TASK_SCHEMA = 'entrorove.cloud-task/1.0';
 const CLOUD_STATUS_SCHEMA = 'entrorove.cloud-status/1.0';
@@ -26,7 +28,10 @@ function validateInput(input) {
   if (input.ideTaskId !== undefined && (typeof input.ideTaskId !== 'string' || !input.ideTaskId.trim() || input.ideTaskId.length > 200)) {
     throw new Error('cloud-task ideTaskId must be a non-empty string of at most 200 characters');
   }
-  if (input.sandboxChoice !== undefined && !['use', 'local'].includes(input.sandboxChoice)) {
+  if (input.sandboxChoice !== undefined && input.answer !== undefined && input.sandboxChoice !== input.answer) {
+    throw new Error('Conflicting cloud sandbox choices');
+  }
+  if ((input.sandboxChoice ?? input.answer) !== undefined && !['use', 'local'].includes(input.sandboxChoice ?? input.answer)) {
     throw new Error('cloud-task sandboxChoice must be use or local');
   }
   return { goal: input.goal, ...(input.ideTaskId === undefined ? {} : { ideTaskId: input.ideTaskId }) };
@@ -48,18 +53,19 @@ function authenticatedHeaders(token, headers = {}) {
   return { ...headers, authorization: `Bearer ${token}` };
 }
 
-export function sandboxChoiceInteraction(id) {
+export function sandboxChoiceInteraction(id, task = {}) {
   return {
     schemaVersion: 'confirm.interaction/1.0', requestId: id, type: 'choice',
-    question: '是否为本任务使用云端沙箱？',
+    question: '是否启用云端沙箱执行思考规划？',
     options: [
-      { id: 'use', label: '本任务使用云端沙箱', hint: '创建真实云端任务并持续记录进度' },
-      { id: 'local', label: '继续本地执行', hint: '仅当前任务退出云端沙箱' },
+      { id: 'use', label: '确认', hint: '为当前任务创建云端思考规划并显示真实进度' },
+      { id: 'local', label: '退出，采用本地方案', hint: '继续当前任务，不改变账号开关' },
     ],
-    default: 'local', timeout: 8_000, timeoutAction: 'local', risk: 'low',
+    default: 'local', timeout: null, timeoutAction: 'local', risk: 'low',
     riskDescription: '这是当前任务的执行位置选择，不改变账号级云端沙箱开关。',
     rememberable: false, memoryKey: '',
-    callback: { operation: 'cloud-task', payload: { sandboxChoice: 'use' } },
+    callback: { operation: 'cloud-task', payload: { ...task } },
+    chatFallback: '是否启用云端沙箱执行思考规划？\n1. 确认：当前任务使用云端沙箱\n2. 退出：自动采用本地方案，继续当前任务',
   };
 }
 
@@ -76,24 +82,30 @@ export async function runCloudTask(input, dependencies) {
   const task = validateInput(input);
   validateDependencies(dependencies);
   const id = requestId(task);
+  const choice = input.sandboxChoice ?? input.answer;
   await dependencies.install();
   if (!await dependencies.agreementAccepted(dependencies.home)) {
     return envelope(task, 'blocked', { code: 'agreement-required', interaction: dependencies.agreementRequired(dependencies.home) });
   }
-  if (input.sandboxChoice === undefined) return envelope(task, 'needs-input', {
-    task, interaction: sandboxChoiceInteraction(id),
+  if (choice === undefined) return envelope(task, 'needs-input', {
+    task, interaction: sandboxChoiceInteraction(id,task),
+  });
+  if (choice === 'local') return envelope(task, 'skipped', {
+    reason: 'task', executionIsolation: 'local', message: '已退出云端沙箱，采用本地方案继续当前任务。',
+    continuation: { goal: task.goal,...(task.ideTaskId ? { ideTaskId: task.ideTaskId } : {}) },
   });
-  if (input.sandboxChoice === 'local') return envelope(task, 'skipped', { reason: 'task' });
 
   const token = await dependencies.readCredential(dependencies.home);
   const origin = trustedOrigin(dependencies.apiOrigin());
   const metadata = { kind: 'remote', operation: 'cloud-task', requestId: id };
   await appendInvocation({ ...metadata, event: 'started' }, dependencies.home);
+  displayIdeEvent({ schemaVersion: 'entrorove.ide-event/1.0',requestId: id,kind: 'status',
+    phase: 'enter',message: '正在进入云端沙箱',separateLine: true },dependencies.onIdeEvent);
   let response;
   try {
     response = await requestTransport(origin, '/api/cloud-task', {
       method: 'POST', timeoutMs: 30_000,
-      headers: authenticatedHeaders(token, { 'content-type': 'application/json' }),
+      headers: authenticatedHeaders(token, { 'content-type': 'application/json',...ideClientHeaders() }),
       body: JSON.stringify(task),
     });
   } catch (cause) {
@@ -124,7 +136,8 @@ export async function runCloudTask(input, dependencies) {
   await appendInvocation({ ...metadata, event: 'completed' }, dependencies.home);
   return envelope(task, 'started', { taskId: result.taskId,
     taskStatus: typeof result.status === 'string' ? result.status : 'running',
-    executionIsolation: typeof result.executionIsolation === 'string' ? result.executionIsolation : 'worker' });
+    executionIsolation: typeof result.executionIsolation === 'string' ? result.executionIsolation : 'worker',
+    nextAction: { operation: 'cloud-watch',input: { taskId: result.taskId,afterId: '0' } } });
 }
 
 function publicTask(task) {
@@ -162,6 +175,7 @@ export async function queryCloudTask(taskId, dependencies) {
       code: typeof taskBody?.error === 'string' ? taskBody.error : taskResponse.status === 404 ? 'cloud-task-not-found' : 'cloud-status-unavailable', httpStatus: taskResponse.status };
   }
   const task = taskBody.task;
+  const feedback = taskBody.feedback ? verifyAutomaticFeedback(taskBody.feedback,taskBody.feedback.requestId) : undefined;
   let usage = [];
   let usageError;
   const usageResponse = await requestTransport(origin, `/api/cloud-sandbox/tasks/${id}/usage`, {
@@ -174,6 +188,7 @@ export async function queryCloudTask(taskId, dependencies) {
   } catch { usageError = 'cloud-usage-invalid-response'; }
   await appendInvocation({ ...metadata, event: 'status' }, dependencies.home);
   return { schemaVersion: CLOUD_STATUS_SCHEMA, status: 'observed', taskId: id,
-    taskStatus: task.status, task: publicTask(task), usage, ...(usageError ? { usageError } : {}) };
+    taskStatus: task.status, task: publicTask(task), usage, ...(feedback ? { feedback } : {}),
+    ...(usageError ? { usageError } : {}) };
 }
 

package/cloud-watch-client.mjs

@@ -0,0 +1,58 @@
+import { trustedOrigin } from './remote-transport.mjs';
+import { consumeCloudStream } from './cloud-event-stream.mjs';
+import { automaticFeedbackIdeEvent, cloudIdeEvent, displayIdeEvent, ideClientHeaders } from './ide-presentation.mjs';
+import { queryCloudTask } from './cloud-task-client.mjs';
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function inputOptions(input) {
+  if (!input || !UUID.test(input.taskId) || Object.keys(input).some(key => !['taskId','afterId','waitMs'].includes(key))) {
+    throw new Error('cloud-watch requires its real taskId and optional afterId and waitMs');
+  }
+  const afterId = input.afterId ?? '0', waitMs = input.waitMs ?? 15000;
+  if (typeof afterId !== 'string' || !/^(0|[1-9][0-9]{0,18})$/u.test(afterId) || BigInt(afterId) > 9223372036854775807n
+    || !Number.isInteger(waitMs) || waitMs < 1 || waitMs > 45000) throw new Error('Invalid cloud-watch cursor or bounded wait');
+  return { taskId: input.taskId,afterId,waitMs };
+}
+export async function watchCloudTask(input, dependencies) {
+  const options = inputOptions(input), { taskId,waitMs } = options;
+  await dependencies.install();
+  if (!await dependencies.agreementAccepted(dependencies.home)) return { status: 'blocked',code: 'agreement-required',
+    interaction: dependencies.agreementRequired(dependencies.home) };
+  const token = await dependencies.readCredential(dependencies.home);
+  const controller = new AbortController(), deadline = setTimeout(() => controller.abort(),waitMs);
+  const events = [], emit = event => { events.push(event); displayIdeEvent(event,dependencies.onIdeEvent); };
+  let afterId = options.afterId, taskStatus = 'running', outputAvailable = false, settled = false, flowId;
+  try {
+    const response = await fetch(`${trustedOrigin(dependencies.apiOrigin())}/api/cloud-sandbox/tasks/${taskId}/events`, {
+      redirect: 'error',signal: controller.signal,headers: { authorization: `Bearer ${token}`,
+        accept: 'text/event-stream','last-event-id': afterId,...ideClientHeaders() } });
+    if (!response.ok) throw new Error(`Cloud event stream unavailable: HTTP ${response.status}; taskId=${taskId}`);
+    if (!response.headers.get('content-type')?.startsWith('text/event-stream')) throw new Error('Cloud event response is not an event stream');
+    await consumeCloudStream(response.body,frame => {
+      if (frame.event === 'stream-error') throw new Error(`Cloud event stream stopped: ${frame.data?.code ?? 'stream-failed'}`);
+      if (frame.event === 'status') {
+        if (frame.data?.taskId !== taskId || !['running','completed','blocked','failed','cancelled'].includes(frame.data.status)) throw new Error('Invalid cloud task status event');
+        taskStatus = frame.data.status; return taskStatus === 'running';
+      }
+      if (!/^[1-9][0-9]{0,18}$/u.test(frame.id ?? '') || frame.data?.id !== frame.id) throw new Error('Invalid cloud event cursor');
+      if (BigInt(frame.id) <= BigInt(afterId)) return;
+      const event = cloudIdeEvent(frame.data,taskId); afterId = frame.id; emit(event);
+      if (typeof frame.data.metadata?.flowId === 'string') flowId = frame.data.metadata.flowId;
+      settled = event.phase === 'workflow' && ['reported','verified','blocked','failed'].includes(event.state);
+      outputAvailable = settled && ['reported','verified'].includes(event.state);
+      if (settled) return false;
+    });
+  } catch (cause) {
+    if (!controller.signal.aborted) throw cause;
+  } finally { clearTimeout(deadline); controller.abort(); }
+  if (outputAvailable) emit({ schemaVersion: 'entrorove.ide-event/1.0',taskId,kind: 'status',phase: 'output',
+    message: '云端沙箱输出完毕；实际验证状态以任务回执为准。',separateLine: true });
+  const current = await queryCloudTask(taskId,dependencies);
+  if (current.status === 'observed') taskStatus = current.taskStatus;
+  if (current.feedback) emit(automaticFeedbackIdeEvent(current.feedback));
+  emit({ schemaVersion: 'entrorove.ide-event/1.0',taskId,kind: 'status',phase: 'exit',
+    message: settled || taskStatus !== 'running' ? '云端沙箱正在退出本次进度订阅' : '云端沙箱仍在执行，下次从当前进度继续读取',separateLine: true });
+  return { schemaVersion: 'entrorove.cloud-watch/1.0',status: current.status,taskId,taskStatus,afterId,outputAvailable,
+    events,...(flowId ? { flowId } : {}),task: current.task,usage: current.usage,...(current.feedback ? { feedback: current.feedback } : {}),
+    nextAction: taskStatus === 'running' && !settled ? { operation: 'cloud-watch',input: { taskId,afterId,waitMs } } : null };
+}

package/ide-presentation.mjs

@@ -0,0 +1,64 @@
+const UUID = /^[0-9a-f-]{36}$/i;
+import { notifyIdeEvent } from './native-notification.mjs';
+export function ideClientHeaders(environment = process.env) {
+  const ide = environment.ENTROROVE_IDE ?? (environment.CODEX_THREAD_ID ? 'Codex'
+    : environment.CURSOR_TRACE_ID ? 'Cursor' : environment.CLAUDE_CODE_ENTRYPOINT ? 'Claude Code' : 'Entrorove CLI');
+  if (typeof ide !== 'string' || !/^[\p{L}\p{N} .+_-]{2,48}$/u.test(ide)) throw new Error('Invalid ENTROROVE_IDE client name');
+  return { 'x-entrorove-ide': ide };
+}
+export function displayIdeEvent(event, sink) {
+  if (sink) sink(event);
+  else process.stderr.write(`${event.message}\n${event.detail ? event.detail + '\n' : ''}`);
+  void notifyIdeEvent(event).catch(() => process.stderr.write('Entrorove system notification unavailable; IDE progress remains visible.\n'));
+}
+function text(value) {
+  return typeof value === 'string' ? value.replace(/[\u0000-\u0008\u000b-\u001f\u007f]/gu, '').slice(0,12000) : '';
+}
+export function cloudIdeEvent(value, taskId) {
+  if (!value || value.taskId !== taskId || !UUID.test(taskId) || !/^[1-9][0-9]{0,18}$/.test(value.id)
+    || !['thinking','execution','notice','error'].includes(value.kind) || typeof value.content !== 'string') {
+    throw new Error('Cloud event lost its original task identity');
+  }
+  const metadata = value.metadata ?? {};
+  let message = text(value.content), phase = String(metadata.stepId ?? 'workflow');
+  if (message === 'Cloud task accepted.') message = '已进入云端沙箱，正在分配沙箱任务';
+  else if (message === 'Cloud workflow started.') message = '云端沙箱任务已分配';
+  else if (message === 'Cloud model classification started.') message = '云端沙箱正在思考中';
+  else if (message === 'Task classification completed.') message = '云端沙箱思考正在输出';
+  const event = { schemaVersion: 'entrorove.ide-event/1.0',taskId,eventId: value.id,kind: value.kind,
+    state: metadata.state ?? 'running',phase,message,separateLine: true };
+  if (metadata.requiresUserInput === true || phase === 'confirm' && event.state === 'pending') event.requiresConfirmation = true;
+  if (typeof metadata.summary === 'string' && metadata.summary !== value.content
+    && value.content !== 'Cloud model classification started.') event.detail = text(metadata.summary);
+  if (value.kind === 'notice' && metadata.url !== undefined) {
+    let url;
+    try { url = new URL(metadata.url); } catch { throw new Error('Cloud promotion link is invalid'); }
+    if (url.protocol !== 'https:' || url.username || url.password) throw new Error('Cloud promotion requires a public HTTPS link');
+    event.url = url.href;
+    event.message = `[${message.replace(/[\\[\]]/gu, '\\$&')}](<${url.href}>)`;
+  }
+  return event;
+}
+export function invocationIdeNotices(output) {
+  const strings = [output?.message,output?.result?.message,
+    ...(Array.isArray(output?.progress) ? output.progress.filter(item => item.kind === 'notice').map(item => item.summary) : [])];
+  return [...new Set(strings.filter(value => typeof value === 'string').flatMap(value => value.split(/\r?\n/u))
+    .filter(value => value === '智能执行中，请勿关闭！' || /^【[^\n】]{1,32}】/u.test(value)).map(text))];
+}
+export function presentInvocationNotices(result, sink) {
+  const messages = invocationIdeNotices(result?.output);
+  for (const message of messages) displayIdeEvent({ schemaVersion: 'entrorove.ide-event/1.0',
+    requestId: result.output.requestId,kind: 'notice',message,separateLine: true },sink);
+  if (result?.feedback) {
+    const event = automaticFeedbackIdeEvent(result.feedback);
+    messages.push(event.message); displayIdeEvent(event,sink);
+  }
+  return messages.length ? { ...result,ideMessages: messages } : result;
+}
+export function automaticFeedbackIdeEvent(feedback) {
+  const disposition = feedback.evaluation.disposition;
+  const status = disposition === 'good' ? '当前调用验证通过' : disposition === 'bad'
+    ? '当前调用被阻断或验证失败' : '交付验证尚未完成，暂不评分';
+  return { schemaVersion: 'entrorove.ide-event/1.0',requestId: feedback.requestId,receiptId: feedback.receiptId,
+    kind: 'evaluation',phase: 'feedback',disposition, message: `本次调用评价已回传至服务器：${status}。`,separateLine: true };
+}

package/local-autocoord17-controller.mjs

@@ -67,15 +67,17 @@ export async function coordinateLocalPeer17(rawInput) {
     return scanIntent17(fresh.state, current, intent, await physicalPeers17(current));
   });
 }
-export async function statusLocalPeer17(rawInput) {
+export async function statusLocalPeer17(rawInput, options = {}) {
   const input = input17(rawInput, ['intentId']); await storageBinding(input);
-  return withCoordination17(input, 'peer-status', async loaded => {
+  const observe = async loaded => {
     const task = coordTask17(loaded.state, input), intent = loaded.state.intents.find(value => value.intentId === input.intentId && value.taskId === task.taskId);
     if (!intent) coordFail17('ENTROROVE_COORD_INTENT_BINDING', 'peer status must name its original task intent');
     await coordNative17(task.material, false);
     const view = scanIntent17(loaded.state, task, intent, await physicalPeers17(task));
-    return { ...view, spawnRequest: loaded.state.spawnRequests.find(value => value.spawnRequestId === view.spawnRequestId) ?? null };
-  });
+    return { ...view, ...(options.readOnly ? { readOnly: true, sequence: loaded.sequence, head: loaded.head } : {}),
+      spawnRequest: loaded.state.spawnRequests.find(value => value.spawnRequestId === view.spawnRequestId) ?? null };
+  };
+  return options.readOnly ? observe(await readCoordination17(input)) : withCoordination17(input, 'peer-status', observe);
 }
 export async function completeLocalPeer17(rawInput) {
   const input = input17(rawInput, ['intentId']); await storageBinding(input);

package/local-cli.mjs

@@ -1,4 +1,5 @@
 import { withLocalInvocation } from './local-invocations.mjs';
+import { readLocalPeerStatus } from './local-peer-status.mjs';
 import { peerCoordinate, spawnBind, completePeer, verifyCoordinationLease } from './local-swarm.mjs';
 import { attestMutationSnapshot14 } from './local-mutation-binding.mjs';
 import { recordMutationDenied14 } from './local-mutation-audit.mjs';
@@ -42,6 +43,7 @@ const operations = {
   'budget-extend': budgetExtend, 'peer-coordinate': peerCoordinate, coordinate: peerCoordinate,
   'spawn-bind': spawnBind, 'peer-complete': completePeer, complete: completePeer,
   'lease-verify': verifyCoordinationLease,
+  'peer-status': readLocalPeerStatus,
   'evidence-sign': signEvidence, 'evidence-verify': verifyEvidence, 'merge-verified': mergeVerified,
   rollback, 'merge-freeze': prepareMergeArtifacts, 'merge-preflight': produceMergeArchguardPreflight,
   'merge-journal-head': produceMergeJournalHead, 'final-gate': finalGate,

package/local-peer-status.mjs

@@ -0,0 +1,6 @@
+import { peerStatus } from './local-swarm.mjs';
+import { statusLocalPeer17 } from './local-autocoord17-controller.mjs';
+
+export function readLocalPeerStatus(input) {
+  return Object.hasOwn(input, 'coordinationHome') ? statusLocalPeer17(input, { readOnly: true }) : peerStatus(input);
+}

package/local-swarm-contracts.mjs

@@ -33,9 +33,12 @@ const spawn = object({ ...common, priority, parentWorkerId: nullable(text) }, [.
 const complete = object({ ...common, status: enumeration(['completed', 'failed', 'blocked']),
   approvalPath: nullable(text), signerConfigPath: nullable(text) }, required);
 const verify = object(common, [...required, 'paths']);
+const peerQuery = object({ ...common, intentId: sha256, priority, workerCount: integer(0, 50) }, required);
+const coordinationQuery = exact({ repositoryRoot: text, coordinationHome: text, taskId: id, agentId: id, chainId: id, intentId: id });
 export const SWARM_LOCAL_OPERATION_SCHEMAS = Object.freeze({
   'peer-coordinate': coordinate, coordinate, 'spawn-bind': spawn,
   'peer-complete': complete, complete, 'lease-verify': verify,
+  'peer-status': { oneOf: [peerQuery, coordinationQuery] },
 });
 // Capture the authority before verification; the gate must verify this exact
 // binding before signing it into the existing pass. This never issues a grant.

package/local-swarm.mjs

@@ -8,7 +8,7 @@ import { withStateLock } from './local-state-lock.mjs';
 import { withTaskHandoffIssueFence, withTaskHandoffReadFence } from './local-task-handoff-fence.mjs';
 import { captureSwarmCompletion, captureSwarmOwnershipCompletions, revalidateSwarmCompletion } from './local-swarm-completion.mjs';
 import { claimSwarmWriteIntent, closeSwarmWriteIntent, readSwarmCheckpointRequests,
-  registerSwarmWriteIntent, validateSwarmWriteIntents } from './local-swarm-priority.mjs';
+  readSwarmWriteIntentHistory, registerSwarmWriteIntent, validateSwarmWriteIntents } from './local-swarm-priority.mjs';
 
 function fail(code, message, details = {}) { throw Object.assign(new Error(message), { code, ...details }); }
 function freshState(authority) {
@@ -173,6 +173,37 @@ async function operate(rawInput, operation) {
     }));
   });
 }
+
+export async function peerStatus(input) {
+  const original = await readSwarmCloudAuthority(input, 'report');
+  const storage = await swarmStorage(original, 'read');
+  return withStateLock(storage.ownershipFile, () => withStateLock(storage.stateFile, async () => {
+    const authority = await readSwarmCloudAuthority(input, 'report');
+    const ownership = await validateSwarmOwnership(await readSwarmOwnership(storage, authority, 'read'), authority);
+    const { index, verified } = await readSwarmWriteIntentHistory(ownership, authority);
+    const state = validateStoredWorkers(await readSwarmJson(storage.stateFile, null), authority);
+    const intentId = sha256(canonical(input.delegationGrant));
+    if (input.intentId !== undefined && input.intentId !== intentId) fail('ENTROROVE_SWARM_INTENT_BINDING', 'status must query the original signed intent');
+    const intent = index.intents.find(value => value.intentId === intentId);
+    if (!intent || !verified.has(intentId)) fail('ENTROROVE_SWARM_INTENT_BINDING', 'the original peer intent has not been coordinated');
+    const worker = state.workers.find(value => value.workerId === authority.grant.workerId && value.leaseId === authority.lease.leaseId);
+    if (worker && worker.grantDigest !== intentId) fail('ENTROROVE_SWARM_LEASE_INVALID', 'worker no longer matches the original intent');
+    const expired = Date.parse(intent.expiresAt) <= Date.now();
+    const conflicting = ownership.records.filter(value => value.grantDigest !== intentId);
+    const blockedPaths = intent.paths.filter(target => conflicting.some(value => value.paths.some(candidate =>
+      candidate === target || candidate.startsWith(`${target}/`) || target.startsWith(`${candidate}/`))));
+    const checkpoints = index.checkpointRequests.filter(value => value.targetGrantDigest === intentId);
+    await readSwarmCloudAuthority(input, 'report');
+    return { schemaVersion: 'entrorove.local-execution/1.0', status: 'reported', readOnly: true,
+      flowId: authority.plan.flowId, taskId: authority.grant.taskId, workerId: authority.grant.workerId,
+      leaseId: authority.lease.leaseId, intentId, intentStatus: intent.status,
+      executionStatus: expired && worker?.status === 'active' ? 'expired' : worker?.status ?? (expired ? 'expired' : 'waiting'), expiresAt: intent.expiresAt,
+      priority: intent.priority, paths: [...intent.paths], blockedPaths,
+      readyPaths: intent.paths.filter(target => !blockedPaths.includes(target)),
+      checkpointRequests: checkpoints.map(value => ({ requestId: value.requestId, paths: value.paths, reason: value.reason })),
+      leaseActive: !expired && worker?.status === 'active', writeAuthorized: false, taskCompletionVerified: false };
+  }));
+}
 export async function peerCoordinate(input) { return operate(input, 'coordinate'); }
 export async function spawnBind(input) { return operate(input, 'spawn'); }
 export async function completePeer(input) { return operate(input, 'complete'); }

package/manifest.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": "entrorove.skill-manifest/1.0",
   "name": "entrorove",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "endpoint": "https://entrorove.com",
   "requestSchemaVersion": "entrorove.skill.request/2.0",
   "supportedRequestSchemaVersions": [

package/native-client.mjs

@@ -0,0 +1,58 @@
+import Ajv from 'ajv';
+import { canonical, sha256 } from './local-integrity.mjs';
+import { postInvocation } from './remote-client.mjs';
+import { presentInvocationNotices } from './ide-presentation.mjs';
+import { trustedOrigin } from './remote-transport.mjs';
+
+const domains = new Set(['aimlock', 'blueprint', 'calctool', 'swarm', 'validator', 'mergeguard', 'archguard', 'confirm-protocol']);
+const runtimeCodes = { aimlock: 'R3mQ8kWpXn', blueprint: 'wvz6zmRWmX', calctool: 'KKyA6xljUX', swarm: 'zj7fTPVh4p',
+  validator: 'Xx9ZkQmW3p', mergeguard: 'Mm7GnPqR2v', archguard: 'Ag4Ch8Rd2K', 'confirm-protocol': 'Cf8Pr7Tm2Q' };
+export function buildNativeInvocation(domain, operation, input, origin = 'https://entrorove.com') {
+  if (!domains.has(domain) || typeof operation !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(operation)
+    || !input || typeof input !== 'object' || Array.isArray(input)) throw new Error('Invalid native domain, operation or input');
+  const requestId = sha256(`${domain}:${operation}:${canonical(input)}`);
+  const body = { schemaVersion: `${domain}.skill.request/${domain === 'aimlock' ? '1.1' : '1.0'}`, requestId, operation, input };
+  const runtimeCode = runtimeCodes[domain];
+  const transport = { flowId: `native:${runtimeCode}`, operation,
+    payload: { schemaVersion: 'entrorove.native-request-transport/1.0', runtimeCode, request: body } };
+  return { url: `${trustedOrigin(origin)}/api/skills/${domain}/invoke`, requestId, body,
+    feedbackHashes: [sha256('continue' + canonical(transport)), sha256(operation + canonical(input))] };
+}
+function discoveredContract(output, operation) {
+  const payload = output.output ?? output;
+  const capabilities = payload.capabilities ?? payload;
+  const operations = capabilities.operations ?? capabilities.operationStatus?.implementedPure;
+  const schemas = payload.operationSchemas ?? capabilities.operationSchemas;
+  const schema = Array.isArray(schemas) ? schemas.find(value => value.operation === operation) : schemas?.[operation];
+  if (!operations?.includes(operation) || !(schema?.input ?? schema?.inputSchema)) throw new Error(`Native capability does not support ${operation}`);
+  return schema.input ?? schema.inputSchema;
+}
+export async function invokeNativeResult(domain, operation, input, dependencies) {
+  const { home } = dependencies;
+  await dependencies.install();
+  if (!await dependencies.agreementAccepted(home)) throw Object.assign(new Error('Entrorove agreement requires explicit acceptance'),
+    { interaction: dependencies.agreementRequired(home) });
+  const call = buildNativeInvocation(domain, operation, input, dependencies.apiOrigin());
+  const token = await dependencies.readCredential(home);
+  let feedbackRequired = operation !== 'capabilities';
+  if (operation !== 'capabilities') {
+    const discovery = await postInvocation(buildNativeInvocation(domain, 'capabilities', {}, dependencies.apiOrigin()), token, home);
+    if (!discovery.response.ok || discovery.result.output.status !== 'succeeded') throw new Error('Native capability discovery failed');
+    const found = discovery.result.output;
+    const extension = (found.capabilities ?? found).responseExtensions;
+    if (extension?.automaticFeedback === 'entrorove.automatic-feedback/1.0') feedbackRequired = !extension.automaticFeedbackObservations.includes(operation);
+    const ajv = new Ajv({ strict: true, strictRequired: false, allErrors: true });
+    ajv.addKeyword({ keyword: 'optional', schemaType: 'boolean', valid: true });
+    ajv.addFormat('uuid', /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+    ajv.addFormat('date-time', value => Number.isFinite(Date.parse(value)));
+    const validate = ajv.compile(discoveredContract(discovery.result.output, operation));
+    if (!validate(input)) throw new Error(`Invalid native ${operation} input: ${ajv.errorsText(validate.errors)}`);
+  }
+  return postInvocation(call, token, home, feedbackRequired);
+}
+export async function runNative(domain, operation, input, dependencies) {
+  const { response, result } = await invokeNativeResult(domain, operation, input, dependencies);
+  process.stdout.write(`${JSON.stringify(presentInvocationNotices(result, dependencies.onIdeEvent))}\n`);
+  if (!response.ok || ['blocked', 'failed', 'incomplete'].includes(result.output.status)) process.exitCode = 2;
+  return result;
+}

package/native-notification.mjs

@@ -0,0 +1,76 @@
+import { execFile } from 'node:child_process';
+import { constants, promises as fs } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { sha256 } from './local-integrity.mjs';
+import { readCredential } from './local-credential.mjs';
+import { withStateLock } from './local-state-lock.mjs';
+
+const messageKinds = { confirmed: '任务需要你确认。', failed: '任务执行失败，请查看 IDE 中的状态。',
+  blocked: '任务已阻断，请查看 IDE 中的所需操作。',
+  reported: '任务输出已生成，请查看 IDE 中的结果。', verified: '任务验证已完成。', test: 'Entrorove 系统通知测试。' };
+function controls(home) { return path.join(home, '.entrorove', 'notifications.json'); }
+async function readControls(home) {
+  const file = controls(home);
+  let stat;
+  try { stat = await fs.lstat(file); } catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  if (!stat.isFile() || stat.isSymbolicLink() || process.getuid && stat.uid !== process.getuid()
+    || process.platform !== 'win32' && stat.mode & 0o077) throw new Error('Notification settings must be private');
+  const handle = await fs.open(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const state = JSON.parse(await handle.readFile('utf8'));
+    if (state.schemaVersion !== 'entrorove.native-notifications/1.0' || typeof state.enabled !== 'boolean'
+      || !/^[a-f0-9]{64}$/.test(state.accountBinding) || !Array.isArray(state.seen) || state.seen.length > 100) throw new Error('Invalid notification settings');
+    return state;
+  } finally { await handle.close(); }
+}
+async function saveControls(home, state) {
+  const file = controls(home), temp = `${file}.tmp-${process.pid}`;
+  await fs.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+  try { await fs.writeFile(temp, JSON.stringify(state) + '\n', { flag: 'wx', mode: 0o600 }); await fs.rename(temp, file); }
+  finally { await fs.rm(temp, { force: true }); }
+}
+export async function notificationSettings(home = os.homedir()) {
+  const state = await readControls(home), binding = sha256(await readCredential(home));
+  return { enabled: state?.enabled === true && state.accountBinding === binding,
+    platform: process.platform, accountBound: Boolean(state && state.accountBinding === binding) };
+}
+export async function configureNativeNotifications(input, home = os.homedir()) {
+  if (!input || Object.keys(input).length !== 1 || typeof input.enabled !== 'boolean') throw new Error('Expected {enabled:boolean}');
+  const state = { schemaVersion: 'entrorove.native-notifications/1.0', enabled: input.enabled,
+    accountBinding: sha256(await readCredential(home)), seen: [] };
+  await withStateLock(controls(home), () => saveControls(home, state));
+  return notificationSettings(home);
+}
+export async function sendNativeNotification(kind, { platform = process.platform, execute = execFile } = {}) {
+  const message = messageKinds[kind];
+  if (!message) throw new Error('Invalid notification kind');
+  let file, args;
+  if (platform === 'darwin') {
+    file = '/usr/bin/osascript';
+    args = ['-e', 'on run argv\ndisplay notification (item 1 of argv) with title "Entrorove"\nend run', message];
+  } else if (platform === 'linux') { file = 'notify-send'; args = ['--app-name=Entrorove', 'Entrorove', message]; }
+  else throw new Error('Native notifications require macOS or a Linux notification service; this platform is unsupported');
+  await new Promise((resolve, reject) => execute(file, args, { timeout: 5000, windowsHide: true }, error => {
+    if (error) reject(new Error('System notification command failed; check OS notification permissions'));
+    else resolve();
+  }));
+  return { submitted: true, displayVerified: false };
+}
+export async function notifyIdeEvent(event, { home = os.homedir(), send = sendNativeNotification } = {}) {
+  const kind = event.requiresConfirmation && event.kind !== 'notice' ? 'confirmed'
+    : event.kind === 'evaluation' ? event.disposition === 'bad' ? 'failed' : null
+    : event.state === 'blocked' ? event.requiresConfirmation ? 'confirmed' : 'blocked'
+      : event.phase === 'workflow' && ['reported', 'verified', 'failed'].includes(event.state) ? event.state : null;
+  if (!kind || event.kind === 'notice') return { submitted: false };
+  const id = event.taskId ?? event.requestId;
+  if (typeof id !== 'string' || !/^[A-Za-z0-9._:-]{1,128}$/.test(id)) return { submitted: false };
+  return withStateLock(controls(home), async () => {
+    const state = await readControls(home);
+    if (!state?.enabled || state.accountBinding !== sha256(await readCredential(home))) return { submitted: false };
+    const key = sha256(`${id}:${kind}`);
+    if (state.seen.includes(key)) return { submitted: false, duplicate: true };
+    state.seen = [...state.seen.slice(-99), key]; await saveControls(home, state);
+    return send(kind);
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@entrorove/skill",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "type": "module",
   "bin": {
     "entrorove": "cli.mjs"
@@ -24,6 +24,7 @@
     "local-swarm-state.mjs",
     "local-swarm-storage.mjs",
     "local-swarm.mjs",
+    "local-peer-status.mjs",
     "local-autocoord17-authority.mjs",
     "local-autocoord17-controller.mjs",
     "local-autocoord17-peers.mjs",
@@ -78,6 +79,10 @@
     "remote-client.mjs",
     "scope-runner-client.mjs",
     "cloud-task-client.mjs",
+    "cloud-watch-client.mjs",
+    "cloud-event-stream.mjs",
+    "ide-presentation.mjs",
+    "automatic-feedback-client.mjs",
     "remote-transport.mjs",
     "local-credential.mjs",
     "local-invocations.mjs",
@@ -185,7 +190,9 @@
     "local-final-gate16-state.mjs",
     "local-final-gate16-proof.mjs",
     "local-final-gate16-contract.mjs",
-    "local-final-gate16-release.mjs"
+    "local-final-gate16-release.mjs",
+    "native-client.mjs",
+    "native-notification.mjs"
   ],
   "scripts": {
     "test": "node --test --test-concurrency=1 test/*.test.mjs",

package/release-state.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": "entrorove.release-state/1.0",
-  "version": "0.1.33",
-  "digest": "79b9167ef252402e374202c08093e75e98fe3bf41227a53f34a44fa757834fe2",
+  "version": "0.1.35",
+  "digest": "a6c953df9972ceb589a3e0bbbd057a3db5fb30f6811962d6c984a8d2cf827f83",
   "files": {
     "local-final-gate16.mjs": "b30caab08441449ad556a6e9a3cefbf91190f0b3f7370f46d2a21156375aa8e3",
     "local-final-gate16-checks.mjs": "1dd30e9666d458d8b12ca6e4975f6f0ac8450c3ea9cbecc7401ae037f66b589a",
@@ -30,30 +30,30 @@
     "local-swarm-authority.mjs": "3d4c149b82c465a81419da40e6edd93c88e68af7bc5aa09c76aac6516c4596eb",
     "local-swarm-baseline.mjs": "e6c22f2ab0876ce43296147ae255343e37f728aac80afd4adb5e58cfc022b7d5",
     "local-swarm-completion.mjs": "2ade4ebe7e7612a22630784c82a33b982143aa56243e7d006f2b3f96d8c5368b",
-    "local-swarm-contracts.mjs": "f2019b48cade9a55ef52d31d2116ea8941b10e01b94ef08bc14031b5cc179cf7",
+    "local-swarm-contracts.mjs": "f9fd409ab76da0a2ed0bee8a918fdd250b9368840ef0f5e797db6d1cc7dde0f6",
     "local-swarm-mutation.mjs": "15b8d0c4c4ea5bd17b4653d84968fc02252d9ccdca2b137ec71b0f08717f90f5",
     "local-swarm-priority.mjs": "7dc595177f6bcfadc83457e9603edcd731758bfe42e5d517e156610e2cddd732",
     "local-swarm-state.mjs": "ff84c5f35ef3e4a0ad9887d145e404f5786ae0dc92496116699d031b98e90c6a",
     "local-swarm-storage.mjs": "4b506481913fe22769f47a14a024a2cc4c0f1e986bb52ef606d14c7844226086",
-    "local-swarm.mjs": "94b5adde0239cc21bada288886482934d409f4383d31076025437ed621ef43b6",
+    "local-swarm.mjs": "8bb6e22f96b7677be9cc24e7fbbd11dfea331d6d607868ebaa3399f8a519782b",
     "local-autocoord17-authority.mjs": "86b79798f6019523b1260b819622070a5b0d39670f607da930fb6923259dff1d",
-    "local-autocoord17-controller.mjs": "1307c4decf8dc98a447e4072d27f69caec64149f8d48545c84ef7cc50a561777",
+    "local-autocoord17-controller.mjs": "ada914d07d8773e2eb1fb45a35378effd00def697eeb37f209c81834880a2e4b",
     "local-autocoord17-peers.mjs": "103d6a6634bbd3b4b850c5db7b571e3f05736b94e59a8fd7da63741281c903a4",
     "local-autocoord17-store.mjs": "b48847a4a40c3aeb16bc1431b6a16221fb5ffdc0a6ba5c263acf196279d80ed1",
     "local-autocoord17-tasks.mjs": "44b9f2d326ab3060c36657685b48b50a98711644e5baf47d4e8cb72c4c45f2a7",
     "local-autocoord17-waits.mjs": "2b0a713987822548a94e1ed3a9a891532db45383797dfc5d5bc8d1e35593cf25",
     "local-validator-isolation17.mjs": "48e94604e28b8fddd567dfb35ff60b73fd094a5803bd49f076388b7f310f92aa",
     "local-calctool-composition17.mjs": "ac89fcb41ab0d0d9b47c1b5696945281b0894eb064820775e36a011c76314e6a",
-    "cli.mjs": "d06e372e7f54f726b700b0d909669616c5f35aa7eaa6c67c008d0670ac18678a",
+    "cli.mjs": "f0a3104ef9f4431ded2a7049c08ae6435b09ed53c4cba486c2bd52db2728d999",
     "review-client.mjs": "3491eef68ed533174b31db3c53febb6519b8f088f71a9964644714a9a4c03c77",
     "version.mjs": "1f392147d72c40af4b03b307ea607075fb815af5174fa07e254b95fe12dbf3e7",
-    "SKILL.md": "726140d61da8561a6a87ff818931964994ad5356c56c45afeb6b5133609697ab",
-    "CAPABILITY-MAP.md": "4b8479928481289b82540ff2624ebb16d1f0a5b6697b6eec52d2d459f86a0001",
+    "SKILL.md": "ffea399b940f9eedd82d2c5e2f9b3bce606f47b27020c2c1b3c8b128e3a2161a",
+    "CAPABILITY-MAP.md": "8e1d007d594ae82dd77f89842cf1aa8d17db56f9cac98691759390c28162d848",
     "AGREEMENT.md": "f93a68e92c457200dd024610e65f74e478b8f60860f951da818b70561f1b9bf8",
-    "package.json": "2afd7c74c464da6f8fa7dfa58d465104e77c1d332ec2b4adb17a8df518b0d3ba",
+    "package.json": "9a7f12414556bcc150d57e64881694aeddfe0b760e98454491ac5a6585ed0421",
     "manifest.json": "ab06e307795bc9da5add926752b6c4dbdaf18625090261a035aa356a679c504f",
-    "release.mjs": "e33a80cb7463f4db532af18d26880b198de637d376ce1952d751668bbd8df44d",
-    "local-cli.mjs": "a79037d7383a29822b465e6db1c862a43d47cc344f05b6651c849633c49d19f7",
+    "release.mjs": "eca6032eae240fb90c7646e0b1509ea6b4c94c23b90aca87e4091996c5b9b5f8",
+    "local-cli.mjs": "9eca8aefcb086cdce792105f9558cc26e34a0c88befaf0a56f4c7bdbd35f0a05",
     "local-state-lock.mjs": "1dbf64264642a0851faf043e07ee9f66d2ad0508e9f799b0626246e42fae893e",
     "local-execution.mjs": "cdada6df6dc8831cebb58a629b56c4b3f8e1bf9aae4e3fdc121521ba20839383",
     "local-integrity.mjs": "4f325376e536999c3b00245f66aac9ef1ae762c33012b363c231622008f72805",
@@ -118,9 +118,16 @@
     "local-scope-state.mjs": "8b600a91fc0068d7a8c0bb752ddba7ed30ada93daafb118d6cba2368fd94cb27",
     "local-scope-workspaces.mjs": "a44c34537e5ed2dcaf193a985e5bc05957989fbb160a650f9e37ba7d66eb2de8",
     "local-task-routing.mjs": "e26d6f1ba134ffe1da2a49b4fb6bb6dfa5617671f774a08e719d04f202cf5eca",
-    "remote-client.mjs": "6df222e3e55a893fda2aa7a15feb545db5ff9d74e33025a1b0e3f03b849f5d14",
-    "cloud-task-client.mjs": "d519e2c020e19a67e8c6e32d2da39bc3fa45538b773e7baf02605505d065daaf",
-    "scope-runner-client.mjs": "940c841e2c56e92793e5bf65e713bf4087151f721d0ecb659e0a75d6fdefeab9",
+    "remote-client.mjs": "f676d17c867e9abd59943528a7716d444a0cf2fa637d48a1e397cbce9f37c640",
+    "cloud-task-client.mjs": "ecb6124ea5e6249f31fb95cb68d13d821d2daea8768fe47ddf6dcf82fc3392cc",
+    "scope-runner-client.mjs": "646ab4f80d4a8209e922fd45f40efd968f0744d9dfc03188b222c1a2e11e83b8",
+    "native-client.mjs": "d0f8a52e1195dd72ba0ae1febe25f0d6c37eff6ecf010e568935cacdf3c975bb",
+    "native-notification.mjs": "f116772178140d1a2a7aac4a8e361a76543b1f47c84b3823a26a797f11a8bfbb",
+    "local-peer-status.mjs": "a971bcc69d60bb32b875ca5bb4297d948631d5d2821b812c279613ea059a8b4f",
+    "cloud-watch-client.mjs": "bfbe636c10af467855776f9d29008d9ce13420b66bcc91b5bf8f6ef79fb2aefe",
+    "cloud-event-stream.mjs": "e0eec9fc3e0613094523929634f25030df5ca5c5b5fe2c1e1a4586ab10574808",
+    "ide-presentation.mjs": "dcf4efaa546a35752247a64dc4a6d0c0feaf7c3c2c8222330288b1202c0484f9",
+    "automatic-feedback-client.mjs": "eeedc0344f91603ff8523fdbc43569a561ed10fec4178cc898db6d61f7663246",
     "remote-transport.mjs": "5e5a8c0b490371f7f5a052cffbeee6202d4cf713dff1c43b6d910fe944f8429c",
     "local-credential.mjs": "2a302a7f67b5ea8dc73453fc96ab33db349b59ca11fa9456e48ca1d9669d877c",
     "local-invocations.mjs": "f6ac4c41c1a5ec34de358c4cca210ca8e403b3a913150a43bb55ec9be55d9998",

package/release.mjs

@@ -92,6 +92,8 @@ const sourceFiles = [
   'local-scope-workspaces.mjs',
   'local-task-routing.mjs', 'remote-client.mjs', 'cloud-task-client.mjs',
   'scope-runner-client.mjs',
+  'native-client.mjs', 'native-notification.mjs', 'local-peer-status.mjs',
+  'cloud-watch-client.mjs', 'cloud-event-stream.mjs', 'ide-presentation.mjs', 'automatic-feedback-client.mjs',
   'remote-transport.mjs', 'local-credential.mjs', 'local-invocations.mjs',
   'local-task-handoff-fence.mjs',
   'local-task-handoff-storage.mjs', 'local-task-handoff-overlay-wire.mjs', 'local-task-handoff-completion-wire.mjs',
@@ -351,9 +353,16 @@ function releaseLabels() {
     'workflow-local-client.mjs': { zh: '工作流真实执行授权', en: 'workflow actual execution authorization' },
     'workflow-local-request.mjs': { zh: '工作流原执行请求恢复', en: 'workflow original execution request recovery' },
     'remote-client.mjs': { zh: '远端恢复客户端', en: 'remote recovery client' },
+    'native-client.mjs': { zh: '八域原生调用与评价核验', en: 'Eight-domain native invocation and evaluation verification' },
+    'native-notification.mjs': { zh: '账号独立的可选系统通知', en: 'Optional account-bound system notifications' },
+    'local-peer-status.mjs': { zh: '协作任务状态只读入口', en: 'Read-only coordination task status entry' },
     'task-message-entry.mjs': { zh: '任务消息实际投递入口', en: 'task message host delivery entry' },
     'task-message-cli.mjs': { zh: '任务消息命令与适配器', en: 'task message command and adapter' },
     'cloud-task-client.mjs': { zh: '云端沙箱任务路由与逐任务选择', en: 'cloud sandbox task routing and per-task choice' },
+    'cloud-watch-client.mjs': { zh: 'IDE 实时云端进度与推广展示', en: 'live IDE cloud progress and promotion display' },
+    'cloud-event-stream.mjs': { zh: 'IDE 实时云端进度与推广展示', en: 'live IDE cloud progress and promotion display' },
+    'ide-presentation.mjs': { zh: 'IDE 实时云端进度与推广展示', en: 'live IDE cloud progress and promotion display' },
+    'automatic-feedback-client.mjs': { zh: '原调用自动评价回执核验', en: 'original invocation automatic evaluation receipt verification' },
   })
 }
 

package/releases.json

@@ -1,4 +1,16 @@
 [
+  {
+    "version": "0.1.35",
+    "date": "2026-10-13",
+    "zh": "新增协作状态查询、Aimlock 专用规划与八域原生调用；接入账号和设备隔离的任务通知，修复失败接续的评价回执冲突，并完善范围门禁接续。",
+    "en": "Add read-only peer status, Aimlock planning and native invocation across eight domains; support account/device-bound task notifications, preserve feedback receipts across authorized retries, and correct scope-gate continuation."
+  },
+  {
+    "version": "0.1.34",
+    "date": "2026-10-12",
+    "zh": "完善 IDE 云端规划选择、实时执行进度与独立推广提示；服务端自动评价绑定原调用并返回可核验回执，支持只读恢复；修复 UUID 调用用量统计，保持账号隔离及沙箱／调用计数分离。",
+    "en": "Improve IDE cloud planning choices, live execution progress and separate promotion notices. Bind automatic server evaluations to their original invocations with verifiable receipts and read-only recovery; correct UUID invocation usage while keeping accounts and skill/sandbox counters separate."
+  },
   {
     "version": "0.1.33",
     "date": "2026-10-12",

package/remote-client.mjs

@@ -2,6 +2,8 @@ import { createHash } from 'node:crypto';
 import Ajv from 'ajv';
 import { parseTransportResponse, requestTransport, trustedOrigin } from './remote-transport.mjs';
 import { appendInvocation } from './local-invocations.mjs';
+import { verifyAutomaticFeedback } from './automatic-feedback-client.mjs';
+import { ideClientHeaders, presentInvocationNotices } from './ide-presentation.mjs';
 
 export const apiUrl = 'https://entrorove.com/api/skill/invoke';
 
@@ -39,6 +41,11 @@ export function buildInvocation(operation, input) {
   const id = requestId(operation, input);
   return { url: apiUrl, requestId: id, body: { schemaVersion: 'entrorove.skill.request/2.0', requestId: id, operation, input } };
 }
+function requiresAutomaticFeedback(operation, input, capabilities) {
+  const actual = operation === 'continue' ? input.operation : operation;
+  return capabilities?.responseExtensions?.automaticFeedback === 'entrorove.automatic-feedback/1.0'
+    && !capabilities.responseExtensions.automaticFeedbackObservations?.includes(actual);
+}
 
 export function validateDiscoveredChecks(input, checks = []) {
   for (const check of checks) {
@@ -65,7 +72,7 @@ export async function invokeRemote(data, dependencies) {
   }
   const token = await readCredential(home);
   const { response, result } = await invokeDiscovered(data, token, { home, apiOrigin });
-  process.stdout.write(JSON.stringify(result) + '\n');
+  process.stdout.write(JSON.stringify(presentInvocationNotices(result,dependencies.onIdeEvent)) + '\n');
   if (!response.ok || result.output.status === 'blocked' || result.output.status === 'failed'
     || result.output.status === 'incomplete') process.exitCode = 2;
 }
@@ -76,20 +83,22 @@ export async function invokeRemoteResult(data, dependencies) {
 }
 async function invokeDiscovered(data, token, { home, apiOrigin }) {
   const call = { ...buildInvocation(data.operation, data.input), url: `${trustedOrigin(apiOrigin())}/api/skill/invoke` };
+  let feedbackRequired = false;
   if (data.operation !== 'capabilities') {
     const discovery = await postInvocation({ ...buildInvocation('capabilities', {}), url: call.url }, token, home);
     if (!discovery.response.ok || discovery.result.output.status !== 'succeeded') throw new Error(`Capability discovery failed: HTTP ${discovery.response.status}`);
     const capabilities = discovery.result.output.capabilities;
+    feedbackRequired = requiresAutomaticFeedback(data.operation,data.input,capabilities);
     const schema = capabilities?.operationSchemas?.[data.operation];
     if (!capabilities?.operations?.includes(data.operation) || !schema) throw new Error(`Capability discovery does not support ${data.operation}`);
     const validate = discoveredAjv().compile(schema);
     if (!validate(data.input)) throw new Error(`Invalid ${data.operation} input: ${validate.errors.map(error => `${error.instancePath || '/'} ${error.message}`).join('; ')}`);
     validateDiscoveredChecks(data.input, capabilities.inputChecks?.[data.operation]);
   }
-  return postInvocation(call, token, home);
+  return postInvocation(call, token, home,feedbackRequired);
 }
 
-async function postInvocation(call, token, home) {
+export async function postInvocation(call, token, home, feedbackRequired = false) {
   const metadata = { kind: 'remote', operation: call.body.operation, requestId: call.requestId };
   const logged = async value => {
     try { return await appendInvocation({ ...metadata, ...value }, home); }
@@ -98,9 +107,9 @@ async function postInvocation(call, token, home) {
   await appendInvocation({ ...metadata, event: 'started' }, home);
   let response; let result;
   try {
-    response = await requestTransport(new URL(call.url).origin, '/api/skill/invoke', {
+    response = await requestTransport(new URL(call.url).origin, new URL(call.url).pathname, {
       method: 'POST', timeoutMs: 135_000,
-      headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` }, body: JSON.stringify(call.body),
+      headers: { 'content-type': 'application/json', authorization: `Bearer ${token}`,...ideClientHeaders() }, body: JSON.stringify(call.body),
     });
   } catch (cause) {
     if (cause.established) await logged({ event: 'outcome-unknown' });
@@ -122,6 +131,14 @@ async function postInvocation(call, token, home) {
     await logged({ event: 'outcome-unknown' }); throw unknownInvocation(call.requestId);
   }
   await logged({ event: response.ok ? 'completed' : 'rejected', usage: result.usage ?? [] });
+  if (result.feedback) {
+    const expected = call.feedbackHashes ?? [call.requestId];
+    if (!expected.includes(result.feedback.requestHash)) throw new Error('Automatic feedback lost its original invocation binding');
+    verifyAutomaticFeedback(result.feedback,call.requestId,result.feedback.requestHash);
+  }
+  else if (feedbackRequired && !['running','pending'].includes(result.output.status)) {
+    throw new Error(`Automatic feedback receipt is missing; query feedback ${call.requestId}. Do not repeat the invocation.`);
+  }
   return { response, result };
 }
 
@@ -158,13 +175,16 @@ export function createTaskMessageClient(dependencies) {
     async invoke(operation, input) {
       const original = buildInvocation(operation, input);
       const token = await machineCredential(dependencies); const origin = machineOrigin(dependencies);
+      let feedbackRequired = false;
       if (operation !== 'capabilities') {
         const discovery = buildInvocation('capabilities', {});
         const discovered = await postInvocation({ ...discovery, url: `${origin}/api/skill/invoke` }, token, dependencies.home);
         if (!discovered.response.ok || discovered.result.output.status !== 'succeeded') throw new Error('Task message capability discovery failed');
         validateMachineCapability(operation, input, discovered.result.output.capabilities);
+        feedbackRequired = requiresAutomaticFeedback(operation,input,discovered.result.output.capabilities);
       }
-      const { response, result } = await postInvocation({ ...original, url: `${origin}/api/skill/invoke` }, token, dependencies.home);
+      const { response, result } = await postInvocation({ ...original, url: `${origin}/api/skill/invoke` }, token, dependencies.home,feedbackRequired);
+      presentInvocationNotices(result,dependencies.onIdeEvent);
       if (stoppedOriginalResume(response, result.output, operation, input)) return result.output;
       if (!response.ok || ['blocked', 'failed', 'incomplete'].includes(result.output.status)) {
         throw new Error(`Task message invocation was rejected: HTTP ${response.status}; requestId=${original.requestId}`);
@@ -178,6 +198,8 @@ export function createTaskMessageClient(dependencies) {
         { authorization: `Bearer ${token}` }, 'original task message status');
       const result = await readResponse(response, 'task message status');
       if (!response.ok || !result?.output || result.output.requestId !== id) throw new Error('Original task message status is unavailable or invalid');
+      if (result.feedback) verifyAutomaticFeedback(result.feedback,id);
+      presentInvocationNotices(result,dependencies.onIdeEvent);
       await appendInvocation({ kind: 'remote', operation: 'status', requestId: id, event: 'status', usage: result.usage ?? [] }, dependencies.home);
       return result.output;
     },
@@ -191,7 +213,8 @@ export async function queryStatus(requestId, dependencies) {
   const result = await readResponse(response, 'status');
   if (!response.ok || result?.output?.requestId !== requestId) throw new Error(`entrorove status failed: HTTP ${response.status}; requestId=${requestId}`);
   await appendInvocation({ kind: 'remote', operation: 'status', requestId, event: 'status', usage: result.usage ?? [] }, dependencies.home);
-  process.stdout.write(JSON.stringify(result) + '\n');
+  if (result.feedback) verifyAutomaticFeedback(result.feedback,requestId);
+  process.stdout.write(JSON.stringify(presentInvocationNotices(result,dependencies.onIdeEvent)) + '\n');
 }
 
 export async function queryFlows(dependencies) {

package/scope-runner-client.mjs

@@ -84,7 +84,8 @@ async function connect(identity, directory, dependencies) {
   const accepted = await remote('scope-runner-attest', { flowId: identity.flowId, attestation: observed.attestation }, dependencies);
   return { schemaVersion: 'entrorove.scope-connection/1.0', status: 'succeeded', flowId: identity.flowId,
     runnerId: binding.runnerId, scopeEvidence: accepted.scopeEvidence, grantsExecutionAuthority: false,
-    nextOperation: 'workflow-gate' };
+    nextOperation: 'workflow-gate', nextInput: { flowId: identity.flowId, operation: 'workflow-gate',
+      payload: { targetFiles: [...identity.targetPaths] } } };
 }
 export async function connectScopeRunner(repositoryRoot, input, dependencies) {
   if (!input || Object.keys(input).some(field => !['flowId', 'paths', 'importContexts'].includes(field))