Authoritative source, reproduced unchanged. Exact Markdown · Agent copy with resolved links. These instructions govern research runs, not checkpoint interviews.

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 "<hypothesis>; next: <item>" --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 = <third>, <fourth>, <dimension>, <target> (the weight of a meeting at each level) and g = <same op>, <same kind>, <different kind>, <opposite> (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:

{"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": "<sha256 of the packet>"}

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/.