Determinism

A build is deterministic when a reader who follows the shipped sentences word for word, inferring nothing the files do not say, lands on the golden. That is how the portal's judge reads. Builds fail it one way: the golden holds only under a reading the author supplies (the write-up, the design note, "plain sense") while the shipped text, read literally, supports another. Findings in 25 judge reports: a write-up figure not reproducing 19 (§5); estimand not literal 16 (§1); convention unpinned 13 (§3); method unforced 9 (§1); a filed rule reading otherwise 7 (§1). task445 passed our judge twice and failed the portal on a population read literally; eight builds lost their stump when a pin removed the ambiguity it lived in.

1. WHAT is filed literally, HOW may stay open

WHAT: the estimand, filed so that its literal execution is the golden's quantity: population (in terms the data executes, saying whether members not yet observed at the as-of date are in it), outcome, window, unit, comparison, inclusion and exclusion, threshold, rounding. Each fixed by the question or by one filed sentence at authority, stated once, never worded so the literal reading is the easy answer. A source the golden completes (a list whose capture it estimates, a link whose error it corrects) says in its own documentation that it does not hold every member, never how many or which: left unsaid, a literal judge reads that source as the count and the other source's excess as error (task448's portal return).

The comparison is WHAT, and a decisive step that is a comparison choice cannot be saved. The five parts above include the comparison, so whose rates, which pool, which peer group supplies the expectation is part of the estimand and has to be filed so its literal execution is the golden. task194's architecture 2 put its decisive step exactly there, on whether the expectation comes from a published standard or from the comparison population's own current rates, and the author compounded it by ruling that the charter must say nothing about whose rates supply it, which withheld the one part the spec requires filed. The judge read the published rates literally, as the only rates the package carries, and filed a different unit; and filing the comparison instead turns the step into executing it. Every lever below it, the pool and the denominator, is also part of the estimand, so there is no position where both gates hold. Before drawing a decisive step, name which of the five parts it is: if it is one of them, it is WHAT, it must be filed, and the stump has to live somewhere else. The HOW is how a fully filed estimand is computed, and the data must force that.

Where the decisive step is an estimator choice, the assertions run over its GROUPINGS, not only over its placements and penalisations. One build asserted a single grouping refuted and left three untested; of those three, two named another candidate at 1.648x and 1.676x and a third pooled the designated unit with its neighbour, so the shipped refutation sentence was weaker there than the note claimed. A 16-member standing family with two names rode through 233 green assertions and three judge passes. Enumerate the groupings the records license (per unit, per parent, shrunk to the pool, collapsed to a binary) and assert each, because a grouping the data cannot reject is the hardest member to see: the groups genuinely share the quantity, so the rival differs from the golden only by estimation noise and the question is whether the decision's own margin clears the noise the grouping adds.

Two candidate denominators can be unseparable in principle, and the test is cheap. Where the open HOW is which exposure base a rate is built on, the record separates the candidates only if their period profiles differ inside the unit the decision is made at. Profile both bases' period counts against the realised events and read 2 dlogL against the events the record actually carries. One build's two bases correlated 0.9951 to 0.9988 by unit and 0.9994 pooled, giving 2 dlogL of 0.22 on one degree of freedom against a 3.84 threshold, so separating them needed about 40,782 events against the record's 96, some 425 times the pack or 743 years of that centre's traffic. A per-unit fit also absorbs exactly the cross-unit variation such a design leans on, which is why no across-unit test touches it. Run the profile before building a pack whose forcing is meant to come from the data.

HOW may stay open only when something forces it (references/forcing-the-answer.md Part 5): the design (the data's structure rules out every other method; preferred), a governing standard's general method, or a filed selection criterion in general terms that never names the method (a recognisable organ, never in consecutive builds). The data separates every reasonable candidate with margin, asserted. Convergence by insensitivity is not forcing either. Before claiming the design forces the method, ask why the agreeing estimator agrees. If it agrees because the graded quantity is insensitive to exactly what the candidate specifications differ on, the agreement is algebra and every other candidate is still standing: task190's architecture 2 reproduced its golden under the average of the surplus below a threshold and the deficit above it, in 186 of 186 specifications, because averaging the two sides cancels the fitted profile's level, while the surplus alone spanned 71 to 786 and the deficit alone 207 to 858 over the same family. A refusal rule that lives only in the generator ("the specifications that fail to reconcile are dropped") is not in the bundle, so a literal reader cannot apply it and the surviving set cannot be reproduced. Three flavours of this have now been measured, and each needs its own check: the data too smooth to separate anything, the candidates differing by less than their own sampling error, and the agreeing estimator insensitive by construction.

Two candidates can be collinear, and then no pack separates them. The three flavours above are measured on the pack; this one is settled before a file exists, because it is a property of the candidate set rather than of the data. Where the candidates are functional forms, write each one out and compare them over the range the record can actually occupy: forms that agree to first order there will fit within noise of each other however much data you cut, and the margin you measure is the fit's arbitrariness rather than a separation. task194's architecture 1 priced its counterfactual as a constant share of the standing excess and its rival as a power on the standardised ratio; near a ratio of 1 those agree to first order, so the two fitted at chi-square 3.30 and 3.34 on 7 degrees of freedom, a likelihood ratio of 1.02 to 1, and separating them would have needed units at ratios of three or four, which the domain does not contain. Neither fix works on a collinear pair: filing the form files the HOW, and more placements buy nothing, so the architecture is spent and the draw is re-rooted onto a quantity the record measures. Enumerate the forms before the routes. That build enumerated eight pooling routes exhaustively and two functional forms carelessly, which is the wrong way round: the forms are the outer loop and a wrong one invalidates every route inside it. And a separation measured on under-dispersed data is not a separation: report the dispersion of the subset carrying the comparison beside the dispersion of the rest of the record, because the same build's placement quarters ran at 0.47 per degree of freedom against 1.65 elsewhere, so every likelihood ratio it reported was inflated about three and a half times.

Forcing measured on smooth data is not forcing. Where the design forces the method, the separation is measured on a pack whose sampling noise is plausible for the process (a Poisson-like record at chi-square per degree of freedom near 1, never far below it), because a draw taken from evenly spaced quantiles of a fixed curve makes every estimator agree whatever the method. Measure the candidates' spread on that pack first, then set the graded granularity from the spread, raising the record's volume where the figure needs finer reporting than the noise supports. Coarsening the stated rounding to dodge the measurement is the banned move; stating the figure at the precision the data carries is the honest one, and leaving the amounts smooth to keep a fine rounding is the defect both ways round (task190 architecture 2: 199 estimators and 180 fit specifications agreed at chi-square per degree of freedom 0.029, and the judge put the realistic spread at plus or minus 50 on a 400 figure reported to the nearest 10). Nothing forcing it: two methods survive (underspecified_objective). The method itself filed: the step is rule application and the stump is gone.

Never file a procedure, basis or formula whose literal application gives another answer: an official decoy and a fork at once. And a pin added to close one fork can open a larger one, so read every new pin's literal execution against the graded quantity and not only against the fork it was written for. A build added a clause pinning the grain ("a partner's household-size band has one award level for those twelve months ... an award level is not taken claim month by claim month") to close a month-by-month reading, and the clause also said the scheme's awards are taken at those levels. Read literally that collapses the within-cell distribution the committed method depends on, so a whole cell refers or none of it does, and the literal answer moved two candidates away from the golden. The next isolated judge filed that literal answer. The pin was endorsed in writing as fixing the unit a level is taken at while leaving open how the distribution is recovered; it did not leave that open, it determined it. The stump lives in HOW, never in WHAT. If a literal estimand makes the call easy, the stump was a fork; redesign the decisive step (stumping), never keep the estimand vague.

Run the fork-is-the-stump test before building the repair, not after. The test is cheap on paper and the repair is not. Its signature: the portal's finding is an unpinned population, and the stump sentence says the easy route omitted that same population. The pin then tells the reader the one question they were not asking, and no wording avoids it. Measured on one build: closing three forks without filing any method left every graded figure frozen and every free gate green, and the call then landed cell for cell. The pin does not necessarily make the decisive step unanalytical, but it removes whatever difficulty consisted of nobody asking, so decide before building whether anything else carries the task.

A pin can leave the decisive step analytical and still spend its difficulty. The two failures are different and the repair reaches them in order. Rule 3 asks what KIND of step decides; Gate F asks whether anyone is stopped by it. On the same build the licensed judge ran 40 variants and measured that every easy route lands materially wrong (the unconditional reading wrong on three platforms, stopping at the snapshot wrong on four, two field misreadings at roughly half and one and a half times the golden), so the decisive step was an estimand choice and rule 3 passed. It still failed, because the remaining step was a reflex: a competent solver conditions a survival curve on survival to the as-of date without deliberating, and that reflex reaches the golden while the filed record supplies every other convention. A reflex reaching the golden spends the stump (stumping Part 6), whatever the step's kind. When a pin closes the last thing a solver had to ask, list the reflexes for what remains and check that each lands wrong.

A leak reader's question-6 answer is its account of a route, not a measurement. On the same build a reader answered that the call followed filed rules and read dates rather than an analytical choice, while the formula it quoted carried the survival-conditioning denominator it never named as a choice. Where a reader's account and the judge's measurement of the alternatives disagree, the measurement decides what kind of step it is.

What is left open after the WHAT is filed must be a method, not a knob. Filing the five parts is mandatory, so a design whose decisive step is one of them has no stump once it is filed, and a design whose only remaining residue is a tolerance, a cut-off, a rounding or a nearest-k has a convention rather than a method: close it (section 3 requires that) and the stump is gone, leave it open and Gate C fails on a flip nobody can defend. task198's architecture 1 filed the comparison correctly, as a candidate's share against its own earlier quarters "which carried the same offered load", and the residue was how closely "the same" must match: three different queues win across licensed readings (a band of 0.05 to 0.2 or load to one decimal gives one, a band of 0.22 to 0.3 or load rounded to whole units gives the plain highest-share answer, five or more nearest quarters pooled gives a third), and its judge read Gate H as rule application because executing the clause correctly is all the answer needs. The test at the draw: name the residue, then ask whether a competent analyst could defend a different value of it. If the honest answer is that any value is as good as another, it is a knob and the design has no decisive step.

2. The literal-reader test and the semantic fork table

On paper before data is cut, again on the finished pack; the result is the design note's ## Literal reader line.

1. Execute the prompt and every filed definition and rule word for word. Where the text is silent, list every option and compute each.
2. Pass only if every literal reading gives the golden, or each differing reading violates a quotable shipped sentence, or the records make the readings converge (C1, asserted on figure and counts).
3. The easy answer comes from an easy method on the same literal estimand, never from another reading.
4. Every write-up step passes the same test; a step needing an unstated inference is an open fork.

The semantic fork table (## Semantic fork table, ids SF1, SF2...) is that test written down: one row per term in the main ask (every noun, unit, period word) and per convention the main computation needs (as-of, inclusion, grain, rounding path, tie-break): the golden reading, each alternative, the call under it, and the sentence that rules it out, or same call. The stump is never one of the readings (six builds, 119 to 134, carried a reading difference as their difficulty and were judged a fork or landed every time). precut.py refuses an unresolved row; checks.py asserts every row.

3. Close every convention

• Walk the 22 axes (references/forcing-the-answer.md Part 1) into the design note's ## Closure table, one row per axis number with the reading and the move; axes that cannot move the answer today included. A design-stage gate: precut.py refuses a missing or empty row.

• Closure moves, strongest first (Part 2): C1 converge (every reading selects the same rows); C2 confirm (a filed criterion shown on closed data to select one candidate, never recovering an unfiled rule); C3 corridor (the parameter unrecoverable, the answer identical across its range); C4 separate (every cell mapped to the sentence it violates, nearest wrong cell at least 6 per cent).

• When the rival route is another correction of the same graded quantity, all four closure moves are exhausted and none of them closes it. Worked on a build whose decisive step corrects a classifier's marks with its recall and false-mark rate, and whose open seventh cell is a calibration of the hand code on the mark plus a month index, extrapolated past the audited months: it files 504 and prints 500 against a golden of 450, and nothing in the bundle rules it in.

  • C1 converge aligns the data so the rival agrees, which here means making the month term extrapolate the drift correctly. The rival then becomes a second correct route, so a solver who fits any month trend files the golden and Gate F pays for what Gate C gained.
  • C2 confirm needs a filed criterion that distinguishes the two corrections. The distinguishing property is that one is free of how common the class was inside the audited months and the other is not, which is the decisive step itself, so filing the criterion hands over the stump (the Part 4 pin test: delete the clause and the answer stops being forced, which is exactly why it is load-bearing, and exactly why it leaks).
  • C3 corridor needs the answer invariant across the parameter's range, but the parameter is what the two corrections disagree about.
  • C4 separate needs a shipped sentence the rival violates, which is C2 under another name.

  So a build in this position is not repaired, it is re-rooted, and the finding is structural rather than particular: two corrections of one graded quantity cannot be separated by the record without either naming the separating property or making them agree. Check it at design time, not at the judge: list every correction of the graded quantity a competent analyst could apply, and if two survive, the decisive step is the wrong shape. This is the Gate C against Gate F dial stated as an enumeration over the closure moves rather than as a tendency.

• A C3 corridor closes the call and forfeits the figures, so it cannot carry a figure-dense prompt shape. When the decisive construction has a fitted nuisance parameter and the data do not identify it, C3 is the honest closure: the parameter is unrecoverable and the answer is identical across its range. But "the answer" that survives is the set-valued call, not the numbers. Measured on one build's corrected interval-censored placement, over a level corridor from 0.70 to 0.999 whose profile likelihood rises monotonically to the boundary, at four seeds:

  what is graded	across the corridor
  the set of eight slots	identical at every level and under both grid variants, every seed
  the ranking of those eight	identical at three seeds of four, not at the fourth
  each slot's own figure	spreads up to 347.6 on a figure near 3,500, about 10 per cent
  the covered total	spreads 6.20 to 9.08 per cent

  So the call is determinate and nothing else is. A prompt shape that draws its criteria from figures per candidate cannot be served, and ../guide-to-prompt forbids making the count up from stacked asks. This closes the whole family from the other side: identify the nuisance parameter and the aggregation bias of 1.1f makes the correction no better than the uncorrected route; leave it unidentified and C3 buys the call at the price of every figure. Before drawing a correction with a fitted nuisance level, decide which figures the shape needs graded and check them across the corridor, not just the call.

  The escape is a correction with no fitted parameter at all, its rate read off a shipped record rather than estimated: then there is no corridor and every figure is determinate.

• Pin at authority, once (Part 6.1). The prompt carries the question and no convention. Sweep for sentences quotable against the answer and qualify or remove them.

• Measure the edge, not the centre. For a value v printed to a unit u, the printed cell is centred on round(v/u)*u and the distance to its nearest edge is u/2 - abs(v - round(v/u)*u). The quantity abs(v - round(v/u)*u) is the distance to the centre, and the two sum to u/2, so computing it reports clearance where it measured proximity: one build read 0.0129 as its tightest share's clearance when the true distance was 0.0371, and the mis-ranking of which figure was tightest followed from the wrong metric rather than from the data. Assert the edge distance, and name the tightest figure from the same number.

• Bins: every graded figure mid-bin on a non-round value, flip condition stated as a number; never grade an iteration count, an even-set median, or a percentage near a one-decimal edge (Part 3).

• The bin is wider than the estimator, measured in bins before data is cut. Where the graded figure is estimated rather than counted, three quantities are measured in units of its bin and written into the ladder: the decisive step's own worth, the spread between the defensible subgroups or samples an estimate could be read off, and the sampling interval of the one the golden uses. The first must exceed the other two together, and it is never the smallest rung gap. A build whose decisive step is worth a fraction of its bin while a subgroup choice is worth more is not repairable by a pin, a world parameter or a coarser bin: the estimate cannot be forced to that precision, the architecture is spent, and a coarser bin brings the default path into the golden's bucket. task157 shipped twice at 0.58 of a bin for the decisive step against 0.90 for the subgroup choice and 0.31 for the rate's own 95 per cent interval, and both portal rounds landed one bucket out. Read the third quantity by whether the estimator has a free parameter. Where the golden's estimator is a fitted rate, its sampling interval becomes real disagreement, because solvers fit it on different subgroups and file different figures: that is what sank task157. Where it is an observed count over a constant the design fixes, with no fitted parameter, window, band width, distribution family or grouping, every solver computing it files the same figure to the unit, and the interval is the quantity's honest uncertainty rather than a fork. It is still measured and still written down, because it sets how much of the bin the ladder may not use, but a build is not spent for it. The distinction is tested, never asserted: compute the estimator under every grouping the records allow and show the total is identical.

• A decisive step that ADDS A TERM TO A FITTED SPECIFICATION can never pass the bin test, and the proof is an identity rather than a measurement. The cheap rungs file the graded figure with the term absent, and the weakest licensed member of the designed family files it with the term absent too, so (a) and (b) are the same quantity and (a) greater than (b) plus (c) is unreachable at every setting of every dial. Measured on a task397 draw at a ratio of 0.999 at both ends of a sixfold sweep: narrowed to the two forms the rigor pattern itself names, (b) 22.72 against (a) 22.75 at one end and 52.28 against 52.50 at the other, with 0 of 8 dial settings passing. The one setting that closes the family (the term's simplest shape) is the setting where the term carries nothing, 0.0059 against a rival's 0.0446, so the golden becomes the rival and there is no stump: buying separation and closing the family are the same move in opposite directions. So screen the FORM of the decisive step before any harness. Adding a control, a level, an interaction, a random effect or a contextual term is a specification extension and is closed as a class, which is most of what a multilevel or regression-shaped task type offers; what passes is a reconstruction whose arithmetic closes over rows the records supply exactly.

• In a fitted family, read (b) and not (c). (c) was expected to bind on a multilevel draw and did not: it measured 3.59 bins and stayed flat across the whole dial, being the cluster-robust sampling error of the fitted coefficients carried to the graded figure by the delta method. The free parameter that kills such a build is not in the variance components, it is WHICH LEVEL the conditioning variable is centred at and WHAT SHAPE the contextual term takes, and both land in (b). One of the five licensed forms of the same construction printed the graded figure with the opposite sign, and the simplest of them forked the call itself, naming the golden's driver in 5 or 6 of 30 worlds against 30 of 30.

• The bin test is necessary and not sufficient, and the screens run beside it rather than after. It prices the decisive move against the readings and the noise, and says nothing about whether a one-divide route is rank-equivalent to the golden. A task198 candidate passed it at 1.26, 1.43 and 1.27 over three seeds, with the decisive step clear of the smallest rung gap, and died on the multiplicative-correction floor: sd(log factor) 0.19 against a dispersion ceiling near 1.4, rho 0.10 against the 0.80 floor, and the easy route naming the same unit in 55 of 60 draws. Run the floor and geometric-mean screens, the deletion tests and the swap test alongside the three measurements, never as a second pass on whatever survives them.

• The second quantity is the WHAT screen read as a number. Where the defensible-subgroup spread is the binding term, the fork lives in the population, the window or the unit, which section 1 requires filed; and filing it leaves the decisive step a division over shipped columns, which is rule application. So a candidate whose spread is closed by filing the population has not been repaired, it has been converted into a banned decisive step. Measured on the same candidate: three defensible populations for a load factor (the event's own half hour, its own day's mean, its own month's mean) spread the figure 4.39 to 6.08 against a decisive worth of 6.58 to 8.03, while the sampling interval was 0.20 to 0.28.

• The third quantity and the reflex's own precision can be one number, and then buying the test with volume is not available. On a repairable-system trend test the same inter-arrival scatter sets the golden's interval and the uncorrected reflex's accuracy, so the setting that lifts the ratio to 1.00 is also the setting where a plain shape estimator reaches the truth more often than the decisive route (31 of 60 against 28). Check whether the dial that raises the first quantity also raises the third before reporting a cell as passing.

• Convergence is proved against a rival's family, never the golden's own. A convergence block that varies only the construction the golden already uses (which periods a ratio is read from, which window, which band widths) measures the golden's internal stability and says nothing about determinism. Every such block names, and computes, at least two families a competent solver would build instead, and the bucket each files. task157's fourteen constructions converged 20 of 20 on the golden in every world tested, including the one two portal judges broke by building a cell model the block never considered.

• The call's robustness is not the figures' determinacy, and both are checked before data is cut. Where the method stays open, run every candidate the data does not close and compare two things separately: which candidate it names, and what each graded figure prints. task182's architecture 3 had every fit form naming the same five dwellings and the same sixth while the fourteen graded levels differed by 0.9 to 1.8 dB, nine to eighteen times the printed unit, so the call was robust and every graded figure was forked. A design can pass the ranking test and fail Gate C on the figures the same ranking produces. Measure each figure's spread across the surviving candidates against its own printed unit, at the design stage, because the cure is a different decisive step rather than a repair. The cell width comes from the asking sentence's stated rounding, never from the quantity's natural unit. For a value v printed to unit u the cell centres on round(v/u)*u and the distance to the nearest edge is u/2 - abs(v - round(v/u)*u); the second term alone is the distance to the centre, and the two sum to u/2. Both halves of that have now been got wrong in one wave: one build measured the distance to the centre and called it the edge, and another measured a fee rounded to the half against the nearest whole unit, so a reported 0.38 of clearance was really 0.12, and the rates then chosen to widen it put four of seven fees exactly on the boundary. Have the verifier recompute the distance from the shipped figure rather than read it out of figures.json.

• No decision metric in the prompt's own voice that a filed policy contradicts.

• No artifact ranks the candidates on the decision and gets it wrong, except a declared wrong-basis distractor (dataset-generation §8.3) that a shipped fact rules out and that is never the stump.

4. Assert in the generator, verify independently

In checks.py and again in verify.py, which reads only the shipped bundle: the literal reading's answer equals the golden, or the readings' convergence; every C1 equality (figure, row and entity counts), every C2 candidate's error and the winner's margin, the C3 corridor, every C4 cell with its violated sentence; every SF row; every graded figure's bin distance; the clean-data test per suspect file (repaired in the generator, the answer and the naive answer unchanged and still apart) and the lens-swap test (the naive read and the answer are not one population at one moment under two lenses); the input gates; two consecutive builds byte-identical. Compute forward; where a rung turns on two axes disagreeing, build the disagreement per candidate (Part 6.5).

5. The write-up and figures.json

Every figure in submission.md is a claim the judge recomputes: the answers the rubric owes and a reproducible path, nothing more (no incidental figure, no count a filed definition does not force, no "the readings agree" without an assertion). Blocks and wording: submission-writeup. The generator writes <task>/generator/figures.json (the call, each critical component, each step's result, every deliverable answer, as the write-up states them), and the blocks are drafted from it. Build-stage gate:

python3 .claude/skills/determinism-check/figures_check.py taskNN   # 0 every number in blocks 1-4 is in figures.json; 1 missing; 2 no file

Typed figures were the commonest judge finding (12 of 16 in one window). Each step names the file and rule in the verifier's words.

figures.json may be written more than once, so a partial rebuild fails the gate on figures nothing is wrong with. task197's pack builder writes it and the write-up emitter then reads it, adds the five figures only the write-up needs (the traverse spans, the obliged-pair count, the count outside tolerance, the episode total and the standard's thresholds) and writes it back. Running the pack builder alone left those five absent and the gate failed on four figures the write-up had always stated correctly. Before reading a gate failure as a typed figure, check which scripts assign the key and whether every one of them ran: the rebuild is the whole chain, not the first script in it.

A constant typed as a literal in the write-up emitter is still a typed figure, and the gate cannot see it. It compares the write-up against figures.json, so a threshold hard-coded in both agrees with itself while disagreeing with the pack the moment the generator's parameter changes. Every constant in figures.json is read from the generator's own parameters.

Every graded figure is printed at the precision its asking sentence states. A figure printed coarser than the prompt asked for is a wrong figure, not a rounding preference: task182's prompt said to give the air to one decimal and its write-up printed the six weekly figures whole, 689 for 689.2, so eighteen asked figures were wrong on the face of the submission while every gate stayed green. figures_check.py cannot see it, because it asks whether each number in the blocks is in figures.json and both carried the same coarse value. Read the prompt's rounding sentence, list the figures it governs, and check each one's printed precision against it by hand or in the verifier.

A robustness claim is graded over the whole range it names. "Furthest above under every number of matched quarters" is checked at every number: task198's held for one to four quarters pooled and failed at five, where a different queue leads. Compute the claim across its stated range or narrow the claim to the range you computed.

A clause that says what another method would give is a graded claim. "Not a background taken from the position's own record, which puts NSL03 and NSL12 in" names two candidates, so the judge builds that background and checks: task182's judge could not get NSL12 into the five under any background proxy it tried, and the method it did reproduce brought in a candidate the sentence left out. Either recompute every rejected route the write-up names, and name exactly the candidates it yields, or write the sentence without the candidate list.

A graded figure the prompt never asked for is an open fork by construction. The rubric can only owe what the question asks, so a figure that sits in Deliverable Answers without an ask behind it has no asking sentence to fix its basis, its population or its rounding, and a judge reads that as Gate E and Gate C at once. task192 graded a five-part decomposition and a per-fortnight shaded series the prompt never requested; both reproduced, and both were findings. Walk the prompt's own sentences against block 4 before the judge does: every number in it answers an ask, or it leaves. The call's components are different and stay in Critical Components, where they are the recommendation's working rather than an answer the rubric owes, and a deliverable may still carry context the prompt did not ask for as long as the write-up does not grade it.

6. The gates, in the judge's order

Gate	Question	Fails as
H	Domain's own analysis (swap test), both layers, and a strong analyst who read every field and rule still wrong the easy way?	SEND_BACK
G	Difficulty survives deleting every wrong number; not a lens swap?	SEND_BACK
A	Every figure recomputes from the shipped files at their grain?	solution_incorrect
B	Every decisive fact shipped; every distinctive term of the recommendation in some input?	missing_input_data, answer_contradicts_files
C	Does an answer flip under an open definition, threshold, scope, window or rounding path? Literal reading first.	underspecified_objective
D	Would rigorous solvers differ by reading a term, not by analysing?	semantic_fork
E	Decision pinned, every ask single and precise?	prompt_ambiguity
F	Can the stump sentence be written (the default path ends on a wrong answer), does at least one of the top two miss the call, and do the asks hold both top responses under two fifths of the ask weight?	too easy

The judge's own text: guidelines/determinism_judge_system_prompt.md.

Running the judge

• When: /build stage 4 (in the background beside the leak reader, after the free gates pass), one re-judge in /fix-determinism, or when the author asks in their own words. Nothing else licenses it. /fix-rubric takes the free mechanical gates and no judge.
• One isolated thread at medium effort, in the background; meanwhile only work that moves no graded figure. It sees a fresh unzip of target.zip, the prompt, the submission's graded blocks and the judge's system prompt inlined verbatim; never the design note, pipeline.json, the stump sentence, an earlier report or anything its orchestrator read. The determinism-judge agent prepares and spawns it; without an Agent tool it returns the brief's path and the main session spawns from it. An orchestrator that has read beyond the bundle never judges in its own thread.
• The graded blocks never sit in the brief. They go in their own file the brief names and tells the thread not to open until its own derivation is written to disk. A brief that ends with the answers relies on the thread choosing to stop reading a file it was told to read, which it will not do: task199's re-judge read the committed answers before deriving and said so, and a verdict from a broken order is weaker evidence on Gate C, because a judge that cannot be surprised cannot tell you the answer was forced. The thread reports whether it kept the order, and a pass that broke it does not spend the architecture's one re-judge: the breach is the orchestrator's, so the cost is.
• The thread reads literally first (§2), then the gates, and counts a fork closed only by inference or by the write-up as open. Our judge is the floor: a fork it settles "by the plain reading" is a FIX_NOW.
• An APPROVE is scoped to the pack the judge saw. It ships that pack, not the folder's future. Any later change that moves a graded figure, or that alters a clause a gate turned on, voids it and the judge re-runs, because Gate A's verdict is that those figures recompute and they are different figures now. task197 was approved on every gate with Gate F strong, and a margin measurement ordered afterwards found a 4.3488 MWh fork in how a loss factor is applied that the judge had never tested, whose closure moved all twenty exposure figures (the tightest bin distance going from 0.0040 to 0.0303 MWh). Work that moves nothing graded, such as realism in a file the call does not read or a wording fix the judge itself asked for, does not void it. So state the condition when ruling out a re-judge, because "APPROVE is not a FIX_NOW" holds only while nothing graded moves.
• After: relay the verdict, disposition, Gate G and Gate H lines. APPROVE ships. FIX_NOW is fixed in the generator and re-judged once. SEND_BACK re-roots or retires (build-pipeline).
• A disposition is read against the gate table, not taken on its label. The table sends back on Gate G and Gate H, the two that say the build is the wrong build. A Gate C or Gate E failure confined to a supplementary ask, with the main call forced and G and H passing, is an ask-layer repair and spends no architecture, whatever the thread called it: the asks are legally free of the call's rules, so the loosest wording in the build sits where Gate C is graded, and that is a wording fix. task196 was paused as spent on a third SEND_BACK whose gates read G PASS, H PASS, F strong with no lever needed, the main call reproducing exactly, and ask 4 alone failing C and E. Re-rooting that throws away a world, a pack and a forced call to repair one sentence. Before spending an architecture, name the gate that failed and check it is G or H.

Checklist

• Estimand filed literally, unobserved members stated; method filed (then not the stump) or forced, candidates separated, asserted
• No filed rule, basis or formula with another literal answer; Literal reader line written
• Semantic fork table complete, every row ruled out or convergent, the stump none of them, every row in checks.py
• 22-axis closure table (precut.py exit 0); pins at authority; counter-pin sweep clean
• Figures mid-bin, flip stated; checks and verifier green; rebuild byte-identical; figures_check.py exit 0
• Judge isolated, literal reading first; FIX_NOW fixed and re-judged once