feat(loop): tri agree - two implementations of one rule, asked the same question

[gHashTag]

Stacked on #473 → #471. Merge in order; bases retarget automatically.

The defect class this repository keeps paying for

Every expensive failure here has been one rule written twice, drifting, with nothing comparing them:

• the boundary rule in three copies — only two knew ## Границы, so seven bees were accused of straying
• can_start_another in five
• five SR-00 rules retyped into TypeScript — three disagreed in production
• eleven more from the rings audit

Yesterday it cost 153 dispatches (#472). The thing that hid it was a comment asserting the two functions could not disagree.

A comment claiming two functions agree is a test that has not been written. This is that test. It does not read the comment and does not reason about the code — it runs both implementations over the rows the system actually holds.

The precedent is already in the tree: t27-parity.mjs does exactly this across languages, 460 cases against the deployed twin. This is the same instrument pointed at two functions in one file, which is where drift is cheapest to create and hardest to see.

The first run corrected the round that motivated it

pair "answered-criteria" - which promised criteria did the bee answer?
  A: unjudgedCriteria (matches by text)
  B: missingVerdictSlots (matches by slot number)

358 row(s) compared, 24 skipped
  agree : 11
  DIFFER: 347

A missed something B found on 196 row(s); B missed something A found on 151.
BOTH directions are populated, so neither side is the rule and picking
one would trade this defect for its mirror image.

    76  sendBack: A=4 B=5 of 5
    44  accept:   A=4 B=0 of 4
    34  accept:   A=5 B=0 of 5

In #472 I wrote that missingVerdictSlots was "the right answer the repository already had." It is not. 156 blocks carry no numbering at all, and slot matching finds nothing covered on every one of those 156 — wiring it would have marked every criterion in 44% of the board unanswered. Corrected at the call site and on that PR.

That is why divergence is reported with its direction. A bare "347 differ" invites picking a winner, and here neither side is the rule.

What it does not claim

Agreement is not correctness. Two implementations can be wrong together and this cannot see that — the same limit rejudge carries and states in its own output. What it rules out is the other case: a divergence sitting in the open behind a sentence saying it cannot happen.

It runs the deployed module, never a copy. Copying the rule into this file would make it the third implementation — the defect it was written to catch.

Calibration

Three cases, each proving a negative:

• a row neither side could answer is skipped, not agreement — counting it as agreement is how a gate reports health for rows it never looked at
• an unreadable row accuses neither side
• a one-way divergence must not claim "both directions", or the sentence stops meaning anything when it does appear
• agreement is never rendered as proof

node .trinity/loop/selftest.mjs — 260 passed, 0 failed. Report-only, in the heal chain, exit 2 on divergence.

🤖 Generated with Claude Code

[gHashTag]

Second and third pairs: one rule, three languages, three processes

A gate that only works on the case it was written for is not a gate. This adds the hardest shape available.

"Which paths may this bee touch?" is answered in the loop's own JavaScript, in the deployed TypeScript, and in the SR-00 Swift ring. A fourth copy sits in queen-brief-shape.ts, whose comment justifies itself with "that copy is module-private" — it is exported now. The stated reason expired and nobody noticed, which is the argument for testing the claim instead of reading it.

This rule has already cost real work: two copies knew ## Границы and one did not, and seven bees were accused of straying outside a boundary they had honoured. The heading was added everywhere; nothing was added that would notice the next divergence.

The answer is agreement, reported plainly

pair "boundary-js-vs-ts"      521 compared   agree 521   DIFFER 0
pair "boundary-ts-vs-swift"   521 compared   agree 521   DIFFER 0

All three return identical path lists on all 521 issue bodies with a boundary section, and on 18 adversarial shapes besides — backticked paths before commas, nested brackets, tab-separated markers, markdown emphasis, two paths on one line. The Swift comment predicts sequential stripping mishandles a backtick before a comma; it does not, because the TypeScript trailing class contains the backtick.

So these are regression guards, not finds — and the output says so rather than letting a clean line read as a discovery.

A missing compiler is not agreement

With swiftc unavailable:

0 row(s) compared
  unreadable, so NOT counted against either side: 521
  NOT BUILT, so nothing is claimed about it: swift
NOTHING was compared. An unbuildable side is not an agreeing one.
exit=3

A pair that compared zero rows no longer counts as a pair that ran — "0 diverging rows" must never be able to mean "we could not look".

Notes

• The TypeScript side is extracted from the shipping ref, not reimplemented. A reimplementation would be the fifth copy of this rule, in the file whose purpose is to complain about there being four.
• One build per script, shared by both boundary pairs: building the ring twice for two questions about the same rows could yield two answers for one run.
• Two new calibration cases: every declared pair is runnable for its kind with no duplicate names, and an unbuilt side classifies unknown.

selftest 262 passed, 0 failed.

[gHashTag]

tri idle — the one number nobody was measuring

The operator's golden rule is that the bees work, and start again the moment they finish. Twenty instruments here count issues, verdicts, briefs, branches and disagreements. None measured whether the swarm was working — and it had been false for a long time:

minutes with ZERO bees working : 356 of 721  (49%)
minutes with every bee working : 268         (37%)
median gap between bursts      : 18.4 min against a 5-minute tick
gaps under a minute            : 1 of 18      <- the golden rule lives here

136 round(s) FAILED in the log window:
   135  GitHub returned 403
     1  deadlock detected

The cause is fixed in #476. This is the instrument that would have surfaced it on day one.

Why the dashboard could not show it

bees running (of 4) has been on the board for weeks. It is an instant — one sample per iteration — of a quantity that turns out to be bimodal, and it read 4 as often as 0.

A rate needs a window; an instant needs none, which is exactly why the instant is the one that gets measured.

It restarts nothing

Idleness has several causes — a failing round, an empty backlog, a full volume, a refused key — and the cure differs for each. It names the cause and stops.

A calibration case caught a real defect before it shipped

A twenty-minute window sampled inclusively holds twenty-one one-minute buckets, so a half-idle window measured 52%. The loop is t < to now. That is what those cases are for.

The other two pin the parts that would otherwise flatter: overlapping bees are one burst so no gap is invented between them, and gaps longer than the tick are reported as "rounds are running and starting nothing" — a different fault from "rounds are rare" — with a branch that refutes it when gaps are within cadence.

selftest 265 passed, 0 failed.