Gate Check

---
name: gate-check
description: "Advisor-checked decision gates. Freezes a drafted option set, has an independent external advisor rule it genuine / collapsed / malformed, then verifies the cited grounds before it reaches the user."
---

# Gate Check

An option set is normally judged by whoever drafted it. That is the one judgment the drafter cannot make well: the options inherit the frame they were drafted from, so an option set standing on the wrong axis looks complete from inside. This skill puts an independent adjudicator on the option set itself — not on the work the gate is about — and then checks the adjudicator's reasoning against the substrate before either reaches you.

The check separates two things that usually collapse into one: **who wrote the options** and **who says they are worth asking**. Everything below exists to keep those apart, including from itself.

## Caller Signature

```
/gate-check [gate?] [advisor?]

gate    : (implicit) | explicit draft   -- optional; defaults to the gate drafted in the current turn
advisor : { codex }                     -- optional; the independent adjudicator behind the
                                        --   (gate question, frozen option set, settled
                                        --    constraints, pointers)
                                        --   → { axis reading, falsifier, a ground cited for every
                                        --      conclusion asserted, and either a verdict — with
                                        --      what a collapse reduces to, or what axis a
                                        --      malformed relocates onto — or, where none of the
                                        --      three fits, the members it could not clear with
                                        --      the repairs available and what each changes }
                                        --      interface
```

The advisor is a parameter, not the identity. Any adjudicator satisfying that interface can drive the check, provided it is a genuinely separate reasoner — a second pass by the drafting agent does not satisfy it, because the independence is the whole mechanism.

## Pipeline Overview

```
/gate-check [gate?] [advisor?]
  Phase 0 : screen + freeze     -- eligible gate? → freeze the option set verbatim, capture a substrate anchor
  Phase 1 : launch ∥ precommit  -- dispatch to the advisor (background), then record the expected
                                   controlling sources and verification criteria BEFORE any advisor
                                   output is visible
  Phase 2 : verify              -- collect the advisor's own words; check each cited ground against
                                   the substrate; check whether its stated falsifier could have
                                   defeated the reading and whether it is there
  Phase 3 : dispose             -- genuine | collapse | malformed | indeterminate | failed
  Phase 4 : synthesize          -- on a settled repair: rebuild the option set under the synthesis guards,
                                   then one external recheck, bounded
  present                       -- three vantage points always; ground-by-ground detail folds to one line
  observer                      -- armed for the session; every cycle converges or fails explicitly
```

## When to Use

- A gate has been drafted whose options are competing approaches, orderings, or scopes, and it is not obvious whether they are genuinely different choices
- A decision keeps feeling like a choice while every option leads to the same place
- A gate that already fired produced an answer that did not settle anything, suggesting the axis was wrong
- An absence carries the option set — that no rule covers this, that nothing else fits, that it cannot be done in one pass. An absence leaves nothing behind to notice it by, so it reads as true off any summary of the ground; only the ground itself separates an absence that was checked from one that was assumed

## When NOT to Use

- The decision is already settled by something citable — say so and proceed
- The gate has one option; there is no set to adjudicate

Both are conditions of the screen below, listed here too because they are reasons not to reach for the skill at all rather than only reasons it declines.

## Eligibility and Exclusions

The check applies to gates that **route a reversible decision**. A decision is reversible when correcting it at the next interaction leaves no persistent state change, lost context, outward-facing commitment, or divergent downstream work.

These are the screen. A gate meeting any of them leaves the check, regardless of what verdict the advisor would have returned — but not all of them leave the same way, and firing them all as gates would put back the very asks the screen just caught. The first four leave as gates and fire on their own terms: they are real decisions the check has no standing over. The last two leave as something other than a gate — a decision already settled is relayed with the source that settles it, and a set down to one option is simply the thing it names, done. Where a gate meets conditions from both halves, the first half wins: an irreversible or environment-mutating decision stays a gate however settled its direction or however few options are left, since what those two conditions protect is a confirmation, and a relay is exactly the thing that skips one. Report every condition that applied, not only the one that decided. Everything elsewhere in this document that speaks of "the screen" means this list, and means all of it — no other passage carries a count of its own, because a count kept in two places drifts in one of them.

- **Gates that measure you rather than route a decision** — comprehension checks and recognition prompts, where a single correct option is the design rather than a defect
- **Options turning on private preference** — where the deciding weight is something only you hold, an external reasoner has nothing to adjudicate against
- **Irreversible actions** — a settled direction never lowers the bar for a decision whose effects cannot be corrected at the next interaction
- **Environment-mutating actions** — the gate is the permission boundary, not a routing question
- **Decisions a citable source already settles** — the direction is determined before the check begins, so a round spent on it confirms what the citation already said
- **Sets down to one option** — there is no option set to adjudicate, only a thing to do

Running the check on an excluded gate is not merely wasted — a `collapse` verdict on an irreversible decision would relay away exactly the confirmation the irreversibility demands. Screen first.

Where the running environment carries its own standing policy about when gates get checked, that policy may narrow this screen further. The skill operates fully without one; no external rule file is required for correct operation.

## Phase 0: Screen + Freeze

1. **Bind the gate.** With an explicit draft argument, use it. Without one, take the most recently drafted gate whose decision is still open — a gate that already fired and whose answer settled nothing leaves its decision open whatever was said. With neither an argument nor a gate to reach for, there is nothing to check: say so and stop, naming what would give the skill a target. An invocation with no gate is a landing like any other, not a silent no-op.
2. **Screen for eligibility** against the screen above, in full. Anything it catches stops the cycle here and leaves the way that condition leaves, reported.
3. **Freeze the option set verbatim.** The frozen text is what the advisor adjudicates and what any later comparison is made against. Rewording an option after freezing invalidates the cycle — restart it rather than patch it.
4. **Capture a substrate anchor** — as a value the later check can re-read and compare against, never as a description of one, and covering whatever of the substrate the check will actually read. Capturing it describes the tree rather than operating on it — the anchor is a thing to read back, not a change to make. Everything downstream is evaluated against this one anchor, and the movement check later asks whether the substrate moved away from it — a question answerable only if what was captured can be held up against what is there now.

## Phase 1: Launch, then Precommit

**Order matters here and is the point.** Dispatch first, record second, and never inspect partial advisor output before the record is written.

**Dispatch.** Send the advisor exactly four things:

- the gate's question, as bound in Phase 0 — what the options are answers to. Without it an option set can only be read for internal consistency, while the judgment being asked for is whether it stands on the right axis, and an axis is only right or wrong relative to the decision the options serve
- the frozen option set, verbatim, including each option's stated implication
- the constraints already settled by the user that the advisor cannot re-derive from the substrate — decisions made in conversation that left no trace on disk
- substrate pointers: paths, search patterns, and commands the advisor can dereference with its own tools. Where the option set rests on an absence, this is the slot that carries it: the search whose result would surface a counter-example, never the claim that none exists. An absence stated is rationale and the boundary below excludes it; an absence the adjudicator runs for itself is the only kind that reaches the adjudication, and it is the stronger one — the drafting side cannot notice what it failed to look for

Ask it for four things back: a verdict (`genuine | collapse | malformed`), its reading of what axis the options actually stand on, a ground cited for every conclusion it reaches — the axis reading is one conclusion and the verdict on it is another, and each owes its own — and, stated after the rest so it accounts for what it just said rather than shaping it, the observation that would break its own reading. Grounds are asked for per conclusion rather than for the answer as a whole because conclusions rest on different evidence: what axis a set stands on and what follows for the set are separate claims, and it is the verdict, not the axis, that routes what happens next.

A verdict asserting anything beyond the axis owes that in the same answer, with its own ground. On `collapse`: which option of the frozen set the others reduce to, and the ground they reduce on. On `malformed`: the axis the options should stand on instead, and the ground for relocating there. These are asked for rather than worked out afterwards because naming them *is* the substance of those verdicts — a set said to collapse without saying what it collapses to, or said to stand on the wrong axis without saying which axis is right, has not been adjudicated. A target named without the ground that carries it defers the same thing one step in, arriving as a conclusion with nothing behind it for the verification to check. Leaving any of it to be supplied later would hand the choice back to the side whose option set is under judgment, which is the collapse of drafter and judge this skill exists to keep apart.

Where two verdicts both fit — a set on the wrong axis whose options also all converge — `malformed` is the one to return. A collapse relayed off a wrong-axis set delivers a settled answer to a question that should not have been asked; relocating first puts the convergence question to the set that belongs there, where it can be asked again and mean something. Say which verdicts were in contention and why the returned one won, so the ordering is checkable rather than assumed.

Where none of the three fits — the set stands on the right axis and still is not the set to ask — say so rather than round to the nearest verdict. What it owes then is the same in kind: which members it could not clear and the ground for each, the repairs available for them, and what each repair changes about the set you would end up answering. A verdict rounded to from a set that fit none of them is worse than no verdict, because it arrives labeled as checked.

**Input boundary.** The dispatch never carries which option the drafting side prefers, the rationale behind the option set, or any prior disposition. An adjudicator told the preferred answer is no longer adjudicating; it is agreeing. Naming the constraint the user settled is conveyance; adding what the advisor should therefore conclude is not. The gate's question sits on the conveyance side of that line and is not the rationale: the rationale is why these options were drafted, which the adjudication must not see, while the question is what they answer, without which there is nothing to adjudicate their fit against.

**Precommit.** While the advisor runs, write down — to the same kind of per-invocation record the dispatch and answer use, for the same reason: what makes this work is that it can be read back afterwards and shown not to have moved, which a recollection cannot be — two things:

- the **expected controlling sources**: which parts of the substrate the answer ought to turn on
- the **verification criteria**: what would have to be true of the returned grounds for them to check out

The precommit is deliberately **not** a preferred option. A recorded preference invites the later comparison to become "did we agree," which is the failure this whole ordering exists to prevent. What the precommit buys is different: it makes the question *did I converge or did I follow* answerable afterwards, which it is not once the answer has been read.

## Phase 2: Verify the Grounds

Collect the advisor's final message and carry it forward as written. Do not parse it into fields — read what it concluded, what it offers in support of each conclusion, and what it names as its own falsifier directly from its own words, and keep the full text intact for reference. Reading it through a fixed set of fields is how a conclusion the answer did assert goes missing before anything has a chance to check it.

Then check it, ground by ground, against the anchored substrate:

- **Does each cited source exist, and does it say what the advisor attributed to it?** A citation pointing at a location that says something else is a failed ground even when the underlying claim turns out to be true elsewhere — the claim and its citation are checked separately, and both are reported.
- **Does the source track what it asserts?** A source that is current but coupled to nothing can silently disagree with the behavior it describes; freshness is not the same as fidelity.
- **Does each cited ground carry the conclusion it was offered for?** Run this once per conclusion the answer asserts, whatever they turn out to be — the axis reading is one, the verdict reached on it is another, and a verdict naming something further asserts that as well. A true premise that does not reach its conclusion is the most common way a verdict looks grounded and is not. They are checked apart because grounds that establish one conclusion leave the others standing untouched, and a conclusion carried on another's grounds is the advisor's own judgment passed through unaudited. A conclusion the answer asserts with no ground offered for it is unchecked, and unchecked is a result rather than a pass — enumerating which conclusions to check would leave whichever the list has not caught up with silently exempt.
- **Could the stated falsifier have defeated the reading, and is it present in the substrate?** Whether it could comes first: an observation that cannot be obtained, or whose obtaining would leave the reading standing, is not a falsifier at all, and its absence certifies nothing. Once it could, presence carries meaning — present means the reading is live-contested, absent means that particular objection does not apply, not that the reading is right. The two are checked apart because absent-because-vacuous and absent-because-tested look identical afterwards, and only the second is a result.
- **Does each proposed repair say what it changes about the set you would answer?** A repair named without that is not yet something anyone can choose between — it says something would be done without showing what the choosing is over, which is the recall the whole presentation exists to spare you. Like any conclusion offered without its ground, it is unchecked rather than passed.
- **Is any material premise inaccessible, ambiguous, or a matter of reading rather than fact?**
- **Did the answer turn on the sources the precommit named, and do the grounds meet the criteria it set?** This is where the precommit is read, and reading it is the only thing that makes it more than paperwork — both halves of it, because a precommit half-read is a precommit half-binding. A source it named that the answer never reaches is an uncovered ground no present citation can speak for: the answer did not refute that source, it went somewhere else. The criteria are applied as they were written, before the grounds arrived; loosening one afterwards to fit what came back is the same substitution the ordering exists to prevent, arriving at the last step instead of the first and leaving every visible step intact. A citation that checks out, a controlling source left untouched, and a criterion quietly lowered are all perfectly compatible, which is exactly the shape a followed answer takes.

This phase is the audit vertex, and it is deliberately narrow: it checks whether the advisor represented and applied the evidence correctly. It does not re-argue the options. A second opinion from the side that drafted them is not independent evidence, and offering it as one would quietly restore the collapse the skill exists to prevent.

**Snapshot consistency.** Read the captured anchor back and hold it against the substrate as it stands now — that comparison is what the anchor was captured for, and no other step performs it. If the substrate moved, re-anchor and run the cycle once more rather than reconciling across two states. Bounded at one, for the same reason the synthesis recheck is: if it moves again, stop re-anchoring and let the cycle land on `indeterminate (anchor)`. A gate held open until the ground stops shifting is a gate that never fires.

## Phase 3: Disposition

Exactly one of these holds — which is three claims rather than one, and they fail separately.

**Every cycle reaches a row.** A situation matching none of them has found a gap in the table, not a way out of it; the cycle does not proceed unlabeled while the gap goes unreported.

**No two rows can both be the answer.** The ordering is what secures that, so a row is read against every row above and below it before it lands, and a row inserted anywhere but the end changes what the rows under it mean.

**Every row can deliver what it promises.** A row whose action names something no phase produces cannot fire however well it reads, and the phase that produces it is named before the row is trusted.

None of the three implies another, and a table can satisfy two of them while silently failing the third.

**What each landing presents follows from two rules, so the rows do not restate them.** What reaches you is the set actually adjudicated — not the set a cycle started from, where those have come apart. And where a rebuild was attempted and its recheck did not come back clean, every set attempted is shown with what the check found against each, none of them as the answer. The pass a cycle is on matters to the rows only where it turns continuation into termination: a first attempt may rebuild, a second may not.

| Condition | Disposition | What happens |
|---|---|---|
| No usable answer — the advisor failed, timed out, returned nothing readable, returned something readable that is neither a verdict nor a report of members it could not clear, or the gate turned out after dispatch to be one the screen catches, so its verdict is discarded | **failed** | Present, labeled as unchecked, with what went wrong. A late-caught screen condition is the exception: the gate leaves the way that condition leaves, since discovering the screen applies does not turn a relay or a settled single option into a gate. The cycle ends in failure and the originating decision still gets an answer |
| The substrate moved again after the one permitted re-anchor | **indeterminate (anchor)** | Unfold everything, naming both anchors and what moved between them. Grounds read against a substrate that will not hold still are not grounds |
| A cited ground is missing, says something other than what was attributed to it, or the answer cites nothing at all | **indeterminate (uncitable)** | Unfold everything, naming which conclusion the failed citation was offered for. Grounds are owed per conclusion, so which one it was is what says how far the finding reaches — and knowing which set carries it does not answer that |
| The advisor's own stated falsifier is present in the substrate | **indeterminate (falsifier live)** | Unfold everything, naming the live falsifier. Checked ahead of the audit conditions below, in the order the verification itself runs them: a falsifier that is live says the reading is contradicted, which outranks the answer having failed to reach something |
| Grounds located, but some obligation the answer carried goes unmet — anything it was required to return, or did assert, left absent, ungrounded, unreachable, or resting on something that does not track what would keep it true. Where the answer was a repair report this fires only once every proposed repair has failed its own check, since a repair failing takes that repair out and not the answer with it | **indeterminate (audit)** | Unfold everything, naming what the answer did not reach |
| Grounds check out, falsifier absent, and the answer reached no verdict — it reports members it could not clear instead | **indeterminate (unmapped)** | Unfold the repair space: every member with whether it cleared, the ground for each that did not, and the repairs available with what each changes about the set you would answer. On a first pass the repair then settles and the rebuild runs on it; on a recheck the cycle ends here |
| Grounds check out, falsifier absent, verdict `genuine` | **genuine** | Present the gate, now checked, with the axis reading |
| Grounds check out, falsifier absent, verdict `collapse` | **collapse** | Relay: state the finding and the option it settles on, with the ground that settles it. No gate |
| Grounds check out, falsifier absent, verdict `malformed` | **malformed** | On a first pass, proceed to the rebuild. On a recheck the rebuild has already had its one attempt, so the cycle ends here with both attempts and the diagnosis surfaced — a second rebuild is the repetition the bound exists to refuse |
| The rebuild cannot be done here — it would need a different kind of answer, it would remove an option only the originating definition can remove, or the rebuilt set came back caught by the screen | **indeterminate (routed back)** | Present the original gate carrying what the check established and where that has to be changed instead, which for every trigger is wherever the original gate was constructed. The gate fires because the decision still needs an answer; it fires disqualified rather than silently, because answering through a set already shown unable to carry the answer is the failure this landing detected |

**An unmapped answer settles its repair before anything is rebuilt.** Where a citable source determines which repair applies — a documented convention, a rule belonging to whatever defined the gate, a decision already made in this conversation — it is relayed with that citation and the rebuild runs on it; asking you to pick where the answer is already written is the over-gating this skill screens for elsewhere. Where more than one repair stays genuinely viable, they reach you as the choice, each with the set it would produce and what that changes downstream, and the rebuild waits. Either way the settled repair enters the same rebuild and the same single recheck a relocation does, because a set quietly changed and handed over unchecked is the one thing no landing here allows.

A repair menu you are asked to choose from is a set the adjudicator authored and never adjudicated — an answer reaching no verdict is what put the cycle here — and verification dropping some of its members makes it a different set again. Authorship does not transfer across a filter, and there is no earlier verdict to fall back on. So the menu goes out for adjudication as the set it now is, and it goes as a dispatch like any other: its own precommit, its own single use, the same ground verification on what comes back. Whatever that answer is, it is a finding about the menu and reports into the cycle already running; nothing nests, because a second synthesis opening inside the first is the repetition the bound refuses. A dispatch exempted from the ordering because it is small is the ordering exempted, and an answer exempted from the verification because its question was narrow is the verification exempted. Where the menu cannot be adjudicated at all — its use spent, the advisor unreachable — it still reaches you inside the same unfold, saying plainly that it was not, with each drop named and what it failed on. An unadjudicated set you can see the gaps in is worth more than a repair you never got to choose, and choosing between those two by preference is not on offer.

**Silence never resolves as agreement.** An advisor that does not answer, a tool that errors, a timeout — each lands in `failed`, and `failed` presents the gate unchecked rather than presenting it as confirmed. There is no path from an absent answer to a folded conclusion.

**A failed cycle does not suspend the gate.** The originating decision still needs an answer; withholding it because the check was unavailable would let one broken external call stall every later decision. The gate fires, and the label carries the fact that it fired unchecked.

## Phase 4: Synthesis (on a settled repair — relocation or member-level)

Two things arrive here. A `malformed` verdict brings a relocation: the options stand on the wrong axis, and the advisor supplied the axis to move to and the ground for it. An `unmapped` answer brings a member-level repair on an axis that was already right, settled either by the citation that determined it or by your answer among the viable ones. Phase 2 checked the grounds under both, the same way, and the replacement option set is built here, where the live context is. Neither kind reaches this phase unchecked — a repair that did not survive verification routed to an indeterminate audit instead, because a set rebuilt on an unverified ground is the original defect one move over. That makes this a synthesis step, not a relay — it selects and composes — so it carries its own guards:

1. **Originating answer type is preserved.** Determine what kind of answer the original gate was asking for. A replacement option may make a generic option concrete while keeping that answer kind; it may not silently add, remove, or swap the kinds of answer available.
2. **A change of answer kind routes back.** If the repair needs a different answer kind — a relocated axis that asks for one, a member fix that cannot be made without one — or belongs to a different phase of the work, report back to wherever the original gate was constructed — that is where the change has to be made, and saying so is the point of routing back. Do not present the replacement as though it were a sharpening of the original. Reporting there does not take the decision away from here: the cycle ends in `indeterminate (routed back)` like any other, and the originating gate fires carrying what the check established it cannot represent. The two are not in tension — one says where the set has to change, the other keeps the decision moving until it does.
3. **Every original option is accounted for.** Each one is retained, collapsed into another, removed as off-axis, or reframed — and each disposition names the advisor ground that licensed it. An option that quietly disappears is a deletion wearing a rewrite's clothes. Where the alternatives were fixed wherever the gate was defined rather than composed for this turn, removing one is not this phase's to do however well grounded: it takes away an answer the user was able to give, which belongs to the definition and not to a rebuild. Such an option is recorded as off-axis and routes back the way a change of answer kind does, landing the cycle in `indeterminate (routed back)`. Making an option concrete leaves the set intact; dropping one makes it smaller.
4. **No unsupported additions.** A new option derives from the ground the repair itself stands on — the relocated axis where there was one, the cited member finding where the axis never moved — together with the substrate. An option that traces only to the drafting side's unrecorded preference is an injection, and injection is the failure mode this skill was built against. The same holds whenever a rebuild turns out to carry only one live path — the relocated axis leaving one, or the member repairs collapsing the set to one without the axis having moved at all: report the set as the one option it is and let the screen route it back to where the gate was defined. Both pathways reach the same temptation because both end at a set someone has to write down. Padding it to two with a dominated stand-in would clear the screen and send a question with no second answer out for adjudication, and the relay that came back would look like a settled finding rather than what it is — the rebuild discovering there was nothing here to choose between. Which of those two you get would then turn on a decision nobody recorded making.
5. **The replacement is itself checked, once, and the recheck is a full pass.** Screen the rebuilt set first, against the same screen the original passed, in full: a relocation can move the decision onto ground the screen exists to keep out, and a set caught there leaves the way any screened-out gate does — it lands in `indeterminate (routed back)` rather than being relayed. A rebuilt set that clears the screen then goes for **one** external recheck, bounded at one. Run the same collapse test on it, but finding that it converges on a single dominant option ends nothing here: the side that built the set has no independent opinion about it, so the recheck goes out regardless and that reading becomes part of the **fresh precommit** written for it — one record, in the order the first dispatch used, launched first and recorded second with nothing of the answer seen in between. The first precommit named the sources an answer about the *old* axis ought to turn on and cannot speak for this one; reusing it would let the verification read a record written for a different question, and skipping it would leave the second answer as the only pass with nothing to compare against — the one pass where the temptation to agree is strongest, because a rebuild everyone wants to be done with is arriving. What comes back re-enters the same ground verification and lands on exactly one disposition, the way the first answer did; a lighter second look would let the rebuilt gate reach you on a verdict that was never checked, which is the one thing no verdict here is allowed to do. A recheck that lands on `genuine` presents the rebuilt gate; one that lands on `collapse` relays the option it settles on together with the ground it settles on, the same pair the first answer owes. Any other landing — the advisor returning `malformed` again, any indeterminate disposition, or an answer that never arrives — ends the cycle here: surface the diagnosis and both attempts, and do not present a third unverified gate. Recursion here manufactures confidence rather than earning it.
6. **Provenance stays separable.** The original gate, the advisor's response, the precommit, the verification result, and the synthesized gate remain distinguishable from one another at every point. Merging them into one narrative destroys the only record that shows how the conclusion was reached.

## Presentation

**Three vantage points are always shown** at the moment a cycle hands something over. They never fold, whatever the landing — and where a landing leaves one of them empty, the emptiness is what gets shown, because an omitted vantage point and an empty one read identically once they are both absent. A first-pass `malformed` hands nothing over yet: it moves to the rebuild, and the three appear at whatever the rebuild lands on:

- the advisor's axis reading, in its own terms; on `failed` there is none, and saying that plainly is the reading
- the resulting option set — the settled option on `collapse`, the rebuilt set when a `malformed` cycle's recheck came back clean, the original set on `failed` and on a first-pass `genuine`, the original set beside the repair space on `unmapped` until a repair settles and beside the rebuilt set once one has, and on any other indeterminate disposition the original set beside the advisor's contested reading of it. What decides this is what the cycle produced, not which verdict word last appeared in it: a recheck landing on `genuine` presents the rebuilt set, because presenting the original there would resurface the very set just found to stand on the wrong axis. Where a rebuild was attempted and did not come back clean — a second `malformed`, an indeterminate landing, an answer that never arrived — neither set is presented as the answer: both are shown, the original labeled with what the first pass actually found — a wrong axis where the rebuild came from `malformed`, the members that could not be cleared where it came from `unmapped` — and the rebuilt one as unchecked, and the originating decision is handed back with that pair rather than with a winner
- the axis that set stands on

These are what you read in order to decide, so they belong in front of you at the moment of deciding.

**The ground-by-ground detail folds to one line, except the grounds a landing promised per member.** Where the disposition undertook to show the ground for each member that did not clear, those grounds are the landing rather than its supporting detail, and folding them would fold the thing itself. What folds is the detail behind grounds that held, together with what the precommit comparison showed — stating that the answer reached what was expected, on the terms set before it arrived, is what makes the converged case distinguishable from an unasked question. The full detail stays available and is produced on request. It folds because it is what you read to decide whether to *trust* the conclusion, not to reach it — a later and rarer need, and one that keeps its own place.

Three things never fold, even inside the summary line:

- **whatever routed the disposition**, with which options it bears on — that is what says whether seeing it once is seeing all of it, or whether the options it belongs to should have been carrying it. This is where that is worked out and said; the landings do not each carry their own. Then what it turned on — the ground that failed and how, the entailment that would not carry, the premise that was a reading rather than a fact, the named source the answer never reached, the anchor that moved. Hiding the router hides the reasoning, and each Phase 3 row names its own
- **the falsifier's status** — whether it could have defeated the reading, and whether it is present, both always stated, because an absence that is a result and an absence that was vacuous read the same otherwise
- **what became of each original option, whenever a rebuilt set is what you are being handed** — retained, collapsed, removed as off-axis, reframed — each with the ground named for it. A rebuilt gate is the same question only if that mapping is visible; without it, a rebuild and a different gate wearing the original's name are indistinguishable from where you sit

Folding the detail while dropping any of them would not be compression; it would be concealment wearing compression's shape.

**The advisor's full text is referenced, not inlined** — its path is given so it can be read directly. Inlining it would push the three vantage points below the fold, which inverts exactly the ordering above.

## Advisor Interface

The adjudicator runs as a background call and is collected on its completion notification — not polled, not slept on. This is what makes the Phase 1 ordering affordable: the precommit is written during a window that already exists.

**What the default adapter does.** With `codex` as the advisor, the call is a background `codex exec` run ephemerally and in read-only mode against this repository — ephemeral because a run that persists its own session leaves a copy of the exchange outside the records this skill tracks, and a lifecycle that governs only the copies it knows about governs nothing, its prompt read from the per-invocation dispatch file and its event stream written to a per-invocation answer file. The final adjudicator message is taken from that stream — the last one, since a high-reasoning run emits progress messages ahead of its answer — and forwarded whole. An empty extraction means the run died before answering rather than answered emptily, and it lands in `failed` along with whatever the run's error output says. The bounding is what gives `failed` its timeout arm a producer: the background call carries an explicit time budget, and exceeding it is the timeout the Error Handling table disposes of. Another advisor satisfying the interface substitutes its own launch, collection, and bound; what it cannot substitute is having them, because a call with no bound cannot time out and a landing nothing produces cannot fire.

- Write the dispatch to a per-invocation unique path; a shared path lets parallel runs overwrite each other and leaves an answer that reads complete but belongs to a different question.
- Ask for the final message to be written to its own per-invocation path, and read that file — a run summary discards the reasoning, which for an adjudication is the entire deliverable.
- Carry the substrate as pointers under a working-directory argument; the advisor re-derives what it needs with its own tools. Copy in only what leaves no trace on disk.
- Read-only access is sufficient: an adjudication reads and answers.
- Forward the collected text verbatim. Regex-extracting it into fields loses the reasoning that the verification phase is about to check.

**Record lifecycle.** Every per-invocation record a cycle writes — the dispatch, the answer, and each precommit, of which a cycle may write up to three — uses a collision-safe path and lives for the remainder of the session. Naming them by kind rather than by list is deliberate: a list here would have to be found and extended every time a cycle learned to write something new, and would be behind by exactly one. Removing them is what the observer does on its way out — on its way out however it goes, a session simply ending being the ordinary way and the one the skill cannot itself guarantee, since nothing it ships runs after the session that was running it, since records outliving every session that never happened to be disarmed explicitly is the accumulation this clause exists to prevent: disarming stops new gates entering at once, then the observer waits out whatever cycle was already in flight and sweeps the records last, its own included. Not an instant but a short closing sequence, because a cycle still running writes its records after the word to disarm is given, and a sweep that fired at that word would miss exactly them. That is the step, and without one "cleaned up eventually" is a wish rather than a lifecycle, leaving per-invocation records to accumulate past every session that ever ran one. Cleanup never runs in the same turn the path was surfaced — a referenced path that is already gone is worse than no reference, because it reads as available.

## Session Observer

Invoking the skill arms it for the rest of the session. Two levels run independently:

- **The observer stays armed until you stop it.** Saying so disarms it: later gates stop entering the screen, and the records from this session's cycles are removed. A cycle already in flight is not one of the things that stops — its dispatch is out, and abandoning it would throw away an answer that is coming while leaving behind the records of a cycle that now reaches no disposition. It runs to its landing like any other and its records go with the rest, which is the same commitment that keeps a failed cycle from suspending its gate. Nothing else about the session changes. Nothing else disarms it — not a failed cycle, not an indeterminate one — because the whole point of arming is that it does not lapse quietly. Until then, every later drafted gate enters the screen without re-invocation. Entering is not optional — the screen is where a gate leaves, by whichever of its conditions caught it, and it leaves reported. "Candidate for checking" left the choice with the side whose gates are being checked, which is the discretion this skill exists to remove; a gate that goes unchecked because nobody looked is indistinguishable afterwards from one nobody needed to.
- **Each cycle converges or fails explicitly.** Every cycle that reaches the table ends in exactly one disposition — no-target and screened invocations end before it and never became cycles, and the two landings that continue (a first-pass `malformed`, a first-pass `unmapped`) end in the disposition their rebuild reaches, not in two. A failed or indeterminate cycle disarms nothing and suspends nothing.

Keeping these separate is what prevents one unavailable advisor from leaving every subsequent gate hanging: the cycle fails, the gate fires unchecked and labeled, and the observer remains armed for the next one.

## Error Handling

| Condition | Action |
|---|---|
| Advisor unavailable in the current environment | Surface what is missing and what would make it available; present the gate unchecked rather than substituting a self-check under the same name |
| Advisor times out | Report the timeout; disposition is `failed`; the gate fires unchecked and labeled |
| Answer arrives but cites nothing | Treat as `indeterminate (uncitable)` — an ungrounded verdict is not a checked verdict |
| Substrate moved between anchor and verification | Re-anchor and run once more; do not reconcile across two states. Movement after that one re-anchor is `indeterminate (anchor)` |
| The gate turns out to be excluded after dispatch | Discard the verdict; the cycle lands in `failed` with the exclusion as what went wrong, and the gate leaves the way that condition leaves |

## Rules

1. **The advisor's verdict is an input, never a ruling.** It enters the record as one reasoner's grounded reading and is checked before it reaches you. Whatever a verdict asserts beyond the axis, the answer names it and the ground it rests on — the option a `collapse` reduces to, the axis a `malformed` relocates onto — because naming them is what those verdicts assert. Supplying any of it afterwards would return the choice to the side under judgment, and a target arriving without its ground is a conclusion the verification has nothing to check. Adopting any of it unchecked would replace one unaudited judgment with another and lose the independence the exchange was for.
2. **Launch before precommit, and never read partial output first.** The ordering is the mechanism. A judgment recorded after the answer is visible cannot be distinguished from the answer, and the whole question the precommit answers — did this converge or follow — becomes unanswerable.
3. **The precommit records expected controlling sources and verification criteria, not a preferred option — and the verification reads it back.** A recorded preference turns the later comparison into an agreement check, which is what the ordering exists to avoid. A precommit nothing later reads is paperwork impersonating a safeguard, and one only half-read binds only half: the check that reads it asks both whether the answer turned on the sources it named and whether the grounds meet the criteria it set, applied as written rather than as they look once the answer is in. A named source left untouched or a criterion gone unmet routes the cycle to an indeterminate audit, and what the comparison showed is stated when the result is presented.
4. **The audit vertex checks grounds, not options.** The side that drafted the options has no independent opinion about them. Its independent contribution is whether the advisor represented and applied the evidence correctly.
5. **Silence, error, and timeout resolve as failure — never as agreement.** No absent answer produces a folded conclusion.
4a. **Whatever set reaches you was adjudicated as the set that reaches you.** A set checked and then changed on the way — filtered, rebuilt, substituted, or fallen back to when something else failed — is a different set, and the check does not travel with it. So each hand-over names which adjudication covers what is now in front of you, or says plainly that none does. Those are two arms of one rule, not a rule and an exception: what it forbids is a set arriving as checked when it is not, never a set arriving at all. A gate whose set the check disqualified still fires, carrying the disqualification — withholding it would trade a visible defect for an invisible one, since a decision that stalls because a check could not close is a decision the check has silently made. This is where an unchecked set most easily passes as a checked one: not by skipping the check, but by being altered after it, while the earlier verdict keeps its wording. The three verdicts, every indeterminate landing, and every fallback are all hand-overs and all answer to this.

4b. **A disqualification reaches the options, not just the page above them.** The finding itself — the answer kind the set has no option for, the members that could not be cleared, the adjudication that no longer covers it — is analysis, and analysis goes before the gate like all of it. What must reach the options is what the finding *does to each one*: every option states what choosing it means now that the finding holds. That is the option's differential implication, which is what belongs in a gate. A disqualification stated only above the options is read after the choice as often as before it, and a finding read afterwards did not reach the decision it was for.

What that comes to is set by which options the finding actually bears on. It reaches exactly those and says so: where it bears on all of them alike, saying it once is already saying it of each, and repeating it per option pads the presentation without adding anything to see; where it bears on some, it reaches those and not the rest, because stated once above a list it leaves you to work out which — the step the presentation exists to have already taken. Its incidence is stated either way. A finding that falls on everything and one that fell on something and was never carried there look the same from outside.

Stating the consequence per option is also the whole of what is owed here. Whether the finding leaves a live choice — whether two options still lead anywhere different once it holds — turns on what you are doing and what you asked for, which the specification is not in a position to know and does not decide. So no landing is added for a choice that has gone flat, and none is withheld on the suspicion that one has: the options come with what the finding does to each, and you are the one who sees whether anything still separates them. If nothing does, saying so in the moment settles it more accurately than a rule written in advance could.
5a. **An answer that could not land unfolds as a repair space, never as a declaration that something is uncertain.** Naming the doubt without naming what could be done about it, and what each of those would change about the set you would answer, hands back the harder half — you would have to reconstruct the repairs yourself, which is exactly the recall this presentation exists to spare you. The three verdicts sort the option set; this landing reports that the sorting did not close, and it earns its place only by arriving full.
6. **The three vantage points always show; only the ground-by-ground detail folds.** Where a disposition leaves a vantage point empty, the emptiness is shown rather than the point dropped — an omitted vantage point and an empty one are indistinguishable once both are absent. What never folds is listed once, where the presentation is described; this rule does not keep a second copy of that list, because the copy is what goes stale when the list grows. Detail that decides the disposition is not detail.
7. **Excluded gates fire on their own terms.** Whatever the screen catches is outside the check, and no verdict changes that — the screen's own list is where those conditions live, and restating them here would be a second copy to drift. A relay on an irreversible decision would remove the confirmation its irreversibility requires.
8. **The option set is frozen before dispatch, and rewording restarts the cycle.** A verdict adjudicates the text it was given; silently editing the options afterwards makes the verdict about something that no longer exists.
9. **The dispatch carries the gate's question, the frozen set, settled constraints, and pointers — nothing else.** Not the preferred option, not the drafting rationale, not prior dispositions. The question is what the options answer and the rationale is why they were drafted; the first is what the adjudication needs to judge their fit, the second is what would tell it the answer. Stating a settled constraint is conveyance; appending what to conclude from it is not.
10. **Synthesis preserves the answer kind, accounts for every original option, and adds nothing unsupported.** Making a generic option concrete while keeping the answer kind is a sharpening; needing a new answer kind is a different gate and routes back to where the original was constructed. An addition tracing to no ground the licensing repair stands on, a removal naming neither a ground nor a disposition, and a swap that quietly puts one option where another stood are the three ways a rebuilt gate stops being the same question — each is a defect, not a shortcut. A grounded addition and a removal recorded as off-axis are neither: what makes a change legal here is the ground that licenses it and the record that it happened, never the direction of the change. One thing no ground licenses — removing an option from a set whose alternatives were fixed where the gate was defined. There a record is not enough, because what goes missing is an answer the user was able to give; that removal routes back to the definition rather than happening in a rebuild.
11. **Every repetition is bounded at one, each on its own account, and the repeat is a full pass.** The bound attaches to each thing that can repeat rather than to a shared pool, because they answer different questions at different moments and a single budget across them would let whichever fired first silently spend the others. The replacement's answer re-enters ground verification and lands on exactly one disposition, as the first answer did — the rebuilt gate presented on a checked `genuine`, a relay on a checked `collapse`. Every other landing ends the cycle with a surfaced diagnosis and both attempts. A substrate that moved is re-anchored once on the same terms, and movement after that lands on `indeterminate (anchor)`. A third attempt at any of them would be confidence manufactured by repetition.
12. **Provenance stays separable to the end.** Original gate, advisor answer, precommit, verification result, synthesized gate — five distinct records. Merged into one account, nothing afterwards can show how the conclusion was reached, which is the only thing that distinguishes a checked gate from a confident one.
13. **Context and question stay separate.** All analysis, evidence, and verification output are text before the gate; the gate carries only the question and each option's differential implication. Where the verification disqualified the set, that implication is what the disqualification does to each option — the finding stays above, its consequence per option travels down.
14. **Plain everyday language in everything you read.** The verdict names, the axis reading, and the options are written to be recognized at a glance, not decoded.