Notes, stage B2: the pilot

Standing instruction from J (2026-10-11, 16:54 Berlin, through the handler)

"Stop cutting room reads to a line length (cut -c1-100 or any other cut). Read room lines whole. When a read is too long, page it by line ranges or by offset, never by truncating lines."

From B2a-r1 on, every room read is whole by line. A long read is paged by line range or offset. No cut -c and no other truncation is applied to room material.

J also said (17:01 Berlin): ask J whenever a question is needed, with mem.py ask; asking does not stop the run.

Leg B2a-r1, build round 1, 2026-10-11

Declarations, made before round 1

The hard set: sizes and sources. 40 items, drawn by out/_analysis/b2_select.py with the string seed b2a-r1:hard. The list is out/_analysis/b2_hardset_r1.tsv.

• 19 confusion-pair items, one for each pair in confusions.md: the 17 ranked at B1e and two sibling pairs added at this leg (T3-014/T3-152 and T3-015/T3-063). Ten of the nineteen pairs are siblings inside one family. Each pair uses the item confusions.md nominated, unless that item renders over 2,500 bytes. Then the pick is seeded from the pair's pool: second-order themes holding both kinds in scheme_current.jsonl and rendering at or under 1,600 bytes. Five nominated items were replaced this way (pairs 7, 8, 11, 12 and 19).
• 8 rule 0 bags: second-order themes with an item_is_a_bag line in multiplacement_log.jsonl, rendering at or under 1,600 bytes, seeded.
• 13 random items, seeded, from the 3,933 placed second-order themes rendering at or under 1,500 bytes.

A departure from section 1, and why (QB2-001 asks J). packets.py B2 serves each round as one packet under the 50 KB ceiling. Section 1 asks for 40 to 60 items, including the ten biggest bags of notes-B1.md.

• Those ten hold about 3,500 concepts. leagueoflegends t02 alone renders 86,762 bytes, over the whole ceiling, and sweden t01 renders 43,314.
• The median second-order theme renders 1,470 bytes, so 40 items fit only near or below the median.
• Rule 0 bags stand in for the ten biggest; the ten stay for stage B3 to flag.
• The cost: the random sample covers only themes at or under the median rendered size. Small themes sit on one kind more often (70.4% at five concepts or fewer, B1e). So the random items are likely easier than the corpus, and the pair and bag items carry the hard part.
• The round-1 items render 49,401 bytes.

The gold set. 40 items by the same rule, seed b2a-r1:gold, in out/_analysis/b2_goldset.tsv: 19 pair items from the pairs' pools (none a round-1 item), 8 rule 0 bags and 13 random. No second-order theme sits in both sets. The items render 42,148 bytes. I placed them myself into out/gold_items.jsonl with confidence and reasons. They are shown to no pilot reader and kept outside the readers' directory.

The stopping threshold. Rounds stop when the mean pairwise agreement on the hard set reaches 0.70 (the definition is below). The other stops of section 5 also hold: a round with no scheme edit, or four rounds. Why 0.70: the set is drawn hard, half from pairs a reader is expected to confuse. On easy items the scheme should do far better, and stage B3 reports that.

The agreement definition, which stages B3 and B4 reuse unchanged.

• An item's placement is the set of third-order themes a reader returns (third_order).
• Two sets agree by their Jaccard index, |A ∩ B| / |A ∪ B|. ["T3-004"] against ["T3-004","T3-011"] scores 0.5, which is partial agreement. Disjoint sets score 0, and identical sets score 1.
• Pairwise agreement is the mean Jaccard over the three reader pairs of each item, then over items.
• Fidelity is the mean Jaccard between each reader's set and the author's set in author_items.jsonl, over readers and items.
• Alpha is Krippendorff's alpha with distance 1 − Jaccard between sets, over items run at more than one reader. Chance correction is over sets: the expected disagreement is computed from all placement sets returned in the round, pooled, as the values of the nominal-like distribution.
• Also reported, never in place of the above: exact agreement on the primary, the first theme of each set.

The gold policy.

• 40 gold items, placed by me, in out/gold_items.jsonl.
• Stage B3 seeds them unannounced into live batches at one gold item per 20 items, so about 5% of a batch, with no more than two in any batch.
• Each gold item is seeded at least once over the run.
• The policy names the rate and that gold is seeded, never which items.

The batch cap for stage B3. Set at the check leg B2b-r1, from the position curves of section 4. It is not set here.

Author placements. Every item of both sets was placed by me into author_items.jsonl and gold_items.jsonl before any packet existed. Each line has the set of third-order themes, a why per theme, a confidence (clear or arguable) and the concepts it rests on. I read each item through mem.py theme <sub>/<tNN>, whole, paged where long. That verb prints the working placements of scheme_current.jsonl above the concepts, so they were in view. Those placements are my own from B1. Each author placement was made against the shipped gates in scheme.jsonl, and where it differs from the working placement, the line says so.

What was built

The author's placements (out/_analysis/b2_author.py, which checked every theme id against scheme.jsonl and every support concept against the item's own concepts in the store):

• author_items.jsonl: 40 items. 5 are clear and 35 arguable; 24 are placed on more than one kind; 25 differ from the B1 working grouping in at least one kind.
• gold_items.jsonl: 40 items. 4 are clear and 36 arguable; 17 are on more than one kind; 19 differ from the B1 working grouping.
• The many arguable placements fit how the sets were drawn: half the items come from pairs I predicted readers would confuse, and eight from rule 0 bags.
• Where my placement differs from the working grouping, it mostly drops a kind whose concepts the gate does not support on their own (b2_author_vs_working.py). In the hard set, 18 items only drop a kind, 5 only add one, and 2 do both; 15 are the same. In the gold set, 15 only drop, 4 only add and 21 are the same. My primary is among the working kinds in 39 of 40 hard items and 40 of 40 gold items. Three examples of a dropped kind: dofus t01 drops T3-002, GreenCorner t03 drops T3-069, and flashtv t13 drops T3-054.

RETURN-B2.md. It holds rule 0 in the contract's words and the return line of section 1. Rule 0's line for multiplacement_log.jsonl is carried on the return line as multiplacement_log, null when multi is false. The check leg copies those lines into the pilot's record, never into the B1 log. It also holds item_is_a_bag, the end marker END-OF-RETURN in the fenced block, and the line telling the reader to confirm it reached the marker.

The packets. packets.py B2 --round 1 --scheme scheme.jsonl --items author_items.jsonl --seed 20261011 --to out/_packets-B2 wrote:

• index.md (33,148 bytes);
• 21 family pages (6,566 to 16,448 bytes);
• P03-r1.md, 40 items in seeded order, 49,720 bytes, sha256 1efc10ac60398acee09ad3503aca758803f96cd1fae8ee0afea3044d0bf868ff;
• MANIFEST.json.

No exemplar is served, and no gold file is in the folder. The scheme served is scheme.jsonl as shipped at B1e. packets.py would otherwise have preferred scheme_current.jsonl, which holds no gates, so --scheme was given.

Where the packets live (QB2-002 asks J). packets.py writes to _packets-B2/round-1/ by default. HOW-TO-RUN.md and validate.py B2 expect the packets flat in _packets-B2/. I built flat. The first, nested build is byte-identical and moved to out/_analysis/b2_packets_round1_nested/, so the dispatch finds one packet only.

Manifest. run_manifest.json has a B2 round-1 entry: readers on @preset/cheap through the gateway, three of them; the seeds; 40 items; and the packet's path and hash. The decoding settings are left to the dispatch, which records what served.

Questions open: QB2-001 (the 50 KB ceiling against the ten biggest bags) and QB2-002 (the packet path). Each carries its assumption, and the work above rests on both.

Reading. From this leg on, no room read was cut to a line length. The only "…" in the reads is mem.py's own display of the label column; the quote column was whole in every read.

The close-check, B2a-r1

validate.py B2 reported:

stage B2:
  leg: build (0 dispatch folders with DONE)
  author items 40, gold items 40, scheme ids 197

0 errors (0 distinct shapes), 0 warnings

The leg closes with done.sh B2 --cut packets-out. The dispatch sends P03-r1.md to three fresh readers. The check leg B2b-r1 scores fidelity, pairwise agreement and alpha, sets the batch cap for stage B3, and makes the edits.

Leg B2b-r1, check round 1, 2026-10-11

What the PI and J ruled before and during this leg

• QB2-001 (answered 15:15Z): serve oversize items in parts to the same reader, as stage B3 serves a large room. Do not cap the hard set by size. Each part stays under the 50 KB ceiling with its end marker, and the reader answers once per item after the last part. If packets.py cannot part a B2 item, the splitter is a helper in out/_analysis/, and the parts are recorded in MANIFEST.json and here. Round 1 goes out as built.
• The round-2 rule (same message): from round 2, the ten biggest bags of notes-B1.md are served in parts. No round may meet a stopping rule of section 5 before those ten have been read by the round's readers at least once.
• QB2-002 was first answered "flat", then corrected by the handler at 15:29Z. fleet.py reads *.md flat in the folder it is given, but CONTROL/harness/dispatch.sh gives it out/_packets-B2/round-K/ for B2 and refuses when that folder is missing. packets.py's default, round-K/, is the right place. J copied round 1's packets into out/_packets-B2/round-1/ to dispatch them. Later rounds are built in round-K/, and earlier rounds stay where they are. The flat copy in out/_packets-B2/ is round 1's and stays.
• QB2-003 (answered during this leg): repairs the gate check found are recorded in scheme_edits.jsonl with caused_by ["gates:T3-a|T3-b"]. A word-for-word mirror takes kind gate-check and owes no recheck and no tier_history line. A new sentence takes its ordinary kind and owes both. Repair all in this leg if possible, before round 2's packets.
• v43.2 tools (J, "Do all changes"):
  • mem.py blind on|off;
  • --width on reads, with the guard refusing cut -c after mem.py;
  • mem.py gates (with --confirm);
  • tools/tokens.py;
  • rule 0's also_present clause for bags, on the return line from the next round;
  • support_by_theme on my records;
  • rechecks owed by every edit (mem.py rechecks --owed, mem.py recheck).
• The reader settings (J, 20:42 Berlin): from round 2 the reader preset is pinned to one provider (Relace) at medium reasoning effort. Round 1's three readers ran at high effort on mixed providers (Relace, Baidu Qianfan, Reka AI), all on the same model, deepseek/deepseek-v4-flash-0731. A change in agreement between rounds 1 and 2 is partly the reader settings, not only my edits. This goes in the round-2 manifest entry too.
• Corrections from the B1e interview, made on the record (notes-B1.md and handback-B1.md carry an appended correction):
  • The T3-005 and T3-021 gates contradicted each other on repair during a raid. Corrected before the pair was scored (edit below).
  • F-001's grain bound does not hold across rooms. out/_analysis/b2_grain_check.py: Spearman −0.08 between a room's mean concepts per theme and its single-kind share (633 rooms). Within rooms, mean Spearman 0.28 between a theme's concepts and its kinds (positive in 482 of 619 rooms). findings.jsonl has the superseding F-001 line, status bounded.
  • "107 episode lines" is 106 (line, kind) pairs over 81 lines (out/_analysis/b2_episode_kinds.py).

The dispatch, in fleet.py's counts

out/_fleet_raw/B2/round-1/ holds four attempts.

• The first (DONE, 17:08Z) returned nothing valid. The reader model reasoned before answering and used its whole 16k output budget. The gateway's response cache then handed eight reissues the same empty reply. EXHAUSTED.tsv names r5, r7 and r9: no end marker. The handler then changed fleet.py: the reader id opens each message, readers run in parallel, the output limit is raised, and the served model is read from the reply.
• Two more attempts failed the same way while those fixes went in (r10, r11; r13 was cut off). Every *.failed.txt is a failed attempt, not a reading.
• The round scored is the last, PARTIAL-2026-10-11T183640Z.json: three valid returns of 40 lines each, r12, r15 and r16. All were served by deepseek/deepseek-v4-flash-0731 (served matches the probe).

The whole last run cost 0.369 USD, with 747,469 input and 494,282 output tokens. Each reader's usage record shows one tool call; the record does not say what it was.

Round 1's three numbers

Scored by out/_analysis/b2_score.py on r12, r15 and r16 only, by the definitions declared above:

• Fidelity against author_items.jsonl: mean Jaccard 0.594. The primary matches mine in 0.742 of reader-items.
• Pairwise agreement: 0.733 (mean Jaccard; primary pairwise 0.767).
• Alpha (distance 1 − Jaccard, chance over the round's pooled sets): 0.726.
• Disagreement: 18 of 40 items have two readers differing.

What licenses these figures, in FLEET.md's words: readers share an architecture with me or with each other, so the figures bound whether the written instrument decides, never whether it is right. The claim they support is what I would have produced at a scale one analyst cannot reach, not what any competent reader would have produced.

By source and by my confidence:

• confusion-pair items: fidelity 0.558, pairwise 0.755;
• bags: fidelity 0.500, pairwise 0.749;
• random items: fidelity 0.705, pairwise 0.692;
• items I marked clear: fidelity 0.833; arguable: 0.560.

The main finding is mine to own. I placed 24 of the 40 items on two kinds. The readers placed one kind in most items: 3, 6 and 1 multi lines out of 40. In 14 items all three readers placed one theme that is among mine, so the item scores 0.5 against me while the readers agree perfectly. Rule 0 asks for a second placement only where one cannot carry the material. The readers read it more strictly than I did. Those second placements are author-errors (the rechecks below record them). The readers are not wrong.

Stopping. Pairwise agreement (0.733) clears the declared threshold of 0.70. Under the round-2 rule no round may stop before the ten biggest bags have been read, and this round made edits. So round 2 opens.

What divided readers, and the verdicts

out/_analysis/b2_r1_items.tsv has every item.

• Author-error (readers right, me wrong):
  • My second kind was not needed, all three readers placing one: 4chan t07, GreenCorner t03, england t03, flashtv t13, floridagators t09, harrypotter t08, kpop t04, megaman t11, redhotchilipeppers t09, furry t10 and nyu t01 (T3-004 never chosen), signal t01, WisconsinBadgers t04, simonfraser t08.
  • My primary was wrong: orderofthebluecorner t08 (all three placed T3-121, exclusion, against my T3-087); stardustcrusaders t19 (all three placed T3-043, thanks, where the gate's default made T3-009 primary).
• Scheme-ambiguous (edited):
  • guatemala t02 (a national flag started and announced; readers placed T3-026 twice and T3-002 once, none T3-065) and catalunya t01 (one reader T3-002);
  • dofus t01 (T3-092, T3-038 and T3-002);
  • cubers t12 (T3-002, T3-041 and T3-169);
  • nVade t04 (all T3-005, where the work defended is another room's);
  • WisconsinBadgers t04 (one reader T3-042);
  • farmcarrots t15 (one reader T3-031).
• Item-is-a-bag (flagged, no edit): acecombat t05, Goodboye t03 and simonfraser t08. They hold four or more kinds and were bags in the B1 record.
• Genuine-joint, or one reader recording rule 0's exception (no edit): Slovakia t07, anarcho_capitalism t12, parabola t02, korea t15, furry t10 (T3-034) and donaldglover t04 (two readers added T3-032).
• Reader-error: none named. The single-reader misses (catalunya, n64, signal, farmcarrots) are covered by edits or by discriminators that already decide.

The edits

scheme_edits.jsonl: 272 lines, all round 1.

The first record bundled mirrors and new questions one line per theme and field (36 lines). After QB2-003 it moved to out/_analysis/scheme_edits_b2b-r1_bundled.jsonl, and the record was rewritten one line per change. The 36 tier_history lines written for the bundled record (253 to 288) are superseded by the per-edit lines that follow them.

• Sentence changes, 6:

  • T3-005 must_not_show: repair "with or without an attacker in view, where no fight is called" goes to T3-021 (the contradiction).
  • T3-021 must_show: repair during a raid counts there when the fixing leads.
  • T3-009 and T3-043 decide_when_both: the side with more concepts is primary (author-error).
  • T3-065 must_show: announcements and calls for the room's own flag go there.
  • T3-092 decide_when_both: a piece begun alone and offered to the room is T3-033 when the offer leads.

• 8 discriminators from round-1 splits: T3-087/T3-121 (author-error), T3-005/T3-011, T3-026/T3-065 and T3-002/T3-169, each in both gates.

• Gate repairs no item caused (QB2-003), until mem.py gates found no defect:

  • 202 word-for-word mirrors of one-way discriminators (kind gate-check);
  • 28 new questions, each written into both gates (56 lines), for must_not_show lines that sent material to a theme with no discriminator. 7 in the first pass are in b2_edits_r1.py; 21 are in out/_analysis/b2_newpairs_r1b.json.
  • Together with the 6 sentence changes and the 8 split-driven discriminators, that makes 70 edits that owe rechecks and tier_history lines.

• After the edits: mem.py gates reports 0 one-way discriminators, 0 such must_not_show lines and 0 unknown ids. Eleven pairs were read and confirmed (out/gate_checks.jsonl): T3-005/T3-021, T3-009/T3-043, T3-002/T3-065, T3-087/T3-121, T3-005/T3-011, T3-026/T3-065, T3-042/T3-076, T3-062/T3-084, T3-033/T3-092, T3-002/T3-169 and T3-004/T3-070. The other pairs of edited themes are not yet confirmed; they are read before the freeze.

• No theme was narrowed, and no theme's members changed. Base rates (author against readers, over 40 items):

  • T3-004: 2 against 0;
  • T3-021: 1 against 0;
  • T3-011: 3 against 1;
  • T3-014: 2 against 8 (2.7 per reader);
  • T3-005: 3 against 9 (3.0 per reader);
  • T3-121: 0 against 3.

  The full table is in the score script's output. Round 2 watches T3-004 and T3-021, which no reader chose.

The rechecks

Every edit that is not a gate-check owes rechecks of my own placements on the themes it touches. There are 70 such edits; they owe 594 records over 78 items. out/_analysis/b2_rechecks_r1.py decides each item once and records it under every edit that owes it, with mem.py recheck and the concepts behind each theme.

• 22 items move: 18 are author-errors, mostly second kinds that rule 0 does not need, and 4 are the edits doing their work (GreenCorner t03, dofus t01, stardustcrusaders t19, guatemala t02).
• The rest are unchanged, each with its reason.
• author_items.jsonl stays as written. From round 2, fidelity is reported twice: against it, and against the rechecked placements.

Section 4

Position curves (each reader's items at positions 1 to 10 against 31 to 40):

• r12: arguable 6 then 5; agreement with the other two 0.70 then 0.80.
• r15: arguable 8 then 6; agreement 0.65 then 0.70.
• r16: arguable 6 then 4; agreement 0.75 then 0.70.

Two of three readers still improve inside the round, so convention formation is not over at 40 items. Ten items per bin and three readers make this weak evidence. Following section 4, the remedy is a warm-up block, not a bigger batch.

The batch cap for stage B3 (declared here): 40 items per batch, the first 10 of them a warm-up block that is placed and not counted. To be revisited with round 2's curves.

Exemplar candidates: the 18 items that divided readers are in exemplar_candidates.jsonl, with the readers' sets and mine.

Predicted confusions, so far

Of the 19 pairs in confusions.md, round 1's readers split on:

• pair 6 (dofus t01, T3-002/T3-033), though not along the predicted line;
• pair 8 (furry t10, T3-004/T3-070), by adding T3-034;
• pair 10 (signal t01, T3-038 against T3-009, not T3-004);
• pairs 2, 7 and 12 by adding a second kind (anarcho_capitalism t12, korea t15, parabola t02);
• pair 11 by moving off both themes (acecombat t05, T3-014 and T3-062).

The hardest predicted pair, T3-005/T3-021, did not split: GreenCorner t03 went to T3-005 for all three readers. The scored scorecard comes after the gold round.

Next

Round 2 is built at B2a-r2, in out/_packets-B2/round-2/, from the edited scheme.jsonl:

• the ten biggest bags served in parts (the splitter as a helper if packets.py cannot part a B2 item);
• RETURN-B2.md with the also_present clause;
• the manifest entry noting the reader settings.

Added after the section above, in the same leg

The deal cluster. Reading T3-010's 17 pairs found seven where a decide_when_both names T3-010 but no discriminator separates the pair: T3-012, T3-035, T3-039, T3-040, T3-084, T3-123 and T3-139. mem.py gates checks only must_not_show lines, so it does not see this shape. Seven questions were written into both gates (out/_analysis/b2_newpairs_r1c.json; scheme_edits 273 to 286). They are kind scheme-ambiguous, with caused_by gates:A|T3-010 and 14 tier_history lines.

The final counts are:

• scheme_edits.jsonl: 286 lines, 202 gate-check mirrors and 84 edits that owe rechecks;
• tier_history.jsonl: 372 lines;
• mem.py gates: no defect; 28 pairs confirmed, 0 stale, 464 unconfirmed. The unconfirmed pairs are read before the freeze.

The rechecks, final. 697 recheck records, none owed. 22 items moved from my original placement: 18 author-errors and 4 edits doing their work.

• 70 records failed when first tried. An earlier recheck had already moved those items off the themes the later edits touch, so mem.py no longer counted them as owed; the record was right to refuse them.
• mem.py recheck takes about 4.5 seconds a record, and the first run went past the ten-minute foreground limit into the background. The rest ran in the foreground in slices (--max).

The close-check, B2b-r1

validate.py B2 reported:

stage B2:
  leg: check (1 dispatch folders with DONE)
  _fleet_raw/B2/round-1: 3 readers, 120 return lines
  author items 40, gold items 40, rounds scored 1, edits 286 (author-error 4), scheme ids 197 (scheme/scheme_current.jsonl)

0 errors (0 distinct shapes), 443 warnings
warn   scheme.jsonl: the pair T3-001|T3-017 touches an edited theme and is not confirmed against its current sentences (mem.py gates T3-001 T3-017 --confirm --reason ...)  [443 lines with this shape; first: T3-001|T3-017]

The 443 warnings are pairs touching an edited theme that are not yet confirmed. They are read and confirmed before the freeze, where they become errors. The check counts 120 return lines because round-1 holds only the three valid readers' .jsonl files; the failed attempts are .failed.txt.

The leg closes with done.sh B2. Round 2's build leg, B2a-r2, comes next.

Leg B2a-r2, build round 2, 2026-10-11

QB2-003, revisited

The PI's answer to QB2-003 arrived during B2b-r1, and that leg applied it in full. Every repair is a scheme_edits.jsonl line with caused_by gates:T3-a|T3-b; mirrors are kind gate-check, with no recheck and no tier_history line; new sentences are scheme-ambiguous and owe both. My assumption, to repair only the pairs round 1's edited themes belong to, was dropped in that leg. No work of this leg rested on it. mem.py gates on the scheme served this round finds 0 one-way discriminators, 0 must_not_show lines without a discriminator and 0 unknown ids. 28 pairs are confirmed and 464 are not. The answer asks me to confirm each pair I read; the 464 are read and confirmed before the freeze.

The ten biggest bags, placed

I read all ten second-order themes whole, paged with --limit and --offset and never cut. Then I placed them, before any round-2 packet existed. out/_analysis/b2_author_r2.py appended them to author_items.jsonl. It checked every theme id against scheme.jsonl, and every concept against the item's own concepts with vlib.support_problems and vlib.also_present_problems. It also checked that no item was already in the hard or gold set, and it took each item's rank from notes-B1.md's list. Each line carries source "biggest-bag", support_by_theme, item_is_a_bag and also_present. All ten are arguable. The hard set is now 50 items.

Rule 0, as amended, decides the form. Round 1 showed that my second kinds were author-errors whenever one theme carried the material. So no line places more than one theme. A bag, an item that needs more than three themes, places one and names the rest under also_present, each with its own concepts.

The next table lists the ten items: the theme placed, the themes named under also_present, and the B1 working kinds.

Six are bags and four take one theme. Points from the reads:

• leagueoflegends t02 and dota2 t05 are the two moderator makeovers (Marc Merrill, and Arteezy as r/tz). Objections to the joke, reactions to Riot's own jokes and asks to keep the theme are present, but the takeover carries them.
• theblackvoid t09 calls attacks on named targets: national flags, the EU flag, the trans ribbon, "the slimy swedes". The B1 working kinds added T3-080 and T3-085. I found the calls to attack carry the material and placed T3-006 alone.
• ainbowroad t11 is outside rooms addressing Rainbow Road as host. Requests for space, pleas for help and pleas not to be run over sit on one host relation, and T3-035 carries them.
• theblackvoid t12: I placed T3-174 (loyalty to the Void's colour: hails, the oath, anthems) over the B1 working T3-031. The creeds are professions of loyalty, not in-jokes played inside the room.
• ainbowroad t07: I placed T3-041 (extending strands, adding features) over T3-038. The road was already built; these concepts extend it.
• ainbowroad t03 holds the line "KILL THE GAYS" (c1395), posted to the room. It is served to readers as it stands.

What was built

RETURN-B2.md. It gains the also_present clause in J's words of section 1. A bag places one theme and names every other with its own concept ids; otherwise the field is {}. It also gains a paragraph on parts: read every part, reply with the end marker alone on every part but the last, and answer for all items on the last. The batch name is now P03-r2. The round-1 text is kept as out/_analysis/RETURN-B2_round1.md; round 1 is scored as it was sent.

The packets, in parts (QB2-001). packets.py B2 writes one packet and exits when it is over 50 KB. Round 2 renders to about 513 KB, and leagueoflegends t02 alone is about 87 KB. So the splitter out/_analysis/b2_parts_r2.py imports packets.py and uses its own Store.item and scheme_pages. It shuffles the 50 items as packets.py does, with seed 20261012. Then it cuts the rendered lines into parts. An item that does not fit runs on into the next part under its heading marked "(continued)". A concept line always travels with its quote line, and positions run on across parts. The helper checks that every concept of every item is served exactly once. It wrote out/_packets-B2/round-2/:

• index.md (33,542 bytes) and 21 family pages (7,839 to 19,772 bytes), from the edited scheme.jsonl, with no exemplars;
• P03-r2-p1 to P03-r2-p11. Ten parts are 50,254 to 50,394 bytes and the last is 9,799; each is under 51,200 bytes with its end line, 513,096 bytes in all;
• MANIFEST.json.

The next table lists the positions each part holds.

Position 37 runs over four parts (p5 to p8); it is leagueoflegends t02. The seeded order and the positions per part are in out/_analysis/b2_order_r2.json, outside the readers' folder. Round 1's packets are where they were: flat in out/_packets-B2/, and J's copy in round-1/. No gold item and no room note is in the folder.

MANIFEST.json, on QB2-004's assumption. QB2-004 is open. It asks what form fleet.py expects when one item is larger than a part. Until it is answered, each part carries count_key position, the B3 exclusions, group P03-r2, part k and parts 11. Parts 1 to 10 carry items 0, since their reply is the end marker alone, and part 11 carries all 50. Each entry also records its positions and the seed. If J answers otherwise, the next build leg rebuilds from the same helper.

Manifest. run_manifest.json has a B2 round-2 entry (out/_analysis/b2_manifest_r2.py). It records the model, deepseek/deepseek-v4-flash-0731, and J's reader settings: one provider (Relace) and medium reasoning effort. Round 1 ran at high effort on mixed providers. A change in agreement between the rounds is therefore partly the settings and not only the edits. The entry also records the seed, 3 agents, 50 items, and every part's bytes and sha256.

The PI's round-2 rule. No round may meet a stopping rule before the ten biggest bags have been read once. Round 2 serves all ten, so its check leg may apply the stopping rules.

Questions open: QB2-004.

The rechecks the ten new items owed

The ten bags sit on themes that round 1's edits changed. The first run of validate.py B2 in this leg therefore found 57 rechecks owed under 42 edits, one error line per edit. No edit can have moved a placement made after it. The check still asks for the record, so out/_analysis/b2_rechecks_r2.py --show printed each edit's changed sentence beside the items it owes. I read each and wrote one reason per edit. None moves a placement. The 57 records went in through mem.py recheck, all unchanged, with the concepts from each line's support_by_theme. rechecks-B2.jsonl now has 754 records, and none is owed.

The close-check, B2a-r2

validate.py B2 reported:

stage B2:
  leg: check (1 dispatch folders with DONE)
  _fleet_raw/B2/round-1: 3 readers, 120 return lines
  author items 50, gold items 40, rounds scored 1, edits 286 (author-error 4), scheme ids 197 (scheme/scheme_current.jsonl)

warn   scheme.jsonl: the pair T3-001|T3-017 touches an edited theme and is not confirmed against its current sentences (mem.py gates T3-001 T3-017 --confirm --reason ...)  [443 lines with this shape; first: T3-001|T3-017]

0 errors (0 distinct shapes), 443 warnings

The 443 warnings are the unconfirmed pairs that touch an edited theme. They are read and confirmed before the freeze. The check calls the leg "check" because round 1's dispatch folder holds DONE; this leg is round 2's build. The leg closes with done.sh B2 --cut packets-out. The dispatch sends the eleven parts of P03-r2 to each of three fresh readers. The check leg B2b-r2 scores fidelity against author_items.jsonl and against the rechecked placements, with pairwise agreement and alpha.

Leg B2b-r2, round 2 rebuilt, 2026-10-12

Why round 2 was rebuilt

Round 2's dispatch ran three times, and every reader was exhausted. There is no valid return. out/_fleet_raw/B2/round-2/ holds DONE, EXHAUSTED.tsv and log.jsonl; nothing in it is scored. The handler gave two causes, both in the log.

• Every reader got HTTP 400 at part 6. Part 5 carried 149,007 input tokens and passed; part 6 would carry about 163,000. The provider's window looks to be about 164,000 tokens (the handler inferred this from the log; it is not confirmed). One conversation over eleven parts cannot fit, since the shared pages alone are about 95,000 tokens.
• Some readers closed part 1 with the packet's end line instead of END-OF-RETURN. fleet.py now names the marker in every message.

QB2-004 was answered before the dispatch: J confirmed my MANIFEST form for parts. J's ruling of 2026-10-12 replaces the parts design, so nothing rests on that answer any longer.

J's ruling, as applied

The ruling asks for self-contained packets: at most 15 items and at most 180,000 bytes of item text each; no item split across packets; no MANIFEST group, part or parts; the same 50 items, shared pages and RETURN-B2.md, minus its parts paragraph.

out/_analysis/b2_packets_r2b.py built them with packets.py's own Store.item. It keeps round 2's seeded order (seed 20261012, out/_analysis/b2_order_r2.json) and cuts it into consecutive packets, choosing the cut points that make the largest packet smallest. No item is over the cap; the largest, leagueoflegends t02, is about 87,000 bytes. Four packets would meet the caps, but one would hold 166,501 bytes of item text, close to the cap. I built five, so the largest holds 128,155 bytes and each reader has more room inside the window.

The next table lists the five packets that the dispatch must read, all in out/_packets-B2/round-2/.

Each packet numbers its items from 1 and says how many lines to return. MANIFEST.json gives each packet its own item count, with count_key position, and no group or part. The items per packet are in out/_analysis/b2_order_r2b.json. The shared pages beside them are index.md and G01.md to G21.md, unchanged from B2a-r2. Packet 4 holds three items: leagueoflegends t02, acecombat t05 and dota2 t05.

The packets are over FLEET.md's 50 KB ceiling by J's ruling, which sets the byte cap at 180,000 of item text. packets.py's writer asserts 50 KB, so the helper writes the files itself.

Superseded, not deleted. The eleven parts P03-r2-p1.md to P03-r2-p11.md and their MANIFEST.json moved to out/_analysis/b2_packets_round2_parts/. The dispatch must not read them.

RETURN-B2.md loses its paragraph on parts. The batch field is now the name on the packet's title line, such as P03-r2-3. The parts version is kept as out/_analysis/RETURN-B2_round2_parts.md.

Manifest. run_manifest.json has a new round-2 entry from this leg (out/_analysis/b2_manifest_r2b.py). It supersedes the B2a-r2 entry, which stays. It records the five packets with bytes and hashes, J's caps, and the same reader settings: one provider (Relace) and medium effort.

The close-check, B2b-r2

validate.py B2 reported:

stage B2:
  leg: check (2 dispatch folders with DONE)
  _fleet_raw/B2/round-1: 3 readers, 120 return lines
  _fleet_raw/B2/round-2: 0 readers, 0 return lines
  author items 50, gold items 40, rounds scored 1, edits 286 (author-error 4), scheme ids 197 (scheme/scheme_current.jsonl)

ERROR  _fleet_raw/B2/round-2 holds a finished dispatch and pilot_rounds.jsonl has no line for round 2; the check leg scores it (fidelity, pairwise agreement, alpha) before it closes
warn   scheme.jsonl: the pair T3-001|T3-017 touches an edited theme and is not confirmed against its current sentences (mem.py gates T3-001 T3-017 --confirm --reason ...)  [443 lines with this shape; first: T3-001|T3-017]

1 errors (1 distinct shapes), 443 warnings

The error conflicts with J's ruling. The failed folder holds no reading, so there is nothing to score, and the check accepts no line without numbers. QB2-005 asks J how to record a failed dispatch. Meanwhile I write no pilot_rounds.jsonl line for round 2 and leave _fleet_raw/B2/round-2/ as the dispatch left it. A diary line of kind ask at 03:56 carries the same question without an id; I wrote it with mem.py log by mistake, and QB2-005 is the record.

The 443 warnings are the unconfirmed gate pairs, read before the freeze.

QB2-005, answered: the failed dispatch moved aside

J ruled (2026-10-12, 06:55 Berlin). The failed folder is renamed and no pilot_rounds.jsonl line is written for it. I ran mv out/_fleet_raw/B2/round-2 out/_fleet_raw/B2/round-2-failed; nothing was deleted. J dispatches round 2 again into a fresh round-2/ folder.

round-2-failed/ holds the three exhausted dispatches of the eleven-part packet and no reading. Its DONE file counts 11 packets, 3 readers, 0 valid returns and 3 exhausted, on deepseek/deepseek-v4-flash-0731. They used 1,873,195 input tokens and 10,054 output tokens, at a cost of 0.087 USD. The log holds 70 calls from 14 reader ids (r1 to r14). The folder holds 13 failure files:

• 9 failed at part 6 with HTTP 400. Part 5 carried 149,007 input tokens and passed; part 6 would carry about 163,000. The provider's window looks to be about 164,000 tokens; the handler inferred this from the log, and it is not confirmed.
• 4 failed at part 1 because the reply ended with the packet's end line ("END OF PACKET" or "END-OF-PACKET") instead of END-OF-RETURN (r6, r8, r10, r14).
• r4 appears in the log with no failure file of its own.

My assumption under QB2-005 was to write no line and leave the folder alone. The first half stands; the folder is now renamed as J ruled.

The close-check after the rename (QB2-006)

After the rename, validate.py B2 reported:

stage B2:
  leg: check (2 dispatch folders with DONE)
  _fleet_raw/B2/round-1: 3 readers, 120 return lines
  _fleet_raw/B2/round-2-failed: 0 readers, 0 return lines
  author items 50, gold items 40, rounds scored 1, edits 286 (author-error 4), scheme ids 197 (scheme/scheme_current.jsonl)

ERROR  stage output 'scheme_final.md' was not written
ERROR  stage output 'scheme_final.jsonl' was not written
ERROR  stage output 'stability-B2.md' was not written
ERROR  stage output 'pilot_report.md' was not written
warn   _fleet_raw/B2/round-2-failed returned but no pilot_rounds.jsonl line is flagged "gold": true; the gold figure is reported beside the last round's
warn   scheme.jsonl: the pair T3-001|T3-017 touches an edited theme and is not confirmed against its current sentences [443 lines with this shape]

The round-2 error is gone. The check treats every folder in _fleet_raw/B2/ that holds DONE and is not named round-N as a gold or stability dispatch, so it reads the stage as finished and asks for the freeze outputs. The stage is not finished, and writing those files now would be false. round-2-failed/ still holds the dispatch's own DONE file, which I leave untouched. QB2-006 asks J which fix he wants: move the folder out of _fleet_raw/B2/, have the dispatch rename DONE, or have the check skip folders named *-failed. Meanwhile the folder stays where J named it, and the leg stays open if done.sh refuses. The five packets in out/_packets-B2/round-2/ are ready for the new dispatch either way.

QB2-006, answered: the failed dispatch moved out of _fleet_raw/B2/

J ruled at 06:55, and the handler placed the folder under that ruling. The check is not changed. I moved out/_fleet_raw/B2/round-2-failed/ whole to out/_analysis/fleet_B2_round2_failed/ (mv). Nothing was deleted, and its DONE, EXHAUSTED.tsv, arm.json, log.jsonl and 39 reader files are inside, untouched. The new path is where the failed first dispatch of round 2 lives; it holds no reading and is never scored. _fleet_raw/B2/ now holds round-1/ only, and J dispatches round 2 again into a fresh round-2/.

validate.py B2 after the move:

stage B2:
  leg: check (1 dispatch folders with DONE)
  _fleet_raw/B2/round-1: 3 readers, 120 return lines
  author items 50, gold items 40, rounds scored 1, edits 286 (author-error 4), scheme ids 197 (scheme/scheme_current.jsonl)

warn   scheme.jsonl: the pair T3-001|T3-017 touches an edited theme and is not confirmed against its current sentences (mem.py gates T3-001 T3-017 --confirm --reason ...)  [443 lines with this shape; first: T3-001|T3-017]

0 errors (0 distinct shapes), 443 warnings

The 443 warnings are the unconfirmed gate pairs, read before the freeze. The leg closes with done.sh B2 --cut packets-out. The dispatch must read the five packets P03-r2-1.md to P03-r2-5.md in out/_packets-B2/round-2/.

Leg B2b-r2-p2, check round 2, 2026-10-12

QB2-005 and QB2-006, revisited

Both were applied at B2b-r2. The failed first dispatch is at out/_analysis/fleet_B2_round2_failed/, and it is never scored. No work of this leg rested on either assumption.

Rounds 1 and 2 had different readers (J, 2026-10-12 07:34 Berlin)

• Round 1: deepseek/deepseek-v4-flash-0731, through @preset/cheap, at high reasoning effort on mixed providers.
• Round 2: deepseek/deepseek-v4.1-flash, called directly, at medium reasoning effort, with max_tokens 128,000.

J's reading: the preset refused even a 32-token probe with HTTP 400. So the part-6 failures of the first dispatch were most likely the preset or its provider pin, not the context window (OpenRouter lists V4.1 Flash at 1,048,576 tokens). The same readers serve B3 and B4. Every change from round 1 to round 2 below is partly a change of readers, not only of the scheme.

The dispatch, in fleet.py's counts

_fleet_raw/B2/round-2/DONE and log.jsonl record 5 packets, each sent to 3 fresh readers (15 readers, r1 to r3 inside each packet folder). There were 15 valid returns, 0 exhausted and 0 reissues. Calls took 67.6 to 235.7 seconds each. The round used 751,923 input and 489,651 output tokens, at a cost of 0.598 USD. All 150 lines came back.

One line mistyped its heading. In P03-r2-5/r2, position 7 returned AyyMD t02, where the packet holds AyyMD t08. Its concepts (c0037, c0041) are t08's, so it is scored as t08 by position.

Round 2's three numbers

out/_analysis/b2_score_r2.py scores the round by the declared definitions, reusing b2_score.py's Jaccard and alpha. out/_analysis/b2_rechecked.py builds the rechecked placements: each item's latest recheck, which moves 19 hard items. The next table gives the figures for the whole set and for its two parts.

Round 1, on its 40 items, scored fidelity 0.594, pairwise 0.733 and alpha 0.726. On the same 40 items round 2 is lower on all three. 27 of 50 items have two readers differing; 24 of them are round-1 items.

The largest change is in how many themes a reader places. Round 2's readers placed more than one theme on 47 of 150 lines; round 1's placed more than one on 10 of 120. Most of round 2's divisions are a second or third theme added by one or two readers. Each comes with a why_not_one that reads "carry" as "cover every concept". Rule 0's words are the contract's and stay. The rate of second placements is a property of the reader model, and B3, which uses these readers, should expect it.

What these figures license, in FLEET.md's words: they support the claim "what you would have produced at a scale one analyst cannot reach". They do not support "what any competent reader would have produced".

The ten biggest bags. All 30 lines put my placed theme first (primary 1.000). Readers marked the six bags as bags on 11 of 18 lines. They also marked bags I did not: ainbowroad t11, dota2 t05, leagueoflegends t02 and theblackvoid t09 each drew one or two bag lines. also_present diverges widely. The themes a reader names, placed and also present, score a mean Jaccard of 0.283 against mine. On 2007scape t04 one reader named 85 themes (the other two 29 and 16). On sweden t01 the three named 34, 35 and 25; I named 5. QB2-008 asks J for a concept floor.

The verdicts

The next table gives one verdict for each item that divided readers, and for each where all three readers left my placement. Stage B4's taxonomy names the kinds. "Rechecked" means my placement after round 1's rechecks.

GreenCorner t03, WisconsinBadgers t04, england t03, megaman t11 and signal t01 are unanimous. Each falls on my rechecked placement: round 1's author-error verdicts, confirmed by new readers. There are eight author-error verdicts this round: AyyMD t08, nyu t01, cubers t12, harrypotter t08, farmcarrots t15, parabola t02, redhotchilipeppers t09 and Slovakia t07. They change no sentence, so they are listed here and not in scheme_edits.jsonl. author_items.jsonl stays as written.

The edits

out/_analysis/b2_edits_r2.py wrote scheme_edits.jsonl lines 287 to 295, all scheme-ambiguous, with tier_history lines 373 to 381. They change 9 fields over 8 themes:

• T3-065's gloss now says a flag built in a room named for a land is that land's flag, unless its concepts name another.
• The T3-002/T3-065 and T3-026/T3-065 questions say so in both gates.
• A new T3-033/T3-038 question asks whether an idea is offered or a mark placed and reported. For a proposal followed by its placing, the side with more concepts is primary.
• New T3-195/T3-011 and T3-195/T3-005 questions ask whether an agreement is invoked, or the work helped or defended with the pledge only the reason.

No edit narrows a theme. b1e_assemble.py --write rebuilt scheme.jsonl, families.jsonl and scheme.md. mem.py gates finds no defect.

The rechecks. The nine edits owed 133 records over 59 items in the hard and gold sets. out/_analysis/b2_rechecks_r2b.py read each against its edit's sentence; none moves. rechecks-B2.jsonl holds 887 records, and none is owed.

The gates. I read ten pairs and confirmed them (out/_analysis/b2_confirm_r2.json): the five new or reworded pairs, and five whose confirmation the edits had made stale. 31 pairs are confirmed, 0 are stale and 464 are unconfirmed.

Section 4

Round 2's packets hold 3 to 15 items, so round 1's curve (first ten items against last ten) cannot be drawn. Within the four packets of 9 or more items, I compared each reader's first half with its last half. The arguable rate falls in 8 of 12 readers and rises in 3. Agreement with the other two falls in 9 and rises in 2. The curve shows no sign that agreement grows with position. The B3 batch cap stays as declared: 40 items, the first 10 a warm-up block.

Stopping (QB2-007)

Section 5 stops the rounds when pairwise agreement on the hard set clears the threshold. Round 2's figure on the 50-item hard set is 0.718, above 0.70. The PI's round-2 rule holds: the ten biggest bags have now been read once. But the 40 items both rounds share fell from 0.733 to 0.685, with new readers, and the ten bags lift the whole. QB2-007 asks J whether the rounds stop and the scheme freezes, or round 3 opens. Meanwhile the rounds stop under the declared rule, with the 40-item figure reported beside it. This leg does not freeze: the freeze needs the 464 unconfirmed pairs read and the decide_when_both clusters checked. The leg closes with done.sh B2.

Questions open: QB2-007 (stopping), QB2-008 (a floor for also_present).

The close-check, B2b-r2-p2: return lines that break the specification (QB2-009)

validate.py B2 reported 44 errors in 9 shapes, all in _fleet_raw/B2/round-2/. fleet.py had accepted every line. out/_analysis/b2_r2_return_problems.py lists 16 of 150 lines in out/_analysis/b2_r2_return_problems.txt:

• One line is incomplete: P03-r2-2/r1, ainbowroad t04, has third_order and why only. It lacks confidence, read, exemplar_read, families_opened, t_start, t and support.
• One line mistypes its heading: P03-r2-5/r2 position 7 returned AyyMD t02 where the packet holds t08. Its five support concepts are t08's.
• 14 lines cite concept ids that are not the item's own, in support, also_present or multiplacement_log. They are on sweden t01 (three readers), ainbowroad t04 (two), 2007scape t04 (two), theblackvoid t09, theblackvoid t12, leagueoflegends t02, dota2 t05, donaldglover t04, duckgame t02 and ainbowroad t07. Each cited id belongs to another second-order theme of the same room, except c1636 on 2007scape t04, which is not a concept of r/2007scape at all.

Every line carries its third_order, and the scores use nothing else. The stage says a return that fails the specification is reissued, not scored. Reissuing is the dispatch's work, not mine. QB2-009 asks J whether the dispatch reissues the ten affected returns (packet 2 r1, r2, r3; packet 3 r1, r2; packet 4 r1, r3; packet 5 r1, r2, r3), or the lines are scored as they stand with their errors on the record.

Meanwhile the scores stand as computed on all 150 lines (pilot_rounds.jsonl line 2). No edit rests on an affected line: edits 287 to 295 came from guatemala t02, nVade t04, n64 t02 and dofus t01, whose lines are all within the specification. The AyyMD t08 author-error verdict rests partly on the mistyped line, one of its two T3-023 placements. The bag figures (primary 1.000, also_present Jaccard 0.283) rest partly on the affected lines. If the returns are reissued, I rescore, write a superseding pilot_rounds line, and revisit these. The leg stays open until the close-check passes.

The bag recut: a proposal to J (QB2-010), not yet acted on

J ruled (QB2-008) that a second-order theme whose concepts spread over 16 to 85 third-order themes was cut too coarse. One item should sit in one theme most of the time, a few in two or three. Nothing below is cut until J's word.

How coarse the themes are (out/_analysis/b2_recut_survey.py, one line per theme in b2_recut_survey.tsv):

• The store's 7,844 second-order themes hold a median of 8 concepts (90th percentile 31, 99th 111, maximum 798).
• B1 placed 3,977 on one kind, 1,972 on two and 1,837 on three. It recorded 846 as bags, themes needing more than three kinds.
• 98 themes hold 100 or more concepts, together 14.5% of all concepts; 49 of them are B1 bags.
• With J's floor applied to round 2's also_present (three concepts of the item's own), readers still name 14 to 43 kinds on 2007scape t04 and 21 to 24 on sweden t01.

A cut by thread does not work. The bags were gathered across threads by what the concepts do. On ainbowroad t03, 309 of 326 concepts are alone in their thread; on sweden t01, 202 of 310. A neutral cut by thread would leave hundreds of one-concept parts. The cut has to be by doing, which is coding work.

The sibling citations. Most of round 2's failing lines cite concepts of sibling themes of the same room. They split into two groups:

• In packets 3 and 5 the sibling was in the same packet: theblackvoid t09 beside t12, ainbowroad t11 beside t07. The reader mixed two items of one room.
• In packets 2 and 4 the room had one item in the packet (sweden t01, ainbowroad t04, dota2 t05, leagueoflegends t02), so the cited ids were never shown. Room ids run in sequence, and an invented number in range nearly always lands on a sibling.

So the citations are not evidence that sibling themes overlap, and the proposal does not regroup siblings. Fleet ids stop the second group. For the first group, the packet builder could keep one item per room in a packet, with J's agreement.

The proposal.

1. Which items.

   • At once, before round 3: the hard set's six author bags (2007scape t04, theblackvoid t12, ainbowroad t03, t04 and t07, sweden t01) and the gold set's bags.
   • Before B3, by the same rule: every B1 bag (846 themes), and every theme of 100 or more concepts that round 3 shows to need more than three kinds.
   • The round-1 items I placed as bags in round 1 (Goodboye t03, acecombat t05) follow the same rule if they still need more than three kinds.

2. By what rule.

   • I read the theme whole, in a blind window (mem.py blind on), so B1's working placements are hidden.
   • I group its concepts into children, each one doing in the room's own terms. Each child gets a label and a note written as a second-order theme, with no third-order ids and no scheme words.
   • A child needs at least three concepts (J's floor). A concept that fits no child of three joins the nearest child by its doing.
   • Every concept goes to exactly one child, and the parent's concept ids are kept.
   • Then, outside the window, each child is placed like any item, with a target of one third-order theme and at most three. A child that still needs more than three is cut again.

3. With which verbs. No verb cuts a second-order theme today: package/store is read-only, and reassign re-places a theme only after a recut. I propose J adds two verbs:

   • A recut writer, mem.py recut <sub>:<tNN> --child "label|note|c1,c2,..." --reason .... It writes a recut layer beside the store (out/recut/themes.jsonl, the children with new room ids after the room's last tNN, and out/recut/codes.jsonl, each concept's child). It marks the parent superseded, never deletes it, and logs kind split.
   • Store readers (mem.py theme, codes --sub, packets.py's Store) that read the layer.

   The children also need fleet ids. J's table maker would draw new T2 ids from the same space, so fleet_ids.jsonl covers them.

4. What it reopens of B1.

   • scheme_current.jsonl: the parents' placements are superseded by the children's (13,432 placements and 7,786 placed themes change by the cut).
   • multiplacement_log.jsonl: the parents' bag records and rule 0 lines are superseded.
   • F-001's within-room grain claim, which counts kinds per theme, is recomputed.
   • Each third-order theme's member counts are recomputed, so its tier (rare at under two unlike rooms) is checked again; rooms per theme do not change.
   • confusions.md rates are recomputed where they count parents.

   Not reopened: the codes themselves (episodes and exemplars cite concept ids, which stay), the third-order scheme's sentences, and the rooms' notes.

5. What it changes in B2. author_items.jsonl stays as written. The children are appended as new lines (source "recut", with their parent), and the parents leave the hard set from round 3, so round 3's set is not round 2's on those items. Round 3's comparison with round 2 is reported on the 40 unchanged round-1 items. J may also prefer that round 3 keeps the parents beside the children, for one round's comparison.

Fleet ids. Round 3 is the first round with fleet ids. out/_analysis/b2_packets_fleet.py builds the packets: room name plus T2- theme ids and C concept ids; no room id in an id position; J's caps of 15 items and 180,000 bytes. A dry run on the current hard set (seed 20261013) gives five packets of 7 to 13 items. out/_analysis/b2_translate_fleet.py translates returns back before scoring and reports every id the table lacks, or that belongs to another room or theme. RETURN-B2.md now asks for fleet ids, and it carries J's floor: a theme enters also_present only with at least three concepts of its own. Its round-2 text is kept as out/_analysis/RETURN-B2_round2.md. B3's specification does not exist yet; the head carries both rules for it.

Two points for J:

• validate.py checks returns against room ids in _fleet_raw, so a fleet-id round will fail its concept check unless the check reads the translated copies (out/_analysis/b2_r<K>_returns/) or the table.
• No round-3 packet is built until J's word on the recut.

QB2-007 and QB2-008, answered; fleet ids (J, 2026-10-12)

QB2-007. J rules that round 3 runs on the edited scheme with round 2's readers: deepseek-v4.1-flash, called directly, at medium effort. Round 3 is the first round in which only the scheme changes. My assumption, that the rounds stop, is withdrawn, and nothing is frozen. pilot_rounds.jsonl line 2 stands as round 2's record. The section "Stopping (QB2-007)" above is superseded by this ruling.

QB2-008. Yes to the floor: a theme enters also_present only with at least three concepts of its own. It is now in RETURN-B2.md, and the head carries it for B3's specification, which does not exist yet. J adds that the bags need a recut, proposed before round 3's packets and not cut before his word. The proposal follows (QB2-010).

Fleet ids. From round 3, and in B3, packets carry only fleet ids for codes and second-order themes (out/fleet_ids.jsonl, seed 20261012). My own files keep the room ids, and returns are translated back before scoring. Round 3 is the first round with fleet ids. A made-up code id lands on a real code about 7.5% of the time, and a made-up theme id about 7.8%; with room ids, an invented c-number in range almost always landed on a sibling.

QB2-009, answered: the 16 lines waived, round 2 scored as it stands

J ruled (2026-10-12, 09:27 Berlin): no reissue of round 2. The 16 lines in out/_analysis/b2_r2_return_problems.txt are waived by name, in out/return_waivers.jsonl (out/_analysis/b2_waivers_r2.py). Each line names the round folder, the file, the item as the line writes it, the problem as listed, and J's ruling. The AyyMD line's reason also names its mistyped heading. validate.py B2 skips the waived lines and counts them aloud.

Round 2 stays scored on third_order, as before. pilot_rounds.jsonl line 2, the verdicts and edits 287 to 295 stand unchanged; nothing rested on a reissue.

The 16 lines are reader faults:

• one incomplete line: packet 2 r1, ainbowroad t04;
• one mistyped heading: packet 5 r2, AyyMD t02 for t08;
• 14 lines citing concepts that are not the item's own.

The faults came from two things, and both are artefacts of room ids:

• Room ids repeat across rooms. c0006 names two different concepts in packet 2, one in each of two rooms.
• Invented ids land on sibling codes. A room's ids run in sequence, so an id a reader makes up within range nearly always names a real concept of a sibling theme. Examples are c0558 on sweden t01 and c1556 on ainbowroad t04, neither ever shown in their packets. Where two items of one room shared a packet (theblackvoid t09 and t12, ainbowroad t07 and t11), readers also took concepts from the other item.

From round 3 the fleet ids of out/fleet_ids.jsonl end both: no id repeats, and a made-up id lands on a real code about 7.5% of the time. fleet.py rejects, and reissues in the dispatch, a line citing an id not under its item. For that check, round 3's builder out/_analysis/b2_packets_fleet.py writes codes_by_item into each packet's MANIFEST entry: the item's fleet theme id, as the line writes theme_id, with the fleet code ids served under it. Tested on guatemala t02 (8 codes) and sweden t01 (310). No round-3 packet is built yet: QB2-010, the recut, waits for J's word.

The close-check, B2b-r2-p2

validate.py B2 reported:

stage B2:
  leg: check (2 dispatch folders with DONE)
  _fleet_raw/B2/round-1: 3 readers, 120 return lines
  _fleet_raw/B2/round-2: 15 readers, 150 return lines, 16 waived by J (return_waivers.jsonl)
  author items 50, gold items 40, rounds scored 2, edits 295 (author-error 4), scheme ids 197 (scheme/scheme_current.jsonl)

warn   scheme.jsonl: the pair T3-001|T3-017 touches an edited theme and is not confirmed against its current sentences (mem.py gates T3-001 T3-017 --confirm --reason ...)  [443 lines with this shape; first: T3-001|T3-017]

0 errors (0 distinct shapes), 443 warnings

The 443 warnings are the unconfirmed pairs that touch an edited theme; they are read before any freeze. The leg closes with done.sh B2. Round 3 opens (QB2-007). Its build waits for J's word on the recut (QB2-010), and its packets carry fleet ids.

QB2-010: the bags split (J approved, 2026-10-12 09:32 Berlin)

J approved the cut as proposed, at medium effort. The handler installed mem.py split. It writes out/recut/themes.jsonl and out/recut/codes.jsonl beside the read-only store and gives each child the room's next free tNN and a fleet id in out/fleet_ids.jsonl. The parent is superseded, never deleted. Each child names me ("analyst") as its author and names the parent it supersedes.

How the cut was made. I read every bag whole in one blind window (mem.py blind on, closed at 07:49:15), with B1's placements hidden. I grouped each bag's concepts into children by what the concepts do; each child has at least three concepts, and every concept is in one child. Each cut is written in out/_analysis/b2_split_<sub>_<tNN>.txt and was run by out/_analysis/b2_split_run.py. The helper checks coverage and the three-concept floor against the store before it calls mem.py split.

mem.py theme printed some concept lines blank (c0084, c0505, c0595 and c0960 of 2007scape t04, for example). I read the bags with mem.py codes --sub S --second tNN, and the helper's coverage check named every concept I had not yet assigned. Each one was read and assigned.

The six hard-set bags became 54 children. The next table lists each bag with its children and their sizes.

The hostility child of ainbowroad t03 holds "KILL THE GAYS" (c1395), posted to the room; it is kept and served as it stands.

The gold set's eight B1 bags. One was cut: dankmemes t16 (12 concepts) became t18, pointing out drawings on the canvas (5), and t19, reporting the build failed and mourning the canvas (7). Seven were not cut:

• cuboulder t04 and ukraine t07 hold 5 concepts each, so no two children of three exist.
• Villanova t01 (building a logo together), tinytardis t06 (negotiating shared space), edboxes t02 (recruiting hands and arranging the next shift) and alberta t04 (arguing whether to attack the Quebec flag) each read as one doing.
• finland t06 holds one doing of 5 concepts (moderators gathering the canvas posts) and three single concepts that each do something different; a second child would mix doings.

These small themes were B1 bags because nearly every concept did something different. With a floor of three concepts per child, they cannot be cut.

The children placed. I placed the 56 children like any item after the window closed (out/_analysis/b2_author_split.py). The 54 hard-set children were appended to author_items.jsonl and the 2 gold children to gold_items.jsonl. Each line carries its parent, source "split", support_by_theme and its fleet theme id. 40 children take one theme and 16 take two; each second theme has concepts of its own, named on the line. No child needs more than three themes, so none is a bag. The parents' lines stay as written. author_items.jsonl now has 104 lines and gold_items.jsonl 42. Round 3's hard set is the 44 unsplit items and the 54 children: 98 items.

The rechecks. The children sit on themes that earlier edits changed, so 86 edits owed them 526 rechecks. I read each edit's changed sentence against the children it owes (out/_analysis/b2_rechecks_split_show.txt), and none moves a child. The closest call is ainbowroad t24's second theme, T3-010: three of its five concepts invoke agreements already made, which T3-195 names. It stays, because the trimming to the agreed size is itself the border being settled. The 526 records were written with out/_analysis/b2_rechecks_split.py, one reason per edit. rechecks-B2.jsonl has 1,413 records, and none is owed.

What the split leaves for the check (QB2-011). validate.py B2 reports 698 errors in five shapes. All come from the split layer meeting records made before it:

• 56 items not in package/store/themes.jsonl: the item check reads the store, not the split layer.
• 186 round-2 return lines and 454 rechecks whose concepts now resolve to the children, not the parents they name.
• pilot_rounds.jsonl lines 1 and 2: n_items 40 and 50 against a hard set counted as 104, the parents included.

QB2-011 asks J whether the check should read the split layer for items, keep a parent's own concepts for records that name the parent, and count the hard set without the superseded parents. Meanwhile the leg stays open. No round-3 packet is built. The 846 B1 bags wait for J's word.

QB2-011, answered: the check reads the split layer

The handler fixed the three error shapes in tools/vlib.py and tools/checks/stage_B2.py. They were faults of the check, not of the run.

• A split child counts as a second-order theme, and its parent stays one. author_items.jsonl and gold_items.jsonl resolve both.
• A split concept belongs to its child and to every theme it was split from. Records made before the split about a parent pass; a concept of a sibling child still fails.
• A round's n_items is held to the items its own MANIFEST sent (out/_packets-B2/round-K/MANIFEST.json), as the handler's correction says.

My assumption needed no revisit. I recorded the 526 rechecks and left these shapes to the check, which now passes. Round 3's packets carry the children, not their parents.

The close-check, B2b-r2-p2, after the split

validate.py B2 reported:

stage B2:
  leg: check (2 dispatch folders with DONE)
  _fleet_raw/B2/round-1: 3 readers, 120 return lines
  _fleet_raw/B2/round-2: 15 readers, 150 return lines, 16 waived by J (return_waivers.jsonl)
  author items 104, gold items 42, rounds scored 2, edits 295 (author-error 4), scheme ids 197 (scheme/scheme_current.jsonl)

warn   author_items.jsonl has 104 items; section 1 says forty to sixty
warn   scheme.jsonl: the pair T3-001|T3-017 touches an edited theme and is not confirmed against its current sentences (mem.py gates T3-001 T3-017 --confirm --reason ...)  [443 lines with this shape; first: T3-001|T3-017]

0 errors (0 distinct shapes), 444 warnings

author_items.jsonl holds 104 lines: the six superseded parents kept as written, beside their 54 children. Round 3 sends 98 items. The 443 pair warnings are the unconfirmed pairs, read before any freeze. The leg closes with done.sh B2. Next comes round 3's build: b2_packets_fleet.py --round 3 on the 98 items, with the superseded parents left out and fleet ids only. The 846 B1 bags wait for J.

Leg B2a-r3, build round 3, 2026-10-12

The answers this leg was told to read

QB2-007 to QB2-011 were all applied at B2b-r2-p2:

• round 3 runs on the edited scheme with round 2's readers;
• also_present takes a theme only with three concepts of its own, and the bags were split;
• the 16 faulty lines are waived;
• the split was approved;
• the check reads the split layer.

Nothing in this leg rests on an assumption.

What was built

Round 3 is the first round in which only the scheme changes (QB2-007), and the first with fleet ids (J, 2026-10-12).

Items. Round 3 serves 98 items: the 44 unsplit hard items and the 54 children of the six split bags. The six parents (2007scape t04, sweden t01, theblackvoid t12, ainbowroad t03, t04 and t07) are not served. author_items.jsonl keeps their lines as written, so it holds 104 lines.

The packets. out/_analysis/b2_packets_fleet.py built the round, with two changes this leg. It now reads the split layer by giving packets.py's Store the out/ path. It also leaves out any item whose children are in out/recut/themes.jsonl. The round has seven self-contained packets in out/_packets-B2/round-3/, cut from the order seeded with 20261013. The next table lists them.

Each packet is within J's caps: at most 15 items and 180,000 bytes of item text, with no item split. The items per packet are in out/_analysis/b2_order_r3.json. Beside the packets are index.md and G01.md to G21.md, built from the edited scheme.jsonl.

Fleet ids. Each item is headed by its room and its T2- id, and each concept by its C id. The builder stops if a room id would stand in an id position, and none did. MANIFEST.json gives each packet its item count and codes_by_item: the fleet theme id of each item with the fleet code ids served under it. With that entry, fleet.py rejects and reissues any line that cites a code its item does not hold (QB2-009). Returns are translated back to room ids with out/_analysis/b2_translate_fleet.py before scoring; the check translates them through out/fleet_ids.jsonl itself (QB2-010).

RETURN-B2.md. It is unchanged since B2b-r2-p2. It asks for fleet ids and carries the floor of three concepts of its own for also_present.

Manifest. run_manifest.json has a round-3 entry (out/_analysis/b2_manifest_r3.py). It records the same readers as round 2 (deepseek/deepseek-v4.1-flash, called directly, medium effort, max_tokens 128,000), the seed, 98 items, and every packet's bytes and hash.

One packing matter for J. Some packets hold several children of one parent; for example, packet 3 holds ainbowroad children beside one another. At round 2, readers took concepts from a sibling item in the same packet. With fleet ids and codes_by_item, fleet.py now catches such a citation and reissues the reader. Packing one item per room per packet was proposed at B2b-r2-p2 and not ruled on, so it is not applied.

The close-check, B2a-r3

validate.py B2 reported:

stage B2:
  leg: check (2 dispatch folders with DONE)
  _fleet_raw/B2/round-1: 3 readers, 120 return lines
  _fleet_raw/B2/round-2: 15 readers, 150 return lines, 16 waived by J (return_waivers.jsonl)
  author items 104, gold items 42, rounds scored 2, edits 295 (author-error 4), scheme ids 197 (scheme/scheme_current.jsonl)

warn   author_items.jsonl has 104 items; section 1 says forty to sixty
warn   scheme.jsonl: the pair T3-001|T3-017 touches an edited theme and is not confirmed against its current sentences (mem.py gates T3-001 T3-017 --confirm --reason ...)  [443 lines with this shape; first: T3-001|T3-017]

0 errors (0 distinct shapes), 444 warnings

The leg closes with done.sh B2 --cut packets-out. The dispatch sends each of the seven packets to three fresh readers.

Leg B2a-r3-p2, the split withdrawn and round 3 rebuilt, 2026-10-12

The split, withdrawn

What was cut. At B2b-r2-p2 (QB2-010) I split six bags of the hard set and one gold bag with mem.py split, in one blind window. 2007scape t04 became 14 children, sweden t01 10, theblackvoid t12 10, ainbowroad t03 8, ainbowroad t04 6 and ainbowroad t07 6. In the gold set, dankmemes t16 became 2. The 56 children are in out/recut/themes.jsonl, and their concepts in out/recut/codes.jsonl. I placed each child and recorded 526 rechecks for them. The B2a-r3 round 3 served 98 items: 44 unsplit items and 54 children.

Why J withdrew it (J, 2026-10-12, 12:04 to 12:10 Berlin). Bags are a coder problem. Second-order themes are the coders' to cut, and the aggregator takes them as given. The split was a mistake, so the run goes back to before any cut and goes on from there, inside this run, with nothing deleted.

What the withdrawal did.

• out/recut/WITHDRAWN.json holds J's ruling word for word. From it on, every tool reads the store as it was before the split: the six parents and the gold bag stand again, and the 56 children are gone from every view. out/recut/ stays as written.
• out/_analysis/b2_split_withdraw.py moved the children's placement lines, unchanged and in order, to out/_analysis/author_items_split_withdrawn.jsonl (54 lines) and out/_analysis/gold_items_split_withdrawn.jsonl (2 lines). author_items.jsonl again holds 50 lines and gold_items.jsonl 40, the counts J named.
• mem.py split now refuses. A bag stays one item: one theme placed, and every other theme under also_present with at least three concepts of its own (QB2-008).

Records that belong to the withdrawn split. No figure counts these. out/_analysis/b2_split_withdrawn_count.py matched each file against the 56 children.

• out/recut/ (themes and codes, kept as written).
• out/_analysis/author_items_split_withdrawn.jsonl and gold_items_split_withdrawn.jsonl.
• rechecks-B2.jsonl lines 888 to 1,413: 526 rechecks of the children, all from B2b-r2-p2. They stay in the file so that they still resolve. Lines 1 to 887 stand.
• The 56 lines of out/fleet_ids.jsonl marked "split": true.
• The 98-item round 3: its packets, moved to out/_analysis/b2_packets_round3_split_withdrawn/, its order, renamed out/_analysis/b2_order_r3_split_withdrawn.json, and the B2a-r3 round-3 entry in run_manifest.json.
• The cut files and scripts in out/_analysis/: b2_split_*.txt, b2_split_run.py, b2_author_split.py and b2_rechecks_split.py.
• In this file: "QB2-010: the bags split", "QB2-011, answered", "The close-check, B2b-r2-p2, after the split", and the B2a-r3 section.

The split wrote no line on a child in scheme_current.jsonl, multiplacement_log.jsonl, tier_history.jsonl, exemplar_candidates.jsonl or scheme_edits.jsonl, so nothing there needs superseding.

What stands. Round 2's scores. The 16 waivers in return_waivers.jsonl (QB2-009). Edits 287 to 295 and their 133 rechecks (records 755 to 887). The 31 confirmed gate pairs.

The B1 bags. This run splits none of them. J will decide how the coders recut them. Struck at B2b-r3 (J, 12:24 Berlin): no one cuts the bags, neither this run nor the coders; the second-order themes stand as the coders made them, and a bag stays one item through B2 and B3, one theme placed and its other themes under also_present, each with three concepts of its own at least. J's ruling counts 841 B1 bags; my head said 846, and I have not reconciled the two counts.

Round 3 is round 2's set

Round 3 serves round 2's 50 hard items, each bag as one item. The six parents are served whole; for example, sweden t01 is served as one item with its 310 concepts. out/_analysis/b2_packets_fleet.py now leaves out no parent when out/recut/WITHDRAWN.json exists. It built five self-contained packets from the order seeded with 20261013. The next table lists the packets.

Each packet is within J's caps: at most 15 items and 180,000 bytes of item text, with no item split. The items per packet are in out/_analysis/b2_order_r3.json. index.md and G01.md to G21.md are built from the edited scheme.jsonl. Each MANIFEST.json entry carries codes_by_item. RETURN-B2.md is unchanged.

Fleet ids (J, 12:15 Berlin: fleet.py refuses a packet with codes_by_item if any room code or room theme id appears in its text, headings included). out/_analysis/b2_r3_roomid_scan.py scanned the five packets and the 22 shared pages and found 0 room ids. The same pattern finds 50 room ids in b2_order_r3.json. All 50 item headings carry T2- ids, and all 4,094 concept lines carry C ids.

Manifest. run_manifest.json now has 6 entries. The new round-3 entry (out/_analysis/b2_manifest_r3b.py, leg B2a-r3-p2) records 50 items in 5 packets and supersedes the B2a-r3 entry. The readers are round 2's: deepseek/deepseek-v4.1-flash, called directly, medium effort, max_tokens 128,000.

Round 3 is the first round in which only the scheme changes (QB2-007). Its check compares it with round 2 item for item.

The close-check, B2a-r3-p2

validate.py B2 reported:

stage B2:
  leg: check (2 dispatch folders with DONE)
  _fleet_raw/B2/round-1: 3 readers, 120 return lines
  _fleet_raw/B2/round-2: 15 readers, 150 return lines, 16 waived by J (return_waivers.jsonl)
  author items 50, gold items 40, rounds scored 2, edits 295 (author-error 4), scheme ids 197 (scheme/scheme_current.jsonl)

warn   scheme.jsonl: the pair T3-001|T3-017 touches an edited theme and is not confirmed against its current sentences (mem.py gates T3-001 T3-017 --confirm --reason ...)  [443 lines with this shape; first: T3-001|T3-017]

0 errors (0 distinct shapes), 443 warnings

The leg closes with done.sh B2 --cut packets-out. The dispatch sends each of the five packets to three fresh readers.

Leg B2b-r3, check round 3, 2026-10-12

J's ruling of 12:24 Berlin, applied

No one cuts the bags, neither this run nor the coders. The second-order themes stand as the coders made them. A bag stays one item through B2 and B3: one theme placed, and its other themes under also_present, each with three concepts of its own at least. The line under "The B1 bags" that waited for a coder recut is struck, and the head's line with it.

The dispatch, as the handler rescued it

The dispatch log (_fleet_raw/B2/round-3/DONE) reported 7 valid returns and 8 exhausted packets. That was the handler's defect, not the readers': fleet.py's new check counted the third-order ids in multiplacement_log.additional as concept codes. The handler fixed it, re-validated every saved reply with the fixed check, and kept per packet the first three valid replies in reader order (_fleet_raw/B2/round-3/RESCUE-2026-10-12.json). The other valid replies are in each packet's _beyond_three/ and are not scored. EXHAUSTED.tsv is superseded by the rescue record.

fleet.py's counts (_fleet_raw/B2/round-3/log.jsonl, read by out/_analysis/b2_r3_look.py): 36 calls on deepseek/deepseek-v4.1-flash, medium effort; 15 first issues, 12 first reissues and 9 second reissues; 1.4904 USD; 7,431 seconds of calls in all. Of the 29 calls refused at dispatch, 27 were refused by the faulty check; two had faults of their own (P03-r3-2 r1 cited C0286150, a code not under its item; P03-r3-2 r5 lacked the end marker). The next table lists the kept replies.

Translation. Round 3 is in fleet ids. out/_analysis/b2_translate_fleet.py --round 3 read only the kept replies and wrote room-id copies to out/_analysis/b2_r3_returns/: 150 lines, 0 id problems. The readers wrote the room as "r/name"; the translator drops the "r/" before the lookup in out/fleet_ids.jsonl. Every line's heading matches its packet position.

The three numbers

out/_analysis/b2_score_r3.py scored round 3 by the declared definitions (per-item table out/_analysis/b2_r3_items.tsv; pilot_rounds.jsonl line 3). The readers are round 2's, so the change from round 2 is the scheme's edits 287 to 295 and the readers' own variation (QB2-007). The next table lists rounds 2 and 3.

Item by item against round 2, pairwise rose on 17 items, fell on 12 and held on 21. By source, pairwise is 0.731 on the pair items, 0.671 on the random items, 0.556 on the round-1 bags and 0.933 on the ten biggest bags.

Bags. 22 lines set item_is_a_bag; 18 lines name 145 themes under also_present, none under the three-concept floor. The themes readers name (placed plus also_present) score Jaccard 0.283 against mine on the ten biggest bags, as at round 2. One reader named 24 on ainbowroad t03. Four lines flag a bag and name no also_present (QB2-013, below).

What round 3 showed

The round-2 edits.

• Edit 287, the T3-065 gloss (guatemala t02). At round 2 all three readers placed T3-002, T3-167 and T3-026, missing whose flag it is. At round 3 two readers place T3-065 and T3-167, my placement, and cite the gloss ("a flag built in r/guatemala being Guatemala's"). The third places T3-038 and T3-002. Pairwise fell from 1.00 to 0.33 while fidelity rose: the edit doing its work on two of three readers.
• The T3-195/T3-005 and T3-195/T3-011 questions (nVade t04). Round 2: two readers on T3-195, one on T3-005. Round 3: two on T3-005, one on T3-195. I placed T3-011 and T3-005.
• The T3-033/T3-038 question (n64 t02, dofus t01). No reader now places n64 t02 on T3-033; they divide T3-002 (two) and T3-038 (one). dofus t01's pairwise rose.

The cluster that still divides. T3-002 (a call for hands), T3-033 (proposing the room's mark) and T3-038 (building and reporting a mark). signal t01 gets three readers on three themes; n64 t02 divides T3-002 and T3-038; on 2007scape t04 one reader leads with T3-070 (directions for placers) where the other two place T3-038. All three items were steady at round 2 except n64 t02. The readers' reasons turn on which act leads: the call, the offer of an idea, or the build and its reports. The scheme's questions in this cluster do not decide that when one item holds all three.

Single-reader departures on items unanimous at round 2. ice_poseidon t16 (one reader on T3-192, joking about damage, against T3-031), WisconsinBadgers t04 (one reader on T3-042 alone, the other two adding T3-042 or T3-006 to T3-076), donaldglover t04 (one reader adds T3-032), kpop t04 (the readers' additions vary between T3-136 and T3-066). None touches an edited theme.

Divisions that persist from round 2. AyyMD t08 (two of three on T3-023, as at round 2; my author-error), flashtv t13 (T3-073 against T3-009), acecombat t05 (two on T3-014), simonfraser t08 and Goodboye t03 (bags), floridagators t09, furry t10, parabola t02, harrypotter t08, nyu t01, cubers t12, Slovakia t07, anarcho_capitalism t12, farmcarrots t15.

Base rates of the edited themes, per reader against my count over the 50: T3-065 2.7 against 3; T3-195 0.3 against 0 (round 2 more); T3-033 2.3 against 2; T3-038 1.7 against 3; T3-002 1.3 against 0; T3-026 0 against 0. No edited theme's rate fell to rare.

Section 4. The packets hold 7 to 13 items, too few for a first-ten against last-ten curve. Within packets, agreement with the other two falls from first half to last in 9 of 15 readers and rises in 6 (all six in the two shortest packets). The B3 cap stays at 40 with a 10-item warm-up. 23 dividing items are appended to exemplar_candidates.jsonl (68 lines).

The decision

Round 3's pairwise agreement on the hard set, 0.728, clears the declared threshold of 0.70. By section 5 the rounds stop, and no round 4 opens. This leg writes no scheme edit. The freeze needs, first, the 443 unconfirmed gate pairs read and confirmed and every cluster read for a decide_when_both that names a theme with no discriminator; the T3-002/T3-033/T3-038 cluster is the first to read. That work and the freeze are the next leg's; I asked J whether a fix to the cluster waits for the gold round or gets a round 4 (QB2-012, assumed: rounds stop).

The figure licenses this claim, in FLEET.md's terms: readers holding only the scheme reproduce what I would have produced at a scale one analyst cannot reach, on hard items, at 0.682 fidelity. It does not license the claim that any competent reader would have produced it.

QB2-013: four bag flags with no also_present

validate.py B2 reports 4 errors. Four kept lines set item_is_a_bag true and leave also_present empty: P03-r3-2/r3.jsonl lines 6, 10 and 11 (acecombat t05, n64 t02, Goodboye t03) and P03-r3-2/r6.jsonl line 6 (acecombat t05). Each places one theme validly. Reader r6 says why: the item is a bag, but no other theme has three concepts of its own. The flag and the three-concept floor collide. fleet.py accepted the lines. I asked J to waive them by name, as at QB2-009, and whether the return spec should say that a bag with no other theme at the floor is not flagged. Meanwhile round 3 is scored with the four lines as given; the flag enters no figure.

The close-check, B2b-r3

validate.py B2 reported:

stage B2:
  leg: check (3 dispatch folders with DONE)
  _fleet_raw/B2/round-1: 3 readers, 120 return lines
  _fleet_raw/B2/round-2: 15 readers, 150 return lines, 16 waived by J (return_waivers.jsonl)
  _fleet_raw/B2/round-3: 15 readers, 150 return lines
  author items 50, gold items 40, rounds scored 3, edits 295 (author-error 4), scheme ids 197 (scheme/scheme_current.jsonl)

ERROR  _fleet_raw/B2/round-3: a return on acecombat/t05 is a bag and names no also_present; rule 0 keeps every theme beyond the one placed, each with its own concepts  [4 lines with this shape; first: r3.jsonl line 6]
warn   scheme.jsonl: the pair T3-001|T3-017 touches an edited theme and is not confirmed against its current sentences (mem.py gates T3-001 T3-017 --confirm --reason ...)  [443 lines with this shape; first: T3-001|T3-017]

4 errors (1 distinct shapes), 443 warnings

The 4 errors are the four bag flags of QB2-013. J had not answered when the leg closed. I write no waiver without J's word, so the close-check refuses this close. The leg reopens on J's answer: with a waiver, I write the four lines into return_waivers.jsonl and close again.

J's answers (13:47 Berlin), and the close

QB2-012. No round 4. A freeze leg of its own does three things: the 443 gate-pair confirmations, the cluster reads for T3-002, T3-033 and T3-038, and any sentence fix to that cluster. A fix made there is tested only by the gold round in B2c. My assumption was that rounds stop and this leg writes no edit. It held, so nothing here changes.

QB2-013. J ruled yes to both parts.

• The four lines are waived by name in return_waivers.jsonl, with the reason "item_is_a_bag true with no theme at the three-concept floor (also_present {}); the placement scored as given" and ruled_by J (out/_analysis/b2_waivers_r3.py). The file now holds 20 waivers: 16 from round 2 and 4 from round 3.
• RETURN-B2.md now says that a bag with no other theme at the three-concept floor is not flagged a bag: item_is_a_bag false, also_present {}. The round-3 text is kept as out/_analysis/RETURN-B2_round3.md.

The also_present bound (J, 13:47). In round 3 some bag returns listed up to 85 themes. RETURN-B2.md now says also_present names "twenty themes at most", each with at least three concepts of its own. It says twenty is a bound, not a goal. The validator and fleet.py apply the bound only where that exact phrase stands. They refuse a return with more than twenty themes, or with a theme that has fewer than three concepts. Returns already kept in rounds 1 to 3 are scored as given. B3's return specification does not exist yet. The head carries both rules into it, with the phrase word for word.

validate.py B2 reported, after the waivers:

stage B2:
  leg: check (3 dispatch folders with DONE)
  _fleet_raw/B2/round-1: 3 readers, 120 return lines
  _fleet_raw/B2/round-2: 15 readers, 150 return lines, 16 waived by J (return_waivers.jsonl)
  _fleet_raw/B2/round-3: 15 readers, 150 return lines, 4 waived by J (return_waivers.jsonl)
  author items 50, gold items 40, rounds scored 3, edits 295 (author-error 4), scheme ids 197 (scheme/scheme_current.jsonl)

warn   scheme.jsonl: the pair T3-001|T3-017 touches an edited theme and is not confirmed against its current sentences (mem.py gates T3-001 T3-017 --confirm --reason ...)  [443 lines with this shape; first: T3-001|T3-017]

0 errors (0 distinct shapes), 443 warnings

The 443 warnings are the gate pairs the freeze leg confirms. The leg closes with done.sh B2.

Leg B2b-r3-p2, J's answers checked, 2026-10-12

J's answers to QB2-012 and QB2-013 (13:47 Berlin) came during leg B2b-r3 and were applied there, before its close (section "J's answers (13:47 Berlin), and the close", above). This leg read both answers again with mem.py asks and checked the files.

• QB2-012. The assumption was that rounds stop at round 3 and the check leg writes no scheme edit. J's answer matches it: no round 4; a freeze leg of its own confirms the 443 gate pairs, reads the T3-002/T3-033/T3-038 cluster and makes any sentence fix there, and only the gold round in B2c tests that fix. Nothing that rested on the assumption changes. This leg starts none of the freeze work.
• QB2-013. The assumption was that round 3 is scored with the four lines as given and that no waiver is written without J's word. Round 3's figures stand unchanged, since the bag flag entered no figure. return_waivers.jsonl holds 20 lines, 4 of them ruled by J at QB2-013. RETURN-B2.md carries the rule that a bag with no other theme at the three-concept floor is not flagged, and the phrase "twenty themes at most".

validate.py B2 reported 0 errors and 443 warnings, the same report as at B2b-r3's close. The 443 warnings are the gate pairs the freeze leg confirms. The leg closes with done.sh B2.

Leg B2b-r3-p3, the freeze, 2026-10-12

J ruled at QB2-012 (13:47 Berlin) that no round 4 runs. The handler made this leg the freeze leg itself (12:25Z). It has four tasks: read the T3-002/T3-033/T3-038 cluster, make any sentence fix the reading calls for, confirm the gate pairs on edited themes, and freeze. A fix made here is tested only by the gold round in B2c.

The cluster read

Round 3's readers split on three items. On signal t01 the three readers chose T3-033, T3-038 and T3-002. On n64 t02 they chose T3-002 with T3-070, T3-002 alone, and T3-038. On 2007scape t04 one reader chose T3-070 and two chose T3-038. I read each item whole:

• signal t01 holds one opening question (c0001, "Anyone else interested in getting /r/signal onto /r/place?") and two concepts that place and report the work (c0002 drawing at a location, c0003 "We did it!").
• n64 t02 holds one opening call to unite (c0010) and three concepts that build and report the logo (c0011 the image imitated, c0012 started at stated coordinates, c0014 the finished logo).

The readers who left T3-038 took the opening post as "the lead". The three pairs of the cluster used three different measures. T3-002 against T3-033 used "the lead". T3-038's decide_when_both used "the larger part". T3-033 against T3-038 used "the side with more concepts". None covered an item holding all three acts.

The fix (out/_analysis/b2_edits_freeze.py, scheme_edits 296 to 302, scheme-ambiguous, caused_by signal t01, n64 t02, 2007scape t04):

• One measure. The decide_when_both of T3-002, T3-033 and T3-038 now carry one rule. Count the concepts of each act. The act with the most concepts of its own is primary. The opening post does not lead because it comes first. On a tie, T3-038 wins when the work was placed. Otherwise T3-002 wins when the mark was already chosen, and T3-033 when it was not.
• The three pair questions are now set word for word the same in both gates, with this count.
• A new T3-038/T3-070 question. T3-038 and T3-070 had no question between them. On 2007scape t04 one reader placed T3-070 where two placed T3-038. On n64 t02 one reader added T3-070 for the link to the finished logo.

No theme was narrowed. Each theme keeps its members, and the edits only order the cluster.

Rechecks (b2_rechecks_freeze.py): 129 records over 44 items, and none moves. I read whole every item that holds two of the cluster's acts, or coordinates beside a report. The next table lists their counts.

On furry t10, c0034 ("working on it at (965, 759)") is now a report of where the work stands, and it leaves T3-070's support.

The gate pairs read

out/_analysis/b2_pairs_dump.py wrote each unconfirmed pair on an edited theme side by side to out/_analysis/b2_pairs_read_first.txt. There were 449 pairs:

• 253 carry one question, the same in both gates;
• 169 carry two wordings of a question;
• 27 carry no question, and one gate's decide_when_both or is_not settles them.

I read all 449, to the end marker. Two faults were found.

• T3-009 against T3-072 and T3-157. T3-009's decide_when_both makes the thanks to allies (T3-072) or the reflection on working together (T3-157) primary when it holds more concepts than the celebrating, as T3-043's does. T3-072 and T3-157 each said "T3-009 primary" with no condition, so the gates of each pair contradicted each other.
• T3-038 against T3-070. My new question sent "where to see it" and a link to the finished work to T3-038. T3-026's must_show already takes "others pointed to where it is". I found this reading the T3-026/T3-038 pair.

The fixes (out/_analysis/b2_edits_freeze2.py, scheme_edits 303 to 306):

• T3-072 and T3-157 now say what T3-009 says: the side with more concepts is primary.
• The T3-038/T3-070 question now keeps T3-038 for work in progress, and points a link that only shows the finished work at T3-026.
• Rechecks: 52 records (b2_rechecks_freeze2.py), and none moves. The five items on T3-009 were read whole: mcgillrobotics t02, montenegro t04, mordhau t05, redhotchilipeppers t09 and ukraine t07. Each holds more celebrating concepts than thanks to allies or reflection. On redhotchilipeppers t09 the count is six celebrating concepts against one thanking allies. On n64 t02, c0014 and c0015 now point to the finished logo, so T3-038's support is c0011 and c0012.
• rechecks-B2.jsonl holds 1,594 records, none missing.

Confirmed. The fixes changed six themes from the round-3 scheme (kept as out/_analysis/scheme_round3.jsonl and .md): T3-002, T3-033, T3-038, T3-070, T3-072 and T3-157. After them, 450 pairs touched an edited theme.

• I read again the 11 pairs the second fixes touched, and read the one new pair (T3-157/T3-164) for the first time (b2_pairs_new.py).
• I confirmed all 450 (b2_confirm_freeze.py). Each reason quotes the question or clause that decides the pair, and the cluster's pairs and the fixed pairs have reasons of their own.
• I read the 20 pairs on unedited themes (b2_pairs_read_rest.txt), and confirmed them too.

mem.py gates reports 496 pairs, all 496 confirmed and 0 stale. It finds no one-way question, no must_not_show with no question against its target, and no undefined id.

The freeze

out/_analysis/b2_freeze.py wrote two files. families.jsonl (21 families) stands beside them.

• scheme_final.jsonl: 197 themes, with every field as in scheme.jsonl.
• scheme_final.md: scheme.md with a frozen header.

The sentences are those after the 306 lines of scheme_edits.jsonl. The sha256 of scheme_final.jsonl is fb8b543a98982d36df299d0494773f1bf9ee481b3966331bffc4d299127be595.

The tier word (QB2-014, open). The rare tier is marked "tier": "rare" (14 themes). The main tier is marked "tier": "common" (183 themes). The B2 close-check accepts only none, rare, common or core, so "main" would fail it 183 times. The C1 check expects main or rare, and it finds moves to rare by looking for "main" in the frozen file. I asked J which word stands, and whether the handler will make the two checks agree. If J rules "main", I supersede scheme_final.jsonl under a new name once the B2 check accepts that word.

Base rates. No theme was narrowed at the freeze, so no theme's base rate falls from these edits. The edits change only which act of the cluster is primary when an item holds several. The gold round shows whether T3-002's and T3-033's rates fall against T3-038's.

The sentence I am least sure a stranger reads as I meant. It is the cluster's new rule, "count the concepts of each: the act with the most concepts of its own is primary". A reader must sort each concept into one act before counting. On 2007scape t04 that sorting is itself a judgement over 349 concepts.

The close-check, B2b-r3-p3

validate.py B2 reported:

stage B2:
  leg: check (3 dispatch folders with DONE)
  _fleet_raw/B2/round-1: 3 readers, 120 return lines
  _fleet_raw/B2/round-2: 15 readers, 150 return lines, 16 waived by J (return_waivers.jsonl)
  _fleet_raw/B2/round-3: 15 readers, 150 return lines, 4 waived by J (return_waivers.jsonl)
  author items 50, gold items 40, rounds scored 3, edits 306 (author-error 4), scheme ids 197 (scheme_final.jsonl), frozen


0 errors (0 distinct shapes), 0 warnings

The leg closes with done.sh B2. B2c builds the gold round and the two stability rounds on the frozen scheme.

Leg B2c, the gold round and the stability rounds built, 2026-10-12

QB2-014 applied: the tier word is "main"

J ruled at 15:06 Berlin that the frozen scheme's main tier is "main", the word of B1's scheme.jsonl and of C1's check. The handler changed checks/stage_B2.py to accept only "main" or "rare" on scheme_final.jsonl. After that change the freeze's file failed the check 183 times.

out/_analysis/b2_freeze_main.py superseded the file:

• the "common" files moved unchanged to out/_analysis/scheme_final_common.jsonl and scheme_final_common.md;
• scheme_final.jsonl was written again with "main" for the 183 themes and "rare" for 14, nothing else changed (checked field by field);
• scheme_final.md names the tier word and the new sha256, 4b471d29dd415fc0507b535f4d7595b40a5b9794ac36448d152a69ba7343e18d.

My assumption was that "common" would stand. J ruled "main", so the file and its header changed, and nothing else rested on the word. The gate check still reads 496 pairs, all confirmed, because the tier is not a gate field.

The three rounds

Stage B2 section 5 asks for three rounds on the frozen scheme. The gold round serves the gold set to fresh readers. The two stability rounds serve the gold set to the same reader arm under two rewordings of the brief that change no test.

out/_analysis/b2_packets_fleet2.py built all three. It is round 3's fleet-id builder with three changes: it reads gold_items.jsonl, it takes the shared pages from scheme_final.jsonl, and it takes the brief from a file. The packets keep J's rules: fleet ids only, at most 15 items and 180,000 bytes of item text a packet, no item split, and codes_by_item in each MANIFEST entry.

One seed, one cut. All three rounds use seed 20261014. The same 40 items fall in the same 3 packets in the same order, so the brief is the only difference between the rounds. The next table lists the packets of each round.

The briefs. The brief is the packet's opening paragraph.

• Gold round: the builder's own brief ("Place each second-order theme below onto the scheme, one line per item in the form the return specification gives...").
• Stability round 1: out/brief-stab-1.md ("For every item below, decide where it sits in the scheme and write one line for it...").
• Stability round 2: out/brief-stab-2.md ("Below are second-order themes to be placed on the scheme. Give each one its own line...").

Each brief tells the reader the same four things in other words: one line per item in the return specification's form, items numbered by position, ids copied exactly, and the packet complete in itself. The item count follows as its own sentence, the same in every round. No brief names a theme, a test or a placement.

Checks. Each round's folder (out/_packets-B2/round-gold/, round-stab-1/, round-stab-2/) holds index.md, G01.md to G21.md, the three packets and MANIFEST.json. out/_analysis/b2_roomid_scan.py found 0 room ids in all 75 files. The gold placements appear nowhere in the packets. The orders are in out/_analysis/b2_order_rgold.json, b2_order_rstab-1.json and b2_order_rstab-2.json.

Return specification. RETURN-B2.md is unchanged since B2b-r3. It carries fleet ids, the three-concept floor for also_present, the rule that a bag with no other theme at the floor is not flagged, and "twenty themes at most".

Manifest. run_manifest.json has three B2c entries (out/_analysis/b2_manifest_b2c.py), 9 entries in all. Each entry records the readers of rounds 2 and 3 (deepseek/deepseek-v4.1-flash, called directly, medium effort, max_tokens 128,000), the seed, the 40 items, every packet's bytes and hash, the frozen scheme's sha256 and the brief.

J runs the three dispatches. The check leg, B2d, scores the gold round against round 3. It writes the stability figure to stability-B2.md and writes pilot_report.md.

The close-check, B2c

validate.py B2 reported:

stage B2:
  leg: check (3 dispatch folders with DONE)
  _fleet_raw/B2/round-1: 3 readers, 120 return lines
  _fleet_raw/B2/round-2: 15 readers, 150 return lines, 16 waived by J (return_waivers.jsonl)
  _fleet_raw/B2/round-3: 15 readers, 150 return lines, 4 waived by J (return_waivers.jsonl)
  author items 50, gold items 40, rounds scored 3, edits 306 (author-error 4), scheme ids 197 (scheme_final.jsonl), frozen


0 errors (0 distinct shapes), 0 warnings

The leg closes with done.sh B2 --cut packets-out.

Leg B2d, the gold round and the stability check scored, 2026-10-12

The dispatches

J ran the three dispatches on the frozen scheme. fleet.py's counts come from each round's DONE record. The next table lists them.

validate.py B2 checked the 360 return lines with no error. out/_analysis/b2_translate_fleet.py translated each round to room ids, 120 lines a round with 0 id problems (copies in out/_analysis/b2_r<round>_returns/).

The scores

out/_analysis/b2_score_final.py scored the three rounds. Its outputs are b2_final_score.json and the per-item table b2_gold_items.tsv. The rounds' lines are lines 4 to 6 of pilot_rounds.jsonl, and the gold line is flagged gold (b2_round_lines_final.py). Gold items are not exported to exemplar_candidates.jsonl, because B3 seeds the gold set unannounced. The next table lists the figures.

Stability: 0.807. This is the mean Jaccard of stab-1 readers against stab-2 readers, nine pairs per item. Primary placements matched in 0.853 of those pairs. Alpha over the six stability readers is 0.784. The figure sits level with the pairwise agreement inside each stability round, so the rewording of the brief adds no disagreement (stability-B2.md).

The gold gap. Gold fidelity (0.624) is lower than round 3's (0.682), while gold pairwise (0.818) is higher. On ten gold items the readers keep only my primary of two placements. The gold set was placed at B2a-r1, before round 1 showed this author-error. Primary match is 0.800, as at round 3.

The blind re-placement

The ten hard items were drawn by seed b2d:blind: guatemala t02, harrypotter t08, ice_poseidon t16, ainbowroad t04, parabola t02, ainbowroad t03, megaman t11, anarcho_capitalism t12, dota2 t05 and theblackvoid t09.

• The window. I read each item whole through mem.py codes inside a blind window (14:01:06 to 14:02:36 in the read log). I placed them in out/_analysis/b2_blind_replace.jsonl before closing the window.
• Self-agreement (b2_blind_score.py): against author_items.jsonl 0.883, against the rechecked placements 0.900, primary 0.90. On the same ten items, the round-3 readers' fidelity was 0.806.
• Caveat. Earlier legs showed me several of these placements in round tables, so 0.883 is an upper bound.

The predicted confusions

Of the nineteen pairs in confusions.md, four split readers in any round and three more than once:

• T3-004/T3-070: 6 splits in 55 reader pairs;
• T3-009/T3-073: 5 in 65;
• T3-001/T3-023: 3 in 58.

The hardest pair, T3-005/T3-021, never split. I had estimated 15 to 20%, and the observed rate is 0 in 64 reader pairs.

The reports

• pilot_report.md covers the rounds, the gold number and its gap, stability, my consistency, every edit by theme (a generated table), the author-error verdicts, the themes that did not stabilise, the scorecard, the cost and the least-sure sentence.
• Author-error verdicts: 32 items (21 hard, 11 gold).
• Wording defects carried to C1: four gold items where readers missed what I placed (uofmn t01, cuboulder t04, mariokart t04, ireland t12).
• stability-B2.md and handback-B2.md are written.

The close-check, B2d

validate.py B2 reported:

stage B2:
  leg: check (6 dispatch folders with DONE)
  _fleet_raw/B2/round-1: 3 readers, 120 return lines
  _fleet_raw/B2/round-2: 15 readers, 150 return lines, 16 waived by J (return_waivers.jsonl)
  _fleet_raw/B2/round-3: 15 readers, 150 return lines, 4 waived by J (return_waivers.jsonl)
  _fleet_raw/B2/round-gold: 9 readers, 120 return lines
  _fleet_raw/B2/round-stab-1: 9 readers, 120 return lines
  _fleet_raw/B2/round-stab-2: 9 readers, 120 return lines
  author items 50, gold items 40, rounds scored 6, edits 306 (author-error 4), scheme ids 197 (scheme_final.jsonl), frozen


0 errors (0 distinct shapes), 0 warnings

The leg closes with done.sh B2.