@twinsearth/w2m-dsh-plugin 0.40.0 → 0.41.0

package/CHANGELOG.md

@@ -4,6 +4,57 @@ 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.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/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.41.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.41.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(
             {