Repository navigation
port(trios-chat): land 66 open CR-CHAT-03/04/07 port PRs in one merge (Refs #8884) - #10098
Merged
Merged
Conversation
The eighth W2 target of the CR-CHAT-04 ring tracker: the pattern uniformity rules for padding blocks - batch bound, duplicate block id, size floor, sample floor and ceiling, and the f64 chi-squared ceiling - as the D5 verdict with the original's rule order and all ten PBPU tests transcribed plus helper and rule-order tests. The BTreeSet duplicate probe becomes a scan over the visited blocks; the chi-squared value arrives as f64 and the comparison runs in f64; the loop fixtures read their id bytes and chi values from const tables, so no narrowing cast appears anywhere in the file. Checks (conventions 0-14): t27b test 13 passed 0 failed; t27c test-report 13/13, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH; ledger row included (pass, 28/28 untouched).
The thirteenth W2 target of the CR-CHAT-04 ring tracker: the diversity rules for class transitions - the batch bounds (8..4096), the per-observation zero-id, duplicate-id and self-move scans, and the floor of three distinct (from, to) moves - as the D5 verdict with every payload field, the original's rule order, and all ten PCTE tests transcribed plus helper and rule-order tests. The BTreeSet id probe becomes a scan of the visited observations, the transition set a scan of the moves already seen; the loop fixtures read their id bytes and class indices from const tables, so no narrowing cast appears anywhere in the file. Checks (conventions 0-14): t27b test 16 passed 0 failed; t27c test-report 16/16, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH; ledger row included (pass, 28/28 untouched).
The sixteenth W2 target of the CR-CHAT-04 ring tracker: the randomness rules for fill bytes - the batch ceiling, the per-block zero-id, duplicate-id, size-floor, unique-byte-floor and chi-squared-ceiling scans - as the D5 verdict with every payload field, the original's rule order, and all ten PFBR tests transcribed plus helper and rule-order tests. The BTreeSet id probe becomes a scan of the visited blocks; the loop fixture reads its id bytes, sizes, unique counts and chi values from const tables, so no narrowing cast appears anywhere in the file. The chi-squared and unique-byte counts arrive as numbers the caller computed over the bytes - no fill byte reaches the spec. Checks (conventions 0-14): t27b test 14 passed 0 failed; t27c test-report 14/14, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH; ledger row included (pass, 28/28 untouched).
…Refs #8884) The seventeenth W2 target of the CR-CHAT-04 ring tracker: the domain separation rules for padding key derivation labels - the batch ceiling, then per record the empty-label probe, the approved-set scan, the zero-context probe and the repeated-pair scan - as the D5 verdict with every payload field, the original's rule order, and all ten PKDS tests transcribed plus helper and rule-order tests. The original's String labels become zero-padded [16]u8 byte forms (t27 has no String); the approved BTreeSet becomes a four-const scan, and the (label, context) BTreeSet a scan over the visited records. The duplicate rule never answers DuplicateLabel - a repeated label fails only when its pair repeats - and the variant stays in the enum, declared and unreachable exactly as in the original. Checks (conventions 0-14): t27b test 15 passed 0 failed; t27c test-report 15/15, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
…efs #8887) The third CR-CHAT-07 ring target (W2, R-CHAT-10): the interval-regularity rules - the batch ceiling, the burst floor (an empty batch fails it), then per burst the zero-id probe, the repeated-id scan and the zero-interval probe, then over the whole batch the standard-deviation floor (the integer root of the mean squared deviation, at least five hundred microseconds) - as the D5 verdict with every payload field, the original's rule order, and all ten CTBI tests transcribed plus helper and rule-order tests. The original's approx_sqrt Newton iteration becomes the bisection over the whole answer range; the u128 variance accumulator becomes u64 (every fixture's diff squares sit far below the ceiling, documented). The BTreeSet dedup becomes a visited scan. Checks (conventions 0-14): t27b test 12 passed 0 failed; t27c test-report 12/12, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
…rd (Refs #8887) The fourth CR-CHAT-07 ring target (W2, R-CHAT-10): the destination-rotation rules - the batch ceiling, then per emission the zero-destination probe, the repeated-id scan and the strictly-increasing timestamp, then over the whole batch the per-destination ceiling (at most ten emissions to one destination) and the unique-destination floor (at least three) - as the D5 verdict with every payload field (the offending destination bytes and its count for the ceiling, prev and current timestamps for the monotonic break), the original's rule order, and all ten CDRF tests transcribed plus helper and rule-order tests. The BTreeSet id dedup becomes a visited scan; the BTreeMap destination counter becomes the per-emission count scan; the unique count is the first-occurrence scan of the distribution lane. Checks (conventions 0-14): t27b test 12 passed 0 failed; t27c test-report 12/12, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
…8887) The fifth CR-CHAT-07 ring target (W2, R-CHAT-10): the destination-uniformity rules - the batch ceiling, the emission floor (twenty), then per emission the zero-destination probe and the declared-set membership, then over the declared destinations the per-destination floor (five) and the dominance ceiling (no destination over three quarters, integer cross-multiplication against a truncated quarter) - as the D5 verdict with every payload field, the original's rule order, and all ten CDUG tests transcribed plus helper and rule-order tests. The slice-of-arrays declared-set parameter becomes the DeclaredDest record form; the BTreeMap counter becomes the per-emission count scan; the per-destination walk runs over the declared destinations. The original's million-record TooMany fixture exceeds the t27b runner's stack ceiling - the port documents the limit and covers the ceiling from below with the largest buildable batch (a hundred thousand), the rule itself staying in the code. Checks (conventions 0-14): t27b test 12 passed 0 failed; t27c test-report 12/12, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
…y guard (Refs #8887) The eleventh CR-CHAT-07 ring target (W2, R-CHAT-10): the inter-destination timing rules - the batch ceiling, then per emission the zero-destination probe, the zero-timestamp probe and the strictly-increasing timestamps, then per destination the two-emission floor and over at least two destinations the stddev ceiling of five thousand - as the D5 verdict with every payload field, the original's rule order, and all ten CIDT tests transcribed plus helper and rule-order tests. The original's stddev folds float means of u64 sums - the int-to-float casts do not lower - so the standard deviation arrives caller-computed per the lane convention; the structural rules stay fully in the spec. The original's BTreeMap walk visits destinations in byte order of their hashes; the port's floor walk enumerates the distinct destinations in the same byte order, so the failing destination's index is its byte- order rank exactly as the original reports. Fixture stddevs are Python-verified exact: the split batch 74250, the uniform batch 250, the twenty-emission walk 1.414. Checks (conventions 0-14): t27b test 12 passed 0 failed; t27c test-report 12/12, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The fifteenth CR-CHAT-07 ring target (W2, R-CHAT-10): the replay rules - the batch ceiling, then per window the zero-index probe, the zero-hash probe, the emission floor (ten; the exact boundary passes), the strictly-increasing index and the repeated-hash scan - as the D5 verdict with every payload field, the original's rule order, and all ten CTRD tests transcribed plus helper and rule-order tests. The BTreeSet dedup becomes a scan over the windows already visited; the hashes stay the fixed [32]u8 form. Checks (conventions 0-14): t27b test 12 passed 0 failed; t27c test-report 12/12, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The sixteenth CR-CHAT-07 ring target (W2, R-CHAT-10): the size-distribution rules - the batch ceiling, the observation floor (sixteen; an empty batch fails it), then per observation the zero-id probe, the repeated-id scan and the zero-size probe, then - both trains present - the Kolmogorov-Smirnov-like distance ceiling over the real and cover empirical distributions (scaled by ten thousand, two thousand the ceiling) - as the D5 verdict with every payload field, the original's rule order, and all ten CTSD tests transcribed plus helper and rule-order tests. The original's KS fold is u64 integer arithmetic throughout, so it ports whole with no float and no caller-computed statistics; the sort-and-dedup of the size union becomes the ascending distinct-size walk, and the cumulative counts read the records directly. The BTreeSet dedup becomes a visited scan. The split fixture measures a distance of exactly ten thousand. Checks (conventions 0-14): t27b test 12 passed 0 failed; t27c test-report 12/12, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The eighteenth CR-CHAT-07 ring target (W2, R-CHAT-10): the timing-correlation rules - the window ceiling, the presence of both trains, then per emission the consecutive-real probe and the one-cover floor between reals, then over the whole window the always-follows rejection (every cover directly after a real is a correlated pattern) - as the D5 verdict (no payloads, the code alone), the original's rule order, and all ten CTCG tests transcribed plus a rule-order test. The original's CTCG-02 ignores its result; the verified outcome is CoverAlwaysFollowsReal (the single cover of real, cover, real sits directly after a real), and the port pins it with the discrepancy named. The original declares two counters twice; the port declares each once. Checks (conventions 0-14): t27b test 11 passed 0 failed; t27c test-report 11/11, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
#8887) The nineteenth CR-CHAT-07 ring target (W2, R-CHAT-10): the jitter-uniformity rules - the batch ceiling, the empty batch (accepted), the interval floor, the interval ceiling (unreachable through the tighter batch ceiling - the original's CTJU-03 exercises the batch rule, the port follows), then per observation the repeated-id scan, then the mean floor and the coefficient-of-variation ceiling (std over mean, x1000, integer cross-multiplication) - as the D5 verdict with every payload field, the original's rule order, and all ten CTJU tests transcribed plus helper and rule-order tests. The original's u64 arithmetic with isqrt ports whole - the Newton iteration becomes the bisection over the whole answer range. Fixture statistics are Python-verified exact: the spiked batch CV 1980 over the ceiling of 300, the uniform walks 96 and below. Checks (conventions 0-14): t27b test 12 passed 0 failed; t27c test-report 12/12, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
…8887) The twentieth CR-CHAT-07 ring target (W2, R-CHAT-10): the ratio-stability rules - the batch ceiling, the empty batch (accepted), the observation floor, then per observation the zero-id probe and the repeated-id scan, then the mean floor (a ratio of at least one half) and the coefficient-of- variation ceiling (a fifth, scaled by a thousand) - as the D5 verdict with every payload field, the original's rule order, and all ten CTVS tests transcribed plus helper and rule-order tests. The original's u64 arithmetic with isqrt ports whole - the Newton iteration becomes the bisection over the whole answer range. Fixture statistics are Python-verified exact: the spiked batch CV 1285 over the ceiling of 200, the stable batch 12, the thirty-window walk 20. Checks (conventions 0-14): t27b test 12 passed 0 failed; t27c test-report 12/12, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The twenty-first CR-CHAT-07 ring target (W2, R-CHAT-10): the volume-stability rules - the batch ceiling, the empty batch (accepted), then per window the zero index, the volume floor (ten), the volume ceiling (ten thousand), the strictly- increasing index and the deviation ceiling (fifteen hundredths of the mean) - as the D5 verdict with every payload field, the original's rule order, and all ten CTSG tests transcribed plus a rule-order test. The original folds a float mean over u64 volumes; the int-to-float casts do not lower under the backends. The deviation rule re-bases to the original's exact rational arithmetic in u64 - the deviation from the mean sum/len is |v*len - sum| / sum, so the ceiling is the integer cross-multiplication |v*len - sum| * 100 > sum * 15 - identical verdicts for every input, no float anywhere. The float mean still arrives as a caller-computed number to ride the verdict's payload field, the lane convention. Checks (conventions 0-14): t27b test 11 passed 0 failed; t27c test-report 11/11, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The twenty-second CR-CHAT-07 ring target (W2, R-CHAT-10): the decoy-entropy rules - the batch ceiling, then per decoy the length floor (32), the length ceiling (16384), the all-identical probe, the unique-byte floor (the original's rounded-then-truncated double check) and the max-frequency ceiling (a third of the payload) - as the D5 verdict with every payload field, the original's rule order, and all ten DMPE tests transcribed plus helper and rule-order tests. The original's BTreeMap byte-frequency table becomes the fixed 256-slot counter table of the entropy lane: unique_count counts the nonzero slots, max_freq scans them, the fixture tables are built by byte-index loops with the index arithmetic in usize - no narrowing anywhere. Checks (conventions 0-14): t27b test 12 passed 0 failed; t27c test-report 12/12, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
…8887) The twenty-third CR-CHAT-07 ring target (W2, R-CHAT-10): the single-payload rules - the length floor (sixty-four), the all-same-byte probe and the repeating-pattern rejection (a two-to-four-byte pattern filling the payload four or more times) - and the pair rules - the pair floor (two), then per pair the decoy's own validation and the length match with its real - as the D5 verdict (no payloads, the code alone), the original's rule order, and all ten DPIG tests transcribed plus helper and rule-order tests. The original's slice pairs become a DecoyPair record (both payloads at a fixed 128-byte capacity plus lengths); the validate functions take the buffer plus its length (the timing-side lane form), and the varied fixtures walk (i * 131 + 17) mod 256 through the identity byte table - no narrowing anywhere. The scanner state hoists above the pattern-length loop (the constant-range unroller). Checks (conventions 0-14): t27b test 12 passed 0 failed; t27c test-report 12/12, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The twenty-fourth CR-CHAT-07 ring target (W2, L-CHAT-7-funnel, R-CHAT-10): the Tailscale-funnel egress fingerprint rules - the locked TLS class (version 0x0303, ALPN h2, cipher TLS_AES_128_GCM_SHA256) checked before any binning, the length quantiser (largest canonical class the bytes reach, smallest below), and the burst-gap quantiser (same shape at finer resolution) - as the D5 verdict (Ok plus the single NonCanonicalTls rejection, the two quantised axes riding every accept), the original's rule order, and all six EFP tests transcribed plus helper and rule-order tests. The original's single-variant enums AlpnId and CipherId keep their one canonical variant; the class comparison reads the fields directly. The binning folds scan the class arrays. Checks (conventions 0-14): t27b test 8 passed 0 failed; t27c test-report 8/8, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The twenty-fifth CR-CHAT-07 ring target (W2, R-CHAT-10): the cadence rules - the window floor (two), the cover-fraction floor (a quarter, the original's percent fold), the real-over-cover ceiling (never twice the covers), then per emission the consecutive-real ceiling (three; the exact boundary passes) and the consecutive-cover ceiling (eight; the all-cover window passes) - as the D5 verdict (no payloads, the code alone), the original's rule order, and all ten ECAD tests transcribed plus a rule-order test. CoverFractionTooHigh is declared and unreachable in the original - no rule compares against the maximum cover fraction - and stays in the enum, declared and unreachable exactly as in the original. The original's u64 percent fold ports whole with the count widening by the int cast. Checks (conventions 0-14): t27b test 11 passed 0 failed; t27c test-report 11/11, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The twenty-sixth CR-CHAT-07 ring target (W2, R-CHAT-10): the size class distribution rules - the batch ceiling, the observation floor (forty), then per observation the valid-class scan, then the presence of all four classes, then per class in ladder order the per-class floor (ten) and the dominance ceiling (three quarters, the integer cross-multiplication against a truncated quarter) - as the D5 verdict with every payload field, the original's rule order, and all ten MSCD tests transcribed plus helper and rule-order tests. The original's BTreeMap count table and HashSet membership become scans over the fixed class ladder; the per-class walk runs in ladder order exactly as the sorted-key BTreeMap iteration does. The million-and-one too-many fixture builds in a loop, the batch rule firing before any observation is examined. Checks (conventions 0-14): t27b test 12 passed 0 failed; t27c test-report 12/12, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The twenty-seventh CR-CHAT-07 ring target (W2, R-CHAT-10): the path diversity rules - the path-pair floor (two), then per path the length floor (three), the length ceiling (eight) and the per-relay zero probe and in-path duplicate scan, then per consecutive pair the overlap ceiling (one shared relay; the measured overlap riding the verdict) - as the D5 verdict with the one payload field, the original's rule order, and all ten MPDG tests transcribed plus helper and rule-order tests. The original's slice-of-slices parameter becomes a MixPath record with a fixed eight-relay capacity plus its length; the pair overlap takes both paths' lengths explicitly so the zero tail of the capacity never counts. The BTreeSet probes become scans. Checks (conventions 0-14): t27b test 12 passed 0 failed; t27c test-report 12/12, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
) The twenty-eighth CR-CHAT-07 ring target (W2, R-CHAT-10): the flow direction rules - the batch ceiling, the strictly-increasing timestamps (the empty batch accepted before them), then over a non-empty batch the inbound floor (ten), the outbound floor (ten) and the ratio ceiling (the larger over the smaller, rounded integer fold, ceiling three) - as the D5 verdict with every payload field (the count and min for the floors, the inbound and outbound counts for the ratio), the original's rule order, and all ten NFDU tests transcribed plus helper and rule-order tests. The original's rounded ratio is pure usize arithmetic and ports whole; the empty batch guards the 1..len range before it runs (the range length underflows on an empty slice). Fixtures verify the ratio math exactly: twenty-to-ten passes at a ratio of two, forty-to-ten answers the ceiling at four. Checks (conventions 0-14): t27b test 12 passed 0 failed; t27c test-report 12/12, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The twenty-ninth CR-CHAT-07 ring target (W2, R-CHAT-10): the fingerprint rotation rules - the tracked ceiling, the empty batch accepted, then per session the empty-fingerprint probe and the length ceiling, then the run fold (a session equal to its predecessor grows the same-fingerprint run, a run past the window of eight answers NoRotation with the run length, a change counts one rotation), then the rotation ceiling over the whole batch - as the D5 verdict, the original's rule order, and all ten OFRG tests transcribed plus helper and rule-order tests. The original's SameAsPrevious is declared and unreachable and stays in the enum. The original's Vec<u8> fingerprint becomes the fixed [128]u8 capacity plus its length; the Option<&[u8]> previous becomes a has-previous flag over the record fields. The rule-order probes pin the observable orders: the tracked ceiling answers over a flooded batch of empty forms, the per-session probes answer inside the loop before the rotation ceiling is read (a sixty-fifth rotation waits while the last session answers its own empty or over-long code), and the run fold answers NoRotation at nine. Checks (conventions 0-14): t27b test 12 passed 0 failed; t27c test-report 12/12, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The thirtieth CR-CHAT-07 ring target (W2, R-CHAT-12, RFC 9420 12.4.3.3): the Welcome ratchet_tree extension rules - the present-but-empty extension probe (a downgrade), the leaf-count pre-pass (the minimum-leaf floor, then the counted leaves against the welcomer's claim), then per node the index range over the derived node count, the duplicate-index probe and the leaf signature probe; blanks hold no index claim and skip - as the D5 verdict (all five original variants carry no payload, so the code is the whole verdict), the original's rule order, and all ten RTX tests transcribed plus helper and rule-order tests. The original's enum-with-payload tree nodes become a kind enum plus one record form; the Vec<u8> signature blob becomes the fixed [64]u8 capacity plus its length; the welcomer's view struct becomes the expected-leaf-count parameter; the BTreeSet of seen indices becomes a scan over the visited nodes that skips blanks. The original's saturating node count saturates only past two billion leaves - the port spells the saturated edge explicitly. The crate-Result convenience adapter stays with the crate; the core validator is what ports. Checks (conventions 0-14): t27b test 13 passed 0 failed; t27c test-report 13/13, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The thirty-first CR-CHAT-07 ring target (W2, R-CHAT-7): the inter-burst timing rules - the batch ceiling (1024), the empty-burst scan over the whole batch (answering with the burst's timestamp), the short-batch acceptance, then the interval walk (a timestamp not strictly increasing answers first, then the interval floor of five hundred, then the interval ceiling of three hundred thousand) and the variance ceiling (sixty thousand) over the floored mean of the collected intervals - as the D5 verdict with every payload field (got and min for the short rule, got and max for the long rule, variance and max for the variance ceiling, the timestamp for the empty burst), the original's rule order, and all ten TBPU tests transcribed plus the rule-order test. The original's Vec<u64> of collected intervals becomes two walks that re-derive each interval from the proven-increasing timestamps - the first sums them, the second finds the largest deviation from the floored mean. The mean keeps the original's integer division. Checks (conventions 0-14): t27b test 11 passed 0 failed; t27c test-report 11/11, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The thirty-second CR-CHAT-07 ring target (W2, R-CHAT-7): the shaped-burst uniformity rules - the count floor (two), the count ceiling (two hundred fifty-six), the first burst's size floor (sixty-four) and ceiling (sixty-five thousand five hundred thirty-six), the per-burst size walk (a size differing from the first answers before that burst's own floor and ceiling), and the interval uniformity walk over batches of three or more - as the D5 verdict (all six original variants carry no payload, so the code is the whole verdict), the original's rule order, and all ten TSBU tests transcribed plus re-basing and rule-order tests. The original casts timestamps to i64 to subtract the gaps; the gap equality is re-based additively - gap(i) equals gap(0) exactly when ts[i+1] + ts[0] equals ts[1] + ts[i], pure u64 addition - and a dedicated test pins the preserved edge: a uniformly decreasing batch stays accepted, as with the original's equal negative gaps. Batches of two skip the interval walk exactly as the original's length-three gate. Checks (conventions 0-14): t27b test 12 passed 0 failed; t27c test-report 12/12, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The thirty-third CR-CHAT-07 ring target (W2, R-CHAT-10): the window volume rules - the window ceiling (one hundred twenty-eight), the emission floor (four), the per-emission zero probe, single-emission ceiling (sixteen thousand three hundred eighty-four) and narrow volume band (seven hundred sixty-eight to twelve hundred eighty), then the standard-deviation ceiling over the window - as the D5 verdict (all six original variants carry no payload, so the code is the whole verdict), the original's rule order, and all ten TVCG tests transcribed plus the rule-order test. The original's standard-deviation ceiling is float arithmetic - the f64 mean, variance and sqrt against 256 * 0.9. t27 has no int-to-float cast, so the check is re-based to the exact rational form in pure u64: with S the volume sum, n the window length and W the fold of squared deviations |v*n - S| squared, the variance is W/n^3 exactly and the ceiling fires exactly when 25*W > 1327104*n^3, because (256*0.9)^2 is 1327104/25. The f64 original rounds only within a band of relative width about 1e-16 around the boundary; no original test sits there (the accepted boundary fixture answers a standard deviation of one hundred eighty-one, the rejected one two hundred fifty-six, against the cut of two hundred thirty point four). The original's saturating low bound never saturates at its constants and ports as the plain band edge. Checks (conventions 0-14): t27b test 11 passed 0 failed; t27c test-report 11/11, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The thirty-fourth CR-CHAT-07 ring target (W2, R-CHAT-10): the statistical gap distribution rules - the empty batch accepts, the observation ceiling (one thousand twenty-four), per gap the zero probe and the canonical-set probe, then over batches of eight or more the class census with its dominance ceiling (no class over three quarters of the total, cross-multiplied) and the standard-deviation ceiling over the gap class indices - as the D5 verdict (all six original variants carry no payload, so the code is the whole verdict), the original's rule order, and all ten WTAG tests transcribed plus helper and rule-order tests. Two variants are declared and never answered, kept exactly as the original keeps them: InsufficientSamples (the prose lists a sample floor but the code gates the statistics at eight and accepts smaller batches) and StdDevTooHigh (the indices span exactly three rungs, and a spread over a range never strictly exceeds half of it - Popoviciu - so the variance never strictly exceeds the cut of nine quarters; no input fires it). The float standard-deviation ceiling is re-based to the exact rational form in pure usize: with S the index sum, n the batch length and W the fold of squared deviations |i*n - S| squared, the variance is W/n^3 exactly and the ceiling fires exactly when 4*W > 9*n^3, because 1.5^2 is 9/4. The helper's direct test pins the mathematical maximum - the first and last classes split evenly answer a standard deviation of exactly the cut, not over it. The Option<usize> position probe becomes the one-past-the-set sentinel index four. Checks (conventions 0-14): t27b test 13 passed 0 failed; t27c test-report 13/13, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The fifth CR-CHAT-03 ring target (W3, L-CHAT-3-confupd, RFC 9420 8.1/11): the confirmation-chain rules, in the original's fixed order - the canonical tag length (thirty-two), the group agreement, the strictly greater epoch, the previous-hash agreement, the non-zero canonical interim seed (a zero seed would reset the chain), and the fresh (group, epoch, tag) link - as the D5 verdict (all six original variants carry no payload, so the code is the whole verdict), the original's rule order, and all ten CTC tests transcribed plus helper and rule-order tests. The original's commit and view structs become flat parameters, the byte vectors arriving as plain slices. The ledger of used chain links becomes a slice of records holding the canonical thirty-two-byte group identifier, the epoch and the thirty-two-byte tag - the original's BTreeSet contains over the triple answered by a scan that reads the incoming slices, a non-canonical length never matching a canonical ledger entry. Checks (conventions 0-14): t27b test 14 passed 0 failed; t27c test-report 14/14, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
The sixth CR-CHAT-03 ring target (W3, L-CHAT-3-extern, RFC 9420 12.2): the external-commit acceptance rules, in the original's fixed order - the group agreement, the claimed epoch equal to the local one, the joining leaf not occupied, the sender equal to the joining leaf, the operations exactly one self-Add of the joining leaf, and the non-empty signature (the placeholder verifier) - as the D5 verdict with every payload field (the claimed and actual epochs, the conflicting leaf, the sender and joining pair, and the offending operations list carried by value with its length), the original's rule order, and all six EXT tests transcribed plus helper and rule-order tests. The original's newtypes flatten to their bare integers - the group identifier to its thirty-two bytes, the epoch to u64, the leaf indices to u32 - and the Op enum becomes a kind enum plus one record form, Update carrying its unread leaf as zero. The occupied-leaf probe becomes a scan over the leaf slice and the single-self-Add rule a length gate then a kind and leaf probe. Checks (conventions 0-14): t27b test 9 passed 0 failed; t27c test-report 9/9, 0 vacuous; gen-rust output compiles under rustc; coverage Untested 0; ASCII only; seal saved, all hashes MATCH;
# Conflicts: # docs/reports/t27b_expectations.json
# Conflicts: # docs/reports/t27b_expectations.json
# Conflicts: # docs/reports/t27b_expectations.json
gHashTag
enabled auto-merge
October 17, 2026 18:48
This was referenced Oct 17, 2026
spec(policy): l2_generation -- gen/json/ is t27c gen-json's backend directory (Closes #10079)
#10082
Merged
Merged
Merged
Each CR-CHAT ring file is a self-contained port of one Rust guard and carries its own copy of small helpers (burst_ids_equal, bytes_equal, approx_sqrt, ...). Landing 66 of them at once grows 12 duplicate-body groups. Ledger written by tools/dupe_scan.py --bless on the Railway lab; the diff is exactly those 12 groups. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Owner
Author
gHashTag
disabled auto-merge
October 17, 2026 19:27
Contributor
The batch brought four type names that two specs each define, and two definitions of one name leave its domain size undetermined: `tri types ratchet` went red, ledger 109 vs observed 113. - IntervalObservation: the emission pattern randomness guard (#9811) repeats master's inter-arrival guard. Renamed EmissionIntervalObservation, byte-identical to #10097's fix, so the two batches merge cleanly. - SizeObservation / SizeDistVerdict: message_size_class_distribution_guard repeats cover_traffic_size_distribution_guard. Renamed SizeClassObservation / SizeClassDistVerdict. - TransitionObservation: padding_class_transition_entropy_guard repeats padding_length_class_transition_uniformity_guard. Renamed EntropyTransitionObservation. Each renamed spec is resealed. Checked on the Railway lab: types ratchet CLEAN at 109, dupe_scan finds no new duplicate body. Refs #8884 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
gHashTag
enabled auto-merge
October 17, 2026 19:31
Owner
Author
|
Update: 427ef22 fixes the types ratchet here. It renames the four duplicated type names (EmissionIntervalObservation, SizeClassObservation / SizeClassDistVerdict, EntropyTransitionObservation) and reseals each renamed spec. The emission guard file and its seal are byte-identical to #10097's f3d55bd, so this PR and #10097 merge cleanly in either order; my earlier note about a conflict no longer applies. Checked on the Railway lab: types ratchet CLEAN at 109, and |
Contributor
PR DashboardGenerated at: 2026-10-17 19:34:52 UTC
Summary
Seal Status
|
gHashTag
added a commit
that referenced
this pull request
Oct 17, 2026
#10098 landed 20 of this batch's PRs with byte-identical files, so only docs/reports/t27b_expectations.json conflicted. Resolved as the union of both sides' rows (sorted, one verdict per path; no path had two verdicts). Against master this PR now adds 5 specs, their 5 seals and 5 ledger rows (#9739 #9754 #9757 #9794 #9802). Refs #10096 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This was referenced Oct 18, 2026
gHashTag
added a commit
that referenced
this pull request
Oct 18, 2026
…loses #10159) (#10161) Move the eight copied helper groups into two shared modules and `use` them from every copy site: - trios-chat/common/helpers.t27: ids16_equal, ids32_equal, zero_id16, bytes_equal, all_zero_bytes, approx_sqrt - trios/common/newton_sqrt.t27: newton_sqrt (was sched_sqrt, ternary_sqrt_newton, sqrt_newton32) 29 CR-CHAT specs resealed. Ledger: eight lines dropped. The four record-bound groups (id_seen_before, obs_seen_before, dest_count, member_contains) stay: they read fields of ring-local structs or differ in integer width, and t27 has no generics to share them. Co-authored-by: Claude Sonnet 5.5 <noreply@anthropic.com>
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
2 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Lands the 66 open port PRs from
dmitrii-f-t27(trios-chat rings CR-CHAT-03, -04, -07) in one merge instead of 66.Refs #8883
Refs #8884
Refs #8887
Why one PR
Every port PR adds one line to
docs/reports/t27b_expectations.json. Each squash merge put every other open port PR into conflict (52 of 66 at the last count), and each re-resolve cost another full CI run. This is the batching rulespecs/policy/pr_budget.t27(#10067) asks for.What is in it
specs/port/, 66 seals under.trinity/seals/, and 66 added lines int27b_expectations.json. Nothing deleted.PRs folded in
port/cr-chat-04-wave2-bport/cr-chat-04-wave2-cport/cr-chat-04-wave2-dport/cr-chat-04-wave2-eport/cr-chat-04-wave2-fport/cr-chat-04-wave2-gport/cr-chat-04-wave2-hport/cr-chat-04-wave2-iport/cr-chat-04-wave2-jport/cr-chat-04-wave2-kport/cr-chat-04-wave2-lport/cr-chat-04-wave2-mport/cr-chat-04-wave2-nport/cr-chat-04-wave2-oport/cr-chat-04-wave2-pport/cr-chat-04-wave2-qport/cr-chat-04-wave2-rport/cr-chat-07-bport/cr-chat-07-cport/cr-chat-07-dport/cr-chat-07-eport/cr-chat-07-fport/cr-chat-07-gport/cr-chat-07-hport/cr-chat-07-iport/cr-chat-07-kport/cr-chat-07-lport/cr-chat-07-mport/cr-chat-07-nport/cr-chat-07-oport/cr-chat-07-pport/cr-chat-07-qport/cr-chat-07-rport/cr-chat-07-sport/cr-chat-07-tport/cr-chat-07-uport/cr-chat-07-wport/cr-chat-07-xport/cr-chat-07-yport/cr-chat-07-zport/cr-chat-07-aaport/cr-chat-07-abport/cr-chat-07-acport/cr-chat-07-adport/cr-chat-07-aeport/cr-chat-07-afport/cr-chat-07-agport/cr-chat-07-ahport/cr-chat-07-aiport/cr-chat-03-eport/cr-chat-03-fport/cr-chat-03-gport/cr-chat-03-hport/cr-chat-03-iport/cr-chat-03-jport/cr-chat-03-kport/cr-chat-03-lport/cr-chat-03-mport/cr-chat-03-nport/cr-chat-03-oport/cr-chat-03-pport/cr-chat-03-qport/cr-chat-03-rport/cr-chat-03-sport/cr-chat-03-tport/cr-chat-03-u🤖 Generated with Claude Code