compass(clock): apply the ponytail-audit of atom/compass/clock/ (#406 phase 2) by jgong5 · Pull Request #410 · jgong5/ATOM

jgong5 · 2026-09-24T03:49:34Z

Closes #406

What this does

This is phase 2 of #406. It applies the ponytail-audit of atom/compass/clock/ (the audit is the phase-1 comment), with the coordinator's ruling: 11 of 12 findings are applied. F7b is skipped, so LpRegistry.__contains__ stays. Without it, [] in registry would return a silent False instead of raising TypeError.

Branch: compass/issue-406, from tip 3eb94cfa7.
The tip does not touch the five files since the audited 37fba4df0, so every audit line number still holds.
Files: identity.py, lookahead.py, registry.py, test_clock_lp_identity.py, test_clock_order_across_processes.py. clock/__init__.py and __all__ are unchanged.
Size: 153 changed lines, net −125 (−139 / +14). The brief estimated about 153 lines, net −124.

No blocking issues.

Findings applied, each beside its measurement

"Audit" means the measurement in the phase-1 comment. "Here" means a measurement re-run for this PR on node 18 (xiaobizh_n18_cpu), on git archive trees of the tip and of this head. atom.__file__ was asserted under each staged root before every run.

#	Tag	Change	Lines (−/+), prod · test	Measurement
F1	delete	`LookaheadMatrix.tightest()` and `test_the_tightest_link_is_the_one_that_bounds_the_run`	−14 · −9	Here: `grep '\.tightest\b'` over `atom/ tests/ scripts/` at `3eb94cfa7` finds only that test. Audit: no use in any held head (#59 #63 #67 #75 #91 #96 #266).
F2	delete	`serializing()` and the module-docstring sentence that names it; `test_a_nonzero_floor_is_not_reported_as_serializing`; the `serializing` assert in `test_a_zero_floor_is_a_declaration_and_not_an_error`, which still pins that a zero floor is accepted	−10/+1 · −11/+3	Here: `grep '\.serializing\b'` finds only the docstring and those two tests. Audit: held heads are clean.
F3	delete	`links()`, `LookaheadMatrix.__len__`, `test_links_are_listed_in_a_stable_order`. The comment in `test_a_declared_floor_cannot_be_rewritten_through_a_handed_out_link` that named `links` now names `inbound` and `declare` (a comment only; the AST is identical)	−7 · −13/+1	Here: `grep '\.links\('` finds only `serializing`, `tightest` and that test. No `len(matrix)` or truth test on a matrix anywhere. Probe: `bool(empty matrix)` goes `False` → `True`, a pre-tagged line.
F4	delete	`LinkClass` members become their label strings. `__init__`, `.label` and `.scale_seconds` go, and `__str__` returns `self.value`. `test_the_three_link_classes_carry_the_scales_that_were_modelled` goes.	−14/+5 · −14	Here: `scale_seconds` is read only by that test. `.label` is read only by `__str__`. Nothing reads `LinkClass(...)` or `link_class.value`. Probe: `str(member)` and `repr(InterLpLink)` are byte-identical over 3 classes × 5 floors. `.value` goes tuple → str, a pre-tagged line.
T3	delete	`test_the_admission_delay_is_kept_per_path` and its `TRAFFIC_TO_ENGINE_FLOOR_SECONDS` import. The constant stays, and held #75 reads it.	· −9	Audit: the mutant `serving_floor` (9.0e-3 → 8.0e-3) fails only this test (1 failed, 68 passed).
(F4+T3)		The `# --- the configured scales` section header, which F4 and T3 leave empty	· −3
T1	delete	`test_inbound_links_come_back_in_the_total_order_whatever_order_they_were_declared`	· −11	Audit: the mutants `inbound_decl` and `inbound_rev` are both still caught by `test_inserting_a_participant_moves_nothing_that_was_already_declared` (1 failed, 42 passed each).
F5	shrink	`inbound` filters `undeclared()` rather than calling the private `_missing_into` walk	−8/+1	Probe: every `inbound(t)` outcome (value or `KeyError` text) is byte-identical over 600 random registries and partial matrices, including an unregistered `t`.
F7a	delete	`LpRegistry.__repr__`	−3	Here: no `repr(`, `str(`, or `{…registry}` of a registry anywhere. Probe: the pre-tagged line `registry-repr-is-custom` goes `True` → `False`.
F7b	native	skipped (coordinator ruling): `LpRegistry.__contains__` stays	0	Probe: the `unhashable-in-registry` line (`[] in registry` → `TypeError`) is now identical on both sides. The audit had tagged it to differ.
T2	delete	`test_the_children_really_did_register_in_different_orders`, plus the child's `print("arrival", …)`, which then has no reader (the audit's optional −1)	· −6	Audit: `child_no_rotate` fails only this guard. `ids_insertion` and `ids_hash`, with or without rotation, are caught by `test_the_total_order_is_the_same_in_every_process`. Here: nothing else reads `run["arrival"]`.
F6	shrink	Drop the `_ordered` cache: `ids()` returns `tuple(sorted(self._members))`	−6/+2	Probe: `ids()` and `list(registry)` are byte-identical in all 600 cases. Audit: 0.041 µs → 3.73 µs per call at 12 participants, and there is no per-grant caller.
F8	shrink	`LpId.__post_init__`: `any(c.isspace() …)` alone; the `strip()` clause is implied	−1/+1	Probe: all 4,456,448 names (every code point × 4 positions) give identical outcomes (digest in the transcript), and the 8 named bad inputs give identical messages. The audit found `strip()` and `isspace()` disagree on 0 of 1,114,112 code points.
		Total	prod −63/+10 · test −76/+4	Matches `git diff --numstat` exactly: `identity.py` 1/1, `lookahead.py` 53/7, `registry.py` 9/2, `test_clock_lp_identity.py` 70/4, `test_clock_order_across_processes.py` 6/0 (removed/added).

Differential probe: byte-identical except the pre-tagged lines

The probe is the audit's probe_equiv.py, unchanged: 39,252 lines covering every retained public answer. It ran at the tip and at this head.

sha_kept 7357322c45be4660 on both sides. That is the same digest the audit recorded, so every untagged line is byte-identical.

diff shows 4 changed lines, all tagged EXPECTED-DIFF in advance:

< EXPECTED-DIFF registry-repr-is-custom | True
< EXPECTED-DIFF bool-empty-matrix | False
< EXPECTED-DIFF linkclass-value | [('traffic_to_engine', 0.01), ('prefill_to_decode', 0.001), ('pipeline_stage_to_stage', 1e-06)]
< EXPECTED-DIFF removed-attrs | ['links', 'serializing', 'tightest', '__len__', '_missing_into', 'scale_seconds', 'label', '__contains__', '_ordered']
> EXPECTED-DIFF registry-repr-is-custom | False
> EXPECTED-DIFF bool-empty-matrix | True
> EXPECTED-DIFF linkclass-value | ['traffic_to_engine', 'prefill_to_decode', 'pipeline_stage_to_stage']
> EXPECTED-DIFF removed-attrs | ['__contains__']

The fifth pre-tagged line, unhashable-in-registry, no longer differs, because F7b is skipped.

Two consequences of the tagged linkclass-value change are not a separate probe line:

LinkClass("traffic_to_engine") now returns the member where the tip raised ValueError.
LinkClass(("traffic_to_engine", 0.01)) now raises where the tip returned the member.

Nothing in atom/, tests/ or scripts/ calls LinkClass(...).

Suite delta: exactly the 7 removed tests

pytest --collect-only over the gate's own selection (tests/ minus cpu_gate_exclude.txt and tests/plugin) collects 5413 at the tip and 5406 at this head. The node-id diff is exactly these 7 removals, with nothing added:

tests/compass/test_clock_lp_identity.py::test_a_nonzero_floor_is_not_reported_as_serializing
tests/compass/test_clock_lp_identity.py::test_inbound_links_come_back_in_the_total_order_whatever_order_they_were_declared
tests/compass/test_clock_lp_identity.py::test_links_are_listed_in_a_stable_order
tests/compass/test_clock_lp_identity.py::test_the_admission_delay_is_kept_per_path
tests/compass/test_clock_lp_identity.py::test_the_three_link_classes_carry_the_scales_that_were_modelled
tests/compass/test_clock_lp_identity.py::test_the_tightest_link_is_the_one_that_bounds_the_run
tests/compass/test_clock_order_across_processes.py::test_the_children_really_did_register_in_different_orders

The clock files (test_clock_lp_identity.py, test_clock_order_across_processes.py, test_backend_kv_geometry.py) give 74 passed at the tip and 67 passed at this head.

Gate 1, run with each tree's own scripts/compass/gate_cpu.sh, stamps written, one gate at a time:

Tree	`commit:` stamp	Result	`GATE_CPU_RC`
Control: tip `3eb94cfa7`	`3eb94cfa7`	5276 passed, 155 skipped, 3 xfailed (187 s)	0
Merged: `git merge-tree --write-tree 3eb94cfa7 7e22e1576` = `9b75e93d6`, which is this head's tree	`7e22e1576`	5269 passed, 155 skipped, 3 xfailed (184 s)	0

Delta: −7 passed, and the skipped and xfailed counts are unchanged. That is the 7 tests listed above.
gpu: not required on both trees.
No timing flake fired, so nothing was re-run.

AST and line changes, production and tests separately

These counts are per definition (ast.dump of each function, class header and module-level statement), comparing the tip against this head.

Production (identity.py, lookahead.py, registry.py): −63 / +10 lines.

7 removed: LookaheadMatrix.tightest, .serializing, .links, .__len__, ._missing_into, LinkClass.__init__, LpRegistry.__repr__.
7 changed:
- LpId.__post_init__;
- LinkClass: the member values and the class docstring;
- LinkClass.__str__;
- LookaheadMatrix.inbound;
- LpRegistry.__init__, .register and .ids.
1 docstring-only: the lookahead.py module docstring.
0 added, 25 unchanged.

Tests (test_clock_lp_identity.py, test_clock_order_across_processes.py): −76 / +4 lines.

7 test functions removed.
1 test changed: test_a_zero_floor_is_a_declaration_and_not_an_error.
2 module-level statements changed:
- the from atom.compass.clock import (…) import, which counts as 1 removed and 1 added statement;
- the CHILD source string, which loses its print("arrival", …) line.
61 unchanged. That includes test_a_declared_floor_cannot_be_rewritten_through_a_handed_out_link, whose change is a comment only.

Other checks:

ruff 0.16.7 on the five files: check passes on both sides. format --check flags the same pre-existing hunk in test_clock_order_across_processes.py (test_the_total_order_is_the_same_in_every_process) on both sides, so the delta is 0.
Comments and docstrings touched say what the code does. A grep of the five files at head for design-doc ids, "principle", gate labels, issue numbers, "audit", "review" or "ponytail" finds nothing.

Held-PR overlap

Measured with REST pulls/<n>/files and with git merge-tree --write-tree <held head> <this head>, against the same heads the audit used; none has moved since.

Changed file	Held PRs whose own diff touches it	Held PRs that inherit it from #59 below them
`atom/compass/clock/identity.py`	#59 (adds it)	#63, #67, #75, #91, #96
`atom/compass/clock/lookahead.py`	#59 (adds it)	#63, #67, #75, #91, #96
`atom/compass/clock/registry.py`	#59 (adds it)	#63, #67, #75, #91, #96
`tests/compass/test_clock_lp_identity.py`	#59 (adds it), #63 (+16 −132), #266 (+11 −6)	#67, #75, #91, #96
`tests/compass/test_clock_order_across_processes.py`	#59 (adds it)	#63, #67, #75, #91, #96

New conflicting files after this PR:

compass: the grant rule and the clock state machine (CA-2, #45) #59, compass: both clock transports from one implementation (CA-3, #46) #63, compass: what a run of the clock says about itself (CA-7, #50) #67, compass: ATOM's deployments driven against the clock, synthetically (CA-4, #47) #75, compass: the causality detectors, and three injected violations that fire them (CA-5, #48) #91, compass: a determinism harness two processes wide, and the set-iteration lint #96: the five files above, added to the three they already conflict on (clock/__init__.py, design/12_open_items.md, design/README.md). compass: both clock transports from one implementation (CA-3, #46) #63 already conflicted on test_clock_lp_identity.py at the tip.
compass(tests): AST guards refuse the spellings they cannot read #266: none new. It still conflicts only on tests/compass/test_runner_non_allocating.py, as at the tip.

How the conflicts resolve:

compass: the grant rule and the clock state machine (CA-2, #45) #59 and the PRs that inherit from it: compass: the grant rule and the clock state machine (CA-2, #45) #59 adds these files byte-identical to the pre-audit tip, so each region resolves to the integration side.
compass: both clock transports from one implementation (CA-3, #46) #63 needs hand resolution at the from atom.compass.clock import (…) block (test_clock_lp_identity.py:47 at the tip). This PR drops TRAFFIC_TO_ENGINE_FLOOR_SECONDS from it, and compass: both clock transports from one implementation (CA-3, #46) #63 rewrites the same block when it moves the package-boundary tests out. The merged import has to take compass: both clock transports from one implementation (CA-3, #46) #63's shape without that name.

🤖 Generated with Claude Code

Remove what the audit of #406 measured as unused or redundant in the clock package and its tests, keeping every retained public answer unchanged. Production: - LookaheadMatrix loses tightest(), serializing(), links() and __len__; no caller in atom/, tests/ or scripts/ besides their own tests. - LookaheadMatrix.inbound finds its missing peers by filtering undeclared() instead of a private second walk of the same pairs. - LinkClass members are their label strings; the unread scale_seconds, label and tuple-valued __init__ are gone, and __str__ returns the value. - LpRegistry.ids() sorts on every call instead of caching; __repr__ is gone. __contains__ stays, so an unhashable operand still raises TypeError. - LpId drops a strip() clause that any(c.isspace()) already implies. Tests: the seven tests that only exercised removed members, restated a literal, or checked the test's own rotation constants are removed, and one comment that named links() now names what still hands out a link. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

jgong5 · 2026-09-24T04:14:19Z

@@ -76,6 +72,3 @@ def __iter__(self):

    def __len__(self) -> int:
        return len(self._members)


Non-blocking. The F7b ruling has no test that fires. This is at __contains__, L67 above; the anchor is here because L67 is outside the diff.

Principle 6: "Refuse rather than fall back. A declined answer with a named reason is a result. A guessed one is a defect."
AI_DEV_RULES, gate 4: "A check counts only once someone has seen it fire."

The coordinator skipped F7b so that [] in registry keeps raising TypeError rather than returning a silent False. The head keeps that behaviour: the probe on node 18 at the merged tree d58491587 (its clock files are byte-identical to 5f9ee034e) gives [] in registry → TypeError: unhashable type: 'list'.

No test holds it, though. With mutate.py contains_via_iter, which deletes LpRegistry.__contains__ and changes nothing else, the three clock files give 67 passed, 0 failed (test_clock_lp_identity.py, test_clock_order_across_processes.py, test_backend_kv_geometry.py). test_membership_and_size still passes, because the __iter__ fallback gives the same answer for every LpId.

So the next ponytail pass will measure F7b as free and propose it again. Two lines in test_membership_and_size would pin the ruling:

with pytest.raises(TypeError): [] in registry

This is not blocking: the PR follows the ruling, and the behaviour is intact at the head.

jgong5 · 2026-09-24T04:14:21Z


    def __str__(self) -> str:
-        return self.label
+        return self.value


Non-blocking, and already true at the tip. No test covers LinkClass.__str__, and this PR rewrites its body.

Principle 6: "A declined answer with a named reason is a result."

str(link_class) has one reader: InterLpLink.__repr__. That repr is the named reason in declare's duplicate refusal (... is already declared as InterLpLink(prefill -> decode, prefill_to_decode, floor=0.001s)).

With mutate.py str_is_name, return self.name in place of return self.value:

at the head, 67 passed and 0 failed;

at the tip, the same mutant on return self.label gives 74 passed and 0 failed.

test_declaring_the_same_link_twice_is_refused matches only "already declared". So the evidence that self.label → self.value is equivalent is the probe, not a test.

My probe on node 18 agrees with the developer's: str(member) and repr(InterLpLink) are byte-identical on both sides for all 3 classes. The change is correct.

Optional one-line pin: add match="already declared as InterLpLink\(prefill -> decode, prefill_to_decode" to that test's pytest.raises.

jgong5 · 2026-09-24T04:14:22Z

 print("hash", hash(names[0]))
 print("module", atom.__file__)
-print("arrival", " ".join(arrival))
 print("registry", " ".join(str(lp_id) for lp_id in registry.ids()))


Non-blocking. ponytail-review.

test_clock_order_across_processes.py:L22-24, L63-64, L67, L74-77, L82, L104: delete: the arrival rotation, which no remaining test checks and no mutant needs. The children register namesdirectly, and_child(seed) drops the rotate argument. About −12 lines.

Once T2 removed test_the_children_really_did_register_in_different_orders, nothing reads the rotation. Nothing it does is needed for detection either. Measured on node 18 over the three clock files at the merged tree d58491587 (its clock files are byte-identical to 5f9ee034e):

Mutant Failures

ids_insertion (tuple(self._members)), rotation on 4 failed

ids_insertion with the child's rotate = 0 the same 4 failed

ids_hash with rotate = 0 the same 4 failed

The 4 failures are the same tests each time, test_the_total_order_is_the_same_in_every_process among them. NAMES is not sorted, so orders[0] == " ".join(sorted(NAMES)) catches an insertion-order registry without any rotation. In-process, test_the_order_does_not_depend_on_the_order_of_registration catches it too.

Removing the rotation also removes the reason for the docstring's "built from the unrotated list on purpose" clause (L16-18) and for the comment at L74-77.

This is a suggestion, not a condition. The rotation is harmless, and removing it goes beyond the audit's 12 findings.

jgong5 · 2026-09-24T04:14:32Z

Review cycle 1 of PR #410 (#406 phase 2), at head 7e22e157600e69b03fac727e4f747681d4801a21. This review was written by an agent.

Verdict: APPROVE at head 7e22e157600e69b03fac727e4f747681d4801a21. Nothing blocks.

I read the eight Design principles in atom/compass/design/README.md and AI_DEV_RULES.md at 60186b80c before reading the diff. All 11 applied findings match the binding audit, and F7b is skipped as the coordinator ruled. Every removed member has no caller at the tip or at any held head. Each removed test either pinned a member that is now gone, or its property is still pinned by a named kept test, and I watched that kept test fail. The one exception is the retained constant, and that one is accepted (row 6 below).

There are 3 non-blocking findings, posted inline:

registry.py: the F7b ruling ([] in registry raises TypeError) has no test that fires (comment 4089855573).
lookahead.py:61: LinkClass.__str__ has no test covering it, at this head or at the tip (comment 4089855817).
test_clock_order_across_processes.py: a ponytail delete: for the rotation machinery that T2 left unread (comment 4089855935).

1. Tip and merged tree

Tip: 60186b80c. While this review ran, compass(tests): key broadcast sites by their repo-relative path, not the base name engine_core.py #407 landed (4116a63a9) and then compass(runner): the exit bullet points at the refusal comment instead of restating its losses #402 landed (60186b80c).
Merged tree: git merge-tree --write-tree 60186b80c 7e22e1576 gives 5f9ee034ec6d.
- Its diff against the tip is byte-identical to the PR's own diff (md5 a583b4ca… on both).
- None of compass(tests): pin the backend and runner module walks to every module, not to one (#232) #395, compass(tests): key broadcast sites by their repo-relative path, not the base name engine_core.py #407, compass(kv): state whole_number union case in two lines under Limits #408 or compass(runner): the exit bullet points at the refusal comment instead of restating its losses #402 touches the five files. compass(runner): the exit bullet points at the refusal comment instead of restating its losses #402 is a 3-line docstring change in atom/compass/runner/__init__.py.
Stamp: git commit-tree stamp 1024cf908, with parents tip and head. It carries no ref.
Which tree each check ran on: the probes, mutants and clean-merge greps below ran on the merged tree at the earlier tip 4116a63a9 (merged tree d58491587e6c, stamp dbb5fcc60). git diff d58491587 5f9ee034e is only compass(runner): the exit bullet points at the refusal comment instead of restating its losses #402's 3-line docstring, so those results carry over. I recounted the held-head conflicts against stamp 1024cf908 and the counts are unchanged.

2. Callers of removed members

I grepped atom/, tests/, scripts/, tools/, and every *.md/*.txt.

Names searched: .tightest(, serializing(, .links(, _missing_into, scale_seconds, ._ordered, len(matrix), LinkClass(, LinkClass.X.value/.label, and truth-tests or len/repr/str on a matrix or registry.

Where I searched:

the tips 4116a63a9 and 60186b80c;
the head;
compass: the grant rule and the clock state machine (CA-2, #45) #59 4c538fdb1, compass: both clock transports from one implementation (CA-3, #46) #63 ea5f78f36, compass: what a run of the clock says about itself (CA-7, #50) #67 65f7dd69f, compass: ATOM's deployments driven against the clock, synthetically (CA-4, #47) #75 27bd29025, compass: the causality detectors, and three injected violations that fire them (CA-5, #48) #91 0f6f71cc1, compass: a determinism harness two processes wide, and the set-iteration lint #96 ee5b591dc and compass(tests): AST guards refuse the spellings they cannot read #266 176cac3d4. These are the current heads, unchanged since the audit.

Hits:

Outside lookahead.py, registry.py and test_clock_lp_identity.py: none, at any ref, and none in any design doc.
Inside those files, at the held heads: the copies compass: the grant rule and the clock state machine (CA-2, #45) #59 adds byte-identical to the pre-audit tip, which is why they conflict.

Runtime check: I computed git merge-tree for each held head against the stamp, then grepped every file that merged cleanly.

The only clock name in a cleanly merged file is TRAFFIC_TO_ENGINE_FLOOR_SECONDS["serving"], at tests/compass/clock/deployments.py:42 (compass: ATOM's deployments driven against the clock, synthetically (CA-4, #47) #75, compass: the causality detectors, and three injected violations that fire them (CA-5, #48) #91, compass: a determinism harness two processes wide, and the set-iteration lint #96). That constant stays.
#67 observability.py:288 calls inbound and #59 authority.py:108 calls len(registry). Both are kept.
Result: no held head breaks at runtime.

Textual conflicts, measured against the tip alone and then against the stamp:

compass: the grant rule and the clock state machine (CA-2, #45) #59, compass: what a run of the clock says about itself (CA-7, #50) #67, compass: ATOM's deployments driven against the clock, synthetically (CA-4, #47) #75, compass: the causality detectors, and three injected violations that fire them (CA-5, #48) #91 and compass: a determinism harness two processes wide, and the set-iteration lint #96 go from 3 conflicted files to 8. The 5 new ones are this PR's files.
compass: both clock transports from one implementation (CA-3, #46) #63 goes from 4 to 8.
compass(tests): AST guards refuse the spellings they cannot read #266 gains none. At this tip it conflicts on test_runner_non_allocating.py and on test_runner_rpc_surface.py, with or without this PR, so both come from the tip and neither from this PR.

This matches the audit's prediction, and the owner ruled to go ahead anyway.

3. Ruling on `LinkClass`: harmless, not a fallback

Principle 6: "Refuse rather than fall back. A declined answer with a named reason is a result. A guessed one is a defect."

Measured on node 18 with probe_linkclass.py, at the tip and at the merged tree:

	tip	head
`.value`	`('traffic_to_engine', 0.01)`, `('prefill_to_decode', 0.001)`, `('pipeline_stage_to_stage', 1e-06)`	`'traffic_to_engine'`, `'prefill_to_decode'`, `'pipeline_stage_to_stage'`
`LinkClass('<label>')`	`ValueError`	the member
`LinkClass((label, scale))`	the member	`ValueError`
`LinkClass('bogus')`	`ValueError`	`ValueError`
`str(member)`, `repr(InterLpLink)`	identical	identical
`pickle` round-trip `is` member	True	True
`member == str(member)`	False	False
`hash(member) == hash(member.name)`	True	True
`json.dumps(member)`	`TypeError`	`TypeError`
`declare(P, D, "prefill_to_decode", …)`	`TypeError: link_class must be a LinkClass, got str`	same
enum `repr(member)`	`<LinkClass.X: ('x', s)>`	`<LinkClass.X: 'x'>`

Why this is not a fallback:

LinkClass('traffic_to_engine') is an exact lookup of the member's own canonical value. Nothing is guessed, and any other string still refuses with ValueError.
The refusal that matters to callers is declare's refusal of a str. It is unchanged and pinned. The mutant declare_coerces_str coerces a str through LinkClass(link_class) before the type check. It fails test_a_link_class_is_not_a_string at the head (1 failed, 66 passed) and at the tip (1 failed, 73 passed).

Why this is harmless:

Nothing serialises or compares a LinkClass value. At no ref is there a LinkClass(, .value or !r on a link class.
compass: both clock transports from one implementation (CA-3, #46) #63's transport JSON carries message.kind.value, not a link class.
compass: what a run of the clock says about itself (CA-7, #50) #67's dump prints link.source and link.floor_seconds only.
The enum repr changes, but nothing formats it.

4. The 7 removed tests

Mutants were applied by mutate.py, which refuses unless the target text occurs exactly once. They ran over the three clock files on node 18 at the merged tree. Without a mutant, the tip gives 74 passed and the merged tree 67.

Removed test	What it pinned	Pinned now by	Mutant → result at head
`test_a_nonzero_floor_is_not_reported_as_serializing`	`serializing()`, which is removed	Acceptance of a zero floor, the part that remains: `test_a_zero_floor_is_a_declaration_and_not_an_error`	`zero_refused` (`floor < 0.0` → `<= 0.0`): FAIL `test_a_zero_floor…` (1 failed, 66 passed)
`test_inbound_links_come_back_in_the_total_order_whatever_order_they_were_declared`	`inbound` returns the row in total order	`test_inserting_a_participant_moves_nothing_that_was_already_declared` (L298)	`inbound_decl`: FAIL `test_inserting…` (1 failed, 66 passed). `inbound_rev`: FAIL `test_inserting…` (1 failed, 66 passed)
`test_the_tightest_link_is_the_one_that_bounds_the_run`	`tightest()`, which is removed	nothing remains to pin	n/a
`test_links_are_listed_in_a_stable_order`	`links()` and `LookaheadMatrix.__len__`, which are removed	nothing remains. `bool(empty matrix)` goes `False` → `True`, and no truth test exists at any ref	n/a
`test_the_three_link_classes_carry_the_scales_that_were_modelled`	`scale_seconds`, which is removed	nothing remains. The scale prose stays in the member comments	n/a
`test_the_admission_delay_is_kept_per_path`	the literal `TRAFFIC_TO_ENGINE_FLOOR_SECONDS`	nothing: now unpinned. Accepted, as the audit reasoned: the constant has no reader at the tip, and the test would equally block a deliberate re-measurement. Its reader arrives with #75 (`deployments.py:42`)	`serving_floor` (9.0e-3 → 8.0e-3): 67 passed at the head. At the tip it fails only the removed test (1 failed, 73 passed)
`test_the_children_really_did_register_in_different_orders`	the test's own rotation (the child's arrival order)	The production property it guarded, a registry that follows arrival order, is pinned by `test_the_total_order_is_the_same_in_every_process` and, in-process, by `test_the_order_does_not_depend_on_the_order_of_registration`	`ids_insertion`: FAIL, both named (4 failed, 63 passed). `ids_insertion` + child `rotate = 0`: the same 4 fail. `ids_hash` + `rotate = 0`: the same 4 fail

Coverage of the refactored production code:

F5: inbound_missing_empty fails test_a_row_missing_a_peer_is_refused_rather_than_handed_over_short. inbound_missing_outbound fails test_a_complete_row_has_one_entry_for_every_registered_peer and test_inserting….
F6: ids_insertion, above.
F8: strip_only, which keeps only the removed clause, fails test_a_name_that_would_not_survive_a_timeline_row_is_refused[pp stage 0]. Separately, strip()-differs and isspace() disagree on 0 of 1,114,112 code points.

Suite delta: --collect-only over the gate's own selection collects 5417 at the tip and 5410 at the merged tree. The node-id diff is exactly the 7 tests above, with nothing added.

5. F7b was skipped

LpRegistry.__contains__ is present at the head.
[] in registry raises TypeError: unhashable type: 'list' at the head and at the tip.
'decode' in registry gives False on both sides.

A gap in pinning this is non-blocking finding 1: the mutant contains_via_iter gives 67 passed.

6. Comments and docstrings

I read every sentence touched by the diff, and every sentence in the five files that named a removed member.

lookahead.py:
- the module docstring no longer names serializing;
- the LinkClass docstring and member comments say nothing about attributes that no longer exist;
- the InterLpLink docstring's "the accessors below hand the object itself to a caller" is still true: declare and inbound both do.
registry.py: the module docstring's "every ordered answer it gives is sorted at the point of iteration" is now literally true, and the ids() docstring dropped "cheapest to call repeatedly", which would now be false.
test_clock_lp_identity.py: the comment at L272 now names inbound and declare, which is correct.
test_clock_order_across_processes.py: the docstring's L22-24 on rotation is still true of the code. It no longer has a witness, which is what finding 3 is about.
A grep of the five files at the head for design-doc ids, "principle", gate labels, issue numbers, "audit" and "ponytail" finds nothing (AI_DEV_RULES: "No design-doc references in code or runtime output.").
No design doc names a removed member.

ruff 0.16.7 on the five files: check gives rc 0 on both sides. format --check gives rc 1 on both sides, for the same pre-existing hunk in test_the_total_order_is_the_same_in_every_process, shifted 6 lines. The delta is 0.

7. ponytail-review

I read the raw skills/ponytail-review/SKILL.md (md5 438e2414…).

test_clock_order_across_processes.py:L22-24,L63-64,L67,L74-77,L82,L104: delete: arrival rotation, unread since T2 and not needed by any mutant (ids_insertion/ids_hash caught identically with rotate=0). Register `names` directly; _child(seed).
net: -12 lines possible.

The production diff is lean. StrEnum for LinkClass would save the 2-line __str__, but it would make every member compare equal to its label string. That is a looser equality, not a simplification, so I do not list it.

8. Gate 1

How it was staged: git archive of the tip and of the stamp, with .compass-commit and .compass-changed written from the same refs. It was copied into xiaobizh_n18_cpu:/tmp/pr410r1/{control,merged}/ATOM with docker exec -i … tar -x, and the tarball md5 eb901f0e… matched on both ends.
How it was run: with each tree's own scripts/compass/gate_cpu.sh, bounded by timeout -k 10 3600 and not piped. atom.__file__ was asserted under each root. No other gate_cpu.sh was running.

Tree	`commit:` stamp	Result
Merged: `5f9ee034ec6d`, tip `60186b80c` + head	`1024cf908`	5273 passed, 155 skipped, 3 xfailed (189 s)
Control: tip `4116a63a9`	`4116a63a9`	5280 passed, 155 skipped, 3 xfailed (183 s)
Merged at the earlier tip: `d58491587e6c`	`dbb5fcc60`	5273 passed, 155 skipped, 3 xfailed (181 s)

Delta: 5280 → 5273, −7 passed. The skipped and xfailed counts are unchanged.
Why the 4116a63a9 control stands for the new tip: --collect-only node ids are identical for the tips 4116a63a9 and 60186b80c (5417), and identical for the two merged trees (5410). Between tip and merged tree, the collect diff is 7 removed and 0 added, and those are the 7 tests in §4.
gpu: not required on every tree.
No timing flake fired, so nothing was re-run.

Blocking: none.
Non-blocking: the 3 inline findings. None of them needs to be answered before landing.

…k refusal text; drop the arrival rotation (#417) Follow-ups from the review of #410 (the clock ponytail audit). - test_membership_and_size now requires `[] in registry` to raise TypeError. This pins the ruling that kept LpRegistry.__contains__ (principle 6). Before, deleting __contains__ passed all 67 clock tests. - test_declaring_the_same_link_twice_is_refused now matches "already declared as .*prefill_to_decode, floor=0\.001s". The refusal must name the declaration that stands, which exercises LinkClass.__str__ through InterLpLink.__repr__. - The arrival rotation in test_clock_order_across_processes.py is removed. Each child registers NAMES, which is unsorted. That alone lets the cross-process test catch an insertion-order registry; with NAMES sorted, that test passes under the mutant. Mutants that each turn one named test red: - contains_via_iter - contains_isinstance - str_is_name - del_str - repr_drops_class - refusal_names_attempt ids_insertion and ids_hash fail the same tests with and without the rotation. All 67 tests pass under five parent hash seeds. The suite delta is +0; the collect-only diff is empty. Gate (node 18, CPU tier, merged tree on 09891e1): 5275 passed, 155 skipped, 3 xfailed, GATE_CPU_RC=0. Closes #414 Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

…rule Base update authorized by the owner on 2026-09-24 ("go ahead and update the clock chain"). The PR keeps its need human label. This commit only resolves the merge. Resolved files: - atom/compass/clock/identity.py, lookahead.py, registry.py, tests/compass/test_clock_lp_identity.py, tests/compass/test_clock_order_across_processes.py: took the integration side whole. This branch carried each one byte-identical to the pre-#410 tip (the #52 landing), so every differing line came from #410 or #417. - atom/compass/clock/__init__.py: this branch's docstring, imports and __all__ (ClockAuthority, the state types), plus the paragraph #53 added on the tip. That paragraph holds for authority.py and state.py: both import only math, enum and dataclasses, and build no set. - atom/compass/design/12_open_items.md: kept both sides' rows. The tip had meanwhile landed P0.6's T83 and T84, so this branch's two rows are renumbered T89 (no retire call on the protocol) and T90 (grant count depends on arrival order), and T90's pointer to "T83 above" now reads T89. The register header now reads 90 rows, T1-T90 with no gaps, 84 open, counted with the header's own grep rule; the allocation sentence names T88 with #196 and T89-T90 with CA-2. - atom/compass/design/README.md: the TODO count line reads 90 registered, T1-T90 with no gaps, 84 open, with the tip's struck list. No member removed by #410 appears anywhere in the merged tree. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Base update authorized by the owner on 2026-09-24 ("go ahead and update the clock chain"). This commit only resolves the merge, which brings in #59's merge of fork/feature/atomcompass_new (3a3267a). Resolved files: - atom/compass/design/12_open_items.md: conflicted on the two TODO rows this branch edits. #59's merge renumbered them T83 -> T89 and T84 -> T90, because the tip had landed P0.6's T83 and T84. Kept this branch's edited text of both rows under the new numbers, after the tip's T88. T90's pointer to "T83 above" now reads T89. This branch's T70 edit merged cleanly. The register still counts 90 rows, T1-T90, 5 struck. - atom/compass/design/01_execution_and_time_model.md (merged without a conflict, edited here so it stays true): this branch's two citations of those rows now use the new numbers, "(T90 records CA-2's reviewer ...)" and "T89: a run whose work is finished ...". The other T83/T84 mentions in the tree are P0.6's and are unchanged. No member removed by #410 appears anywhere in the merged tree. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

…arness Base update authorized by the owner on 2026-09-24 ("go ahead and update the clock chain"). This commit only records the merge, which brings in #59's merge of fork/feature/atomcompass_new (3a3267a). Resolved files: none. The merge had no conflicts, and no file was edited beyond what git merged. This branch's own files (tests/compass/clock/) read TRAFFIC_TO_ENGINE_FLOOR_SECONDS and the LinkClass members, all of which #410 kept. No member removed by #410 appears anywhere in the merged tree. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

…an PR (#437) The need human label stopped every commit on a held PR, with one exception: gh stack link. So a held branch could not take the base update the branch-update rule calls for, and it drifted further from the tip with every landing. After #410 and #417, the held clock chain conflicted with the tip in 8 files, and the owner had to authorize each update by hand (2026-09-24). This adds a second exception. An agent may merge as the branch-update rule calls for, and nothing else: - For an unlinked child whose parent landed, the agent patches the PR's base via REST just before the push. A refused merge therefore never leaves a patched base. - The merge keeps every change from both sides. Where it cannot, the agent commits nothing and names the conflict hunk in a PR comment. This also rules out -s ours and -X ours. - A PR comment lists each resolved file. - The label allows one delta review of the resolutions. - Only the owner removes the label. The review measured why the patch timing matters on #61. Merging without patching the base shows 122 files. Patching and then refusing the merge shows 7 files / +2208, of which 1457 lines are the landed #60. Merging and patching keeps #61's own 3 files. No test or script reads the file. Gate (node 18, CPU tier, merged tree on 1dc8939): 5280 passed, 155 skipped, 3 xfailed, GATE_CPU_RC=0. Closes #434 Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

jgong5 mentioned this pull request Sep 24, 2026

compass(clock): ponytail-audit of atom/compass/clock/ and its tests, then apply it #406

Closed

jgong5 commented Sep 24, 2026

View reviewed changes

jgong5 marked this pull request as ready for review September 24, 2026 04:15

jgong5 merged commit 9a63179 into feature/atomcompass_new Sep 24, 2026

jgong5 mentioned this pull request Sep 24, 2026

compass(rules): let agents merge the integration tip or parent head into a need-human branch (base update only) #434

Closed

Navigation Menu

compass(clock): apply the ponytail-audit of atom/compass/clock/ (#406 phase 2) - #410

compass(clock): apply the ponytail-audit of atom/compass/clock/ (#406 phase 2)#410
jgong5 merged 1 commit into
feature/atomcompass_newfrom
compass/issue-406

jgong5 commented Sep 24, 2026

Uh oh!

jgong5 Sep 24, 2026

Uh oh!

jgong5 Sep 24, 2026

Uh oh!

jgong5 Sep 24, 2026

Uh oh!

jgong5 commented Sep 24, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

		@@ -76,6 +72,3 @@ def __iter__(self):

		def __len__(self) -> int:
		return len(self._members)

Mutant	Failures
`ids_insertion` (`tuple(self._members)`), rotation on	4 failed
`ids_insertion` with the child's `rotate = 0`	the same 4 failed
`ids_hash` with `rotate = 0`	the same 4 failed

Conversation

jgong5 commented Sep 24, 2026

What this does

Findings applied, each beside its measurement

Differential probe: byte-identical except the pre-tagged lines

Suite delta: exactly the 7 removed tests

AST and line changes, production and tests separately

Held-PR overlap

Uh oh!

jgong5 Sep 24, 2026

Choose a reason for hiding this comment

Uh oh!

jgong5 Sep 24, 2026

Choose a reason for hiding this comment

Uh oh!

jgong5 Sep 24, 2026

Choose a reason for hiding this comment

Uh oh!

jgong5 commented Sep 24, 2026

1. Tip and merged tree

2. Callers of removed members

3. Ruling on LinkClass: harmless, not a fallback

4. The 7 removed tests

5. F7b was skipped

6. Comments and docstrings

7. ponytail-review

8. Gate 1

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

3. Ruling on `LinkClass`: harmless, not a fallback