@entrorove/skill 0.1.34 → 0.1.36

package/CAPABILITY-MAP.md

@@ -1,6 +1,19 @@
 # 能力对账图（WP-02 / AC-20）
 
-## 2026-10-12 补充：旧版八技能的 IDE 调用链
+## 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 保留其历史基线与当时测试边界。
 
@@ -10,13 +23,13 @@
 | 实际进度必须进入 IDE | `cloud-watch` 订阅本人任务 SSE，输出独立 IDE 事件；调用方必须把公开消息和摘要展示到对话进度 |
 | 执行提示与推广可见 | `智能执行中，请勿关闭！` 与服务端选中的真实推广独立输出；保留推广 HTTPS 链接，按事件 ID 去重 |
 | 断线恢复原任务 | `cloud-watch` 带原 `taskId/afterId` 只读续接；`status` 与 `feedback` 查询原请求，不重发业务 POST |
-| 服务端自动评价，无第二次评价写入 | 调用完成事务保存本人原 request 的评价与结果摘要；CLI 校验回执。旧式适配器使用幂等持久化并在同一 HTTP 响应返回 |
+| 调用结束立即确认评价回传 | 调用完成事务保存本人原 request 的评价与结果摘要；CLI 核验后立即回传原回执身份，服务端返回 IDE 接收确认，不重复写评价或计用量；只读恢复保留原执行代次 |
 | 未验证不可记好评 | intake、模型摘要、reported、不完整证据无评分；阻断、失败、P0/P1 不产生好评；发现和状态查询不生成新评价 |
 | 实际 IDE 与原调用绑定 | `ENTROROVE_IDE` 或宿主检测写入原调用标签；每个 OS 用户继续复用受限凭据存储 |
 | 最新官方技能说明生效 | 新调用使用 `npx --yes --prefer-online @entrorove/skill@latest`；安装更新后重新读取 managed `SKILL.md` |
 | 调用次数与沙箱次数分开 | 普通调用与旧式 UUID 记录技能用量；`cloud-task` 才创建沙箱。所有查询和评价按账号权限过滤 |
 
-自动技术评价是私有调用记录。公开用户评价仍须使用本人原话、真实评分和明确公开同意。原生系统通知、手机推送未实现；确认使用 IDE 问题工具或可见文本回退。思考详情只展示服务端公开的规划摘要。
+自动技术评价是私有调用记录。公开用户评价仍须使用本人原话、真实评分和明确公开同意。原生系统通知与手机推送已按 2026-10-13 的公开入口接入；通知权限由用户开启。确认继续遵循 IDE 的明确问题与答案。思考详情只展示服务端公开的规划摘要。
 
 本表把旧八域的远端公开操作与当前本地执行器分开统计。旧版 `SKILL.md` 只规定入口、状态和边界，没有逐域列出操作名；远端操作名采用随包锁定的 v2 runtime catalog 交叉核对，本地操作名直接来自 `local-contracts.mjs` 的 `LOCAL_OPERATION_SCHEMAS`。两个分母不能合并。
 
@@ -43,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 为准。
 
@@ -85,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,9 +1,19 @@
 # Changelog
 
+## 0.1.36 — 2026-10-13
+
+- 技能调用结束立即确认 IDE 评价回传，提供原账号、原调用与执行代次绑定的接收回执；完善原回执只读恢复与公开合同校验。
+- Confirmed IDE evaluation acknowledgements immediately after skill calls, bound reception receipts to the original account, invocation and generation, and improved read-only recovery and published contract validation.
+
+## 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 调用漏计用量，保持账号隔离及沙箱／调用计数分离。
-- Restore visible IDE cloud choice, authoritative live progress and separate promotion notices from the original eight-skill workflow. Persist account-bound automatic invocation evaluations with verifiable receipts and read-only recovery; meter legacy UUID calls without mixing skill and sandbox counters.
+- 完善 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.34.
+Version: 0.1.36.
 
 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.
 
@@ -53,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.
 
@@ -71,9 +75,19 @@ 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. Discovery/status queries create no evaluations.
+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; domain adapters return an idempotent receipt with the same HTTP response. The CLI verifies the original identity and evaluation digest, then immediately returns that exact receipt identity to the authenticated acknowledgement endpoint before finishing the call. Cloud watches do the same as soon as the original evaluation is available. A confirmed `acknowledgement` records the IDE and server reception time without changing the evaluation or counting another invocation. Preserve `receiptId`, `requestId` and `evaluation.digest`; never generate a score or comment locally. Immediately display the confirmed evaluation acknowledgement in visible IDE commentary before the task's final answer, deduplicated by receipt ID. Tool output alone is insufficient. Say “已回传” only with a confirmed acknowledgement; an upload failure must remain visible and cannot become successful feedback. 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.
 

package/automatic-feedback-client.mjs

@@ -12,7 +12,8 @@ export function verifyAutomaticFeedback(feedback, requestId, requestHash) {
   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) || !evaluation
+    || !/^[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)
@@ -32,12 +33,48 @@ export function verifyAutomaticFeedback(feedback, requestId, requestHash) {
   }
   return feedback;
 }
-export async function queryAutomaticFeedback(requestId, dependencies) {
+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);
-  const response = await requestTransport(trustedOrigin(dependencies.apiOrigin()),`/api/skill/feedback/${requestId}`,
+  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);
 }
+
+function confirmedAcknowledgement(value, original, expectedIde) {
+  verifyAutomaticFeedback(value,original.requestId,original.requestHash);
+  const ack = value.acknowledgement, generation = original.generation ?? 1;
+  if (value.receiptId !== original.receiptId || value.resultDigest !== original.resultDigest
+    || value.evaluation.digest !== original.evaluation.digest || (value.generation ?? 1) !== generation
+    || !ack || ack.schemaVersion !== 'entrorove.feedback-acknowledgement/1.0' || ack.stored !== true
+    || ack.receiptId !== original.receiptId || ack.requestId !== original.requestId || ack.generation !== generation
+    || typeof ack.ide !== 'string' || !/^[\p{L}\p{N} .+_-]{2,48}$/u.test(ack.ide)
+    || expectedIde && ack.ide !== expectedIde || !Number.isFinite(Date.parse(ack.receivedAt))) {
+    throw new Error(`IDE feedback is not confirmed; query feedback ${original.requestId}. Do not repeat the invocation.`);
+  }
+  return value;
+}
+
+export async function acknowledgeAutomaticFeedback(feedback, origin, token, ideHeaders) {
+  verifyAutomaticFeedback(feedback,feedback.requestId,feedback.requestHash);
+  if (feedback.acknowledgement) return confirmedAcknowledgement(feedback,feedback);
+  const route = `/api/skill/feedback/${feedback.requestId}`;
+  const headers = { authorization: `Bearer ${token}`,...ideHeaders };
+  let response;
+  try {
+    response = await requestTransport(trustedOrigin(origin),`${route}/ack`, { method: 'POST',
+      headers: { ...headers,'content-type': 'application/json' },body: JSON.stringify({ receiptId: feedback.receiptId,
+        requestHash: feedback.requestHash,resultDigest: feedback.resultDigest,evaluationDigest: feedback.evaluation.digest,
+        generation: feedback.generation ?? 1 }) });
+  } catch (cause) {
+    if (!cause.established) throw new Error(`IDE feedback was not sent; query feedback ${feedback.requestId}. Do not repeat the invocation.`);
+    // A lost acknowledgement response is recovered only by reading this
+    // immutable receipt. Neither the execution nor its acknowledgement POST is replayed.
+    response = await requestTransport(trustedOrigin(origin),`${route}?generation=${feedback.generation ?? 1}`, { headers });
+  }
+  if (!response.ok) throw new Error(`IDE feedback acknowledgement failed: HTTP ${response.status}; query feedback ${feedback.requestId}. Do not repeat the invocation.`);
+  return confirmedAcknowledgement(parseTransportResponse(response,'IDE feedback acknowledgement').feedback,feedback,ideHeaders?.['x-entrorove-ide']);
+}

package/cli.mjs

@@ -8,6 +8,8 @@ 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';
@@ -440,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`);
@@ -452,8 +462,8 @@ async function main() {
     await runCloudStatus(await stdinJson());
   } else if (command === 'cloud-watch' && args.length === 0) {
     await runCloudWatch(await stdinJson());
-  } else if (command === 'feedback' && args.length === 1) {
-    process.stdout.write(`${JSON.stringify(await queryAutomaticFeedback(args[0],remoteDependencies()))}\n`);
+  } 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) {
@@ -475,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-watch | cloud-status | feedback <requestId> | 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-watch-client.mjs

@@ -2,6 +2,7 @@ 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';
+import { acknowledgeAutomaticFeedback } from './automatic-feedback-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) {
@@ -49,7 +50,10 @@ export async function watchCloudTask(input, dependencies) {
     message: '云端沙箱输出完毕；实际验证状态以任务回执为准。',separateLine: true });
   const current = await queryCloudTask(taskId,dependencies);
   if (current.status === 'observed') taskStatus = current.taskStatus;
-  if (current.feedback) emit(automaticFeedbackIdeEvent(current.feedback));
+  if (current.feedback) {
+    current.feedback = await acknowledgeAutomaticFeedback(current.feedback,dependencies.apiOrigin(),token,ideClientHeaders());
+    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,

package/ide-presentation.mjs

@@ -1,4 +1,5 @@
 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');
@@ -8,6 +9,7 @@ export function ideClientHeaders(environment = process.env) {
 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) : '';
@@ -25,6 +27,7 @@ export function cloudIdeEvent(value, taskId) {
   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) {
@@ -44,9 +47,12 @@ export function invocationIdeNotices(output) {
 }
 export function presentInvocationNotices(result, sink) {
   const messages = invocationIdeNotices(result?.output);
-  if (result?.feedback) messages.push(automaticFeedbackIdeEvent(result.feedback).message);
   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) {
@@ -54,5 +60,6 @@ export function automaticFeedbackIdeEvent(feedback) {
   const status = disposition === 'good' ? '当前调用验证通过' : disposition === 'bad'
     ? '当前调用被阻断或验证失败' : '交付验证尚未完成，暂不评分';
   return { schemaVersion: 'entrorove.ide-event/1.0',requestId: feedback.requestId,receiptId: feedback.receiptId,
-    kind: 'evaluation',phase: 'feedback',message: `本次调用评价已回传至服务器：${status}。`,separateLine: true };
+    kind: 'evaluation',phase: 'feedback',disposition,
+    message: `${feedback.acknowledgement?.stored === true ? '本次调用评价已回传至服务器' : '服务器已保存本次调用评价'}：${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.34",
+  "version": "0.1.36",
   "endpoint": "https://entrorove.com",
   "requestSchemaVersion": "entrorove.skill.request/2.0",
   "supportedRequestSchemaVersions": [

package/native-client.mjs

@@ -0,0 +1,61 @@
+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);
+    // JSON Schema permits object keywords without an adjacent type keyword.
+    // Validate their actual semantics rather than rejecting the published
+    // contract through Ajv's optional strictTypes authoring convention.
+    const ajv = new Ajv({ strict: true, strictRequired: false, strictTypes: 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.34",
+  "version": "0.1.36",
   "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",
@@ -189,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.34",
-  "digest": "88b67ef8c4be3ddf86777218a7324b095e37b2e6df30a002ac267a48548e2a31",
+  "version": "0.1.36",
+  "digest": "31125fc03752d64a87f994186ebf770a40966984d65a99358239ef71ab926723",
   "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": "b890c2173195edc9ccbaa1f9d1b45a845cad0f1838c300d90a77b1f776c8f178",
+    "cli.mjs": "f0a3104ef9f4431ded2a7049c08ae6435b09ed53c4cba486c2bd52db2728d999",
     "review-client.mjs": "3491eef68ed533174b31db3c53febb6519b8f088f71a9964644714a9a4c03c77",
     "version.mjs": "1f392147d72c40af4b03b307ea607075fb815af5174fa07e254b95fe12dbf3e7",
-    "SKILL.md": "11469bd5f51e008c26492d2e01401959451c259e04699dd4b8c833701c27d0b2",
-    "CAPABILITY-MAP.md": "f1dd06d99f191daa27f7b1520a3d6d26b1ceba139d30cd287d2b9bfd79459923",
+    "SKILL.md": "f06fd87e2008e5951c778c2e206cb42eed668d21d5c0f2a12108a0a031fde9ad",
+    "CAPABILITY-MAP.md": "40755edd3c698bbbbd4f49bc47a21c5ad9bbb8eb05e9542dd7d3a11a0254ea35",
     "AGREEMENT.md": "f93a68e92c457200dd024610e65f74e478b8f60860f951da818b70561f1b9bf8",
-    "package.json": "559c14f546a781839ed5e741602d26f888a9c98399a397b788c0fc17da1c4083",
+    "package.json": "9a7f12414556bcc150d57e64881694aeddfe0b760e98454491ac5a6585ed0421",
     "manifest.json": "ab06e307795bc9da5add926752b6c4dbdaf18625090261a035aa356a679c504f",
-    "release.mjs": "1b1925df27dd26164874d291c2dbac9a13010fca7892a9d5b529a3e6e99c0139",
-    "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,14 +118,17 @@
     "local-scope-state.mjs": "8b600a91fc0068d7a8c0bb752ddba7ed30ada93daafb118d6cba2368fd94cb27",
     "local-scope-workspaces.mjs": "a44c34537e5ed2dcaf193a985e5bc05957989fbb160a650f9e37ba7d66eb2de8",
     "local-task-routing.mjs": "e26d6f1ba134ffe1da2a49b4fb6bb6dfa5617671f774a08e719d04f202cf5eca",
-    "remote-client.mjs": "3c95a81bcad3e53f63071a87929dae4b7c71e6a45034263269c731d9d494d529",
+    "remote-client.mjs": "886ca19718b1d23209807ee3ce7d336053a17c0ad2190bb71f4c96371694dff4",
     "cloud-task-client.mjs": "ecb6124ea5e6249f31fb95cb68d13d821d2daea8768fe47ddf6dcf82fc3392cc",
-    "scope-runner-client.mjs": "940c841e2c56e92793e5bf65e713bf4087151f721d0ecb659e0a75d6fdefeab9",
-    "cloud-watch-client.mjs": "bfbe636c10af467855776f9d29008d9ce13420b66bcc91b5bf8f6ef79fb2aefe",
+    "scope-runner-client.mjs": "646ab4f80d4a8209e922fd45f40efd968f0744d9dfc03188b222c1a2e11e83b8",
+    "native-client.mjs": "ea4d9c687b62858dc4e8fb6bceca59bb049cba0c2762380be460821393e025db",
+    "native-notification.mjs": "f116772178140d1a2a7aac4a8e361a76543b1f47c84b3823a26a797f11a8bfbb",
+    "local-peer-status.mjs": "a971bcc69d60bb32b875ca5bb4297d948631d5d2821b812c279613ea059a8b4f",
+    "cloud-watch-client.mjs": "f9629e67d1f14f50e9fb52f65001059e07999352fb224b7c7e28590b95609a8a",
     "cloud-event-stream.mjs": "e0eec9fc3e0613094523929634f25030df5ca5c5b5fe2c1e1a4586ab10574808",
-    "ide-presentation.mjs": "026bf425d06276300ca748a8e22f66596ee52ff268fe0e6ffeff230885533d9a",
-    "automatic-feedback-client.mjs": "817e76b7ca4b5a282b9408ac9cf3daf7e09085db5aacbb49d74d8b6bcc4bb611",
-    "remote-transport.mjs": "5e5a8c0b490371f7f5a052cffbeee6202d4cf713dff1c43b6d910fe944f8429c",
+    "ide-presentation.mjs": "d8f54505cf559af98cd1a93a739817c13df3e1e68d2dff9fde90554ea14cb10c",
+    "automatic-feedback-client.mjs": "75e92f50d6fbfa4f482af36e16c9ce5dd323a02e99eb9b434dcfa3faa846a532",
+    "remote-transport.mjs": "93caaca646fca298a4e08142678b134ecc3a657e00de5b9939e2364b2db9d6c4",
     "local-credential.mjs": "2a302a7f67b5ea8dc73453fc96ab33db349b59ca11fa9456e48ca1d9669d877c",
     "local-invocations.mjs": "f6ac4c41c1a5ec34de358c4cca210ca8e403b3a913150a43bb55ec9be55d9998",
     "local-task-handoff-fence.mjs": "5532a359ee29b885f7ce0cf7178f76dba0fc9245bdd92ef460982275baf0d557",

package/release.mjs

@@ -92,6 +92,7 @@ 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',
@@ -352,6 +353,9 @@ 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' },

package/releases.json

@@ -1,9 +1,21 @@
 [
+  {
+    "version": "0.1.36",
+    "date": "2026-10-13",
+    "zh": "技能调用结束立即确认 IDE 评价回传，提供原账号、原调用与执行代次绑定的接收回执；完善原回执只读恢复与公开合同校验。",
+    "en": "Confirmed IDE evaluation acknowledgements immediately after skill calls, bound reception receipts to the original account, invocation and generation, and improved read-only recovery and published contract validation."
+  },
+  {
+    "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": "Restore visible IDE cloud choice, authoritative live progress and separate promotion notices from the original eight-skill workflow. Persist account-bound automatic invocation evaluations with verifiable receipts and read-only recovery; meter legacy UUID calls without mixing skill and sandbox counters."
+    "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",

package/remote-client.mjs

@@ -2,7 +2,7 @@ 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 { acknowledgeAutomaticFeedback, verifyAutomaticFeedback } from './automatic-feedback-client.mjs';
 import { ideClientHeaders, presentInvocationNotices } from './ide-presentation.mjs';
 
 export const apiUrl = 'https://entrorove.com/api/skill/invoke';
@@ -98,7 +98,7 @@ async function invokeDiscovered(data, token, { home, apiOrigin }) {
   return postInvocation(call, token, home,feedbackRequired);
 }
 
-async function postInvocation(call, token, home, feedbackRequired = false) {
+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); }
@@ -107,7 +107,7 @@ async function postInvocation(call, token, home, feedbackRequired = false) {
   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}`,...ideClientHeaders() }, body: JSON.stringify(call.body),
     });
@@ -131,7 +131,12 @@ async function postInvocation(call, token, home, feedbackRequired = false) {
     await logged({ event: 'outcome-unknown' }); throw unknownInvocation(call.requestId);
   }
   await logged({ event: response.ok ? 'completed' : 'rejected', usage: result.usage ?? [] });
-  if (result.feedback) verifyAutomaticFeedback(result.feedback,call.requestId,call.requestId);
+  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);
+    result.feedback = await acknowledgeAutomaticFeedback(result.feedback,new URL(call.url).origin,token,ideClientHeaders());
+  }
   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.`);
   }

package/remote-transport.mjs

@@ -57,8 +57,10 @@ export async function requestTransport(origin, pathname, options = {}) {
   const trusted = trustedOrigin(origin);
   if (typeof pathname !== 'string' || !pathname.startsWith('/api/') || pathname.includes('://')) throw new Error('Invalid Entrorove API path');
   const url = new URL(pathname, trusted);
-  if (url.origin !== trusted || url.search || url.hash) throw new Error('Invalid Entrorove API path');
   const configured = { timeoutMs: 15_000, method: 'GET', ...options };
+  const originalGeneration = configured.method === 'GET' && /^\/api\/skill\/feedback\/[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(url.pathname)
+    && /^\?generation=[1-9][0-9]{0,14}$/.test(url.search) && Number.isSafeInteger(Number(url.searchParams.get('generation')));
+  if (url.origin !== trusted || url.hash || url.search && !originalGeneration) throw new Error('Invalid Entrorove API path');
   if (!['GET', 'POST'].includes(configured.method)) throw new Error('Invalid Entrorove transport method');
   for (let number = 1; number <= 3; number++) {
     try {

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))