@twinsearth/w2m-dsh-plugin 0.40.0 → 0.42.0

package/CHANGELOG.md

@@ -4,6 +4,106 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.42.0] — 2026-10-15
+
+**The README catches up with 62 versions — and gathering the numbers found a defect that had survived all of them.**
+
+### The progress section, in both languages
+
+The README's newest version reference was **v0.4.0**, thirteen times, and its install command pinned a
+**v0.6.3** tarball. **Thirty-four versions of work had no record in the file a newcomer reads first.**
+
+There is now a **Progress** section (with a matching 进度 section) built from the CHANGELOG rather than from
+memory: **62 versions since 0.8.0, 11 tools, 79 suites, 2199 tests, 12 pre-flight checks, 0 failures.** It
+carries the three properties the project set out to have, the roadmap's **delivered / partial** state per
+version, what the reachability work found, the measured-on-real-machines table, and an explicit **"this is not
+1.0.0"**.
+
+**The seven accepted orphans are listed with what would remove each one**, and the **three that are defects are
+named as defects** rather than folded in with the four libraries — because the import graph cannot tell them
+apart, and only a written reason can.
+
+### `layer-check` printed "clean" and exited 1
+
+Gathering the numbers meant running the checks and reading their output and their status side by side, and two
+of them contradicted each other:
+
+```
+clean: every cross-layer edge is declared
+exit=1
+```
+
+**The clean path called `process.exit(1)`.** Every reader that trusts the exit code — a shell, CI, a script,
+`&&` — **read a passing check as a failing one.**
+
+**The pre-flight never noticed, and the reason is the interesting part: its own step reads the PRINTED TEXT
+rather than the status.** A check can therefore be wrong for a hundred versions while the gate over it stays
+green. It now exits `0`, with the failure paths still distinct (`2` for a violation, `3` for unexplained), and
+a regression test asserts **the status rather than the message** — because a test that read the message would
+have passed against the broken version, which is exactly what happened.
+
+### Also corrected
+
+* the install instructions now say **how to verify you got the version you asked for**, because this
+  repository's own profile installed from a pinned tarball and **fell 30+ versions behind**. A successful
+  install and a current install are two different things.
+* both language halves now name **`pnpm`** as the fallback where `npm` is absent — which is the case in the
+  packaged DSH runtime this was tested against.
+* one dead in-page anchor, from assuming GitHub's slugger keeps an em dash. It does not.
+
+**2 new tests, 0 failures.**
+
+## [0.41.0] — 2026-10-15
+
+**`field-authority.mjs` has a caller. The correction from 0.29.0 lands, six versions after the claim.**
+
+### What was wired, and the claim it settles
+
+0.29.0's entry said *"the connection now exists."* **It existed inside that module and nowhere else** — the
+0.36.0 classification reported the file as an **orphan**, and reading the tree rather than the changelog
+confirmed it: `grep 'field-authority' src/` matched **comments and documentation only.**
+
+`w2m_memory` now accepts a received CAT7 block **field by field, at the actor's authority level**, and writes it
+as a row in the same JSONL the conclusions use — one store, one rotation, one answer to *"what does this machine
+remember."* Measured, all six cases:
+
+```
+no level   ok=false  MEMORY_BLOCK_NO_AUTHORITY
+level 0    ok=true   accepted=[subject,body] refused=[evidence]
+level 70   ok=true   accepted=[subject,body,evidence]
+tampered   ok=false  BLOCK_HASH_MISMATCH
+no ancestor ok=false BLOCK_MISSING_PARENT
+with ancestor ok=true accepted 3/3
+```
+
+**A refused field is OMITTED, not set to null** — v4.8.0's first falsifying test, now reachable through a tool.
+**An unset level REFUSES rather than accepting the block whole**, because accepting whole is the exact behaviour
+field-level acceptance was built to replace, and it would look like success. **A block naming an ancestor the
+caller cannot produce is refused, never re-rooted**, because re-rooting turns an unverifiable history into no
+history — which reads as a fresh, independent assertion. And **refusals are stored**, not discarded: what a
+machine declined to believe is as much a part of its memory as what it took.
+
+### The list policed itself, which is the part worth keeping
+
+`field-authority` was removed from `scripts/accepted-orphans.mjs` **not by a decision to tidy up, but because
+the gate went red.** Its stale-entry check fails when an accepted orphan stops being an orphan — so the moment
+`tools.mjs` imported the file, the run demanded the acceptance be withdrawn. **Orphans: 8 → 7. Exports: 72 →
+65.**
+
+### My own error, and it is the eighth of this exact shape
+
+I inserted the new branch by matching an **anchor string** and never checked **what block that string was
+inside.** It landed inside `if (conclusionText !== null)`, so the feature only ran when the caller *also* passed
+`record`. Six tests failed, and I diagnosed it by **guessing at return shapes twice before printing them** —
+`verifyBlock` and `acceptWithAuthority` were both exactly what I had assumed, and the actual fault was a
+scoping mistake three steps earlier.
+
+**Two wrong hypotheses, then one printed value, then ten seconds to the answer.** That is the eighth time in
+this span that printing would have been faster than predicting, and the note is here because the pattern has
+now survived being written down seven times.
+
+**6 new tests, 0 failures.**
+
 ## [0.40.0] — 2026-10-15
 
 **The acceptance document, converged — and bound to the pre-flight so it cannot drift.**

package/README.md

@@ -14,6 +14,71 @@ English | [中文](#中文说明)
 
 ---
 
+## Progress — where this actually is
+
+**Current: `0.41.0`.** 62 versions since `0.8.0`. The number that matters more than the version:
+**11 tools, 79 suites, 2199 tests, 12 pre-flight checks, 0 failures.**
+
+### The three properties this project set out to have
+
+| Property | State | What it means concretely |
+|---|---|---|
+| **分模块** (modular) | **enforced** | every file belongs to exactly one declared layer; `layer-check` fails on an undeclared edge |
+| **分层级** (layered) | **enforced** | six ranked layers and an **allow-list** of edges — not a rule that can be interpreted, a list that can be read |
+| **分权限** (tiered authority) | **built, opt-in** | four bands, escalation moves **exactly one band**, nothing destructive auto-settles. **Off by default** — see the gap below |
+
+### Roadmap
+
+| Version | Deliverable | State |
+|---|---|---|
+| **v4.8.0** | field-level acceptance, MMP P1/P2, lineage | **delivered** — `w2m_memory` accepts a received CAT7 block **field by field at the actor's level**; a field that costs more than the actor has is **omitted, not nulled**; a block naming an ancestor the caller cannot produce is **refused, never re-rooted** |
+| **v4.9.0** | approval queue | **partial** — the queue, the escalation bridge and the raise-limiter are wired and reachable by an operator through `w2m_approvals`. **The "front door" named in the roadmap was never built**: `approval-index.mjs` imports `authority.mjs` and nothing else |
+| **v4.10.0** | committee governance | **delivered** — seven phases, weighted votes, **a tie is refused rather than broken**, and a sealed decision is **retrievable with its dissent and its reasons** after the council that produced it is gone |
+
+### What the reachability work found, because it is the honest part
+
+Three mechanisms were shipped in this span **fully tested and reachable by nothing** — `field-authority`,
+`approval-gate`, and `council`. Two were **described as delivered** while nothing ran them. A single `grep`
+disproved one of them.
+
+There is now a **gate**: a module nothing reaches makes the pre-flight **red** unless it appears in
+`scripts/accepted-orphans.mjs` **with a reason and a statement of what would remove it**. An acceptance that
+outlives its cause also fails. **Seven remain**:
+
+| Module | Kind | What would remove it |
+|---|---|---|
+| `health.mjs` | **defect** | the agent calling it on a schedule |
+| `log-bounds.mjs` | **defect** | the same — it is the answer to a **measured 40× log growth** |
+| `storage.mjs` | **defect** | a tool writing through its undelatable tiers |
+| `fleet-scale.mjs`, `fleet-state.mjs`, `exit-channel.mjs`, `test-report.mjs` | library | a caller, when one is wanted |
+
+**The defect class is named as a defect rather than folded in with the libraries**, because the two are
+indistinguishable from the import graph alone and only a written reason can separate them.
+
+### The gap that matters most right now
+
+**The plugin this machine runs is 30+ versions behind this source tree.** Every source-level conclusion about
+the running runtime is void until it is upgraded — which is one command, and it is in
+[Install](#3-the-dsh-plugin).
+
+### Measured on real machines
+
+| Fact | Evidence |
+|---|---|
+| a **seven-phase council** runs on macOS | `exit 0` on MacMini: phases 7, dissent retained, recount reproduced |
+| **field-level acceptance** holds on macOS | `exit 0` on MacMini: level 0 cannot reach `evidence`, level 70 can, tampering caught, a missing ancestor refused rather than re-rooted |
+| the fleet is **3 usable machines of 5 paired** | and `fleet-scale.mjs` **refuses to extrapolate** from five |
+| **`P2P_PUNCH_FAILED`** | **UNVERIFIED.** Three hypotheses measured and excluded (BLAKE2s-256, the wider primitive set, version skew). **The plugin that raises it runs 0.9.5** — upgrading is the next experiment |
+
+### Not claimed
+
+**This is not 1.0.0.** `docs/1.0.0-ACCEPTANCE.md` sorts all 30 criteria into **ENFORCED / MEASURED /
+UNVERIFIED** by a rule rather than an opinion, names **seven claims this work had to retract**, and states
+plainly that four of its own closing items are undone. It is bound to the pre-flight by a test, so a criterion
+cannot quietly become unenforced while the file keeps claiming otherwise.
+
+---
+
 ## The problem
 
 You have a Windows desktop and a Mac laptop. You are working on one project. You
@@ -250,9 +315,18 @@ dsh plugin --profile <profile-name> add @twinsearth/w2m-dsh-plugin
 
 ```bash
 dsh plugin --profile <profile-name> add \
-  https://github.com/TwinsEarth/dsh-windows2macos/releases/download/v0.6.3/twinsearth-w2m-dsh-plugin-0.6.3.tgz
+  https://github.com/TwinsEarth/dsh-windows2macos/releases/download/v0.41.0/twinsearth-w2m-dsh-plugin-0.41.0.tgz
 ```
 
+This form **pins a version by construction**, which is both its virtue and the trap: a
+profile that installs this way stays on that version forever unless somebody edits the
+line. **This repository's own profile did exactly that and fell 30+ versions behind** —
+so if you use it, re-check the number against the badge at the top of this file.
+
+**No `npm`?** Some hosted runtimes (including the packaged DSH) ship `node` and `pnpm`
+but not `npm`. `pnpm add @twinsearth/w2m-dsh-plugin@0.41.0 --save-exact` installs the
+identical tarball from the identical registry.
+
 **From the repository** — the form a marketplace's one-click installer uses (it clones
 the repo, builds nothing, and registers `cordis.patch.yml`):
 
@@ -270,6 +344,14 @@ answer, not three.
 > listed in `package.json` but never composed is the failure this project hit once
 > already — see `cordis.patch.yml`'s header for what that looked like.
 
+**Then check the version you actually got**, because a successful install and a current
+install are two different things:
+
+```
+w2m_status   →  actor_authority and approvals should be present (0.9.5 has neither)
+tool list    →  w2m_council should be present (it arrived in 0.37.0; anything older lacks it)
+```
+
 Then give it the relay URL in that profile's `cordis.patch.yml` — or leave
 `rabbitUrl` empty to use the shared server:
 
@@ -532,6 +614,10 @@ Read this before exposing the relay to anything.
 
 This project's rule is that claims carry their evidence.
 
+> **Current state lives in [Progress](#progress-where-this-actually-is) above.** What follows is the
+> **v0.4.0 record**, kept because it is the measurement the direct path still rests on — not because it
+> describes what ships today. The version is now `0.41.0`.
+
 ### v0.4.0 — the direct path is the default, and here is what that is worth
 
 v0.3.9 shipped the P2P transport and admitted in its own §8 that nothing read
@@ -778,6 +864,60 @@ When something does not work, start from the symptom: [TROUBLESHOOTING.md](TROUB
 
 **同一个 DeepSeek 账号，一条指令，让在线的 Windows 与 Mac 跑同一个项目。**
 
+### 进度 —— 它现在到底到哪一步了
+
+**当前版本：`0.41.0`**。自 `0.8.0` 以来共 **62 个版本**。比版本号更重要的数字是：
+**11 个工具、79 个测试套件、2199 个用例、12 项预检、0 失败。**
+
+#### 三项目标本来的属性
+
+| 属性 | 状态 | 具体含义 |
+|---|---|---|
+| **分模块** | **已强制** | 每个文件属于且只属于一个已声明的层；出现未声明的依赖边，`layer-check` 直接失败 |
+| **分层级** | **已强制** | 六个带序号的层，以及一张**允许清单**——不是一条可以被解读的规则，而是一张可以被读的清单 |
+| **分权限** | **已建成，需手动开启** | 四个权限带、升级**恰好一级**、破坏性操作**永不自动放行**。**默认关闭**，见下方缺口 |
+
+#### 路线图
+
+| 版本 | 交付物 | 状态 |
+|---|---|---|
+| **v4.8.0** | 字段级接受、MMP P1/P2、lineage | **已交付** —— `w2m_memory` 接收来自其他机器的 CAT7 认知块，**按字段、按接收方的权限级别**逐项接受；接收方买不起的字段**是「缺席」，不是 null**；祖先无法产出时**拒绝，绝不重新生根** |
+| **v4.9.0** | 审批队列 | **部分完成** —— 队列、升级桥、发起限流器都已接线，操作者可通过 `w2m_approvals` 处理。**但路线图里写的那道「前门」从未构建**：`approval-index.mjs` 只导入 `authority.mjs`，别无其他 |
+| **v4.10.0** | 委员会治理 | **已交付** —— 七个阶段、加权投票、**平票是拒绝而不是打破**；封印的决定在产生它的委员会消失之后，**仍可连异议和异议的理由一起取回** |
+
+#### 可达性检查发现了什么（这部分才是诚实的部分）
+
+这一跨度里有**三个机制被完整实现、完整测试、却没有任何东西能到达**——`field-authority`、`approval-gate`、`council`。其中**两个在被描述为「已交付」时，没有任何东西在跑它们**。一条 `grep` 就推翻了其中一个。
+
+现在有**门禁**了：一个没人能到达的模块会让预检**变红**，除非它出现在 `scripts/accepted-orphans.mjs` 里，**并写明理由和「什么能让它下榜」**。已经修好的条目若还留在清单上，同样失败。**目前还剩 7 个**：
+
+| 模块 | 性质 | 什么能让它下榜 |
+|---|---|---|
+| `health.mjs` | **缺陷** | agent 按计划调用它 |
+| `log-bounds.mjs` | **缺陷** | 同上——它是对**实测到的 40 倍日志增长**的答案 |
+| `storage.mjs` | **缺陷** | 有工具真正通过它的「不可删除」层写入 |
+| `fleet-scale.mjs`、`fleet-state.mjs`、`exit-channel.mjs`、`test-report.mjs` | 库 | 需要时给它们调用方 |
+
+**「缺陷」这一类被单独命名，而不是和「库」混在一起**——因为仅凭导入图这两者无法区分，**只有写下来的理由能分开它们**。
+
+#### 眼下最要紧的那个缺口
+
+**本机实际运行的插件比这份源码落后 30 多个版本。** 在升级之前，**任何关于运行时行为的源码级结论都作废**。升级只需一条命令，见[快速开始](#快速开始)第 3 步。
+
+#### 在真机上实测到的
+
+| 事实 | 证据 |
+|---|---|
+| **七阶段委员会**能在 macOS 上跑通 | MacMini `exit 0`：7 个阶段、异议被保留、`recount` 复现成功 |
+| **字段级接受**在 macOS 上成立 | MacMini `exit 0`：级别 0 拿不到 `evidence`、级别 70 拿得到、篡改被抓、**缺祖先时拒绝而不重新生根** |
+| 编队是**5 台配对中 3 台可用** | 而 `fleet-scale.mjs` 因此**拒绝外推** |
+| **`P2P_PUNCH_FAILED`** | **未验证。** 三个假设已测量并排除（BLAKE2s-256、更广的原语集、版本偏差）。**抛出它的是跑着 0.9.5 的插件**——升级就是下一个实验 |
+
+#### 不作声明
+
+**这不是 1.0.0。** `docs/1.0.0-ACCEPTANCE.md` 把全部 30 条准则按**一条规则**（而非观点）分成
+**已强制 / 已测量 / 未验证**三类，列出**这一跨度不得不撤回的 7 条声明**，并明说它自己收尾清单里的四项尚未完成。它被一个测试**绑定到预检**，所以**一条准则不可能在文件仍声称它被强制的同时悄悄变成未被强制**。
+
 ### 为什么需要它
 
 DSH 目前**不能**跨机器协作，而且不是疏忽：
@@ -817,8 +957,21 @@ node bin/w2m-localside.mjs --rabbit http://<中继地址>:8787 --pair PAIR-XXXXX
   --allowed-commands '["node --test","git status --porcelain"]'
 
 # 3) 装 DSH 插件
-dsh plugin --profile <profile-name> add \
-  https://github.com/TwinsEarth/dsh-windows2macos/releases/download/v0.6.3/twinsearth-w2m-dsh-plugin-0.6.3.tgz
+#    v0.4.0 起可从 npm 装（比逐个指定 release 的 tgz 更好：不会锁死在某个旧版本上）。
+#    本仓库自己的 profile 就一直锁在一个本地 0.9.5 的 tgz 上，结果落后了 30 多个版本。
+npm install @twinsearth/w2m-dsh-plugin@latest
+#    或者，如果你想钉死一个具体版本：
+#    npm install @twinsearth/w2m-dsh-plugin@0.41.0
+#
+#    没有 npm 的托管运行时（DSH 打包版就是这种）用 pnpm 即可，同一个 registry、同一份 tarball：
+#    pnpm add @twinsearth/w2m-dsh-plugin@0.41.0 --save-exact
+```
+
+装完后**重启 DSH**，然后确认版本对上了——这一步别跳过，因为**本仓库自己就在这里栽过**：
+
+```
+w2m_status  →  应能看到 actor_authority 与 approvals 两个字段（0.9.5 没有）
+工具列表    →  应能看到 w2m_council（旧版只有 8 个工具）
 ```
 
 然后在 profile 的 `cordis.patch.yml` 里给插件 `rabbitUrl`（留空即用共享服务器）与 `operatorToken`，重启 DSH，即可直接用自然语言指挥：

package/docs/1.0.0-ACCEPTANCE.md

@@ -126,7 +126,7 @@ limiter down to `util`, **not** to add the edge.
 | 3.7 | Nothing destructive auto-settles, at any level | `mayAutoSettle`, asserted | **yes** |
 | 3.8 | An escalated dispatch reaches a queue an approver can answer | `w2m_approvals`, asserted end to end | **yes** |
 | 3.9 | The queue's front door meters **raising only** | `approval-gate.mjs`, wired in 0.31.0 | **yes** |
-| 3.10 | Field-level memory acceptance is driven by the same model | `field-authority.mjs` | **mechanism yes, caller NO — see §4** |
+| 3.10 | Field-level memory acceptance is driven by the same model | `field-authority.mjs`, called by `w2m_memory` since 0.41.0 | **yes** — the caller arrived six versions after the mechanism |
 | 3.11 | **The gate is ON by default** | `requireAuthorityLevel`, asserted | **NARROWED — see below** |
 | 3.12 | A level is chosen by name, never typed | `authority-choice.mjs`, asserted | **yes** |
 | 3.13 | A misconfigured level is reported, not silently ignored | `w2m_status.actor_authority` | **yes** |
@@ -181,7 +181,7 @@ within a week. **A check that cannot fail is a report.**
 | 1.2 | every dependency edge is declared, and every declared edge is used | `layer-check` |
 | 1.3 | every suite on disk is named by a script | `test wiring` |
 | 1.4 | every document's claim about the artifact matches the artifact | `claims`, 48 claims |
-| **1.5** | **no orphan module without a written reason** | **`reachable or accepted`** |
+| **1.5** | **no orphan module without a written reason** | **`reachable or accepted`** — **7 orphans, 65 exports, down from 8 and 72** |
 | 2.1–2.4 | ranked layers, an allow-list of edges, no upward edge | `layer-check` |
 | 3.2 | every declared capability is reachable by some band | `auditCapabilities`, asserted |
 | 3.4 | the dispatch path consults the gate | `tools.test.mjs`, end to end |
@@ -198,9 +198,9 @@ within a week. **A check that cannot fail is a report.**
 
 | # | Criterion | What is actually measured |
 |---|---|---|
-| 1.6 | **reachability itself** | 72 orphan, 14 cli. **The classifier cannot tell a defect from a library**, so the *decision* is enforced (§1.5) while the *classification* is not |
+| 1.6 | **reachability itself** | 65 orphan exports, 14 cli. **The classifier cannot tell a defect from a library**, so the *decision* is enforced (§1.5) while the *classification* is not |
 | 3.1 | capabilities declared with a cost | the table is read by `permission.mjs`; a new capability with no caller would still be listed |
-| 3.10 | **field-level memory acceptance driven by the authority model** | the mechanism is asserted; **it has no production caller** and is on the accepted-orphan list as `interface-unrouted` |
+| ~~3.10~~ | ~~field-level memory acceptance driven by the authority model~~ | **PROMOTED TO ENFORCED in 0.41.0.** It was the one `interface-unrouted` orphan whose removal had a known answer, and `w2m_memory` now accepts a received block field by field at the actor's level |
 | 3.11 | the gate is on by default | `requireAuthorityLevel` makes it enforceable **per machine**; the default is still off |
 | 4.1 | four suites run on MacMini | verified once, in 0.28.0, with that machine's exit code. **Nothing re-runs them** |
 
@@ -243,9 +243,12 @@ found something the previous three rounds had missed.**
 
 1. **Flip §3.11's default.** `requireAuthorityLevel` exists and is tested; whether 1.0.0 ships with it on is a
    decision about who the release is for. **A permission system that is off is one that has never run.**
-2. **Wire the four `interface-unrouted` orphans**, or delete them. `health` is the sensor the user asked for by
-   name; `log-bounds` is the answer to a measured 40× growth; `storage` holds the undelatable tiers;
-   `field-authority` is the half of v4.8.0 that was claimed. **Each is on the list with what would remove it.**
+2. **Wire the remaining three `interface-unrouted` orphans**, or delete them. `health` is the sensor the user
+   asked for by name; `log-bounds` is the answer to a measured 40× growth; `storage` holds the undelatable
+   tiers. **Each is on the list with what would remove it.**
+   ~~`field-authority`~~ **was the fourth and is DONE — 0.41.0 gave it the caller its entry named.** It is
+   worth noting what removed it: **not a decision to tidy up, but the gate's stale-entry check going red** the
+   moment something imported the file. The list policed itself.
 3. **Re-run the 69 unverified suites on MacMini**, which needs `node_modules` there — an environment change
    nobody has made.
 4. **Promote every MEASURED row to ENFORCED**, so this document stops being a parallel list that can drift from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@twinsearth/w2m-dsh-plugin",
-  "version": "0.40.0",
+  "version": "0.42.0",
   "description": "DSH: Windows2MacOS — drive the same project on online Windows and macOS machines from one DeepSeek account, across networks and regions. P2P hole punching is the default path (relay + shared server as rendezvous, ledger and fallback), with a bundled STUN responder, Tailscale/public-VPS/tunnel shapes, Rabbit relay + per-machine Localside + eight DSH tools (replicate / split), nine aggregate verdicts and signed requests.",
   "type": "module",
   "main": "lib/index.js",

package/src/plugin/tools.mjs

@@ -98,6 +98,12 @@ import path from 'node:path';
 // skipped rather than fatal, and the rotated generation reachable -- and a second implementation would
 // drift from the writer's shape without anything failing.
 import { appendMemory, readMemorySync } from '../agent/memory.mjs';
+// v0.41.0: v4.8.0's other half. Written in 0.9.9 and 0.29.0, and **nothing called them** until here --
+// `field-authority.mjs` was reported as an orphan in 0.36.0 and stayed on the accepted list until 0.41.0.
+// `makeBlock` is NOT imported: this path receives blocks and only reads them. Building one here would be the
+// plugin asserting a claim on its own behalf, which is the sender's job.
+import { acceptBlock, verifyBlock } from '../agent/blocks.mjs';
+import { acceptWithAuthority } from '../agent/field-authority.mjs';
 
 // The base-address rules live in one place (§2), shared with the agent side. Importing the - rather
 // than re-deriving them her - is what stops the plugin and the agent from disagreeing about what
@@ -202,7 +208,7 @@ const MAX_STAGES = 16;
  * `package.json` during `scripts/pack.mjs` rather than hand-maintained, and `W2M_PLUGIN_VERSION`
  * overrides it at runtime for tests and packagers.
  */
-const PLUGIN_VERSION = '0.40.0';
+const PLUGIN_VERSION = '0.42.0';
 
 /** How long any single HTTP call may take before it is aborted, in milliseconds. */
 const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
@@ -5044,6 +5050,29 @@ export async function apply(ctx, config = {}) {
           'field a machine is not allowed to write itself -- the machine stores the fact, a reader ' +
           'asserts the meaning. Written as a new record so nothing already written is rewritten.',
       },
+      accept_block: {
+        type: 'object',
+        description:
+          'v0.41.0. Accept a CAT7 cognitive block received from another machine, per field, DRIVEN BY AN ' +
+          'AUTHORITY LEVEL (actor_authority below) rather than accepted whole. A field the level cannot ' +
+          'afford is OMITTED from the stored block rather than set to null, and lineage is checked against ' +
+          'the ancestors you supply: a block whose parent cannot be produced is REFUSED, never silently ' +
+          're-rooted, because re-rooting turns an unverifiable history into no history. Every field decision ' +
+          'is reported, so a refusal is readable rather than mysterious.',
+      },
+      actor_authority: {
+        type: 'number',
+        description:
+          'The authority level, 0..100, for accept_block. Required with it: an unset level means there is ' +
+          'no actor to judge, and accepting a block whole would defeat the point of field-level acceptance.',
+      },
+      lineage: {
+        type: 'array',
+        items: { type: 'string' },
+        description:
+          'The hashes of the ancestors you can actually produce, for accept_block. A block naming an ' +
+          'ancestor outside this list is refused rather than re-rooted.',
+      },
     },
     output: jsonOutput,
     async execute(args, exec) {
@@ -5119,8 +5148,91 @@ export async function apply(ctx, config = {}) {
        * text, which is the thing a reader most needs when a conclusion turns out to be wrong.
        */
       const conclusionText = typeof args?.record === 'string' && args.record.trim() !== '' ? args.record.trim() : null;
+      /**
+       * v0.41.0: accept a received cognitive block, field by field, driven by the authority model.
+       *
+       * ## Why the block is written as a ROW rather than into a structure of its own
+       *
+       * The memory file is JSONL rows with a \`kind\`. A conclusion is one kind; an accepted block is
+       * another. Giving blocks their own file would mean two stores to read, two to rotate, and two
+       * answers to "what does this machine remember" -- and the rotation in \`appendMemory\` already
+       * handles the size problem a second store would be created to solve.
+       *
+       * ## Why an unset authority level REFUSES rather than accepting everything
+       *
+       * Field-level acceptance exists because a receiver should not adopt everything a sender asserts.
+       * With no level there is no actor to judge, so accepting the block whole would be the exact
+       * behaviour this mode was built to replace -- and it would look like success.
+       */
+      // Hoisted above both branches that write: block acceptance and the conclusion. One read of the
+      // configured directory, so the two cannot disagree about where memory lives.
+      const stateDirForRecord = cfg.stateDir ?? null;
+
+      if (args?.accept_block !== undefined && args?.accept_block !== null) {
+        if (stateDirForRecord === null) {
+          return JSON.stringify({ ok: false, scope: 'local', reason_code: 'MEMORY_NO_STATE_DIR', detail: 'this plugin has no stateDir configured, so a block has nowhere to be accepted into' });
+        }
+        if (!Number.isInteger(args?.actor_authority)) {
+          return JSON.stringify({
+            ok: false,
+            scope: 'local',
+            reason_code: 'MEMORY_BLOCK_NO_AUTHORITY',
+            detail: 'accept_block needs actor_authority as an integer 0..100; without a level there is no actor to judge the fields, and accepting the block whole is what field-level acceptance exists to prevent',
+          });
+        }
+        const received = args.accept_block;
+        const verified = verifyBlock(received);
+        if (!verified.ok) {
+          // A block that fails its own hash is refused entirely: field-level acceptance is about trust, and
+          // there is nothing to trust about content that does not match what it claims to be.
+          return JSON.stringify({ ok: false, scope: 'local', reason_code: verified.code, detail: verified.detail, verified: false });
+        }
+        const { accepted, refused, decisions } = acceptWithAuthority(
+          received,
+          { level: args.actor_authority, id: self },
+          { accept: acceptBlock, ...(Array.isArray(args.lineage) ? { lineage: args.lineage } : {}) },
+        );
+        if (accepted === null) {
+          // Refused as a whole -- a missing ancestor, most likely. Reported with the whole field list, because
+          // "refused" without "why" is the failure this project keeps having to correct.
+          return JSON.stringify({ ok: false, scope: 'local', reason_code: refused[0]?.why?.split(':')[0] ?? 'MEMORY_BLOCK_REFUSED', detail: refused[0]?.why ?? 'the block was refused', refused, decisions });
+        }
+        const row = {
+          at: new Date().toISOString(),
+          kind: 'block',
+          machine_id: selfId,
+          machine_name: self,
+          // The block's own hash identifies what was accepted; the lineage it declared travels with the row, so
+          // a reader can tell an accepted block from a fabricated one without re-deriving anything.
+          block_hash: received.hash ?? null,
+          lineage: Array.isArray(received.lineage) ? [...received.lineage] : [],
+          accepted_by_level: args.actor_authority,
+          accepted,
+          accepted_fields: decisions.filter((d) => d.accepted).map((d) => d.field),
+          // Refusals are stored, not discarded: "what did this machine decline to believe" is as much a part
+          // of its memory as what it took, and the design's whole third test is about dissent surviving.
+          refused_fields: decisions.filter((d) => !d.accepted).map((d) => ({ field: d.field, why: d.reason })),
+        };
+        const written = appendMemory(stateDirForRecord, row);
+        return JSON.stringify({
+          ok: written.ok === true,
+          scope: 'local',
+          recorded: written.ok === true,
+          kind: 'block',
+          block_hash: row.block_hash,
+          accepted_fields: row.accepted_fields,
+          refused_fields: row.refused_fields,
+          accepted,
+          decisions,
+          path: written.path ?? null,
+          reason_code: written.ok === true ? null : 'MEMORY_BLOCK_WRITE_FAILED',
+          detail: written.ok === true
+            ? `accepted ${row.accepted_fields.length} field(s) at level ${args.actor_authority}; ${row.refused_fields.length} omitted`
+            : (written.error ?? 'the block could not be written'),
+        });
+      }
+
       if (conclusionText !== null) {
-        const stateDirForRecord = cfg.stateDir ?? null;
         if (stateDirForRecord === null) {
           return JSON.stringify(
             {