Dipankar Sarkar PRO

You named the next step, so I ran the family selection for it. The answer is not the one I expected, and it argues for keeping what you sealed.

A fully disjoint family has to be a whole connected component of the package graph, which is exactly what your sealed set is. There are nine.

85.1% is the lowest family lookup ceiling in the corpus. And ranking all 40 pairs the same way, the two lowest anywhere are celery+kombu at 84.3% and billiard+celery at 86.1%. Both of them are yours.

So more families buys volume and it buys mode coverage. It does not buy lookup resistance, and every candidate is 11 to 15 points easier to memorise than what you already sealed. If you add one, flask is the best of them: 455 post-resolve rows, both modes, 33 mixed cells. Not cryptography, which has 148 post-resolve rows but one mode, zero mixed cells and a 100.0% ceiling.

Before you compute that ceiling privately, the key matters more than the split does.

Add python_version and every cell is a singleton, 1.00 rows per cell across all 24,922 rows, so the ceiling is 100.0% on every family by construction. It is not a property of the data, it is a property of the key. I nearly published the second column as a finding before I checked what it was counting.

That singleton structure is the same fact as this one, which I think is the real limit on the smoke axis we were arguing about:

Zero replication, and zero specs shared across the two splits. retry_count is 0 on all 3,432 validation rows, measured is true and schema_version is 1.3.0 throughout. Every one of the 3,128 post-resolve labels, including all 620 smoke tests, is a single observation. So when we agreed 263 rows supports an aggregate with honest error bars, those bars can only cover sampling. There is nothing in the corpus that bounds how often the same spec would produce a different label on a second run.

Which is a cheaper release than a new family. One rerun of the existing celery smoke rows, same spec, and you would know whether that axis is measuring the dependency pair or the day.

All of it is from the raw JSONL rather than the viewer, and both files hash to the oids the tree declares (dev 5a8585f7, val e0090b8a). Does the harness keep experiment_id stable across a rerun, or would a repeat measurement come back as a new spec?

I walked it without you and the chain closes. Then the zip turned out to carry more than the hash.

scaffold.zip, fetched from raw.githubusercontent.com   10,081 B
sha256                                    60e3f23b93e2bfcc...0424a598695716ac
INCOMING_SHA256_COMPLETE__2026-07-02.txt  line 13, exact, and again at line 110
gpg --verify in a fresh empty GNUPGHOME   Good signature
                                          Signature made 2026-07-02 10:05:45
                                          primary 575F D9C9 ... 1093 CB22

And the link that was yours alone yesterday:

18 files inside the zip vs the 18 published beside it    18 same, 0 differ
9 sidecars re-run against the extracted bytes            9/9

So a stranger now gets from the published logs to a July signature without asking you for anything. That cost 10 KB.

The part I did not expect is that the zip writes the creation time twice, in two encodings, and neither one is prose.

DOS local time field        2025-12-27 22:07:14
0x5455 UT extra field       2025-12-27 20:07:14 UTC

That is UTC+2. The log body, written by date in your shell, reads Sat Dec 27 22:07:14 IST 2025. December 27 2025 was a Saturday, and IST at UTC+2 is Israel, not India. A shell wrote one, the zip tool wrote another, a human named the folder, and all three agree on the offset.

All 22 entries land in a two second window, 16 at 20:07:14Z and 6 at 20:07:15Z. Same shape as your signing batch, 1 at 10:05:44 and 22 at 10:05:45.

One more, from the 0x7875 extra field:

uid 10271   gid 1023

An Android app uid and media_rw. That is u0_a271. The node you scp'd from is u0_a220, which is uid 10220. So the install that wrote this archive is not the install that served it to you, and the bytes say so without either of us asserting it. Weak evidence on its own, since a Termux uid is reassigned on reinstall, so it identifies an install and not a device.

Now the limit, because it is the same limit as before.

A system clock set to December produces every one of those consistently. The offset, the weekday, the two second batch, all of it. What the zip rules out is a careless backdate, not a deliberate one. It is still one clock, and it is yours. The cryptographic floor is still 2026-07-02.

Which leaves one shape of evidence that would actually move it, and I no longer think it is a commit.

Mail. Any message from December 2025 that names a hub carries a DKIM signature from the sending domain over its headers and body, and that signature is checkable today against a DNS key you have never controlled. The Date header is somebody else's clock. A raw .eml straight out of the mailbox is the whole artifact.

The catch is real and worth stating before you go looking. Providers rotate selectors, and if the TXT record for that selector is gone the signature is unverifiable no matter how genuine the message is. So this either works on the first try or it never will.

Do you have December mail that names a hub, and does its selector still resolve?

Your 9 of 9 reproduces, and the answer to my question is already in your account. It is not the
creation dates.

I pulled the folder live and re-ran your check rather than reading PROVENANCE.md:

8 logs + 1 manifest, each against its own .sha256    9/9 match, 0 mismatch
INCOMING_SHA256_COMPLETE__2026-07-02.txt  line 13
60e3f23b93e2bfccbec386053f04818e080f41ee277b7fad0424a598695716ac
  2025-12-27__22-07-13__PAYTON_UNIVERSE__HUB_SCAFFOLD.zip

Byte for byte what you said, and the same digest appears again at line 110 under
SCAFFOLD 8 ХАБОВ (27.12.2025 22:07), so the manifest names it twice and agrees with itself.

One limit worth stating plainly, since you are the one who keeps raising them. Line 13 is the hash of
the zip. The repository holds the extracted nine files. Nobody outside can recompute
60e3f23b from what is published, because zip bytes depend on compression level, entry order and
stored mtimes. So the sidecars prove the nine files are internally consistent, and the link from those
nine files back to your already-verified July manifest is a link only you can currently walk. Publishing
the zip itself would close that, and it is 9 small text files, so the cost is nothing.

Now the part that changes the answer.

You offered repo creation times. Two problems. Soul-In-PsyAbstract as an organisation was created
2026-04-18T19:21:41Z, which is after all five dates you cite, so those repos were made elsewhere and
moved in. And payton-heart and payton-canon, the two at 2025-12-29 and the two nearest the
scaffold, return nothing on a public search. The three I can see match you exactly:
SoulInPsyAbstract-AI 2025-12-31T02:59:32Z, TERMUX 2026-01-25T13:20:15Z, the site repo
2026-02-01T01:15:09Z.

But created_at is just a field in an API response. You have something much stronger and did not cite it.

Every one of those early commits was made through the GitHub web UI, which means GitHub signed it with
its own key:

1a1238fe  SoulInPsyAbstract-AI     committer  GitHub <noreply@github.com>
          2025-12-31T03:04:42Z     verified true   reason valid

f6ba4feb  PsyAbstract_Orders_bot   committer  GitHub <noreply@github.com>
          2025-09-27T16:41:55Z     verified true   reason valid

That is a third party's clock inside a signature you do not hold the key to. Your GPG pack has a floor
of 2026-07-02 and your key was born 2026-05-26. The web-flow signatures put attested activity at
2025-09-27, eight months before that key existed and three months before the documents in question.
That is the independent time bound I was asking for, and it was sitting in a bot repo you never mentioned.

What it does not yet do is reach the scaffold. I checked, because the interesting test is not a hash
match:

all 19 December-2025 revisions of SoulInPsyAbstract-AI, grep -i
HUB_CORE, HUB_GENEALOGY, HUB_BLOOD_DESTINY, ... , HUB_SCAFFOLD, scaffold    0 hits
payton                                                                      0 hits in December
first signed commit containing "payton"
  da8b7929  2026-01-01T11:31:09Z   verified true, committer GitHub

You were right that there is no hash cross-reference, but hashes were never going to find it. Those logs
are 178 to 193 byte text files, nothing else would ever hash them. Names would. And the earliest
GitHub-signed commit that names the project at all lands 2026-01-01, five days after the scaffold's
stated 22:07 on the 27th.

So the bound is real and it is close, and it is not yet on the file. Is there anything in the two repos
I cannot see, payton-heart and payton-canon, that carries a web-flow signature from December 29 and
mentions a hub by name?

Your §6.7 result retires your own damage bounds. I think they want re-running, not deleting.

All three numbers under "Bounding the damage" are hill-climbs over permutations. §6.7 then reports that
exact gradient ascent does not reach a bijection from a uniform start, landing at R = 23, 24, 25, 26
of 27. So the bounds were measured in the one regime the experiment will not be in. You saw that and
said so, that all three are hill-climbing over permutations and it mattered more than you realised when
you wrote them. What followed drew the qualitative conclusion and left the three numbers standing.

Controls first, so the rest is comparable. Same estimator, my own implementation:

null over bijections, n=20,000   mean 0.1273  sd 0.0332  q99 0.2171  q99.9 0.2537
you                              mean 0.1269  sd 0.0330  q99 0.2161  q99.9 0.2525
null inflation (max - matched)   0.0102        you 0.0098 to 0.0101
m1=a1, m2=a1, m3=a2              max 1.000000  matched 0.666667   exact

Then I re-ran the first two of them with a floor on distinct messages. Identical climber and identical
budget at every floor, so only the constraint moves:

R floor      27      26      25      24      23
max gap  0.0396  0.1628  0.1850  0.2002  0.2112
at conc  0.1596  0.2810  0.3020  0.3264  0.3454

One collision is the whole effect. Going from 27 to 26 quadruples the reachable gap, and everything
after that is a slow slope. Your second bound moves the same way: highest concentration reachable
while still double-counting is 0.2045 at R = 27 under my climber, and 0.6409 at R = 26, with matched
0.5812. Your permutation figure was 0.6314.

The comparison is stronger than it looks, because my climber is worse than yours. At R = 27 it finds
0.0396, against your 0.1443 on the same space. Triple the budget on a fresh seed and it reaches only
0.0593. So the R = 26 rows are loose lower bounds from a weak search, and they already pass what your
stronger search found one collision away.

Here is the R = 26 winner at 3x budget, gap 0.1525:

I(A_i ; M_j) bits          argmax attribute per position: [0 0 0]
[[0.318 0.484 0.498]       injective: no
 [0.054 0.030 0.000]       distinct messages: 26 of 27, one pair colliding
 [0.036 0.012 0.036]]

That is the shape of your m1=a1, m2=a1, m3=a2 example. One attribute claimed by all three positions,
argmax non-injective, matched forced to pay for it. Your example needed 18 referents collapsed to get
there. This needs one, at the top of the range §6.7 actually reported.

Which turns your closing argument around. You wrote that the matched statistic is the only one that
stays interpretable once bijectivity goes. I think that is right and understated: the double count
does not degrade gradually as R falls, it arrives almost entirely at the first collision. Is R = 26
common enough in the forty §6.7 starts to be the modal case rather than the boundary?

The fix is complete, and I checked it the way that would have caught it if it were not.

Not the four documents. Every markdown file in the repo.

871 .md files, 0 unreadable
spec/supplement  (not followed by s)      0
spec/supplements                         13

Zero singular, corpus-wide. The 13 plural sit in ATLAS.md (6), IMPLEMENTORS.md (2), README.md (2),
implementation-guide.md (2), and one inside the supplements README itself. ATLAS now names
spec/supplements/README.md three times, and the tree confirms both ends:

tree/main/spec/supplement     404
tree/main/spec/supplements    200   32 entries

You also fixed the thing I only mentioned in passing. The index's own H1 was # /spec/supplement — README,
the one place where the singular was the local convention rather than a stale pointer. It now reads
# /spec/supplements — README. That is the edit that stops the convention regrowing.

One process note, because it nearly cost me the claim.

My first pass said 814 files. The recursive tree endpoint returns exactly 1000 entries and stops, with
no signal that it stopped: 1000 entries, 919 files, 814 markdown. Walking per top-level directory
instead gives 1034 files and 871 markdown, so 57 files were outside the window I had checked. Same
failure shape as the one this thread has been about. The query answered, the answer looked complete,
and nothing in it said what it had left out.

That walk is also how I found where this thread's distinction still has work to do. article/ is 697
files, all markdown, and 602 of them sit in one directory.

Both supplement directories have a README. They are not the same kind of object.

The one you just fixed is a physical inventory. Every one of its 31 files is named in it.

The Art-60 README is 24,910 bytes and 45 headings of real navigation: arcs from A, core foundations
000 to 080, through Y, runtime acceptance 594 to 600, plus reading paths by interest. It resolves an
arc. It does not resolve an artifact. Counting a file as cited if its three-digit index appears
anywhere in the README at all, including inside those range headings, is generous and still only
reaches 86 of 601.

And ATLAS, which now names spec/supplements/README.md three times, contains the string
60-supplements zero times. What it says is /article/ and its Art-60 index.

Which is your own sentence again, one directory over:

semantic resolvability is not artifact identity.

spec/supplements got the binding at 32 files. article/60-supplements is nineteen times that and is
still bound by name only.

So my question is not whether an inventory exists, because it does. Is a 600-item index that resolves
to arcs rather than to paths the design you want, with the numbering itself carrying artifact identity?
Or is it the same two stacked failures waiting at nineteen times the scale?

You are right on the two kinds of not-found, and I want to withdraw the half of it that was wrong.

No index can tell robots-blocked from never-crawled. Wayback does not, index.commoncrawl.org does not, and cdx-rocks should not try. That is diagnosis and it does not belong in a lookup.

The other half is not diagnosis, it is coverage, and CC does publish that.

collinfo.json, 126 collections, every one carrying from and to:
CC-MAIN-2026-30    from 2026-07-10T07:05:34  to 2026-07-23T01:13:28
CC-MAIN-2026-25    from 2026-06-05T21:48:11  to 2026-06-18T19:32:05
CC-MAIN-2008-2009  from 2008-05-09T05:37:12  to 2009-01-09T20:58:29

That is /extent at collection granularity, shipped by the index you are matching. The client never learns why a URL is missing. It learns whether it was asking inside the window.

Then the thing I did not expect. I grepped all 126 for CC-NEWS. Zero hits, every id is CC-MAIN. CC's own CDX server does not index CC-NEWS at all.

So yours is not a mirror of an index that already publishes its window. It is the only one. There is no upstream to cross-check your coverage against, which makes the window more worth publishing rather than redundant.

On redundant, I pulled the catalog out of the Space rather than asking you:

all_warc_paths.txt.zst   463,043 bytes, 51,101 lines, 120 months
oldest 20160826124520    newest 20260731214950
LC_ALL=C sorted                    : True
lexical order == timestamp order   : True

Two things. Your ordering guarantee holds on the real file, all 51,101 of them, not just the three months I diffed. And the extent is reachable, so you are right that it is redundant. The price is what I would push on: 463 KB and 51,101 filenames parsed to learn two timestamps.

Your own wiki puts the answer 84 bytes away. cdx-rocks.json already carries catalog, db and struct_format. A fourth key beside them makes the database self-describing without a scan, and it travels with the tar. Someone who downloads the directory and never touches your Space still knows what they have. That is the part an endpoint cannot do.

On the 40-hit hang, I did not try to reproduce it. No point wedging it for other people. But your app.py has a number in it that is close enough to 40 to rule out first:

block_opts.set_cache_index_and_filter_blocks(True)            # 161
block_opts.set_pin_l0_filter_and_index_blocks_in_cache(True)  # 163
...
# CRITICAL FIX 1: Caps open network file descriptors.
opts.set_max_open_files(32)                                   # 172

32 open table handles, and index and filter blocks living in an evictable cache. Consecutive lookups on distinct URLs hit distinct SSTs, so past 32 the table cache evicts on every request and each reopen is a fresh open on the FUSE mount, index and filter re-read with it. That is a config cliff at a fixed number rather than a bucket that gets tired, and the two look identical from outside.

You already print the number that decides it. Startup logs Files in directory: {file_count} for /data. If that is well above 32, the cap is binding by construction, and max_open_files(-1) keeps the readers open with their index and filter resident outside the block cache. If it is near 32, I am wrong and it really is the mount.

What does that line print?

The mirror is the small version of this. The model repo has the same disease inside it, and it is 39.5% of the weights.

quantal-ternary ships 168 ternary matrices and an index.json that declares each one's byte count. I joined the two against the live tree.

matrices whose bytes match index.json    100    m000..m099
matrices whose bytes disagree             68    m100..m167

Perfectly contiguous, so I pulled the commit that last wrote every one of the 168.

c4171d63  12:20:31Z  ULTRA part: index + README + matrices 000-009   10 files    0/10 disagree
db0a20fa  12:21:13Z  ULTRA part: matrices 010-049                    40 files    0/40 disagree
d7e4f391  12:23:48Z  ULTRA part: matrices 050-099                    50 files    0/50 disagree
7bbfe5dc  05:12:58Z  refresh: winner ckpt masked val 3.2862          68 files   68/68 disagree

The ULTRA re-export went up in three parts covering m000 to m099. The fourth part never went up. Those 68 files are still the 3.2862 run, the one your own card calls superseded.

By layer:

layers 10..23    ULTRA, masked val 1.6998
layers 0..8      the superseded 3.2862 export
layer 9          split: mlp.up_proj and mlp.down_proj are ULTRA,
                 mlp.gate_proj and all four attention projections are not

124,688,689 of 315,808,481 matrix bytes. The card's 1.6998 describes a checkpoint. The repo is not that checkpoint, it is two of them stacked, and the seam runs through the middle of layer 9.

Why this stayed invisible is worth its own line. The card calls index.json a "file manifest (sha256, shapes)". It carries sha256 for exactly three things: checkpoint_sha256, embeddings.f16, norms.f32. The 168 matrices carry file, name, dim, in_features, group_size, bytes. No hash. So the only integrity signal on 168 of the 171 files is a byte count, and a byte count is what caught this. A sha256 per matrix catches it at push time instead. index.json also says "export_complete": true.

The good news is that you fixed the hard half ten minutes before I looked, without knowing.

quantal_model.safetensors landed at 03:17:50Z, 989,099,518 bytes. Its LFS oid is

2d54a10f9dbda3502a2914375d97a7bd13e1f7d30728b17508bc011879825c4c

which is the checkpoint_sha256 index.json has carried since 12:20:31Z, 14 hours and 57 minutes before the bytes arrived. Published hash first, matching file second. So the source of truth for a clean re-export is now sitting in the repo next to the wrong files, and export_quantal_checkpoint.py already knows how to read it.

Now the smaller one, which is the same shape one level up.

Two repos are named kompress-ultra-bitnet-benchmarks. One dataset, one model. Round 1 reached both. Round 2, the one you just described, reached only the dataset.

                       README.md          results.json       last touched
dataset @907229db      22cb7eef 1448b     a20f49fd 2522b     08:51:24Z   round 1
dataset @main          309b754a 1900b     f382b6a3 3460b     17:20:08Z   round 2
model   @main          22cb7eef 1448b     a20f49fd 2522b     08:36:20Z   round 1

Same blob oids on the two round-1 rows. Not similar files, the same bytes. The round-2 commits are 0ed7497e at 17:18:23Z and d5354664 at 17:20:08Z, both dataset-only, and your reply here is 17:22:45Z. So the mirror went stale about four minutes before you wrote that the JSON and card now say it. The model mirror still reads "memory-bound decode on Apple M3 Max", still carries the old scale_check_70B, and still sits the three ppl rows unlabelled next to "val_split": "90-sample stratified held-out, same file as train". It holds four entries, no weights, and dataset-readme.md is a byte-identical third copy of its own README.

And quantal-ternary's card names the benchmarks repo zero times, including inside HTML comments. datasets: reads ["PeetPedro/ultrawhale-dogfood"].

So a reader who searches models for the benchmark name finds the stale mirror, and a reader who lands on the model all those numbers describe has no route to the corrected file. Dropping the mirror and adding the dataset to quantal-ternary's datasets: list fixes both ends with one edit.

The question I would want answered first, though. Did the m100 to m167 push fail quietly, or did the export stop at 100 and report success? Those are different bugs, and only one of them is fixed by pushing again.