# Head, claude-v43-1

Under 3,000 words, rewritten whole at every close. Last written at B3a-p2, 2026-10-12 (UTC): the gold check after dispatch group 1 passed; group 2 goes out as built. J runs it; B3b checks the whole fleet after its DONE.

## The method question, in one sentence

Can independently reconstructed case histories be composed into a shared dynamic account that supports explanations at successive levels of specificity, from population-wide patterns, through forms and subforms, to particular organizational histories, while keeping access to the evidence from which those explanations were developed?

The theory question is unchanged: when strangers organize on a clock they did not set, with no way to compel anyone and no goal given to them, what forms does organizing take, how do they differ in their functioning, and which of them keep the work alive?

## Where the run stands

Stage A1 is closed. Stage B1 (the third-order scheme, 197 themes in 21 families) is done. Stage B2, the pilot, is done: three rounds, the freeze, the gold round and the stability check (`pilot_report.md`, `stability-B2.md`, `handback-B2.md`). Stage B3, the fleet, is open. B3a built it. Group 1 went out and passed the gold check (B3a-p2). Group 2 and then B3b come next.

## Stage B3, as built (B3a)

**J's ruling (QB3-001, QB3-002, 16:37 Berlin).** B3 uses B2's packet shape: every packet self-contained, at most 15 items and 180,000 bytes of item text, no parts, its own item count; a room may spread over several packets, each with the sibling blocks of the rooms it holds; gold copies listed in `items` and `gold_items`, exempt from room membership and coverage; records ride on the item line; pass-2 lines carry `revises` after the pass-1 lines; warm-up in reserve, no exemplars. The handler fixed the check (7,844 items, the withdrawn split ignored) and `fleet.py` (room-id guard on id positions only; 0-line packets accepted). The first build (whole rooms in parts) is kept under `out/_analysis/*_parts_superseded*`.

**Declarations** (`notes-B3.md`): R = 2; seed 20261015 (under `:redraw2`); 15 positions and 180,000 bytes of item text a packet; rooms poured in seeded order and spread where a batch fills; gold one copy per 20 items, at most two a batch, positions spread least-used first; one duplicate a batch; no exemplars; warm-up in reserve (B2's agreement fell, not rose, within packets); dispatch in two groups, 100 then 1,110, the gold check between; the ten biggest bags flagged; cost about 40 to 55 USD.

**Built.** `out/_analysis/b3_allocate2.py` wrote `batches-B3.jsonl`: 1,210 batches, one reader each (605 a replicate); one component; each replicate places the 7,844 items once; 17,653 positions (15,688 readings, 1,210 duplicates, 755 gold copies, 18 or 19 per gold item). `out/_analysis/b3_packets_fleet2.py` wrote `_packets-B3/`: 22 shared pages, 1,210 packets (at most 178,758 item bytes), fleet ids only, `codes_by_item` in the MANIFEST. One coder note held a room id (nyjets t11, c0104): served as its fleet id. `RETURN-B3.md` carries J's two rulings word for word. `validate.py B3`: 0 errors, 0 warnings.

**Group 1 and the gold check (B3a-p2).** J sent the first 100 batches at 15:17Z. They returned 100 valid replies (4 reissued, 0 exhausted; `_fleet_raw/B3/PARTIAL-2026-10-12T153202Z.json`). No DONE exists yet, and I write none. The stop rule was declared in `notes-B3.md` before scoring: a fall over 0.193 (1 − 0.807) in gold fidelity or primary match, against the mean of B2's nine frozen-scheme readings of the same items, stops group 2. Of the 72 gold copies seeded, 72 came back. Fidelity was 0.637 against 0.625 (fall −0.011, interval −0.065 to +0.045), and primary match 0.833 against 0.812. So group 2 goes out as built. Five items had their own fall beyond the floor on 1 to 4 copies each, among them ukraine t07 (T3-073 placed for T3-009). Per copy: `out/_analysis/b3_gold_group1.tsv`. `fidelity-B3.md` waits for the check leg.

## Stage B2, in short

**The rounds.** The next table lists the figures (mean Jaccard; fidelity is agreement with my placements, pairwise the readers' with each other).

| round | set | fidelity | against rechecked | pairwise | alpha |
|---|---|---|---|---|---|
| 1 | 40 hard | 0.594 | - | 0.733 | 0.726 |
| 2 | 50 hard | 0.639 | 0.701 | 0.718 | 0.710 |
| 3 | 50 hard | 0.682 | 0.760 | 0.728 | 0.721 |
| gold | 40 gold, frozen scheme | 0.624 | 0.661 | 0.818 | 0.809 |

**Readers.** Round 1 ran deepseek-v4-flash-0731 through `@preset/cheap` at high effort. From round 2 on: deepseek/deepseek-v4.1-flash, called directly, medium effort, max_tokens 128,000. The same readers serve B3 and B4 (J, 2026-10-12).

**Stability 0.807.** The gold set under two reworded briefs: stab-1 readers against stab-2 readers, nine pairs per item. It sits level with each round's own pairwise (0.800, 0.756), so the brief's wording adds no disagreement. It is the floor every later figure is read against.

**What the pilot showed.**
- Readers place one theme almost always; my second placements are author-errors under rule 0. 32 items in all (21 hard, 11 gold); on ten gold items the readers keep only my primary.
- Primary match on gold is 0.800, as at round 3: the frozen scheme carries to unseen items.
- Only T3-004/T3-070, T3-009/T3-073 and T3-001/T3-023 split readers more than once among the 19 predicted pairs of `confusions.md`; T3-005/T3-021, predicted hardest, never did.
- Four gold wording defects go to C1: uofmn t01 (T3-001/T3-048), cuboulder t04 (T3-004/T3-033), mariokart t04 (T3-084 against T3-002/T3-005), ireland t12 (T3-160/T3-002).
- My blind re-placement of ten hard items: 0.883 against my placements, 0.806 for round 3's readers (an upper bound: I had seen several of the ten).

**The frozen scheme.** `scheme_final.jsonl` (197 themes; tier "main" 183, "rare" 14, J at QB2-014; sha256 4b471d29...), `scheme_final.md`, `families.jsonl` (21). All 496 gate pairs confirmed in `gate_checks.jsonl`. The freeze gave T3-002, T3-033 and T3-038 one rule: count the concepts of each act, the most is primary, the opening post does not lead because it comes first. That rule is the sentence I am least sure a stranger reads as I meant.

**Edits.** `scheme_edits.jsonl` 306 lines: 202 word-for-word mirrors, 100 scheme-ambiguous, 4 author-error; no theme narrowed, no edited theme's base rate fell on gold.

## J's rulings that bind B3 (carry them)

- **Bags.** No one cuts the bags, neither this run nor the coders (J, 12:24 Berlin). The second-order themes stand as the coders made them. A bag stays one item through B2 and B3: one theme placed, its other themes under `also_present`, each with three concepts of its own at least. `mem.py split` refuses; `out/recut/WITHDRAWN.json` keeps the withdrawn split out of every view.
- **The bound (J, 13:47).** `also_present` names "twenty themes at most", each with three concepts of its own; a bound, not a goal. The validator and `fleet.py` apply it only where that exact phrase stands.
- **The not-flagged bag (J, QB2-013).** A bag with no other theme at the three-concept floor is not flagged a bag: `item_is_a_bag` false, `also_present` `{}`.
- **Fleet ids (J, 09:14 and 12:15).** Packets carry only fleet ids for concepts and second-order themes (`out/fleet_ids.jsonl`: `C` and seven digits, `T2-` and five digits), never a room id, headings included; `fleet.py` refuses a packet with `codes_by_item` that carries one. Returns are translated back before scoring; my files keep room ids.
- **Codes by item (J, QB2-009).** Each MANIFEST entry carries `codes_by_item` {fleet theme id: [fleet code ids]}; `fleet.py` rejects and reissues a line citing a concept its item does not hold.

## Standing words from J and the PI (carry into every head)

**J's words for B1 (7 October 2026):** "national elements are very important here"; "we need to get as much variance on organizing behavior early on so that later we have enough to create the model". National, political and conflict content is study material, named as plainly as any other. **The handler's rule:** a choice to leave out or soften content for any reason other than the study's goes to J first with `mem.py ask`, and the content stays meanwhile.

**J on reading (11 October, 16:54 Berlin).** Stop cutting room reads to a line length. Read room lines whole. Page a long read by line ranges or offset, never by truncating lines. Use `--width N` on a `mem.py` read if a clip is ever needed; the guard refuses `cut -c` after `mem.py`.

**J on asking (11 October, 17:01 Berlin).** Ask J with `mem.py ask` whenever a question is needed; asking does not stop the run.

**The PI's clarifications (8 October, approved by J):** the thresholds are the design's heuristic; the rule is unchanged.

**How to work, from J (8 October, 23:45 Berlin, "can you do a hot change for the batching?"; relayed by the handler at 22:03Z; carry this paragraph into every head).** A change in how I work, not in what I read or decide. Fewer turns. When two or more tool calls do not depend on each other's output, make them in one turn. Chain ordered commands in one Bash call with &&, so that a failure stops the rest; for example, the `mem.py log` or note just decided, then the next `mem.py codes`. Never put a write in the same turn as the read it depends on. Never run two writes to the same file as separate parallel calls. Keep one room's material per read, as now. Every tool still writes its own record; nothing about what I read or decide changes.

**Two rules from J at B1b-29 (through the handler, 20:10Z; carry them into every head).** Write rule 0 lines and bags with `b1_multiplace_write4.py` and `b1_bags_from_file2.py`, not the old scripts, which made one `mem.py` call per row of the whole table and grew to 8.5 minutes a write. Never end a turn while a job runs in the background; run every write and check in the foreground.

## The pilot's declarations (from `notes-B2.md`)

- **Agreement:** Jaccard on placement sets (`["T3-004"]` against `["T3-004","T3-011"]` scores 0.5). Fidelity is mean Jaccard against my set. Alpha uses distance 1 − Jaccard, chance over the round's pooled sets. Primary exact agreement is reported beside, never in place.
- **Gold:** 40 items in `gold_items.jsonl`, never shown to a reader, seeded in B3 at 1 per 20 items, at most two per batch.
- **B3 batch cap:** 40 items, the first 10 a warm-up block not counted (stated at B2a-r1, kept at rounds 2 and 3).

## The scheme

`scheme_final.jsonl` holds 197 themes (183 main, 14 rare) in 21 families. Rare: T3-007, T3-025, T3-067, T3-077, T3-093, T3-106, T3-128, T3-133, T3-144, T3-161, T3-166, T3-186, T3-191 and T3-197. F-001, as superseded: half the 7,786 placed second-order themes sit on one kind; themes about dealing with other rooms need the most kinds.

## Open, carried

- **From B1.** The ruling on testing G13, G14 and G15 as one index page (B2's scorecard found readers did not confuse T3-010 with T3-149 or T3-150). The B1d leftovers: 106 (line, kind) pairs over 81 episode lines whose kinds none of their rooms holds; seven pairs of lines telling one event; E989; the cfb and finland records; shared-member counts that may include EA1r+K5p/lVBLesLhCFRrKOPN+I=; the 76 themes holding both T3-005 and T3-021 acts; T3-149 and T3-150 members that may hold T3-195; kinds left out of bags. The second-order theme the scheme handles worst: argentina t06.
- **Distinctions** (none filed in `_questions/`): who started the work; wars told twice; rivals who turn partners (E1076, E1122, E1142, E1318); whose flag a shared flag is (E1118); records that disagree on who attacked, on promises, truces, bots and design changes; who drove a bot and why it left a work (E1025); a room's own scripts barring it from sparing a neighbour (E843), or wrecking a protectorate it then rebuilt (E1209); one member on both sides of a quarrel (E820, E947); objections to altering the final image (T3-054 or T3-105).
- **The bag count.** J counts 841 B1 bags; this head said 846. Not reconciled.

## Ledgers at this close

- B1: `scheme_current.jsonl` (197 themes, 7,786 placed second-order themes, 13,432 placements); `families.jsonl` (21); `confusions.md` (19 pairs); `findings.jsonl` (2 lines); `multiplacement_log.jsonl` (6,663); `episodes-B1.jsonl` (1,341).
- B2: `notes-B2.md` (1,192 lines); `pilot_report.md`, `stability-B2.md`, `handback-B2.md`; `author_items.jsonl` (50); `gold_items.jsonl` (40); `RETURN-B2.md`; `pilot_rounds.jsonl` (6); `scheme_final.jsonl` (197), `scheme_final.md`; `scheme_edits.jsonl` (306); `rechecks-B2.jsonl` (1,594, of which 526 the withdrawn split's); `gate_checks.jsonl` (519 lines, 496 pairs confirmed); `exemplar_candidates.jsonl` (68, hard items only); `tier_history.jsonl` (392); `run_manifest.json` (9); `return_waivers.jsonl` (20).
- Asks QB2-001 to QB2-014 and QB3-001 to QB3-002 are answered; none is open.
- B3: `notes-B3.md`; `RETURN-B3.md`; `batches-B3.jsonl` (1,210); `_packets-B3/` (22 shared pages, 1,210 packets, MANIFEST); `run_manifest.json` (11).

## Rules kept

- Never type an id, an order or a name from memory; check with `jq` or a script. Never log a write before the tool answers. Count a ledger's lines after appending.
- There is no `--kind close` and no `--kind episode`; log those as notes.
- A question to J is `mem.py ask "<question>" --assume "<meanwhile>"`; `mem.py log --kind ask` writes only a diary line and gives no id.
- A reader's thread must fit the provider's window (about 164,000 tokens, inferred at round 2); the shared pages alone are about 95,000.
- Check a notes section against the diary before closing. Never put a placeholder or a no-op in a command. Never put an Edit and the read that checks it in one turn. Count the head's words before the closing line, not after.
- Never write an id-like token the run does not define in the head, such as a D or a P followed by digits: `done.sh` reads it as an unresolved link. Name later stages and packet files in words.
- The permission check refuses: "=w="; shell for and while loops, and words beginning "for_"; shell functions, brace groups and heredocs; awk with system() or `$` fields; a variable set from `$(...)`, and some `python3 -c` scripts; jq with a `test()` regex, and env-var prefixes; cat or jq on `out/diary/`; `cut -c`, `cut -b` and `colrm` after `mem.py`, `cite.py` or a helper (use `--width`). Split those, or write a script file in `out/_analysis/`.
- `mem.py` pages long output (`[lines 1-80 of N]`); fetch the rest with `--offset` before trusting a count. A Bash output over about 30 KB is saved where I cannot read it; page it.
- After a compaction the guard requires the head and stage file read again and the exact line "compacted; head reconciled" through `mem.py log --kind note`, in a call of its own, before any other write. After an interrupted turn or a lost connection, check the record before rerunning anything.

## The next comparison

In B3, against stage B2's figures: gold fidelity against `gold_items.jsonl` and the rechecked gold placements (0.624, 0.661), primary match (0.800), and agreement read above the stability floor (0.807).