review-engine-impl
Skill331 starsChanged 4 months agoApache-2.0View on GitHub
Review an implementation in scope, such as an uncommitted diff, a just-finished agent change, a commit, or named files, for missing or wrong behavior in phase.rs. Use when Codex needs a findings-only architecture and correctness review across engine, parser, frontend, multiplayer, AI, deck, build, or release changes.
In this repository33 other files it gives its agents.
- CLAUDE.mdCLAUDE.md
- add-ai-feature-policySkill
- add-card-data-pipelineSkill
- add-engine-effectSkill
- add-engine-variantSkill
- add-frontend-componentSkill
- add-interactive-effectSkill
- add-keywordSkill
- add-replacement-effectSkill
- address-reviewSkill
- add-static-abilitySkill
- add-triggerSkill
- ai-duelSkill
- audit-card-parsingSkill
- batch-mechanicsSkill
- bug-coverage-classifierSkill
- bug-triageSkill
- card-testSkill
- casting-stack-conditionsSkill
- changelogSkill
- engine-implementerSkill
- engine-plannerSkill
- oracle-parserSkill
- parser-velocitySkill
- pr-contribution-handlerSkill
- pr-flow-auditSkill
- project-referenceSkill
- pr-review-loopSkill
- retrain-ai-weightsSkill
- review-engine-planSkill
- ship-commitsSkill
- unlock-setSkill
- validate-cr-annotationsSkill
The file
Show its rules and text
We split this skill into the rules it gives an agent
14 rules. About 0 are common, 7 are distinctive, and 7 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈7
Distinctive · estimate
This author's own choices. Worth a look.
7
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 83
When a claimed outcome fails because of a base defect, report both.
- Distinctive: line 89
Re-reviews: When an earlier maintainer review exists (it is in the feedback you were given), review the complete diff and also:
- Distinctive: line 110
Sibling coverage: If one site in a class changed, name siblings that needed the same treatment and verify they were handled or …
- Very specific: line 121
Serialized-surface contracts: If the diff changes an enum, GameAction, WaitingFor, game-state field, card-data export shape, or serialized …
- Very specific: line 123
Edge cases: Check empty inputs, multi-target/modal/repeat interactions, simultaneous events, eliminated players, im::Vector::truncate(n) …
- Very specific: line 130
Verify every new or moved // CR <rule> by checking docs/MagicCompRules.txt.
- Very specific: line 132
Check reuse of building blocks in parser/oracle_nom/, parser/oracle_util.rs, game/filter.rs, game/quantity.rs, game/ability_utils.rs, …
- Distinctive: line 133
Keep game logic in the engine.
- Very specific: line 140
Verify plural, possessive, opponent, non-X, another, and sibling phrase variants for new parser arms — including article/quantity …
- Very specific: line 142
Prefer composable nom axes over cartesian lists of full tag() strings.
- Very specific: line 148
Check React effect dependencies, unmount cleanup, touch equivalents, mobile scroll containment, and empty/loading/error states.
- Distinctive: line 156
Check reconnect and 3+ player behavior when touched.
- Distinctive: line 172
Use this exact finding shape:
- Distinctive: line 178
When a finding turns on what a card does, its evidence names the printed card and quotes its Oracle text and the CR (real cards).
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Review Implementation
Review for gaps: things that are missing or wrong. Do not spend findings on style nits, CI-enforced formatting, or a diff recap.
Review the change
This applies in every mode. Findings are defects in the change under review: what it introduces, the premises it rests on, and what it states it delivers but does not.
- A defect is pre-existing when it reproduces at the change's base. The change depends on it when a test or acceptance row the change asserts cannot pass, or would have to be weakened, without fixing it. Run that one probe only when the answer changes what happens next.
- A pre-existing defect the change depends on is a finding (
behavior; in charter mode, a decision finding). In PR Review Mode the tiers there replace this rule. - Any other pre-existing defect goes in a separate Pre-existing list after the findings, once, with its evidence. It is untagged, never blocks, and is not repeated in a later round.
- Aim probes at the change's own claims. Do not hunt for pre-existing defects.
Workflow
- Identify the changed surface from the diff, commit, or named files.
- Classify the surface area: engine logic, parser, frontend/UI, multiplayer/transport, AI heuristics, deck/format/feeds, build/CI/release, or docs.
- Apply only the relevant lenses below.
- If the scope is a PR, fetch whatever external review comments exist (CodeRabbit, human reviewers) and confirm-or-refute each against the current head with code evidence, folding confirmed findings into your own. Assume none exist by default — Gemini Code Assist has been sunset, so no bot is guaranteed to have pre-screened this PR. Your own lenses are the complete review, not a supplement to a bot's; do not under-invest expecting a backstop. Where an external finding does exist, silently omitting it — or returning a verdict less severe than an open, unrefuted finding from another reviewer — is itself a defect. Review comments, checks, and uploaded/sticky artifacts count only when their evidence identifies the current PR head SHA; otherwise report the evidence as missing rather than attributing it to the current diff.
- If the scope is a PR touching engine/parser source, the parse-diff sticky comment (marker
<!-- coverage-parse-diff -->) is required evidence: fetch its full body and confront the card-level diff against the PR's claimed scope. Unexplained gained/lost/changed cards are findings (unintended parser blast radius). A Baseline pending body means the diff is unavailable — flag it so the handler brings the branch current to regenerate it; an absent comment despite changed engine source, or a comment/artifact not bound to the current PR head SHA, means CI evidence is missing for the current head. This PR-head requirement does not apply to Engine-Implementer Checkpoint Mode: review the committedBASE_SHA..CANDIDATE_SHAdiff instead. - Report findings, then the Pre-existing list when it has entries. Silence on both means LGTM.
When pr-contribution-handler explicitly requests the manual quality gate, add Quality Gate: PASS|FAIL before findings. PASS requires all three current-PR facts: (1) claimed parse-impact count equals the measured parse-diff count and the normalized card sets are identical, using the full artifact when the sticky comment truncates examples; (2) the change is at an existing authority/right seam and reuses its vocabulary; and (3) a production-pipeline test is demonstrated to fail when the production change is reverted. On PASS, return the applicable existing praise tokens (right-seam, scope-discipline, discriminating-runtime-test, parameterized-not-proliferated) for the ordinary review/enqueue event. Never infer quality from Tier or standing and never create a quality_recommended event.
Skip checks CI already enforces:
scripts/check-parser-combinators.shcargo fmt --checkandcargo clippy --all-targets -- -D warningsscripts/coverage-regression-check.sh --fail-on-engine- TypeScript
pnpm type-checkandpnpm lint
Engine-Implementer Checkpoint Mode
Default review output is findings-only. Exception: when /engine-implementer invokes this skill against a checkpointed candidate, it supplies BASE_SHA, CANDIDATE_SHA, the in-scope paths, the named START_SHA, what the completion checks were and how they came out, the existing maintainer-simulation matrix, and the original task with shared scope/attempt history. Confirm the first round has START_SHA == BASE_SHA and each fix round starts from the prior reviewed candidate.
The maintainer-simulation matrix and production-path coverage map are one table, as defined in executor.md. Review the same rows for both requirements; do not request a duplicate artifact.
In this mode, emit these lines before findings:
Review Head: <CANDIDATE_SHA>
Completion Gate: PASS|DEFERRED|FAIL
Maintainer-Simulation Gate: PASS|FAILReview Head must be the supplied CANDIDATE_SHA, and the reviewed diff must reproduce from exactly BASE_SHA..CANDIDATE_SHA; otherwise report a blocking finding.
Completion Gate follows engine-implementer Step 5, including its verification timing. Emit PASS when all applicable checks passed with valid candidate evidence; DEFERRED when checks due now passed and remaining checks are explicitly scheduled for a later boundary under Step 5; FAIL for an observed failure or evidence missing when due. DEFERRED does not block phase acceptance or code review and is not a claim of completed verification. Check the set against the candidate diff rather than against the plan. Run an additional check only when it answers a concrete unresolved claim and its result is needed now under Step 5; otherwise defer it. A check run against uncommitted edits, or against a different tree, does not count unless Step 5 permits carrying forward unaffected evidence. In all engine-implementer review modes, additional checks must address a concrete unresolved claim within the original task. Follow the orchestrator's task scope and run limits; do not independently construct or repair verification machinery. Return missing evidence to the orchestrator without claiming completion, including when a proposed probe needs redesign before it can run. This does not waive required checks or current-candidate evidence.
Phase Mode (chartered runs)
Activated when the spawn inputs include a phase charter and one phase's deferral allowlist — supplied by /engine-implementer for per-phase reviews (composing with checkpoint mode above) or by /implement-task for per-step reviews. The allowlist scopes this file's lenses and gates as stated here — this section, not the spawn prompt, is the authority:
- Deferred ≠ gap; foreclosure = gap. An item on the phase's deferral list is chartered to a named later phase: do not report it as missing, dropped, or incomplete. DO report any code that forecloses or contradicts a deferred item.
- Lens scoping: the new-field-threading, sibling-coverage, claim-to-test, and serialized-surface lenses evaluate consumers against the charter's phase attribution — a consumer attributed to a later phase is deferred, not silently dropped. The class-vs-single-case lens is satisfied from the charter's class attribution — an infrastructure phase's class coverage lives in the charter and lands with its consumer phase.
- Maintainer-Simulation Gate carve-out: a matrix row whose consuming function or hostile fixture is deferral-listed to a named later phase is recorded
DEFERRED(phase n)and does not FAIL the gate; a row the phase's own code forecloses still FAILs. "FAIL when any row is missing" is otherwise unchanged. - Checkpoint mode's evidence rules still apply, including Step 5's verification deferrals and the
DEFERREDcompletion verdict. Deferring test execution does not require deferring the underlying feature or omitting its tests. The suppliedBASE_SHAis the phase base, and the reviewed span is that phase'sBASE_SHA..CANDIDATE_SHA.
Integration Mode (chartered runs, final review)
Activated when the spawn inputs include a phase charter and the run-span diff with no single-phase allowlist. Scope is exactly:
- Cross-phase seams — files touched by two or more phases, deferral handoff points, and the surfaces the charter's seam notes name.
- Charter completeness — every deferral-list item either landed in its attributed phase or is reported unresolved.
The universal-lens full sweep is NOT re-run over the cumulative diff — each phase's review already ran it phase-scoped, and re-running it over the whole span would recreate the oversized-review non-convergence this machinery exists to eliminate. Chain integrity is NOT this review's job — the orchestrator verifies it mechanically at run-level acceptance. This mode is findings-only.
PR Review Mode
Activated when the scope is a contributor PR. Checkpoint, Phase and Integration modes are unaffected.
Tiers.
introduced:- (a) a defect in code or data the PR adds or changes. It is cleared only by correcting it, removing it, or fencing it in code, with a test proving the fence. Editing the title, body or claims never clears (a).
- (b) an incomplete claim: a case, sibling or outcome the PR claims (title, body, linked issue, reported coverage) that it does not deliver, including because of a base defect. It is cleared by delivering it, or by narrowing the claim everywhere it is made. A claim made by code is narrowed by a fence.
- Both are fixed in this PR at every severity, never as follow-ups. Tag a finding
[maintainer-fixup]when its close is text only (narrowing a title or body claim, or correcting a comment, doc comment, assertion message or CR citation); the lead makes that change instead of the author.
pre-existing: a defect that reproduces at the base and lies outside the claim. List it once under Pre-existing. It never blocks and is never raised again.- When a claimed outcome fails because of a base defect, report both.
Reach. Reach governs findings that report wrong card or rules behaviour. Such a finding blocks only when its witness is a legal game, reached through public game actions, built from printed cards' Oracle text: one card, or several cards named with the player count. A saved game is in reach only when a released writer or this PR's writer produces it from such a game. A witness that splices clauses no printed card carries, that the reviewer cannot reach with named printed cards (for example because a guard or the parser stops them), or that depends on state a player edited by hand, is out of reach. A card the PR claims is always in reach. An out-of-reach item is not a finding and belongs to no tier, as a Pre-existing entry does not: list it once as a Reach note: line naming the nearest printed card. It is non-blocking, never a follow-up, and never raised again. For a form no printed card produces, the note may ask whether the PR's code for it is needed. Reach applies to incomplete claims: a claimed case no printed card reaches is cleared by narrowing the prose claim, and a claim made only by code is a Reach note:. A finding whose only harm is out-of-reach behaviour takes that behaviour's verdict under any category. Security findings, where input crosses a trust boundary (a network peer, the server, or a file from another player), block regardless, as do a false CR claim, a test that does not discriminate the PR's claim, a hard stop and a broken build.
Round 1. Confirm or refute each CodeRabbit item against the head. A confirmed item becomes your own finding. List each refuted item in one line.
Re-reviews. When an earlier maintainer review exists (it is in the feedback you were given), review the complete diff and also:
- Carry findings forward. For every finding in an earlier maintainer review that no later maintainer review has credited as fixed or withdrawn, verify it at this head against its
Closes when:line when it has one. If it remains, re-raise it as your own numbered finding marked(carried from <URL>); if it is fixed, credit it under ✅ Clean. Re-verifying an open finding is not a new finding. An author's reply that a finding is fixed or disputed is a claim to verify, never a disposition. A carried finding that fails Reach is withdrawn under ✅ Clean and listed as aReach note:line. - Late findings. A new finding is late when it is on code the author has not changed since the last reviewed head (you are given that diff). A defect caused by a changed or deleted line is anchored at that change and is not late.
- When a late finding is raised: only when it is must-fix — wrong behaviour you reproduced or derived step by step on any surface the PR touches, a false CR claim, a test that does not discriminate the PR's claim, security, a hard stop, or a broken build. Name the category.
- Late notes: any other late point is a
Late note:line. It is non-blocking and never a follow-up. - Round limit. Once the PR has five earlier maintainer reviews that requested changes (the lead gives you the count), a late finding blocks only when a card or case the PR claims behaves wrongly, or for security, a hard stop, a broken build or a false CR claim. Any other late point is a
Late note:line. Findings on code changed since the last reviewed head are unaffected, as are carried findings that were not late when raised; a carried finding that was raised late takes the round limit's verdict. - Findings that are not late keep the severity calibration and are fixed at every severity.
Scout fact pack
A scout fact pack may accompany the diff. Treat it as unverified leads: check anything you rely on, and look beyond it. A missing fact is not evidence of absence, and the pack never bounds a sweep: the new-field-threading and sibling-coverage greps are yours to run in full.
Universal Lenses
Two gates lead every review; apply them before the rest.
- Correct seam / location: Is the change at the architecturally correct location — the layer/module/function the codebase's design says owns this responsibility — or a symptom-patch at the wrong seam that merely makes a test pass? A wrong-location fix is technical debt even when it works: it ossifies a dead or duplicate path and leaves the real seam (and the rest of the card class) untouched. This is the highest-priority check; a wrong seam is disqualifying no matter how clean the code looks. Name the correct seam in the finding.
- Grep for the rule, not the symbol.
rg "CR 115\.3" crates/finds the code that already asserts ownership of the behavior. If an authority already cites the rule the change implements, the change belongs there — extending it — not beside it. This paragraph is the check's one home; other skills link here instead of restating it.
- Grep for the rule, not the symbol.
- Most idiomatic change at the seam: Given the right seam, is this the implementation a principal engineer steeped in this repository would write — the established building block reused rather than re-implemented, an existing typed enum parameterized rather than a new
boolor sibling variant,nomcombinators composed rather than string dispatch? "Works and is in the right place" is not enough when a cleaner house idiom exists; a correct-but-unidiomatic change is a finding, not a style nit. Three structural checks make this concrete: a reference enum (HandSize,LifeTotal) must not carry aFixed/constant payload that belongs one level up in an expression wrapper (mixed abstraction layers); a new sibling on anX/OpponentX/TargetXcluster should be one parameterized variant — but only when the axis stays within a single CR rule section (don't unify across sections, e.g. life CR 119 vs power/toughness CR 208/209); and before flagging or accepting any new enum variant, grepdata/engine-inventory.json(gitignored — runcargo engine-inventoryto (re)generate it locally first) to confirm it doesn't already exist and to surface the cluster smell.
- Class vs single case: Does the change cover a reusable class? Name at least three examples in that class. If there is only one, flag a special-case smell.
- Sibling coverage: If one site in a class changed, name siblings that needed the same treatment and verify they were handled or intentionally unaffected.
- Test adequacy: Ensure tests exercise the failure path and the building block, not only one card or a constructor shortcut that bypasses production wiring. Use card-test for the matching production entry and completion boundary: required prompts are unconditional assertions, and empty stack alone does not prove an interactive continuation finished.
- Real cards: Apply real cards to every test the diff adds and to every justification in the PR body, addenda, reports and review replies. Flag a card whose text the test exercises that is not printed, unless the test states that no printed card exhibits the shape and names the nearest printed card; if no printed card exhibits the shape, flag the behavior unless the change shows why it is needed. Flag any claim whose authority is a test name, a synthetic card or an abstract shape instead of a printed card's verbatim Oracle text and the CR. At least MED.
- Vacuous negative assertions: For every negative assertion (
!detector(...), "does not parse to X", "counter NOT applied"), verify the input actually reached the code under test. An upstream short-circuit makes the negative pass for the wrong reason — canonical instance:check_swallowed_clausesreturns early when any parsed ability containsEffect::Unimplemented, so!has_swallowed_clause(...)passes on a card that failed to parse at all. Require a paired positive reach-guard in the same test (parse succeeded, zeroEffect::Unimplemented, expected positive shape) or a runtime assertion that flips on revert. This is the highest-frequency contributor-PR finding — check it on every test the diff adds. - New-field threading and semantic consumers: Sweep constructions and consumers when a field is added or its meaning, cardinality, scope, or binding changes. Flag silent drops/defaults in resume paths, single/multi-pick branches, batch handlers, AST visitors, and adapter/serialization constructors. Each affected site must carry the new semantics or explain why its behavior is still correct. Prefer the existing scoped traversal in
types/ability_visit.rswhen it fits; preserve own-resolution vs registered-later boundaries. - Claim-to-test map: For every behavior the PR claims to support, identify the changed seam/function, production entry point, and test that reaches it. Flag any behavior tested only through a helper, constructor, parsed AST, or direct resolver call when production reaches it through
apply(),WaitingFor,GameAction, stack/casting, combat declaration, replacement handling, or the scenario runner. Parser shape tests do not satisfy runtime semantics or coverage-support claims; they are acceptable for parser-only work only when unsupported semantics remain red/honest. - Fixture path-divergence: A test can drive the real production entry point and still miss the bug if its fixtures are shaped so simply that they take a different internal branch than production inputs. Technique: trace the fix's entry through its first input-shape dispatches —
is_none()/is_some(),is_empty()/len(), variantmatch, and "has-X" guards (e.g.if ability_def.is_none() { return fast_path() }). For each such branch the fix can reach, map every test fixture to the arm it triggers, and flag any production-reachable arm with no fixture. Smell: every fixture is degenerate in the same way (no ability/effect, no targets, empty or single-element collection, default/Nonefield), so only the trivial shortcut arm runs while the arm real data takes ships untested. Name the unexercised arm and the minimal fixture change that would reach it. - Coverage honesty: If parser code accepts full Oracle text while intentionally ignoring any semantic rider, replacement, delayed trigger, restriction, granted ability, continuation, or other rules-bearing clause, coverage must remain honest. Flag changes that make
cargo coveragemark a card/class supported while those semantics are deferred or dropped instead of preserved asEffect::unimplemented, an equivalent strict-failure marker, or unchanged unsupported coverage. - Selected authority / provenance: For "this way", "that source", "chosen", "cast using", "from among them", selected modes/targets, replacement predicates, duration-bound effects, or controller/owner-relative text, verify the selected authority is carried from the production choice point to the consuming function. Flag global rescans that can pick a different permission, source, cost, replacement, tracked set, controller, or owner unless a multi-authority fixture proves equivalence.
- Snapshot / latch semantics: Flag live predicates where the CR requires a value or duration to be fixed when a spell/ability resolves, a replacement applies, or an effect's duration ends. Require tests for post-resolution value changes, controller changes, zone changes, and non-revival after duration expiry when relevant.
- Empty / decline / natural-event paths: For optional choices and tracked sets, verify all-decline or empty selections publish/clear the same state a non-empty choice would. For resource/event counters, verify natural game progression is not counted as a created extra resource.
- Serialized-surface contracts: If the diff changes an enum,
GameAction,WaitingFor, game-state field, card-data export shape, or serialized AI/community scenario shape, verify existing repo-owned serialized data still loads via migration/defaults/fixture updates and protocol-visible changes bump the wire contract when required. - Target/scope matrix: For combat, targeting, controller, owner, protector, defender, or player-scope changes, enumerate the variants/scopes reachable at the touched production boundary. Require negative tests for semantically adjacent sibling variants that are plausibly affected, or a concrete explanation for why a sibling is unreachable/out of scope.
- Edge cases: Check empty inputs, multi-target/modal/repeat interactions, simultaneous events, eliminated players,
im::Vector::truncate(n)bounds, and async races when relevant. - Idiomatic code: Flag new bools that should be typed enums, wildcard match arms that should be exhaustive, verbatim Oracle strings in parser logic, hand-rolled
starts_with+ index slicing that should bestrip_prefix/strip_suffix/TextPair,as any, fresh@ts-expect-error, and unchecked casts.
Surface-Specific Lenses
Engine Logic
- Verify every new or moved
// CR <rule>by checkingdocs/MagicCompRules.txt; the cited rule must actually describe the code. - Compound CR annotations are the project's documented convention, not format violations:
CR X + CR Yfor interacting rules,CR X / CR Yfor alternatives, and range/subpart forms likeCR 702.45a/b(see CLAUDE.md "MTG Comprehensive Rules Annotations"). Do not flag the+/// range forms as malformed or as regex violations — external reviewers routinely raise these and they should be refuted, not echoed. Only flag a CR citation whose base number does not resolve indocs/MagicCompRules.txt, or one that does not describe the annotated code. - Check reuse of building blocks in
parser/oracle_nom/,parser/oracle_util.rs,game/filter.rs,game/quantity.rs,game/ability_utils.rs,game/keywords.rs,game/zones.rs, andgame/targeting.rs. - Keep game logic in the engine. If player-visible state was added, verify multiplayer filtering.
- For non-battlefield zones, player-scoped queries usually use
owner, notcontroller. - Zone changes should route through replacement-aware pipelines rather than direct moves when replacements can apply.
Parser
- Reject verbatim full-string Oracle matches and ad hoc dispatch.
- Verify plural, possessive, opponent, non-X, another, and sibling phrase variants for new parser arms — including article/quantity word-forms (
a/an/one/two/N/X/each) when dispatch splits on a count or article boundary. - When one parser arm rejects a value to defer to another (e.g. a multi-count arm returns
Nonefor count==1 so the single-count arm handles it), trace the receiving arm and prove it actually accepts that form — do not trust the comment. A deferral to a path that doesn't handle the form silently drops the card to Unimplemented (precedent: "roll one d6" — the multi-die arm rejected count==1 and the single-die arm only matched"a "/"an ", so the word "one" parsed nowhere despite a comment claiming otherwise). - Prefer composable
nomaxes over cartesian lists of fulltag()strings. - For multi-position phrases, use the
oracle_nom::primitives::scan_at_word_boundariesfamily. New caller-local.find(' ')scanning loops duplicate that authority; structural cursor operations inside the shared primitive are not parsing dispatch.
Frontend / UI
- The frontend renders engine-provided state; it must not infer game rules or hidden data.
- Check React effect dependencies, unmount cleanup, touch equivalents, mobile scroll containment, and empty/loading/error states.
- Type-check passing is not proof of feature correctness; say when browser verification was not performed.
- i18n: Flag frontend-authored user-facing text (titles, labels, buttons, tooltips, placeholders, log templates) hardcoded in JSX instead of routed through
t(). Conversely, flag engine/card pass-through (card names, Oracle text, interpolated enum strings) that was wrongly wrapped int()— it belongs to the content pipeline, not chrome. Boundary rule: a string getst()iff the frontend authored it (client/src/i18n/README.md). Also flag hand-rolled pluralization (count === 1 ? …) that should usekey_one/key_other, and any directi18n.changeLanguagecall (the preferences store owns language).
Multiplayer / Transport
- Verify hidden-information filtering.
- Round-trip new fields across WASM, WebSocket, Tauri, and P2P adapters where applicable.
- Check reconnect and 3+ player behavior when touched.
AI
- Classifiers must cover the full enum/category, including untargeted board wipes and non-target effects.
- Deadline-bail branches must score candidates consistently with the no-bail path.
- Cache keys must include all inputs that alter decisions.
- Combination generators should short-circuit infeasible cases before enumerating.
Deck / Format / Feeds
- Format checks should use semantic identity, such as
Basicsupertype, not brittle name allowlists. - Feed code must not overwrite cached state with empty or zero-deck responses.
Output
Use this exact finding shape:
**[HIGH/MED/LOW]** <short summary>. Evidence: <path:line>. Why it matters: <one sentence>. Suggested fix: <one line>.When a finding turns on what a card does, its evidence names the printed card and quotes its Oracle text and the CR (real cards).
In PR Review Mode, number each finding F1…Fn (introduced findings only; all of them block). The finding head replaces the bracketed shape above and is exactly **F<n> · <SEV> — <short summary>** at the start of a paragraph, with <SEV> one of CRITICAL, HIGH, MED, LOW or NIT and <n> counting from 1. Tag a finding [late: <category>] or [incomplete-claim] as applicable, after the summary and inside the head. The Evidence, Why it matters and Suggested fix parts follow as above. Each finding then ends with a **Closes when:** label: the observable outcome that clears it, stated so the author can aim at it and a re-review can check it — a behaviour a production-path test asserts; for an architecture, citation or wording finding, what the corrected source shows; for an incomplete claim, the claim that must be delivered or the text that must change. It states the outcome, never the implementation. It is evidence that the finding is resolved: it replaces no part of the finding, and it never limits what a re-review may raise. Any other bold-led paragraph or list item inside a finding is a label: one to four words, then a colon. Example head:
<!-- finding-head-example -->F1 · MED — Opponent filter ignored on the resolver path
<!-- /finding-head-example -->Then list the Late note: and Reach note: lines, the Pre-existing list and refuted external items, unnumbered.
In engine-implementer reviews, including the final PR review, append the orchestrator's tag to each finding — [behavior], [text] or [machinery], as its run limits define them; when in doubt, [behavior]. A [text] finding quotes the old text and gives the replacement. A finding that names a pattern gives the predicate, the command, and every matching site with its disposition; that list is the fix's scope. On a fix round, check the fix executor's unrequested edits first: a sentence added beyond the prior finding's supplied text is the least-reviewed line in the diff.
Severity calibration outside PR Review Mode: a latent bug — one not reachable today because a guard or parser blocks it — is still a finding. Rate it by what happens when the form is reached or the guard removed, not by today's reachability: if it then produces a wrong result for a card-class the feature appears to cover, it is at least MED, and "unreachable today" belongs in the evidence, not as a reason to downgrade to LOW. A feature that ships silently incorrect for a sub-class it looks like it handles (e.g. a multi-die roll that overwrites the stored result each iteration instead of supporting the aggregate) is a MED the maintainer must see — never a NIT. In PR Review Mode, Reach decides whether a latent bug blocks; an out-of-reach one is a Reach note: line naming the nearest printed card and what stops it.
A concrete violation of a mandatory architecture rule is also at least MED even when current outputs are correct. Cite the rule and the existing authority or typed alternative that fits the change; do not invent a runtime bug to justify the severity. A merely different implementation preference without that evidence is not a finding. In engine-implementer reviews, a repair that changes a non-comment line of code is [behavior], not [text] because its observable output happens to be unchanged.
Findings first. No praise, no diff recap.
Exception: in Engine-Implementer Checkpoint Mode, the Review Head, Completion Gate, and Maintainer-Simulation Gate lines precede findings.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

