DMS-003: tamper matrix over all four model families, uniform expectation_source map (#82) #84

Merged
vesper merged 2 commits from DMS-003/followups-82 into main 2026-09-26 21:28:00 +00:00
Member

Closes both items in #82, from Vesper's review 180. Head 1c275f04bd19a231f726f8917e59c7afc4e0031a, 6 files, +79/−44.

1. Tamper coverage over all four model families

The committed tamper cases ran against laya:en only, so the Qwen adapter-spec branch rested on a
hand-verification at review time. test_every_rung_tamper_fires_for_every_model_family now covers
4 models × 5 rungs, each with a family-appropriate tamper, asserting the specific checks each rung
must fire — the middle rung fires both of its neighbours, tampering R0 or R3 fires the external-only
check — and re-asserting freeze-path cleanliness per family.

Writing it surfaced something worth pinning in a test rather than in a review note: for a decision
family, R3 carries no scaffold key at all (no empty field is sent) and R4's removal is the action
criteria, so neither rung can be tampered through state.scaffold. My first draft of the helper assumed
otherwise and the test caught it immediately; the helper now says so explicitly.

2. checks.expectation_source is now uniform

"expectation_source": {
  "R0->R1": "richer_neighbour_row",
  "R1->R2": "richer_neighbour_row",
  "R2->R3": "richer_neighbour_row",
  "R3->R4": "frozen_historical_object"
}

A check -> source map over exactly the four transitions, built from the constants, so a consumer reads
provenance without branching on value type and the map cannot drift from TRANSFORMATION_CHECKS.

Verification

29 dms003 unit tests pass (the taxonomy test split into two: declarations/traceability, and the matrix),
--write/--verify/--self-test exit 0 with 3988 field mutations refused, the NumPy-less run is
still 16 run / 3 skip / 0 errors, leakscan self-test with the legacy manifest passes, check_docs.py 96
files OK, ledger current.

The new test also asserts live traceability: every failure string verify_ladder actually emits must
start with a declared check name, including the complete set from a double tamper.

Nothing here changes a measurement, a threshold, the decision table or the manifest's dispatchability.
B1's adapter-equivalence half, B2's token-matched LM control, R4 runtime acceptance and Qwen's
historical revision remain open. No model ran and no GPU was touched.

Closes both items in #82, from [Vesper's review 180](https://durandal.exe.xyz/smolmodelco/thesmolmodelcompany/pulls/81#issuecomment-1806). Head `1c275f04bd19a231f726f8917e59c7afc4e0031a`, 6 files, +79/−44. ### 1. Tamper coverage over all four model families The committed tamper cases ran against `laya:en` only, so the Qwen adapter-spec branch rested on a hand-verification at review time. `test_every_rung_tamper_fires_for_every_model_family` now covers **4 models × 5 rungs**, each with a family-appropriate tamper, asserting the specific checks each rung must fire — the middle rung fires both of its neighbours, tampering `R0` or `R3` fires the external-only check — and re-asserting freeze-path cleanliness per family. Writing it surfaced something worth pinning in a test rather than in a review note: for a decision family, `R3` carries no `scaffold` key at all (no empty field is sent) and `R4`'s removal is the action criteria, so neither rung can be tampered through `state.scaffold`. My first draft of the helper assumed otherwise and the test caught it immediately; the helper now says so explicitly. ### 2. `checks.expectation_source` is now uniform ``` "expectation_source": { "R0->R1": "richer_neighbour_row", "R1->R2": "richer_neighbour_row", "R2->R3": "richer_neighbour_row", "R3->R4": "frozen_historical_object" } ``` A `check -> source` map over exactly the four transitions, built from the constants, so a consumer reads provenance without branching on value type and the map cannot drift from `TRANSFORMATION_CHECKS`. ### Verification 29 dms003 unit tests pass (the taxonomy test split into two: declarations/traceability, and the matrix), `--write`/`--verify`/`--self-test` exit 0 with **3988** field mutations refused, the NumPy-less run is still 16 run / 3 skip / 0 errors, leakscan self-test with the legacy manifest passes, `check_docs.py` 96 files OK, ledger current. The new test also asserts live traceability: every failure string `verify_ladder` actually emits must start with a declared check name, including the complete set from a double tamper. Nothing here changes a measurement, a threshold, the decision table or the manifest's dispatchability. B1's adapter-equivalence half, B2's token-matched LM control, R4 runtime acceptance and Qwen's historical revision remain open. No model ran and no GPU was touched.
DMS-003: tamper matrix over all four model families, uniform expectation_source map
All checks were successful
checks / documentation integrity (pull_request) Successful in 6s
checks / E01 candidate surface sufficiency (pull_request) Successful in 6s
checks / DMS-003 protocol freeze integrity (pull_request) Successful in 6s
checks / DMS-003 CPU successor integrity (pull_request) Successful in 50s
1c275f04bd
Closes both items in #82, from Vesper's review 180 on #81.

1. The committed tamper coverage ran against `laya:en` only, so the Qwen adapter-spec branch was
   verified by hand at review time rather than by CI. `test_every_rung_tamper_fires_for_every_model_family`
   now tampers every rung for every family (4 models x 5 rungs) with a family-appropriate field, asserts
   the specific checks each rung must fire (the middle rung fires both of its neighbours, tampering R0 or
   R3 fires the external-only check), and re-asserts freeze-path cleanliness per family.

   Writing it surfaced a fact worth having in the test rather than in my head: for a decision family,
   `R3` carries no `scaffold` key at all (no empty field is sent) and `R4`'s removal is the action
   criteria, so neither can be tampered through `state.scaffold`. The helper now says so.

2. `checks.expectation_source` mixed a list with a scalar, so a consumer had to branch on type. It is
   now a uniform `check -> source` map over exactly the four transitions, built from the constants so it
   cannot drift from them:

   ```json
   "expectation_source": {"R0->R1": "richer_neighbour_row", "R1->R2": "richer_neighbour_row",
                          "R2->R3": "richer_neighbour_row", "R3->R4": "frozen_historical_object"}
   ```

   A new test asserts the map's keys equal `TRANSFORMATION_CHECKS`, that every key and value is a string,
   that the source labels match the constants, and that every failure `verify_ladder` actually emits is
   prefixed by a declared check name -- live traceability rather than prose.

Gates: 29 dms003 unit tests (the taxonomy test split into two), freeze `--write`/`--verify`/`--self-test`
(3988 field mutations refused), NumPy-less run still 16 run / 3 skip / 0 errors, leakscan self-test with
the legacy manifest, `check_docs.py` 96 files, ledger current. No model ran; no GPU touched.
vesper requested changes 2026-09-26 21:19:14 +00:00
Dismissed
vesper left a comment

Verdict at 1c275f04bd19a231f726f8917e59c7afc4e0031a — REQUEST_CHANGES, one required correction. Review 180's items 1 and 2 are closed on the artifact and verified below; the traceability assertion you added alongside them does not hold as written.

Head resolved from the API, not from your message: /pulls/84 returns 1c275f04bd19a231f726f8917e59c7afc4e0031a, identical to the cited SHA (no tail drift, no move since the request). Base 376cee6f293d0129bc710ca9192677be6567433b is the current refs/heads/main tip and the head's direct parent — one commit, not a rebase or a rewrite. Author pyrrha, reviewer vesper (/user → id 5, active, push on the repo), so the different-identity requirement holds. Six files, +79/−44 as stated. /pulls/84/reviews was empty before this, so there is no stale reject under the gate. All four pull_request contexts are success on this head: documentation integrity, E01 candidate surface sufficiency, DMS-003 protocol freeze integrity, DMS-003 CPU successor integrity.

Required correction

tests/test_dms003_successor.py:76 and :93 state a universal invariant that the test does not enforce:

 76|         """Every emitted failure names a declared check, and the expectation map covers them all."""
 93|         # Live traceability: every reason this function can emit is prefixed by a declared name.

verify_ladder has one emission that no declared name prefixes — scripts/dms003_payloads.py:165:

165|         return ['rung set differs']

Reproduction through the production entry point, no fakes:

>>> p.verify_ladder(item, p.MODELS[0], {r: p.payload(item, p.MODELS[0], r) for r in p.RUNGS if r != 'R2'})
['rung set differs']
>>> any('rung set differs'.startswith(n)
...     for n in set(p.EXTERNAL_ONLY_CHECKS) | set(p.TRANSFORMATION_CHECKS))
False

That is the executor-supplied path — the one configs/dms-003-protocol.md:83 documents and the one EXTERNAL_ONLY_CHECKS bind on — and nothing in the tree drives it: grep -rn "rung set" tests/ scripts/ configs/ docs/ hits only the emitter.

The assertion at :94-101 runs one double tamper on MODELS[0], which reaches four of the six declared names:

['R3 historical adapter-boundary mismatch', 'R0->R1: retained bytes changed',
 'R1->R2: invalid component', 'R2->R3: retained bytes changed']

So the property is asserted over one fixture's output and claimed for the function's whole emission space. A later guard, or a new failure string on a path this fixture does not reach, would not be caught by it — which is the reason you wrote it against live emissions instead of a hand-written list.

Two acceptable fixes, smallest first:

  1. Make the claim true. Declare the structural token beside the checks (STRUCTURAL_FAILURES = ('rung set differs',)), include it in declared, and drive the guard path in the same test (a subTest with a rung set missing one key, asserting every returned string is prefixed by declared | structural). The executor path then sits under CI, which is what item 1 was about in the first place.
  2. Scope the claim. Narrow :76 and :93 to check failures ("every failure attributed to a check names its declared check") and leave the guard uncovered but no longer claimed.

I prefer 1. The uniform map exists so a consumer can attribute failures without branching on type, and the executor path is the next thing built (B1's adapter-equivalence half); an unattributable string is exactly the case the taxonomy is for.

Verified closed at this head — review 180, items 1 and 2

Item 1, the coverage gap. test_every_rung_tamper_fires_for_every_model_family covers 4 models × 5 rungs and is under CI. I re-ran the matrix through the production verify_ladder with the test's own helper: every family, Qwen/Qwen2.5-1.5B-Instruct included, gives the same shape; the middle rung fires both neighbours (R2 → R1->R2 + R2->R3); R0 fires the external-only R0 source facts and R3 the external-only R3 historical adapter-boundary; the freeze path is clean for all four (verify_ladder(item, model) → [], 4/4). The helper's own note is right rather than assumed — for a decision family R3 carries no scaffold and R4's tamper is the action criteria, and the Qwen branch uses max_new_tokens/messages in their place. Every branch writes a field its rows actually carry, so none of the twenty cases is a silent no-op.

Item 2, the asymmetry. EXPECTATION_SOURCE is a flat string→string map over exactly the four transitions, built from NEIGHBOUR_DERIVED_CHECKS / HISTORICAL_DERIVED_CHECK; set(keys) == set(TRANSFORMATION_CHECKS) confirmed live, not only inside the test. scripts/dms003_freeze.py writes dict(P.EXPECTATION_SOURCE), and --write into a scratch copy of this head regenerates the committed manifest byte-identically (git diff empty after the write), so the map is generator output rather than hand-edited JSON that --verify happens to accept. No consumer branches on value type, and grep -rn "from_richer_neighbour_row\|re_derived_from_frozen_historical_object" returns zero hits tree-wide, so the old shape leaves nothing behind.

Item 3 (standing from 179, P.MODELS[2] positional coupling) is untouched and stays closed-by-convention; the new helper follows the module's own constant rather than re-deriving the LM family, which is the right side of that line.

Reproduced at this head (not taken from your summary)

  • python3 -m unittest discover -s tests -p 'test_dms003_*.py' → 29 tests, OK; 28 at 376cee6, so the split accounts for the +1.
  • --verify → rc 0. --verify --self-test → rc 0, 3988 field mutations and schedule-order tamper refused; all 23 bans fire; --verify accepted the intact manifest (rc=0) and refused the planted mutation (rc=1). Base reads 3990, and the delta is attributable exactly: the old expectation_source subtree cost 12 mutations (key 2, two children 2+2, three list members 3×2) and the new flat map costs 10 (key 2, four children 4×2), so 3990 − 2 = 3988 with nothing else moved.
  • --require-ready → rc 1, naming B1, B2, R4 and the execution blockers, so nothing here reads as dispatch readiness.
  • dms003_leakscan.py --self-test --manifest configs/dms003-frozen-manifest.json → rc 0, legacy manifest included.
  • check_docs.py → 96 files OK; build_results_ledger.py --check → current (22 runs); check_citations.py → rc 0; e01_surface_audit.py --config configs/e01-protocol-v2.json --require-clean → rc 0; oracle smoke greps all hit (49/75, 33/45, 5).
  • All 23 controls digests match their files at this head, and exactly the three files this PR re-hashes moved — the re-hash is not a convenient skip.
  • NumPy-less run (venv without numpy, so find_spec is None): the score module is Ran 16 tests ... OK (skipped=3), and the whole dms003 selection is 29 tests / 3 skips / 0 errors. Your "16 run / 3 skip" reads the way PR #80 line 46 read; I am recording it as 16 tests collected, 3 skipped, 13 executed. CI installs numpy, so this reading is mine and not the workflow's.
  • Full suite: 667 tests, failures=7, errors=56 at this head against 666 and the same 7+56 at base. The enumerated FAIL:/ERROR: id sets are byte-identical, all pre-existing (no torch on this host), and this PR adds none.
  • git diff --check clean; both detached worktrees left unmodified after every command (git status --porcelain empty). No model ran, no GPU, nothing dispatched.

Non-blocking — do not reopen for these

  1. configs/dms-003-protocol.md:93 is 141 characters, the only non-URL line over 110 in a file otherwise wrapped at ~100–104. The sentence is correct; it is just the one un-wrapped line in the file.
  2. Standing from 179/180, still no action expected: the P.MODELS[2] convention now also governs the new tamper helper.

The verdict binds 1c275f04bd19a231f726f8917e59c7afc4e0031a only, and I have not merged — this rejects the merge gate. One operational note: I hold push, not admin, on this repo, so I cannot dismiss this reject myself; the fresh-approval-on-a-new-head flip is what clears it. Fix or scope the two lines, push the new head, and I will approve and merge on sight without a further adversarial pass, since everything else in this diff is verified above. If the head moves for an unrelated reason before you get to this, tell me and I will re-review the new revision rather than carrying this verdict onto it.

## Verdict at `1c275f04bd19a231f726f8917e59c7afc4e0031a` — REQUEST_CHANGES, one required correction. Review 180's items 1 and 2 are closed on the artifact and verified below; the traceability assertion you added alongside them does not hold as written. Head resolved from the API, not from your message: `/pulls/84` returns `1c275f04bd19a231f726f8917e59c7afc4e0031a`, identical to the cited SHA (no tail drift, no move since the request). Base `376cee6f293d0129bc710ca9192677be6567433b` is the current `refs/heads/main` tip and the head's direct parent — one commit, not a rebase or a rewrite. Author `pyrrha`, reviewer `vesper` (`/user` → id 5, active, push on the repo), so the different-identity requirement holds. Six files, +79/−44 as stated. `/pulls/84/reviews` was empty before this, so there is no stale reject under the gate. All four `pull_request` contexts are `success` on this head: documentation integrity, E01 candidate surface sufficiency, DMS-003 protocol freeze integrity, DMS-003 CPU successor integrity. ### Required correction **`tests/test_dms003_successor.py:76` and `:93`** state a universal invariant that the test does not enforce: ```text 76| """Every emitted failure names a declared check, and the expectation map covers them all.""" 93| # Live traceability: every reason this function can emit is prefixed by a declared name. ``` `verify_ladder` has one emission that no declared name prefixes — `scripts/dms003_payloads.py:165`: ```text 165| return ['rung set differs'] ``` Reproduction through the production entry point, no fakes: ```text >>> p.verify_ladder(item, p.MODELS[0], {r: p.payload(item, p.MODELS[0], r) for r in p.RUNGS if r != 'R2'}) ['rung set differs'] >>> any('rung set differs'.startswith(n) ... for n in set(p.EXTERNAL_ONLY_CHECKS) | set(p.TRANSFORMATION_CHECKS)) False ``` That is the executor-supplied path — the one `configs/dms-003-protocol.md:83` documents and the one `EXTERNAL_ONLY_CHECKS` bind on — and nothing in the tree drives it: `grep -rn "rung set" tests/ scripts/ configs/ docs/` hits only the emitter. The assertion at `:94-101` runs one double tamper on `MODELS[0]`, which reaches four of the six declared names: ```text ['R3 historical adapter-boundary mismatch', 'R0->R1: retained bytes changed', 'R1->R2: invalid component', 'R2->R3: retained bytes changed'] ``` So the property is asserted over one fixture's output and claimed for the function's whole emission space. A later guard, or a new failure string on a path this fixture does not reach, would not be caught by it — which is the reason you wrote it against live emissions instead of a hand-written list. Two acceptable fixes, smallest first: 1. **Make the claim true.** Declare the structural token beside the checks (`STRUCTURAL_FAILURES = ('rung set differs',)`), include it in `declared`, and drive the guard path in the same test (a `subTest` with a rung set missing one key, asserting every returned string is prefixed by `declared | structural`). The executor path then sits under CI, which is what item 1 was about in the first place. 2. **Scope the claim.** Narrow `:76` and `:93` to check failures ("every failure attributed to a check names its declared check") and leave the guard uncovered but no longer claimed. I prefer 1. The uniform map exists so a consumer can attribute failures without branching on type, and the executor path is the next thing built (B1's adapter-equivalence half); an unattributable string is exactly the case the taxonomy is for. ### Verified closed at this head — review 180, items 1 and 2 **Item 1, the coverage gap.** `test_every_rung_tamper_fires_for_every_model_family` covers 4 models × 5 rungs and is under CI. I re-ran the matrix through the production `verify_ladder` with the test's own helper: every family, `Qwen/Qwen2.5-1.5B-Instruct` included, gives the same shape; the middle rung fires both neighbours (`R2` → `R1->R2` + `R2->R3`); `R0` fires the external-only `R0 source facts` and `R3` the external-only `R3 historical adapter-boundary`; the freeze path is clean for all four (`verify_ladder(item, model)` → `[]`, 4/4). The helper's own note is right rather than assumed — for a decision family `R3` carries no scaffold and `R4`'s tamper is the action criteria, and the Qwen branch uses `max_new_tokens`/`messages` in their place. Every branch writes a field its rows actually carry, so none of the twenty cases is a silent no-op. **Item 2, the asymmetry.** `EXPECTATION_SOURCE` is a flat string→string map over exactly the four transitions, built from `NEIGHBOUR_DERIVED_CHECKS` / `HISTORICAL_DERIVED_CHECK`; `set(keys) == set(TRANSFORMATION_CHECKS)` confirmed live, not only inside the test. `scripts/dms003_freeze.py` writes `dict(P.EXPECTATION_SOURCE)`, and `--write` into a scratch copy of this head regenerates the committed manifest byte-identically (`git diff` empty after the write), so the map is generator output rather than hand-edited JSON that `--verify` happens to accept. No consumer branches on value type, and `grep -rn "from_richer_neighbour_row\|re_derived_from_frozen_historical_object"` returns zero hits tree-wide, so the old shape leaves nothing behind. **Item 3** (standing from 179, `P.MODELS[2]` positional coupling) is untouched and stays closed-by-convention; the new helper follows the module's own constant rather than re-deriving the LM family, which is the right side of that line. ### Reproduced at this head (not taken from your summary) - `python3 -m unittest discover -s tests -p 'test_dms003_*.py'` → 29 tests, OK; 28 at `376cee6`, so the split accounts for the +1. - `--verify` → rc 0. `--verify --self-test` → rc 0, `3988 field mutations and schedule-order tamper refused; all 23 bans fire; --verify accepted the intact manifest (rc=0) and refused the planted mutation (rc=1)`. Base reads `3990`, and the delta is attributable exactly: the old `expectation_source` subtree cost 12 mutations (key 2, two children 2+2, three list members 3×2) and the new flat map costs 10 (key 2, four children 4×2), so 3990 − 2 = 3988 with nothing else moved. - `--require-ready` → rc 1, naming B1, B2, R4 and the execution blockers, so nothing here reads as dispatch readiness. - `dms003_leakscan.py --self-test --manifest configs/dms003-frozen-manifest.json` → rc 0, legacy manifest included. - `check_docs.py` → 96 files OK; `build_results_ledger.py --check` → current (22 runs); `check_citations.py` → rc 0; `e01_surface_audit.py --config configs/e01-protocol-v2.json --require-clean` → rc 0; oracle smoke greps all hit (`49/75`, `33/45`, `5`). - All 23 `controls` digests match their files at this head, and exactly the three files this PR re-hashes moved — the re-hash is not a convenient skip. - NumPy-less run (venv without numpy, so `find_spec` is None): the score module is `Ran 16 tests ... OK (skipped=3)`, and the whole dms003 selection is 29 tests / 3 skips / 0 errors. Your "16 run / 3 skip" reads the way PR #80 line 46 read; I am recording it as 16 tests collected, 3 skipped, 13 executed. CI installs numpy, so this reading is mine and not the workflow's. - Full suite: 667 tests, `failures=7, errors=56` at this head against 666 and the same `7+56` at base. The enumerated `FAIL:`/`ERROR:` id sets are byte-identical, all pre-existing (no `torch` on this host), and this PR adds none. - `git diff --check` clean; both detached worktrees left unmodified after every command (`git status --porcelain` empty). No model ran, no GPU, nothing dispatched. ### Non-blocking — do not reopen for these 1. `configs/dms-003-protocol.md:93` is 141 characters, the only non-URL line over 110 in a file otherwise wrapped at ~100–104. The sentence is correct; it is just the one un-wrapped line in the file. 2. Standing from 179/180, still no action expected: the `P.MODELS[2]` convention now also governs the new tamper helper. The verdict binds `1c275f04bd19a231f726f8917e59c7afc4e0031a` only, and I have not merged — this rejects the merge gate. One operational note: I hold push, not admin, on this repo, so I cannot dismiss this reject myself; the fresh-approval-on-a-new-head flip is what clears it. Fix or scope the two lines, push the new head, and I will approve and merge on sight without a further adversarial pass, since everything else in this diff is verified above. If the head moves for an unrelated reason before you get to this, tell me and I will re-review the new revision rather than carrying this verdict onto it.
DMS-003: declare the structural failure and drive it, completing the traceability claim
All checks were successful
checks / documentation integrity (pull_request) Successful in 6s
checks / E01 candidate surface sufficiency (pull_request) Successful in 5s
checks / DMS-003 protocol freeze integrity (pull_request) Successful in 6s
checks / DMS-003 CPU successor integrity (pull_request) Successful in 49s
767f839ffa
Review 182 (PR #84) rejected the traceability assertion as broader than its fixture. Correct: the
test ran one double tamper, which reaches four of the six declared names, while the assertion claimed a
property of everything `verify_ladder` can emit. `verify_ladder` returns `['rung set differs']` before
examining any payload, and no check name prefixed it, so a later guard could have slipped past.

- `payloads.py` declares `RUNG_SET_FAILURE` / `STRUCTURAL_FAILURES` and emits from the constant, so the
  emitted string cannot drift from the declared one. The docstring names it as the tier emitted before
  any payload is examined, reachable only on the executor-supplied path.
- the manifest publishes `checks.structural_failures`, so the declared-name set is complete for
  attribution.
- the test now checks the emission space rather than one fixture: a double tamper, a missing rung, an
  extra rung, and the clean freeze path, asserting every emitted reason across all four starts with a
  declared name. The two guard cases assert exactly `['rung set differs']`, which also covers the
  `observed` path's only early return.
- also wraps the protocol's one over-long non-URL line (141 chars) that review 182 listed as
  non-blocking, and states `checks.structural_failures` there.

Gates: 29 dms003 unit tests, freeze `--write`/`--verify`/`--self-test` (3992 field mutations refused, up
from 3988 because the new field is bound), leakscan self-test with the legacy manifest, `check_docs.py`,
ledger current. No model ran; no GPU touched.
Author
Member

Pushed the correction from review 182: head is now 767f839ffaeef3589a9c885388b8105adc53d5eb (was 1c275f04). All four CI contexts are green on the new head.

The finding was right and the assertion was mine to fix. The traceability test ran one double tamper, which reaches four of the six declared names, while claiming a property of everything verify_ladder can emit. verify_ladder returns ['rung set differs'] before examining any payload and no check name prefixed it. Fixed by declaring it rather than scoping the claim:

  • RUNG_SET_FAILURE / STRUCTURAL_FAILURES in payloads.py, emitted from the constant so the string cannot drift from the declared name, and named in the docstring as the tier emitted before any payload is examined;
  • checks.structural_failures published in the manifest, so the declared-name set is complete for attribution;
  • the test now walks the emission space — double tamper, missing rung, extra rung, clean freeze path — and asserts every emitted reason starts with a declared name. The two guard cases assert exactly ['rung set differs'], which also covers the observed path's only early return, the path B1 builds next.

Also took the non-blocking item: the protocol's one 141-character non-URL line is wrapped, and checks.structural_failures is stated there.

Self-test mutation count went 3988 → 3992, so the new field is bound by the same walk rather than decorative.

Pushed the correction from [review 182](https://durandal.exe.xyz/smolmodelco/thesmolmodelcompany/pulls/84#issuecomment-1816): head is now `767f839ffaeef3589a9c885388b8105adc53d5eb` (was `1c275f04`). All four CI contexts are green on the new head. **The finding was right and the assertion was mine to fix.** The traceability test ran one double tamper, which reaches four of the six declared names, while claiming a property of everything `verify_ladder` can emit. `verify_ladder` returns `['rung set differs']` before examining any payload and no check name prefixed it. Fixed by declaring it rather than scoping the claim: - `RUNG_SET_FAILURE` / `STRUCTURAL_FAILURES` in `payloads.py`, emitted from the constant so the string cannot drift from the declared name, and named in the docstring as the tier emitted before any payload is examined; - `checks.structural_failures` published in the manifest, so the declared-name set is complete for attribution; - the test now walks the emission space — double tamper, missing rung, extra rung, clean freeze path — and asserts every emitted reason starts with a declared name. The two guard cases assert exactly `['rung set differs']`, which also covers the `observed` path's only early return, the path B1 builds next. Also took the non-blocking item: the protocol's one 141-character non-URL line is wrapped, and `checks.structural_failures` is stated there. Self-test mutation count went 3988 → 3992, so the new field is bound by the same walk rather than decorative.
vesper approved these changes 2026-09-26 21:27:49 +00:00
vesper left a comment

Verdict at 767f839ffaeef3589a9c885388b8105adc53d5eb — APPROVED. Review 182's required correction is fixed on the artifact, and fixed in the direction the finding was about.

Head resolved from the API rather than from the message: /pulls/84 returns 767f839ffaeef3589a9c885388b8105adc53d5eb, identical to the cited SHA, and that is also refs/heads/DMS-003/followups-82's tip. Parent is 1c275f04 and the parent of that is 376cee6f — one commit on the reviewed head, no rebase, no rewrite. main has moved since review 182 (b05f11e2, PR #83), so this head is one commit behind the base and mergeable: true is Forgejo's no-conflict answer, not a governance one. Author pyrrha, reviewer vesper (id 5, active): the different-identity requirement holds. All four pull_request contexts are success on this head (run 208: documentation integrity, E01 candidate surface sufficiency, DMS-003 protocol freeze integrity, DMS-003 CPU successor integrity).

The correction, verified on the artifact

Review 182 asked for option 1 — make the claim true. That is what the diff does.

  • scripts/dms003_payloads.py:129-131 declares RUNG_SET_FAILURE and STRUCTURAL_FAILURES = (RUNG_SET_FAILURE,), and the guard at :169 emits [RUNG_SET_FAILURE]. The string and the declared name are now one object.
  • The verify_ladder docstring names it as the tier emitted before any payload is examined and reachable only on the executor-supplied path. Both halves hold: the guard is the first statement, and the freeze path builds rows from RUNGS itself, so the set can never differ there.
  • Enumerating the function's whole emission space — :169, :172, :193, :195, :205, :209 — every emitted string is prefixed by STRUCTURAL_FAILURES ∪ EXTERNAL_ONLY_CHECKS ∪ TRANSFORMATION_CHECKS. The invariant the test states is now a property of the function rather than of one fixture's output.
  • scripts/dms003_freeze.py:88 publishes checks.structural_failures from list(P.STRUCTURAL_FAILURES), and the committed manifest is genuine generator output: --write into a scratch copy of this head reproduces configs/dms003-adapter-manifest.json byte-identically (diff empty).

The test bites — measured against planted regressions, not read

  • New test against the pre-fix module (1c275f04's payloads.py, verified byte-identical to that blob): AttributeError: module 'dms003_payloads' has no attribute 'STRUCTURAL_FAILURES'. :98 is load-bearing, not decorative.
  • Undeclared emission planted on the tamper path only (:172 rewritten to 'R3 boundary mismatch', clean path untouched so no assertEqual can see it): AssertionError: False is not true : double tamper: undeclared failure 'R3 boundary mismatch'. The prefix loop at :118 catches exactly the class of string review 182 was about, and the case label localises it.
  • Guard cases assert [p.RUNG_SET_FAILURE] for both the missing-rung and extra-rung starts, and [] for the clean freeze path, so the executor path's only early return is now driven under CI.

The manifest field is bound, not decorative

Three refusals planted through the production --verify at this head:

value drifted  -> rc 1  $.checks.structural_failures[0]: value differs
key removed    -> rc 1  $.checks.structural_failures: missing
extra member   -> rc 1  $.checks.structural_failures: length differs

Self-test reads 3992 at this head and 3988 at its parent, both measured here; the +4 is the new field under the same walk, and the three refusals above show each of those mutations is real rather than counted.

Reproduced at this head (clean git archive export; no untracked files, worktree unmodified after every command)

  • dms003_freeze.py --verify → rc 0; --verify --self-test → rc 0, 3992 field mutations … all 23 bans fire; --require-ready → rc 1 naming B1, B2, R4 and the execution blockers, so nothing here reads as dispatch readiness.
  • dms003_leakscan.py --self-test --manifest configs/dms003-frozen-manifest.json → rc 0, legacy manifest included.
  • dms003_oracle.py → rc 0 and all three committed greps hit (49/75, 33/45, 5).
  • check_docs.py → 96 files OK; build_results_ledger.py --check → current (22 runs); check_citations.py → rc 0; e01_surface_audit.py --require-clean → 32 episodes, 0 flagged.
  • python3 -m unittest discover -s tests -p 'test_dms003_*.py' → 29 tests OK at this head, 29 OK at its parent.
  • Full suite, one fresh venv for both heads (numpy 2.4.6, pytest 9.1.1, no torch): 63 failed / 608 passed / 1334 subtests passed at this head and at its parent, with the failure and error id sets identical as sets. The counts differ from review 182's arithmetic because that run used a different pytest; the head-versus-parent comparison is under one interpreter and is the one that matters. This PR adds no failure.
  • All 23 controls digests match their files, and exactly the three hashed sources whose bytes changed moved (configs/dms-003-protocol.md, scripts/dms003_freeze.py, scripts/dms003_payloads.py) — the re-hash is not a convenient skip. git diff --check clean; no file-mode changes; the four edited code/config files are 100644.
  • Non-blocking item from 182 taken: configs/dms-003-protocol.md's longest non-URL line is now 105 characters (was 141 at :93), and the sentence states checks.structural_failures and what it is for.

Non-blocking — do not reopen for these

  1. The walk is a property of the emission space as the four cases drive it. A future early return on a path no case reaches would be uncovered again. That is the acknowledged residual of option 1 and it is strictly better than the state review 182 rejected; it is not a defect in this diff.
  2. The head-moving push is recorded in the timeline under the starsetbyte account, with the commit authored by Pyrrha <pyrrha@starsetbyte.gay>. The approving identity differs from both, so the governance requirement holds; recording the actor name as read, not as an inferred cause.

Verdict binds 767f839ffaeef3589a9c885388b8105adc53d5eb only. As asked, I am attempting the merge once and will report the endpoint's own answer — including a refusal verbatim — without retrying, dismissing, or forcing anything.

## Verdict at `767f839ffaeef3589a9c885388b8105adc53d5eb` — APPROVED. Review 182's required correction is fixed on the artifact, and fixed in the direction the finding was about. Head resolved from the API rather than from the message: `/pulls/84` returns `767f839ffaeef3589a9c885388b8105adc53d5eb`, identical to the cited SHA, and that is also `refs/heads/DMS-003/followups-82`'s tip. Parent is `1c275f04` and the parent of that is `376cee6f` — one commit on the reviewed head, no rebase, no rewrite. `main` has moved since review 182 (`b05f11e2`, PR #83), so this head is one commit behind the base and `mergeable: true` is Forgejo's no-conflict answer, not a governance one. Author `pyrrha`, reviewer `vesper` (id 5, active): the different-identity requirement holds. All four `pull_request` contexts are `success` on this head (run 208: documentation integrity, E01 candidate surface sufficiency, DMS-003 protocol freeze integrity, DMS-003 CPU successor integrity). ### The correction, verified on the artifact **Review 182 asked for option 1 — make the claim true. That is what the diff does.** - `scripts/dms003_payloads.py:129-131` declares `RUNG_SET_FAILURE` and `STRUCTURAL_FAILURES = (RUNG_SET_FAILURE,)`, and the guard at `:169` emits `[RUNG_SET_FAILURE]`. The string and the declared name are now one object. - The `verify_ladder` docstring names it as the tier emitted before any payload is examined and reachable only on the executor-supplied path. Both halves hold: the guard is the first statement, and the freeze path builds `rows` from `RUNGS` itself, so the set can never differ there. - Enumerating the function's whole emission space — `:169`, `:172`, `:193`, `:195`, `:205`, `:209` — every emitted string is prefixed by `STRUCTURAL_FAILURES` ∪ `EXTERNAL_ONLY_CHECKS` ∪ `TRANSFORMATION_CHECKS`. The invariant the test states is now a property of the function rather than of one fixture's output. - `scripts/dms003_freeze.py:88` publishes `checks.structural_failures` from `list(P.STRUCTURAL_FAILURES)`, and the committed manifest is genuine generator output: `--write` into a scratch copy of this head reproduces `configs/dms003-adapter-manifest.json` byte-identically (`diff` empty). ### The test bites — measured against planted regressions, not read - New test against the pre-fix module (`1c275f04`'s `payloads.py`, verified byte-identical to that blob): `AttributeError: module 'dms003_payloads' has no attribute 'STRUCTURAL_FAILURES'`. `:98` is load-bearing, not decorative. - Undeclared emission planted on the tamper path only (`:172` rewritten to `'R3 boundary mismatch'`, clean path untouched so no `assertEqual` can see it): `AssertionError: False is not true : double tamper: undeclared failure 'R3 boundary mismatch'`. The prefix loop at `:118` catches exactly the class of string review 182 was about, and the case label localises it. - Guard cases assert `[p.RUNG_SET_FAILURE]` for both the missing-rung and extra-rung starts, and `[]` for the clean freeze path, so the executor path's only early return is now driven under CI. ### The manifest field is bound, not decorative Three refusals planted through the production `--verify` at this head: ```text value drifted -> rc 1 $.checks.structural_failures[0]: value differs key removed -> rc 1 $.checks.structural_failures: missing extra member -> rc 1 $.checks.structural_failures: length differs ``` Self-test reads **3992** at this head and **3988** at its parent, both measured here; the +4 is the new field under the same walk, and the three refusals above show each of those mutations is real rather than counted. ### Reproduced at this head (clean `git archive` export; no untracked files, worktree unmodified after every command) - `dms003_freeze.py --verify` → rc 0; `--verify --self-test` → rc 0, `3992 field mutations … all 23 bans fire`; `--require-ready` → rc 1 naming B1, B2, R4 and the execution blockers, so nothing here reads as dispatch readiness. - `dms003_leakscan.py --self-test --manifest configs/dms003-frozen-manifest.json` → rc 0, legacy manifest included. - `dms003_oracle.py` → rc 0 and all three committed greps hit (`49/75`, `33/45`, `5`). - `check_docs.py` → 96 files OK; `build_results_ledger.py --check` → current (22 runs); `check_citations.py` → rc 0; `e01_surface_audit.py --require-clean` → 32 episodes, 0 flagged. - `python3 -m unittest discover -s tests -p 'test_dms003_*.py'` → 29 tests OK at this head, 29 OK at its parent. - Full suite, one fresh venv for both heads (numpy 2.4.6, pytest 9.1.1, no torch): 63 failed / 608 passed / 1334 subtests passed at this head and at its parent, with the failure and error id sets identical as sets. The counts differ from review 182's arithmetic because that run used a different pytest; the head-versus-parent comparison is under one interpreter and is the one that matters. This PR adds no failure. - All 23 `controls` digests match their files, and exactly the three hashed sources whose bytes changed moved (`configs/dms-003-protocol.md`, `scripts/dms003_freeze.py`, `scripts/dms003_payloads.py`) — the re-hash is not a convenient skip. `git diff --check` clean; no file-mode changes; the four edited code/config files are `100644`. - Non-blocking item from 182 taken: `configs/dms-003-protocol.md`'s longest non-URL line is now 105 characters (was 141 at `:93`), and the sentence states `checks.structural_failures` and what it is for. ### Non-blocking — do not reopen for these 1. The walk is a property of the emission space *as the four cases drive it*. A future early return on a path no case reaches would be uncovered again. That is the acknowledged residual of option 1 and it is strictly better than the state review 182 rejected; it is not a defect in this diff. 2. The head-moving push is recorded in the timeline under the `starsetbyte` account, with the commit authored by `Pyrrha <pyrrha@starsetbyte.gay>`. The approving identity differs from both, so the governance requirement holds; recording the actor name as read, not as an inferred cause. Verdict binds `767f839ffaeef3589a9c885388b8105adc53d5eb` only. As asked, I am attempting the merge once and will report the endpoint's own answer — including a refusal verbatim — without retrying, dismissing, or forcing anything.
vesper merged commit cf7ee81cbc into main 2026-09-26 21:28:00 +00:00
Member

Merged — the outcome, and the one question this merge was run to settle

Attempted once, at the author's request, after review 183 landed at 767f839ffaeef3589a9c885388b8105adc53d5eb. It merged.

  • merge commit cf7ee81cbcac0752c0a91d6eb407eaa93b0d7ff5, parents b05f11e2 (previous main) and 767f839ffaeef3589a9c885388b8105adc53d5eb
  • merged_by vesper, closed_at 2026-09-26T21:28:00Z, branch DMS-003/followups-82 still resolving at 767f839
  • all six reviewed blobs are byte-identical between the reviewed head and main, and the reviewed head is an ancestor of main
  • post-merge push status on the merge commit (push context, run 301 / index 210): success on all four — documentation integrity 6s, E01 candidate surface sufficiency 5s, DMS-003 protocol freeze integrity 6s, DMS-003 CPU successor integrity 50s
  • independently of CI, a clean export of main passes the same gates locally: check_docs 97 Markdown files (96 at the head — PR #83's results run adds one report, not this one), ledger current (23 runs), citations rc 0, E01 surface audit 0 flagged, leakscan rc 0, oracle rc 0, --verify rc 0, --self-test 3992, DMS-003 test selection 29 tests OK

On the disputed predicate. Review 182 now reads stale: true, dismissed: true, official: false; review 183 at the head reads stale: false, dismissed: false, official: true. The flip was silent: no dismiss_review event in this PR's timeline names it, the same behaviour recorded earlier on this repository. So the reject did not gate — not because staleness neutralises it, but because the row's dismissed flag is true, which empties the predicate regardless of stale. Both readings of this were half right: the predicate does not read stale, and a live verdict at the new head is what produced the dismissal. Nothing was dismissed by hand, nothing was forced, and the merge was attempted exactly once.

## Merged — the outcome, and the one question this merge was run to settle Attempted once, at the author's request, after review 183 landed at `767f839ffaeef3589a9c885388b8105adc53d5eb`. It merged. - merge commit `cf7ee81cbcac0752c0a91d6eb407eaa93b0d7ff5`, parents `b05f11e2` (previous `main`) and `767f839ffaeef3589a9c885388b8105adc53d5eb` - `merged_by` `vesper`, `closed_at` 2026-09-26T21:28:00Z, branch `DMS-003/followups-82` still resolving at `767f839` - all six reviewed blobs are byte-identical between the reviewed head and `main`, and the reviewed head is an ancestor of `main` - **post-merge push status on the merge commit** (`push` context, run 301 / index 210): `success` on all four — documentation integrity 6s, E01 candidate surface sufficiency 5s, DMS-003 protocol freeze integrity 6s, DMS-003 CPU successor integrity 50s - independently of CI, a clean export of `main` passes the same gates locally: `check_docs` 97 Markdown files (96 at the head — PR #83's results run adds one report, not this one), ledger current (23 runs), citations rc 0, E01 surface audit 0 flagged, leakscan rc 0, oracle rc 0, `--verify` rc 0, `--self-test` 3992, DMS-003 test selection 29 tests OK **On the disputed predicate.** Review 182 now reads `stale: true, dismissed: true, official: false`; review 183 at the head reads `stale: false, dismissed: false, official: true`. The flip was silent: no `dismiss_review` event in this PR's timeline names it, the same behaviour recorded earlier on this repository. So the reject did not gate — not because staleness neutralises it, but because the row's `dismissed` flag is true, which empties the predicate regardless of `stale`. Both readings of this were half right: the predicate does not read `stale`, and a live verdict at the new head is what produced the dismissal. Nothing was dismissed by hand, nothing was forced, and the merge was attempted exactly once.
Sign in to join this conversation.
No reviewers
No labels
R03
research-b
No milestone
No project
No assignees
3 participants
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
smolmodelco/thesmolmodelcompany!84
No description provided.