# Panel review and Review This file says how a panel, `architect` or arena runs, and how a panel reviews a diff. The pstack block in `AGENTS.md` points here. The `sync-pstack` skill renders this file from its shared source in `udecode/dotai`, so change it there. - **Panel review.** A plan goes on to its build, as the Autopilot rule says. The lead writes a plan whose panel runs and runs that panel before its first behavior edit; an owner's go on a proposal made in conversation approves the direction, never a skip of that plan or its panel. A diff whose panel runs gets it after the writing passes and before land.mjs lands it. The lead writes the filled prompt once to a file in the run directory, and every seat reads that file. The prompt names run-directory files by their absolute paths in the main checkout, because the run directory is ignored and a seat's worktree holds no copy. A seat reads every path the prompt names, the decision log included, and every repository its probes can scan. The lead runs probes and new tests in a separate copy. Until every reviewing subagent has answered or failed, comment-sicko included, the lead edits none of the files that subagent reads; it queues new decision rows in the run directory until then, logs any slip as a row, and then synthesizes once. The intent quotes the user's typed asks verbatim and names the invariants to attack, never the author's conclusion that they hold. Every brief, an `architect` or arena brief included, tags each invariant and outcome by its source: the user's typed ask, a cited law line or the lead's own conclusion. It lists the lead's own conclusions as premises for the seats to attack. It lists each outcome the user's typed ask states and each property it gives a mechanism it asks the run to change or settle, with that mechanism, as an `[ask]` invariant in the ask's own words, and a later round's brief never narrows one. A later round's brief also lists each earlier critical finding the lead dismissed, recorded or left `open`, with the lead's reason, as a premise to attack. Interrogate ranks no findings, so the brief defines the severities and asks each seat to tag each finding with one: `critical` for a defect that would cause bugs, data loss, a security hole or fundamentally broken behavior, such as a check or test that passes when it should fail; `warning` for a design concern, maintainability risk or correctness issue that breaks nothing yet but will cause pain; and `nit` for style, naming or a minor improvement. For a review-only panel, on work this run does not change such as another person's PR, the lead returns the findings in the reply and keeps no plan, page or decision log, whatever Plans and trails or Plan pages would otherwise ask. Each round logs decision-log rows under phase `panel`. Once every seat has answered or been skipped, or the owner has said to go on without a seat that failed, the round opens with one row whose decision is `seats` followed by each seat as ` @`, copied from the `seat:` line `seats.mjs` printed for it, with `missing` after a seat that failed and `skipped` after a seat that `seats.mjs` reports skipped. Its evidence names the reviewed tree as a commit or a saved patch, and every before-fix reproduction for that round runs on that tree. Each critical finding then gets its own row whose decision opens `critical [, ...]:`. The brackets name each seat that raised the issue at any severity, as the round's `seats` row names it or by the part after the last hyphen of exactly one model in that row, such as `sol` for `gpt-6.2-sol`, or `lead` when only the lead raised it, so `scorecard.mjs` can count what each seat caught. The brackets never name a seat the `seats` row marks `missing` or `skipped`. The row's result starts with `applied`, `dismissed`, `recorded` or `open` and gives the lead's reason. The round's warnings and nits share one row whose decision starts with `warning` and lists each one with the seats that raised it and its outcome, each deferred one with its `owner:` and `stop:`; its result starts with `applied` when any was applied, otherwise `deferred` when any was deferred, otherwise `dismissed`. Before it logs a confirmed finding, the lead matches it against the rule-only rows of the rules table that `/pstack:correct` keeps. A match is a repeat of that rule, so the lead adds a todo to run `/pstack:correct` on its class before the close. A `dismissed` result that cites a mechanism names where that mechanism stops the seat's case, traced hop by hop with file and line from the caller the seat names. A critical finding's dismissal also names a mutation that removes exactly that mechanism, and the test, or the logged runtime run where no test can reach it, that then fails on the seat's case; a warning's or nit's dismissal needs that mutation only when the trace does not reach the seat's case. A critical finding dismissed because the seat's case did not reproduce counts only once the same probe fails with the seat's mechanism planted, because a probe that cannot see the defect also reports no reproduction, and its row cites that failing run. The lead appends a finding's row only after the work its result claims has run: for `applied`, its fix and its reproduction; for `dismissed`, the proof above; for `open`, what the rule that leaves it open asks for first, such as the seat's case on the base and the edits that state each limit, or a pivot's evidence lanes, so a pivot's row comes before its design pass. It appends a summary row only once each finding it lists is settled, and an `applied` result names the test or path that applies it; until then the finding waits in the todo list. The lead weighs each finding against the user's ask and applies only what the ask needs, because every fix is new unreviewed code; a critical finding follows the apply-or-open rule below instead. It weighs a critical finding by how often real use reaches it and by its worst outcome, so a rare path with a recoverable outcome may be dismissed with that reason, and a miss on a common flow may not. Before dismissing a critical finding as rare, the lead runs the seat's exact case through the real code on the repository's fixtures, and cites a count of the finding's trigger condition from the most real data the project lets the run read without a stop, naming that environment, the count and when the query ran. A count from fixture-only data supports a rare call only as inferred, and a critical finding whose rarity rests only on an inferred count is not dismissed as rare. The rule grants no new access. After any change the run makes to the same limit or configuration, the lead runs that query again, and a higher count reopens the dismissal. A critical finding about a wrong value written into a clinical, legal or financial record, one the project's own product keeps rather than one an app built on a library might hold, is never dismissed or narrowed on a reviewer's check of text that the same faulty step produced, and it counts as fixed only when the seat's named consumer and harm reproduce as gone. A warning or nit outside the ask is `deferred` with its `owner:`, and a critical finding is applied, dismissed, recorded or `open`, never deferred. The lead dismisses a critical finding only on the proof above that its case is no defect or is rare, never because it lies outside the ask or predates the run. A no-defect dismissal may, in place of the trace and mutation, quote a law line that requires the seat's case to behave as it does. That line is older than the run or one the verbatim ask has the run write, and the dismissal shows that the case meets every outcome the user's typed ask states. A line that only permits the behavior never excuses a case that worked on the run's base and fails after its change. The user's typed ask includes, verbatim, the task text of the card or brief that started the session. A finding's age says who caused it, not whether the ask needs it fixed. The lead applies a critical finding, or pivots the run to it as the Autopilot rule says, unless the reach rule below records it or all three of these hold. First, the seat's own case, with its values, path and consumer, fails the same way on the run's base commit, the commit the run started from. Neither this run's change nor its plan causes it, worsens it or increases exposure to it, such as through a new flow, a default, a frequency or more traffic. A case that cannot run on the base because it needs a flow the run adds fails this condition, and a nearby case the base can run never stands in for it. Second, it breaks no outcome the user's typed ask states and no property the ask gives a mechanism it asks the run to build, change, fix or settle, even one phrased as how that mechanism works today; a file or function the ask names only to point at the work states neither. Third, it shows no requirement of this run's own design unmet in the Autopilot rule's sense, such as a budget the plan froze or a cost of the adopted design that only a new owner or stored shape removes, whether or not the plan lists it; a law line, doc sentence or claim the finding makes false is a line it limits, not such a requirement. The lead judges this against the verbatim ask, never against a brief's tags or paraphrase. A pivot writes a new plan iteration with its own decision log, whose rounds count from zero. Before a pivot's design pass, `architect` or under "fast" the lead's own, the lead runs evidence lanes on the finding's own case, the example a user would meet, never on the plan's wider question. A mechanism a panel sends back to planning gets the same lanes, because it starts a new plan as a pivot does. A source lane reads what other projects that ship the same behavior do with that case, in their source at a named revision, and runs as the Extraction rule says. A product lane tries the case in each product that ships the behavior and records what the product did and the date it ran. The lead or a helper with a browser runs it, using only a sign-in that browser already holds, so a lane never signs in or asks for a credential. A runtime with no browser, such as a Codex seat or a Codex lead, writes "not run" with that reason, and so does a lane on a product that needs a sign-in the browser lacks. For each product a lane could not try because the browser lacked a sign-in, the lead adds one Needs you line that names the product and asks the owner to sign that browser in, and the run keeps going. The line asks for access, never for the owner to try the case. Under "fast" the lead runs every lane itself. A lane writes "not found" when nothing ships the case, and that is evidence for leaving the case a limit, never a reason to skip the design pass. The lead saves the lanes' report in the run directory. Then, before the design pass starts, the lead logs the finding in the old log as `open` with `patch:` the new plan's path, `owner:` the owner, `stop:` its build, `proof: none` and `prior-art:` the report's path. When a built step's review raised the finding, the lead then saves that step as a patch in the run directory, reverts it and logs a `delivery` row `step dropped` with `proof:` that patch, so the old plan's steps that do not depend on the finding keep landing from the old log until the new plan is written. The new plan lists each old step it keeps, the saved patch under a new step number when it comes back, and once it is written the old plan builds nothing more. The design pass gets the report with the finding, and the new plan says what the report found for that case. The new log's first row after its `lead` row cites the old log's row, and the new plan's first brief lists the old log's dismissed and `open` critical findings as a later round's would. `decisions-check.mjs append` refuses an `open` row whose `patch:` names a new plan in the plans directory that the run's logs have not named yet, unless the row names `prior-art:` with an existing file under `docs/plans/artifacts/`. The lead makes the first pivot or return to planning since the run's last landing on its own. Before a second one with nothing landed since, the run stops for the owner, as the Second plan rule in `.agents/pstack/rules/long-runs.md` says, and the owner's answer there may leave `open` a finding the lead would otherwise have to apply. A critical finding for which all three hold stays `open`. Before the first diff round, the lead reruns its case on the built tree, and one that now fails a condition follows the apply rule. Its result gives `patch: none`, `owner:`, `stop:` and each line it limits, and its evidence gives `proof: none` and cites the base run. A design that leaves two critical findings open may need a redesign. So from a log's second open critical finding on, each open critical row also names `task:` in its result. A pivot's rows count too, because a run that pivots again and again owes the owner that question as well. A plan's next iteration starts the count again in its own log. That task is an offered or started `kind: decide` task in the ledger that asks whether the design those findings live in, the code the base run fails on, needs a redesign, and its finding, or one folded or merged into it, cites the plan's file name. Before it logs the row, the lead offers that task, with `via: panel` when it ranks P2 or P3, or folds the finding into the topic's open design question. `decisions-check.mjs append` refuses the row without it. In the log of a plan whose project playbook turns on its `redesign-runs` check, a row whose decision starts with `redesign run:` lifts that task, because the verdict that row records already answered that question. That playbook says when the lead writes the row, and `decisions-check.mjs append` takes it only in phase `owner`, or in phase `verdict` with evidence that names the verdict's page or an earlier log. No landing gate runs that check again, so a row written without `append`, in the log or in the ledger, skips it. The lines it limits are each law line, doc sentence or claim the finding makes false. The lead finds them by searching the project's law files, its docs and this run's text for the finding's predicate and its paraphrases. In the same change, each of them states that limit, and each in a law file or plan also names the owner; a public docs page states the limit only. The task or tracked item that owns the fix names each line to restore once the fix lands. A line in a file this run cannot change goes under the page's Open work with its file, owner and stop. The finding's Defaults row states what the fix would cost in this run and names the word that pivots the run into it. Once the run has closed, that word starts the task or tracked item that owns the fix instead. The lead rates it `look`, and `answer` once a later round or the decision-trail review raises a finding on the same mechanism and case again, in any wording, because the lead's reading of the ask is then disputed, which leaves the call no clear pick. The pick stays `open`, the more reversible option, since the limit is stated and the word still pivots the run. Only a finding that meets all three conditions gets this row and its `open` pick, however often it is raised. A dismissed critical finding raised again that way, whose dismissal the lead keeps on its proof, gets the same row rated `answer`, with the dismissal as its pick. The lead triages each critical finding by reach. It fixes the finding before the step under review lands when the seat's case reaches users, through a public export, a default, a docs page, a flag on by default or a shared path users already reach, when the case fails something that passed on the run's base commit, or when it writes a wrong value into a clinical, legal or financial record. It pivots the run, as the Autopilot rule says, when the adopted design or its stored shape cannot meet the case. A case that fails the same way on the base follows the `open` rule above. A case the step's own proof runs is fixed in that step, because the step lands only once its proof passes. The lead records any other critical finding, and never withdraws an export, a default or a doc to make one recordable. It saves the seat's case as a file in the run directory, logs the finding `recorded` with `proof:` that file in its evidence and `step:` the plan step that fixes it in its result, and adds that step, with the saved case as its proof that fails before its fix and passes after, before the first step that lets users reach the code the finding is in; when that step, or one planned before it, has a proof that runs the case, the earliest such step fixes it instead and the row's `step:` names it. The step under review then lands. The `built:` row of that first step holds `reach:` and what it opens. `decisions-check.mjs append` refuses each such `build` row while a counted recorded finding, logged in any phase, has no later `panel` or `build` row whose evidence names the same `proof:` file and whose result starts with applied, dismissed, fixed or verified. The helper reads the row's step from the word after `built: step`, and a finding's steps from the word after each `step:` label in its result, in any letter case for both, where a label does not follow a letter, a digit or `_`. Words split at spaces and commas. A step id is one to nine digits followed by at most one ASCII letter, in either letter case, once any trailing `.`, `,`, `:`, `)`, `]`, `}`, quote, backtick or `*` is cut. The helper counts a recorded finding when one of its steps is the row's step or an earlier one. It orders step ids by number and then by letter, so `1a` comes before `1b`, `2` and `10`, and when the numbers match and either id has no letter, the finding counts. A finding that a later step fixes lives in code this row does not open, as the placement rule above requires of its `step:`, so it does not count. The helper still counts a finding that names no `step:`. It also counts one when the row's decision has no `built: step`, when the word after it or after one of the finding's labels is not a step id, or when another word that starts with a digit, past any symbols, follows that word before the next `;`, and on the row before `reach:`, or on the finding before its next label. So a row that builds several steps, such as `built: step 6 and 7`, or that names a count or a dated path before its first `;`, counts every recorded finding, and its refusal says so. Only `append` runs this check, so a whole-log check skips it. A recorded finding does not count toward the design question above, and a seat that raises the same saved case again in a later round adds no row, while a case the saved one does not run is a new finding. The commit body of the step under review names each finding it recorded and the step that fixes it. The plan page counts the rounds and lists each one from these rows. A plan gets one panel round before its build starts, and each step's diff gets one round. A round that applied three or more critical findings, recorded ones not counted, earns one more round on the diff of its fixes, and that round's fixes land without another. A re-review checks only what changed; a change made for another reason gets its own review, as the Review rule says. A project whose `.agents/pstack.json` sets `maxRounds` uses that number in place of one. An agent changes that number only when a person asks for the change in their own words. A new number holds from each log's next `seats` row. Changing the number adds no `another round:` row. A row of the reviews list triggers only the tool and stage it names, so a row that names a panel on the diff does not by itself run `architect` or a panel on the plan; a pstack step's own trigger still runs a panel. `architect` runs its runners from the models sheet's `architect runners` line only for the work the reviews list names, for the design of a pivot the Autopilot rule starts and on the user's word "full". Every other `architect` call, such as Feature's design step or a fix that crosses a function boundary outside Bug fix's focused-fix exception, is pstack's own sketch. The lead sketches two shapes and picks one, and a large or contested design runs an arena. A change the run makes to agent prose alone gets no panel, `architect` or arena, even where a pstack or project playbook step calls for one, unless the owner asks for one or a reviews-list row names agent instructions (owner's word, 2026-10-28). Agent prose is skills, rules, playbooks, `AGENTS.md` and workflow guides, the plans, decision logs and subject files that record a change to them, and what a sync or build writes from them, such as a workflow manifest, `.agents/pstack.json` or a synced copy of a helper. A plan or subject file for product work is not agent prose, so a plan that changes a public API still gets its reviews. A helper gets its review, or the owner's word to skip it, in its source repository, so a sync never reviews its copy again. A review-only panel on someone else's work still runs. A change confined to agent prose and the helpers, checks or hooks agents run, a helper alone included, gets one round on its diff, under the same cap (owner's word, 2026-10-28). A round's fixes are not a build step. `decisions-check.mjs append` refuses a `seats` row past that cap until one of two restarts. One is a `build` row whose decision starts with `built:` and names the files a plan's build or a new step changed, with a result that starts with applied, fixed, partial, proven, recorded or verified. A `built:` row whose `step ` the log has built before records that step's fixes and restarts nothing. The other is an `owner` row whose decision starts with `another round:` and quotes the owner asking for one. The helper checks only those prefixes, the step number and that result word. A log from before the cap whose completed build has no `built:` row adds one naming that build before its next round. Before it launches seats, the lead runs `decisions-check.mjs rounds `, which exits 1 at the cap; before a diff round it adds `--patch ` with the step's diff, which also exits 1 when that diff changes more product lines than the step budget, 400 unless `stepBudget.lines` in `.agents/pstack.json` says otherwise, not counting tests, specs, fixtures, Markdown, the plans directory, the paths each `generated` entry rebuilds or `stepBudget.exclude` globs. Over the budget, the lead splits the step into lettered steps that land one by one, each with its own diff round, unless an `owner` row whose decision starts `big step:` quotes the owner, which lifts the budget for that one round. The budget also holds while the step is built. A checkout builds a plan step when its change, in either half of a companion pair, touches a dated plan or its decision log. In such a checkout, `guard.mjs` refuses a Claude Code edit of a file the budget counts once the public half's changes pass the budget. It counts tracked and untracked changes since the merge base nearest `HEAD` among the branch and the protected branch on `upstream` or `origin`. `decisions-check.mjs append` then also refuses a `build` row to a log in that checkout. Neither check runs in a checkout with no such branch, or when git fails. A `big step:` owner row in a changed decision log lifts both checks until that log's next `landed as` row. The guard also passes an edit of a file the public half's git ignores, because the budget counts none of them. So the lead splits the step when the guard first refuses, not after its build. At the cap the lead never hands back. It stops reviewing, settles each open finding as applied, dismissed on the proof above, deferred with its owner when it is not critical, or open with its `patch:`, `owner:`, `stop:` and `proof: none` when the rule above lets it stay open, or recorded as the reach rule says, and states each remaining limit on the page. A critical finding the lead must apply, as above, is applied before the next gate or pivots the run; naming an unapplied patch does not settle it. A plan then builds, so later rounds read code that runs, and a diff moves on to its next gate; a plan-only or read-only request, or the owner's "stop at plan" or "hold", ends with the published page instead. Before a lessons panel, the lessons' edits get their own `built:` row naming the files they changed. When a seat names the producer of a bad case, the first fix changes that producer instead of adding a guard where the case is read. When a critical finding lands in code that a second fix on the same mechanism added in this plan iteration, the lead stops patching that mechanism. It writes down the premise both fixes share, tests it directly as `pstack:principle-attack-the-premise` says, logs the test as a row, and pivots the run when the premise fails. A claim about a wrong value in a clinical, legal or financial record is never narrowed, and its mechanism always goes back to planning. A critical finding about real data counts as fixed only after the lead reruns the seat's own probe on that data; a mutation run on the lead's own fixtures is weaker proof, and a fix that rests only on one is logged `partial`. Before shipping, the lead reruns every seat probe the last round's fixes touch. A revert or a removal that resolves a critical finding counts as applying its fix. A plan the panel reviewed goes on to its build as a `look` default whose word is "hold". A panel whose models sheet names seats of one model family runs on them, and the page labels it same-family. The lead that changes a panel seat's model or effort, wherever it is set, such as a models sheet, `/setup-pstack` or a project rule like an effort override, runs `node .agents/pstack/replay.mjs --dir ` once, before any panel round runs on the new seat. It passes one `--seat` entry for each seat of the new panel and one for each replaced seat at its old model or effort, each naming its effort. The lead puts the replay's table on the page or in the reply. A case the new seat misses and the replaced seat caught is a `look` call, with a Defaults row that names the word reversing the change. When fewer than six cases come from fixes' `Introduced-by:` lines, the lead adds `--case` pairs it traced with `git log -L` or `git bisect`. `git blame` only names a suspect, which counts once the lead has read that commit's diff and the fix. Replay takes the mined cases first and fills the rest from `--case` pairs. When replay reports cases left past its limit, the lead offers the larger run as a suggested task, as the Time budget rule says. Apart from the two exceptions below, a seat or runner that cannot run on the model the models sheet names for it stops the run as blocked, whatever the cause, such as a usage limit, even one whose error names a reset time, or a lapsed subscription. The lead never replaces it with another model, the session's included (owner's word, 2026-10-18). The lead runs no separate check of a seat before its round. A seat cannot run when its run fails again after one rerun on that model; an `opus` seat may rerun as an `Agent` call on the same model and effort. The stop goes under Needs you with the seat's error and three options: fix the account, such as by renewing the plan or running `codex login`, run `/setup-pstack` to put another model in its place in the sheet, or go on without the seat. The run resumes on the owner's word after any of them. When the fix is the user's, it never goes under other owners' work. While the run waits on that stop, the lead starts no other work, as the Autopilot rule says of a stop the run has reached, and that includes checking the answered seats' findings. It logs no `seats` row for the round, applies none of its findings and edits none of the files its seats read, other than the plan's `Status:` line and the Open questions entry that record the stop. The round opens once the seat answers after the owner's word, or with the seat marked `missing` when the owner says to go on without it. There are two exceptions, which `seats.mjs` reports as skipped. One is a seat or runner whose provider refuses its prompt, which `cross.mjs` prints as `refused: security` from Codex or `refused: safety` from agy. The other is an agy seat or runner that fails for any reason, such as a usage limit (owner's word, 2026-11-20). The lead skips such a seat for the round: it gets no rerun, no reworded prompt and no other model, the run does not stop, and the round counts with the seats that answered (owner's word, 2026-11-19). The next round seats it again with the brief every seat gets. When the seats that answered a round share one model family, after this skip or after the owner went on without a seat, the round is same-family: the `seats` row's why cell says so, and the page shows the seat that did not answer as skipped or missing. Agreement counts once per model family among the seats or runners that raised a point, and the lead verifies each critical finding whatever that count. A pick that only one family's seats or runners reached, such as a code arena's winner or the fix for a finding only that family raised in a same-family panel, goes to the next panel with a seat of another family as an invariant to attack. A review-only panel has no rounds and logs no rows, so the apply, open, limit, pivot, round, row and page rules above do not apply to it. A project playbook that names `pstack:interrogate`, `pstack:arena` or `pstack:architect` cites the row it serves as `(reviews: )` on the same line. To change the list, the user says so in plain words, such as "from now on best-api design runs architect", and the `sync-pstack` skill edits `reviews` in `.agents/pstack.json`, renders the pstack block again and verifies it. A seat named `codex: @` runs `node .agents/pstack/cross.mjs --to codex --reach --model --effort --prompt-file `. It replaces the `Agent` call and the rejected-slug fallback the panel skill would use for that entry. A seat named `agy: @` runs `node .agents/pstack/cross.mjs --to agy --model --effort --prompt-file `. That command runs the Antigravity CLI on the model `-`, such as `gemini-4-neon-xhigh`, from a scratch folder, so no project hook or rule loads. The seat may read any file and use the web and the owner's MCP servers, as a Codex seat may, unless `seats.mjs` runs with `--offline`. It runs every shell command in agy's sandbox and writes only its scratch folder. It never runs with `--dangerously-skip-permissions`, because that flag approves a command outside the sandbox, which can write the project. `cross.mjs` denies every other action the seat would ask permission for, because an agy print run that asks for a permission ends with no answer. `seats.mjs` reports an agy seat that fails as skipped, one whose prompt Gemini's filters block included, as it does a Codex seat its provider refuses. An `opus` seat runs `node .agents/pstack/cross.mjs --to claude --prompt-file ` in both runtimes, adding `--effort ` when its models-sheet entry names one; without a level it runs at the project's `maxEffort`, or at Claude's default effort when the project sets none. `cross.mjs` runs no seat above `maxEffort`, and prints the model and effort it ran at on a `seat:` line on stderr. The lead starts a round's seats or read-only runners together in one background command, `node .agents/pstack/seats.mjs --dir --prompt-file =:@...`, with `codex` for a `codex:` seat, `agy` for an `agy:` seat and `claude` for an `opus` or `fable` seat, and gives that command no timeout, because no seat has one; `cross.mjs` stops a seat only once it shows no sign of work, as the Time budget rule says. It lets each `opus` seat read the main checkout, which a seat started from a worktree otherwise cannot, and `--read-dir ` adds any other folder the brief cites, such as a transcript's. `seats.mjs` runs each seat as the commands above do, writes each answer to `.md` and each failure and `seat:` line to `.err`, and exits once every seat has answered or failed. One command per seat would wake the session once per seat, and each wake re-reads its whole context. A seat's rerun goes through `seats.mjs` with that seat alone, except that an `opus` seat may rerun as an `Agent` call, as the Panel review rule says. `cross.mjs` runs every seat it starts with hooks off and no write access to the project, so a project hook that stages files cannot write from a seat. With `--reach`, a Codex seat loads the user's Codex config, connectors, web search and network, but not exec rules, and writes only a scratch folder. It can search the web, query `gh` and clone upstream sources to check a claim. Its brief says to read and report, and never to post, comment or change anything outside that folder. The lead uses each answer verbatim, and a seat that `seats.mjs` reports failed reruns once on its model and then stops the run, as the Panel review rule says, and one it reports skipped does neither. `seats.mjs` exits 0 when every seat answered or was skipped and at least one answered. When the skill expects a seat to write a file, such as an arena candidate's artifact, the seat returns the content and the lead writes it to that path. A code `arena` runs its slots on `opus`, because a `cross.mjs` seat cannot write. For the same reason a seat's brief asks only for checks that write nothing outside a Codex or agy seat's scratch folder, and an explicit "not run" for anything else that writes, such as a test suite with temp files; the lead runs those itself and never counts them as the seat's. Since every seat reads one prompt file, the brief says that a Codex or agy seat may write and run repro scripts in its scratch folder and that a Claude seat runs in plan mode and writes nothing. An arena or `architect` cross-judge reads copies of the candidates named `cand-1` to `cand-n`, in which each runner's model name is replaced by its label and nothing else changes, and the lead keeps the name map until scoring is done. - **Review.** These mechanics apply whenever a panel runs on a diff, from the reviews list or the user's word. A row that names a kind of code judges it by what the code gates, not by what the diff touches, and a fix for an unintended write, invite or send counts as that write, invite or send, even when the diff only changes rendering. Review the worktree's diff against `origin/next`, with its uncommitted work, before land.mjs pushes it. Review a PR's branch diff against its base. Package the diff with each caller or entry-point file whose behavior the change can break, such as every wrapper of a changed shared primitive, and rebuild that list each round from what that round's delta can reach. A seat that says something cannot be verified leaves that concern unreviewed; add its files to the package or prove it at runtime before calling it fixed. Verify each critical finding, and the cause it states, against the code or the raw output before logging it, fix the real ones the Panel review rule does not leave `open` or record, rerun each fixed finding's own reproduction, such as the seat's probe or the interleaving that broke a race, so it fails before the fix and passes after, and rerun the review when a round applied a critical fix, as the Panel review rule says. When that reproduction is a test that already runs on the fixed code, the lead reverts the fix alone in a scratch copy and confirms that the test then fails with its assertion's own message. The reproduction keeps the seat's exact values, ordering and affected consumer, with inputs a shortcut fix would not pass by coincidence. A fix that adds a refusal or a guard also runs a must-still-accept case on the nearest legitimate flow before the next round. Each reproduction fails on its own, as its own test or an isolated run, because a grouped test proves only its first failing assertion. When a critical finding names a rule, fix every writer, reader and matcher of that rule together, and when the new code copies rules an existing function already applies, call that function instead. Treat every confirmed finding as one case of its class. Before patching, list each call site of the pattern and each context where its token means something, such as a mode, an escape or a position, and fix them together, except a member no user can reach yet, which the Panel review rule's reach rule records. When the class is a third-party grammar too large to list, narrow the claim to a lossless fallback with a report instead of copying more of the grammar. A type system counts as such a grammar, so a new check that reads types enters its first panel claiming only the forms its tests run. The way JavaScript looks up a property counts too, own or inherited, enumerable or not, through a getter or a proxy trap. A check on an options key therefore moves to a closed option set, or the wrapper passes the caller's object untouched to the one owner that reads the key, with no check of its own. Stop when no critical finding remains or every remaining one is dismissed on the Panel review rule's proof or left `open` or recorded as that rule allows; warnings and nits never block. A design that changes after its last interrogate or review for a reason other than that review's findings, including cuts the user approved, runs `/pstack:interrogate` again before its first behavior edit, or before it ships when it is already built, except a change confined to agent prose and the helpers, checks or hooks agents run, which gets only the panels the Panel review rule gives it; a fix to a round's findings earns another round only as the Panel review rule says. Every round counts toward that rule's cap, and a design that changes at the cap is reviewed in the diff panel after its build. An approval covers only what the user saw.