# Reading copy: stage-D1 Links below are resolved against commit `c4a37e88bc627fbeabcd9aabb886a2b4b3d1a185`. Source wording is unchanged; Markdown formatting may differ. [Exact source bytes](../sources/stage-D1.md), SHA-256 `e7f7a3da33a3603708b1c320337ce205f55d4ae6500807d4558c3a94853fdc4d`. [Source and link manifest](manifest.json). Repository links require access while the repository is private. From an authorized checkout, read the named repository paths at this commit. --- # Stage D1. The return: the build. **Model:** as `arm.json` sets for this stage (your platform file lists the model and effort). **Legs:** one. **Fleet:** none here; D2 runs them. You never run a labeler or a reader and never call a model. **Steps:** `D1a`, one leg: `handoff.py` writes the folder once per version. Each leg is named by its step (STANDING §2). **Safe stops:** before `handoff.py` runs (it writes the folder once, so a pause after it is a close). At a safe stop, check for `.pause` (`ls .pause`); if it is there, log where to pick up, your working hypothesis and the next room or item (`mem.py log "; next: " --kind pause`), and close with `done.sh D1 --pause` (STANDING §2). **Startup packet:** `_head.md`, this file, `FLEET.md`, `SCHEMA-adaptations.md`, the last five diary entries, `validate.py --open D1`. The adaptation shelf arrives (METHOD.md). **Reads allowed:** `model/` at its frozen hash; `account.md`; `implications-C5.md`; `propositions.jsonl`; `assignments_final.jsonl`; `_views/data-structure.tsv`; `_wiki/`; the last `story_rooms-pN.jsonl`; `prior.md`, into which you write §7 and §8 here; `rooms.jsonl` for each room's concept count and off-platform pointers; `mem.py room --size`; the rooms' coder documents through the verbs. **Forbidden:** writing any adaptation or verdict yourself; reading `DROPS/`; serving the canvas, a room note, your notes or another room to any task or packet (rule 7). **Outputs:** `handoff-D/` with `RETURN-D.md`, `VOCABULARY.json`, `VERSION`, `MODEL.md`, `LADDER.md`, `tasks//TASK.md` and the room's documents, `tasks/index.tsv`, `HANDLER.md`; `verdict-D/` with `RETURN-D2v.md` and the verdict packets; `prior.md` §7 and §8; `notes-D1.md`; `handback-D1.md`. **`prior.md` §7 and §8 first.** Before you build anything, and before any adaptation is seen, write the distance weights and grades for stage D4 (§7) and the concept floor and the off-platform threshold for `cannot-tell` (§8), each with one line on why that figure. §7 carries two lines in the form `distance.py` reads: `w = , , , ` (the weight of a meeting at each level) and `g = , , , ` (the grades). You set them now because the model is fixed and no room has yet answered it. `done.sh` records `prior.md`'s hash at D1's close (`out/_closes/prior-D1.sha256`), and stage D4 refuses weights that changed without a departure (rule 10). **The model is fixed.** Nothing here changes an element, an arrow, a fourth-order theme or a dimension. What a room does to the model is written against the model by a labeler and ruled on at D3; a change after C5 is a D3 amendment under rule 11, logged with the adaptation lines that caused it. This is the test the loop prepared for: stage C2 read rooms against every telling of the story, and the rooms its last story could not tell are the first ones to watch. List them in `notes-D1.md` from `story_rooms-pN.jsonl` before you build anything, so that D3 can count how they fared. The return is Eisenhardt's replication only if something is predicted before it is seen; `EXPECTATIONS.jsonl` is that prediction, and it is written here, before any return exists. ## 1. The handoff folder (SCHEMA §9) `handoff.py D` builds it from your inputs; you check it and write what the script cannot. Before you run it, write the two files only you can write: `MODEL-D1.md` (the model as prose with ids, below) and `EXPECTATIONS-D1.jsonl` (below). The script copies them in, projects the rest from `model/`, the scheme, `fourth/`, `dimensions.jsonl`, `assignments_final.jsonl`, the store and the coder documents, writes `VERSION`, hashes the folder into `handoff-D.sha256` and `RUN.json`, and prints the payload distribution for §3. It will not overwrite a built folder. - `RETURN-D.md`: the return specification for the labelers, verbatim in every task: the two outputs, the ledger line and its fields, the operations with their required fields, the room model's form and its grade line, the end marker, the reissue rule, the rule that every claim carries a node id and a concept id, the rule that free text lives only in `how`. The template ships with this stage; you do not rewrite it, and a defect in it goes to `handback-D1.md`. - `VOCABULARY.json`: the id vocabulary at the frozen model version: every element with id, kind, statement, tier and dimension, every arrow with id, kind, from, to and mechanism, and `status: tentative` where an entry is one; every third-order and fourth-order theme with id and name; the dimensions. Nothing else. Arrows are in it by id, so a room instantiates, restricts or contradicts an arrow as it does any element; an arrow with no concept in the room is not instantiated there. An element or arrow entered at stage C4 from the field carries `status: tentative` and nothing else that says where it came from; it goes to every room, which answers it from its own record like any other element, silence included (J, 2026-09-29). The mark `from-field` stays in `out/sealed/FIELD.jsonl`, which `handoff.py` writes and never serves; stages D3 and E1 read it and report the field's entries apart. An element on a form-pass tier (`FP-01` ...) also goes to every room, since no second-order theme lifts to it; its unit is the turn, and a room answers it from its turns. - `VERSION`: the hash of the model and its tiers as `done.sh` recorded it at C5d's close (`out/_closes/model-C5.sha256`). `ingest.py` rejects a return written against any other version, whole, and the handler reissues it. - `MODEL.md`: the global model as prose with ids, from `account.md`, cut to the ceiling the labeler's context allows and declared in `notes-D1.md`, with an entry for each of the elements the room's second-order themes were placed under appended per task. Every arrow in it reads *when X, Y follows, because Z*; it describes the universe, not the mode, so that a labeler can read an odd room as one way of running the same structure. Nothing in it refers to a room note, a branch, your notes or the canvas. - `LADDER.md`: the coding table from quote to aggregate dimension with representative concepts for every tier the model uses, projected from `_views/data-structure.tsv` for the dimensions and elements in `MODEL.md`. A labeler that sees only its own concepts cannot understand a dimension, so it cannot say what the model fails to explain. - `EXPECTATIONS.jsonl`, sealed in `out/sealed/` (out of the handler's and the labelers' reach), per room, from `implications-C5.md`, `propositions.jsonl` and the room's placements, which elements the model expects to instantiate and which to be absent, one line: `{"sub": "...", "expect_instantiate": ["P07", "A03"], "expect_absent": ["P03"], "from": ["implications-C5 §2", "placements"], "why": "one clause per element, in the model's terms"}`. Rule 6 governs every `expect_absent`: an element the room had no opportunity to carry is `not-testable-here`, not expected absent. Sealed by the harness, kept outside the readers' and the labelers' directories, never served, scored at E1. This is what makes the return a replication and not a re-reading. - `tasks//TASK.md`: the labeler's instruction (the template ships with this stage): read the coder documents, rewrite `case.md` in the model's vocabulary as `model-D.md`, write `adaptations.jsonl`, grade the fit; the room's `case.md`, `codes.jsonl`, `themes.jsonl`, `brief.md`, `forest.md` (the room's coded threads as reply trees, `trees/.md`, so that `evidence.transitions` rests on the forest); `placements.jsonl`, the placements of the room's second-order themes (third-order theme, fourth-order theme, dimension, or none); where the outputs go. Not in any task: the room note, the account beyond `MODEL.md`, your notes, the propositions, any canvas field, any other room. A labeler who sees a large area grades a success; rule 7 names this fleet. - `tasks/index.tsv`: one row per room with `items_in_window` and the payload in bytes from `mem.py room --size` plus the documents served; the handler dispatches by it, size ascending. - `HANDLER.md`: the adaptation handler's brief (ships with this stage): dispatch by size ascending; how to run a labeler in Codex, one fork of the matching original case-lead checkpoint per room, the model and session id recorded in `DROPS/D//run.json`; the per-room check `ingest.py --check ` and the repair; the return path `DROPS/D//`; that completion comes before any limit and the handler marks a room `unreturned` in `DROPS/D/UNRETURNED.tsv` only when it cannot return it; `DROPS/D/DONE` with the counts; what never to do (no access to `out/` beyond this folder, no edits to the vocabulary, no merging of rooms, no summarising the model for a labeler). ## 2. The verdict fleet's packets `handoff.py D` writes them too, into `verdict-D/` (`--verdict-only` rebuilds them alone): per room, the model as prose with ids, the room's second-order themes with their placements, the room's concepts the model did not use (those of themes placed nowhere, and a seeded sample of those no element cites), the verdict criterion from FLEET.md §3 verbatim, and none of the coder's prose (no `case.md`, no theme notes), no other room, under the 50 KB ceiling with the end marker and the line telling the reader to confirm it reached it. The concept floor and the off-platform threshold for `cannot-tell` are read from `prior.md` into the specification, and each packet states the room's concept count and off-platform pointers from `rooms.jsonl` beside them, so that the reader does not estimate what the store already holds; every verdict carries the count (contract §5). `RETURN-D2v.md`, frozen with this file, and `RETURN-D2v.schema.json`, which `fleet.py` checks every line against (`tools/dreturn.py`): the verdict, the themes and the unused concepts it rests on, one sentence, the end marker. The return line: ``` json {"sub": "...", "reader": "r1", "verdict": "composes|composes-with-residue|does-not-compose|cannot-tell", "themes": ["t03", "t07"], "concepts": ["c0041"], "residue": ["t11"], "cannot_tell_under": "coded-share|off-platform|both|null", "sentence": "one sentence, in the criterion's terms", "served": ""} ``` The reader's id is the name of its return file (`ingest.py` sets it). `residue` lists the themes or concepts with no element and is null unless the verdict is `composes-with-residue`; `cannot_tell_under` names the threshold and is null otherwise. `R = 2` readers per room, so that a disagreement is visible (FLEET §1). A verdict is one value and is a reading with a reason, never a profile, a score or a coordinate: stage D4 projects it onto the branches afterwards and never clusters on it. ## 3. The payload, measured Before the folder is hashed, write in `notes-D1.md` the distribution of task payloads and of verdict packets (median, p90, largest, from `tasks/index.tsv`), the ceiling declared for `MODEL.md` and what it cut from `account.md`. No stage carries a budget (contract §4): a room whose documents exceed what one labeler session can hold is not cut, not split and not read by you; name it in `notes-D1.md` and `handback-D1.md`, and the handler returns it whole or marks it `unreturned` with the reason. The tokens go to `RUN.json` through `done.sh`. ## 4. What you check Every task resolves every id it names against `VOCABULARY.json`; no task and no packet holds a canvas field, a room note or another room's material; every room of the analysed set has a task, an `index.tsv` row and a verdict packet; `MODEL.md` fits the declared ceiling; `EXPECTATIONS.jsonl` has a line per room and sits outside both served folders; `VERSION` equals the harness's hash of `model/`; the folder is hashed and the hash is in `notes-D1.md` and `RUN.json`. A room whose task could not be built goes to `handback-D1.md` with why; you do not invent a document. ## Moments to log The story-miss rooms listed; the ceiling declared; each expectation line written that departs from a plain reading of `implications-C5.md`, with why; the payload distribution; the folder built and hashed; any room whose task could not be built and why. ## Final message Counts: tasks built, verdict packets built, elements and arrows in the vocabulary, the `MODEL.md` ceiling, expectations written (instantiate and absent, by element), rooms `not-testable-here` on any element, story-miss rooms carried, the largest payload; the folder's hash and `VERSION`. A return value. ## Close **Stop here.** `done.sh D1 --cut packets-out`; `handback-D1.md`; the head; the closing diary line. Your session ends. The labelers run in Codex and the verdict fleet on the reader route without you, and nothing of the return (D1 to D3) runs on your model until D2 is launched as the check leg, told that the labelers and the readers left their files in `DROPS/D/` and `_fleet_raw/D2v/`.