feat(gate): choose provider, model, effort and self-consistency runs — per repo, and escalated on guarded paths (#9821)

* feat(gate): choose provider, model, effort and self-consistency runs — per repo, and escalated on guarded paths

Effort DID already exist (CLAUDE_AI_EFFORT -> `claude --effort`, CODEX_AI_EFFORT ->
model_reasoning_effort) but only as a GLOBAL env var, while provider and model were
already per-repo manifest fields. Self-consistency runs had the same asymmetry.
So the two knobs that most directly control review depth were the two a repo could
not set.

Close that, and use it where it matters most. Adds:

  gate.aiReview.effort / .selfConsistencyRuns   — per-repo parity with the env vars
  gate.guardrailEscalation.{provider,model,effort,selfConsistencyRuns}
                                                — used INSTEAD when a PR touches a
                                                  hardGuardrailGlobs path

Precedence resolves per field independently: escalation > per-repo > global. An
escalation block that sets only `effort` still inherits the repo's model and the
global provider -- the common ask is "same model, think harder", not "swap the
model out".

WHY: a guardrail hit used to change exactly one thing -- it suppressed auto-merge
and queued a human. It bought no extra analysis at all: a PR touching
.github/workflows/** got the same single-pass, same-model, same-effort review as a
README typo. Measured on the production ORB that was 74 distinct PRs held in 14
days, on repos whose guardrail lists had already been narrowed twice. A guarded
path can now buy MORE SCRUTINY instead of maintainer toil; manual review stays the
fallback when the escalated review is not clean.

Every layer unset ⇒ null throughout ⇒ byte-identical to today for every existing
repo and self-hoster. An escalation is logged (ai_review_guardrail_escalated) and
describeReviewEscalation renders the one-line "why" for the panel/decision record.

* fix(gate): actually apply the resolved effort/model/provider at the invocation

Review blocker on #9821, and correct: resolveReviewKnobs was computed, logged,
and then DROPPED. Only selfConsistencyRuns was consumed, so "choose provider,
model, effort" was unimplemented at the one place it takes effect -- and the doc
comment claiming the fields "ride through to the provider invocation" was false.

Apply them where review.ai_model's overrides already land:

  claudeModel/codexModel/ollamaModel/openaiModel/openaiCompatibleModel/
  anthropicModel  <- reviewKnobs.model ?? review.ai_model ?? env
  claudeEffort/codexEffort                <- reviewKnobs.effort ?? ... ?? env

reviewKnobs wins over review.ai_model because it is strictly more specific: it is
the only layer that can differ PER PR, and an escalation existing at all means it
should win for the PR that triggered it. Unset ⇒ `??` falls straight through, so
a repo using only review.ai_model is untouched.

Provider also now governs the BYOK key. The providerKey gate runs before the
knobs are resolved and only knew settings.aiReviewProvider, so an ESCALATED
provider would have kept using a stored key belonging to a different one. Same
rule, re-applied with the resolved value: a mismatch drops the key.

Also re-syncs config/examples/loopover.full.yml with .loopover.yml.example --
caught by running the FULL suite this time, which is the same break class that
took main down after #9813.

* test(gate): cover every new manifest branch, and fix the serialize guard the coverage exposed

Codecov flagged 39 uncovered lines on #9821, and closing them found a REAL bug:
gateConfigToJson's outer aiReview guard was never taught the two new fields, so a
manifest whose aiReview block set ONLY effort/selfConsistencyRuns serialized to
NOTHING -- the setting silently vanished on the next snapshot reload. The new
round-trip assertion failed on exactly that before touching coverage at all.
(An earlier edit had aimed at this guard and hit the presence expression instead;
the round-trip test is what caught the difference.)

Coverage added:
 - engine parse: full/partial/invalid/non-mapping guardrailEscalation, invalid
   effort + runs values warn and stay null, presence flips on EACH of the six
   fields alone (the #9813 presence-gap class, per field), serialize round-trips
   full AND partial blocks
 - resolution: every field lands on effective settings; absent leaves the stored
   value untouched
 - END-TO-END escalation: env self-consistency OFF, manifest hardGuardrailGlobs
   + guardrailEscalation.selfConsistencyRuns=3, a guarded changed file -- the
   pipeline delivers 1 primary + 2 rotated-exemplar extra calls, proving the
   resolved knobs reach the invocation (the #9821 review blocker, now pinned by
   an integration test, not just the precedence mirror)
 - INERT invariant: same escalation block, no guarded file -- zero
   selfConsistency usage rows (counted via the usage marker, not raw AI.run
   calls, matching the flag-off baseline's discipline)

* fix(gate): consume the resolved model/effort in ai-review.ts itself, where the reviewer looked

Re-review blocker: the diff still showed only selfConsistencyRuns consumed in
src/services/ai-review.ts. The orchestration DID pre-apply model/effort to the
claude*/codex*/HTTP-model fields, so behavior was correct -- but this module,
which owns the doc comment claiming the fields "ride through to the provider
invocation", never read them, and any OTHER caller passing reviewKnobs would
have been silently ignored.

Fold reviewKnobs.model/effort into the AiRunCorrelation, which IS what becomes
the provider's per-call options at this module's dispatch. Same ?? precedence as
the orchestration, so applying it in both places is idempotent, and this module
is now self-sufficient.

Correct the doc comment to state exactly what is consumed WHERE, including that
`provider` is deliberately NOT consumed here -- it governs BYOK key selection at
the orchestration, before this runs, and rides along for logging/replay only.

Test captures the options the provider actually receives (claudeEffort/
claudeModel/codexEffort/anthropicModel) for a guarded-path PR with an escalation
block, rather than asserting on the precedence mirror.

* test(engine): cover the new manifest branches in the ENGINE's own suite

Codecov kept reporting focus-manifest.ts at ~65% despite the root vitest suite
covering every added line. The reports disagree because they measure differently:
the root v8 run instruments only the 11 lines it actually executes from that
source, while the engine's own c8 run uses --all over dist/ and instruments all
66 -- and the engine's node:test suite never exercised the new branches. Codecov
merges both, so 21 lines read as uncovered no matter how thorough the vitest
tests were.

Add the engine-side tests: parse, per-field presence, serialize round-trip (full
AND partial -- the case whose guard was genuinely broken), invalid-value
rejection, non-mapping escalation, and absent-means-null including that the
serializer emits no escalation block at all.

Engine c8 now reports 0 of 66 added lines uncovered, down from 21.

Author: JSONbored

.loopover.yml.example

@@ -272,6 +272,24 @@ gate:
   # app(s) YOU run; loopover hardcodes no vendor. List of { name, appSlug }, or omit. Default: not
   # configured (byte-identical behavior for every repo that doesn't opt in). Config-as-code only — no DB
   # column or dashboard toggle.
+  # Review settings used INSTEAD of the repo defaults when a PR touches a `hardGuardrailGlobs` path
+  # (#9808/#9821) — so a guarded path buys MORE SCRUTINY rather than an automatic manual-review hold.
+  #
+  # Without this, a guardrail hit changes exactly one thing: it suppresses auto-merge and queues a human. The
+  # review itself is identical to any other file's — same model, same effort, single pass. That turns a
+  # protected path into maintainer toil without the analysis actually going up, and on a busy repo it is the
+  # single largest source of manual reviews.
+  #
+  # Any subset may be set; each unset field falls through to the repo value, then the global env. The common
+  # shape is "same model, think harder" — set only `effort` (and optionally `selfConsistencyRuns`) and the
+  # model/provider are inherited untouched. Manual review remains the fallback: if the escalated review is
+  # not clean, the PR still holds.
+  guardrailEscalation:
+    effort: high
+    selfConsistencyRuns: 3
+    # provider: anthropic
+    # model: claude-opus-5
+
   advisoryCheckRuns:
     - name: Contributor trust
       appSlug: example-security-app
@@ -426,6 +444,16 @@ gate:
     # String or null. Default: null (the key record's model, else a conservative
     # per-provider default).
     model: null
+    # Reasoning effort for the review pass: low | medium | high | xhigh | max (#9821). Per-repo parity with
+    # the global CLAUDE_AI_EFFORT / CODEX_AI_EFFORT env vars, which used to be the ONLY place this could be
+    # set even though provider and model were already per-repo. Unset ⇒ whatever the env configures
+    # (medium by default). Higher effort costs more tokens and runs longer — raise it for repos where a
+    # missed defect is expensive, not everywhere.
+    effort: medium
+    # TOTAL evaluations per review, primary included (#9821). Per-repo parity with
+    # AI_REVIEW_SELF_CONSISTENCY_RUNS. Clamped to {0, 2, 3}: one run cannot measure agreement, and the
+    # benefit saturates by three. 0 (default) = a single pass. Each extra run is a full paid review.
+    selfConsistencyRuns: 0
     # Minimum calibrated AI-reviewer confidence (0-1). Under `mode: block`,
     # consensus and split AI-review defects still BLOCK the gate regardless of
     # this floor — what varies below it is `lowConfidenceDisposition` below.

apps/loopover-ui/public/openapi.json

@@ -10146,6 +10146,51 @@
                 "appSlug"
               ]
             }
+          },
+          "aiReviewEffort": {
+            "type": "string",
+            "nullable": true,
+            "enum": [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max",
+              null
+            ]
+          },
+          "aiReviewSelfConsistencyRuns": {
+            "type": "number",
+            "nullable": true
+          },
+          "guardrailEscalationProvider": {
+            "type": "string",
+            "nullable": true,
+            "enum": [
+              "anthropic",
+              "openai",
+              null
+            ]
+          },
+          "guardrailEscalationModel": {
+            "type": "string",
+            "nullable": true
+          },
+          "guardrailEscalationEffort": {
+            "type": "string",
+            "nullable": true,
+            "enum": [
+              "low",
+              "medium",
+              "high",
+              "xhigh",
+              "max",
+              null
+            ]
+          },
+          "guardrailEscalationSelfConsistencyRuns": {
+            "type": "number",
+            "nullable": true
           }
         },
         "required": [

config/examples/loopover.full.yml

@@ -286,6 +286,24 @@ gate:
   # app(s) YOU run; loopover hardcodes no vendor. List of { name, appSlug }, or omit. Default: not
   # configured (byte-identical behavior for every repo that doesn't opt in). Config-as-code only — no DB
   # column or dashboard toggle.
+  # Review settings used INSTEAD of the repo defaults when a PR touches a `hardGuardrailGlobs` path
+  # (#9808/#9821) — so a guarded path buys MORE SCRUTINY rather than an automatic manual-review hold.
+  #
+  # Without this, a guardrail hit changes exactly one thing: it suppresses auto-merge and queues a human. The
+  # review itself is identical to any other file's — same model, same effort, single pass. That turns a
+  # protected path into maintainer toil without the analysis actually going up, and on a busy repo it is the
+  # single largest source of manual reviews.
+  #
+  # Any subset may be set; each unset field falls through to the repo value, then the global env. The common
+  # shape is "same model, think harder" — set only `effort` (and optionally `selfConsistencyRuns`) and the
+  # model/provider are inherited untouched. Manual review remains the fallback: if the escalated review is
+  # not clean, the PR still holds.
+  guardrailEscalation:
+    effort: high
+    selfConsistencyRuns: 3
+    # provider: anthropic
+    # model: claude-opus-5
+
   advisoryCheckRuns:
     - name: Contributor trust
       appSlug: example-security-app
@@ -440,6 +458,16 @@ gate:
     # String or null. Default: null (the key record's model, else a conservative
     # per-provider default).
     model: null
+    # Reasoning effort for the review pass: low | medium | high | xhigh | max (#9821). Per-repo parity with
+    # the global CLAUDE_AI_EFFORT / CODEX_AI_EFFORT env vars, which used to be the ONLY place this could be
+    # set even though provider and model were already per-repo. Unset ⇒ whatever the env configures
+    # (medium by default). Higher effort costs more tokens and runs longer — raise it for repos where a
+    # missed defect is expensive, not everywhere.
+    effort: medium
+    # TOTAL evaluations per review, primary included (#9821). Per-repo parity with
+    # AI_REVIEW_SELF_CONSISTENCY_RUNS. Clamped to {0, 2, 3}: one run cannot measure agreement, and the
+    # benefit saturates by three. 0 (default) = a single pass. Each extra run is a full paid review.
+    selfConsistencyRuns: 0
     # Minimum calibrated AI-reviewer confidence (0-1). Under `mode: block`,
     # consensus and split AI-review defects still BLOCK the gate regardless of
     # this floor — what varies below it is `lowConfidenceDisposition` below.

packages/loopover-contract/src/api-schemas.ts

@@ -453,6 +453,12 @@ export const RepositorySettingsSchema = z
     expectedCiContexts: z.array(z.string()).readonly().nullable().optional(),
     advisoryCheckRuns: z.array(z.object({ name: z.string(), appSlug: z.string() })).readonly().nullable().optional(),
     ignoredCheckRuns: z.array(z.object({ name: z.string(), appSlug: z.string() })).readonly().nullable().optional(),
+    aiReviewEffort: z.enum(["low", "medium", "high", "xhigh", "max"]).nullable().optional(),
+    aiReviewSelfConsistencyRuns: z.number().nullable().optional(),
+    guardrailEscalationProvider: z.enum(["anthropic", "openai"]).nullable().optional(),
+    guardrailEscalationModel: z.string().nullable().optional(),
+    guardrailEscalationEffort: z.enum(["low", "medium", "high", "xhigh", "max"]).nullable().optional(),
+    guardrailEscalationSelfConsistencyRuns: z.number().nullable().optional(),
     copycatGateMode: z.enum(["off", "warn", "label", "block"]).optional(),
     copycatGateMinScore: z.number().nullable().optional(),
     gateDryRun: z.boolean().optional(),

packages/loopover-engine/src/focus-manifest.ts

@@ -114,6 +114,22 @@ export type FocusManifestGateConfig = {
   aiReviewByok: boolean | null;
   aiReviewProvider: "anthropic" | "openai" | null;
   aiReviewModel: string | null;
+  /** `gate.aiReview.effort` (#9821): reasoning effort for the review pass — low | medium | high | xhigh | max.
+   *  Per-repo parity with the global CLAUDE_AI_EFFORT/CODEX_AI_EFFORT env vars, which were previously the ONLY
+   *  way to set it: provider and model were already per-repo, effort was not. Unset ⇒ the env default. */
+  aiReviewEffort: "low" | "medium" | "high" | "xhigh" | "max" | null;
+  /** `gate.aiReview.selfConsistencyRuns` (#9821): TOTAL evaluations per review, primary included. Per-repo
+   *  parity with AI_REVIEW_SELF_CONSISTENCY_RUNS. Clamped downstream to {0,2,3} -- one run cannot measure
+   *  agreement and the benefit saturates by three. Unset ⇒ the env default. */
+  aiReviewSelfConsistencyRuns: number | null;
+  /** `gate.guardrailEscalation` (#9808/#9821): the review settings to use INSTEAD of the repo defaults when a
+   *  PR touches a `hardGuardrailGlobs` path. Any subset may be given; each unset field falls through to the
+   *  repo/global value. This is what makes a guarded path buy MORE SCRUTINY rather than a manual hold --
+   *  today a guardrail hit reviews identically to any other file and merely stops the merge. */
+  guardrailEscalationProvider: "anthropic" | "openai" | null;
+  guardrailEscalationModel: string | null;
+  guardrailEscalationEffort: "low" | "medium" | "high" | "xhigh" | "max" | null;
+  guardrailEscalationSelfConsistencyRuns: number | null;
   aiReviewAllAuthors: boolean | null;
   /** `gate.aiReview.closeConfidence` (#7): minimum calibrated AI-reviewer confidence (0-1) for an AI defect to BLOCK
    *  under `aiReview.mode: block`. null (unset) ⇒ the gate's 0.93 default. Clamped to [0,1] at parse time. */
@@ -631,6 +647,12 @@ export type FocusManifestSettings = Partial<
     | "aiReviewByok"
     | "aiReviewProvider"
     | "aiReviewModel"
+    | "aiReviewEffort"
+    | "aiReviewSelfConsistencyRuns"
+    | "guardrailEscalationProvider"
+    | "guardrailEscalationModel"
+    | "guardrailEscalationEffort"
+    | "guardrailEscalationSelfConsistencyRuns"
     | "aiReviewAllAuthors"
     | "aiReviewConfirmedContributorsOnly"
     | "closeOwnerAuthors"
@@ -1342,6 +1364,12 @@ const EMPTY_GATE_CONFIG: FocusManifestGateConfig = {
   aiReviewByok: null,
   aiReviewProvider: null,
   aiReviewModel: null,
+  aiReviewEffort: null,
+  aiReviewSelfConsistencyRuns: null,
+  guardrailEscalationProvider: null,
+  guardrailEscalationModel: null,
+  guardrailEscalationEffort: null,
+  guardrailEscalationSelfConsistencyRuns: null,
   aiReviewAllAuthors: null,
   aiReviewCloseConfidence: null,
   aiReviewSalvageabilityMinScore: null,
@@ -1815,6 +1843,7 @@ const GATE_TOP_LEVEL_KEYS = new Set<string>([
   "expectedCiContexts",
   "advisoryCheckRuns",
   "ignoredCheckRuns",
+  "guardrailEscalation",
   "aiJudgmentBlockers",
   "copycat",
 ]);
@@ -1837,6 +1866,10 @@ function parseGateConfig(value: JsonValue | undefined, warnings: string[]): Focu
   }
   const aiReview = record.aiReview;
   const aiReviewRecord = aiReview !== null && typeof aiReview === "object" && !Array.isArray(aiReview) ? (aiReview as Record<string, JsonValue>) : undefined;
+  // #9821: `gate.guardrailEscalation` — same "nested mapping, each field optional" shape as gate.aiReview above.
+  const escalation = record.guardrailEscalation;
+  const escalationRecord =
+    escalation !== null && typeof escalation === "object" && !Array.isArray(escalation) ? (escalation as Record<string, JsonValue>) : undefined;
   if (aiReview !== undefined && aiReview !== null && aiReviewRecord === undefined) {
     warnings.push(`Manifest gate field "gate.aiReview" must be a mapping; ignoring it.`);
   }
@@ -1881,6 +1914,12 @@ function parseGateConfig(value: JsonValue | undefined, warnings: string[]): Focu
     aiReviewByok: normalizeOptionalBoolean(aiReviewRecord?.byok, "gate.aiReview.byok", warnings),
     aiReviewProvider: normalizeOptionalEnum(aiReviewRecord?.provider, "gate.aiReview.provider", ["anthropic", "openai"] as const, warnings),
     aiReviewModel: normalizeOptionalString(aiReviewRecord?.model, "gate.aiReview.model", warnings),
+    aiReviewEffort: normalizeOptionalEnum(aiReviewRecord?.effort, "gate.aiReview.effort", ["low", "medium", "high", "xhigh", "max"] as const, warnings),
+    aiReviewSelfConsistencyRuns: normalizeOptionalNonNegativeInt(aiReviewRecord?.selfConsistencyRuns, "gate.aiReview.selfConsistencyRuns", warnings),
+    guardrailEscalationProvider: normalizeOptionalEnum(escalationRecord?.provider, "gate.guardrailEscalation.provider", ["anthropic", "openai"] as const, warnings),
+    guardrailEscalationModel: normalizeOptionalString(escalationRecord?.model, "gate.guardrailEscalation.model", warnings),
+    guardrailEscalationEffort: normalizeOptionalEnum(escalationRecord?.effort, "gate.guardrailEscalation.effort", ["low", "medium", "high", "xhigh", "max"] as const, warnings),
+    guardrailEscalationSelfConsistencyRuns: normalizeOptionalNonNegativeInt(escalationRecord?.selfConsistencyRuns, "gate.guardrailEscalation.selfConsistencyRuns", warnings),
     aiReviewAllAuthors: normalizeOptionalBoolean(aiReviewRecord?.allAuthors, "gate.aiReview.allAuthors", warnings),
     aiReviewCloseConfidence: normalizeOptionalConfidence(aiReviewRecord?.closeConfidence, "gate.aiReview.closeConfidence", warnings),
     aiReviewSalvageabilityMinScore: normalizeOptionalScore(aiReviewRecord?.salvageabilityMinScore, "gate.aiReview.salvageabilityMinScore", warnings),
@@ -1947,6 +1986,8 @@ function parseGateConfig(value: JsonValue | undefined, warnings: string[]): Focu
     gate.aiReviewByok !== null ||
     gate.aiReviewProvider !== null ||
     gate.aiReviewModel !== null ||
+    gate.aiReviewEffort !== null ||
+    gate.aiReviewSelfConsistencyRuns !== null ||
     gate.aiReviewAllAuthors !== null ||
     gate.aiReviewCloseConfidence !== null ||
     gate.aiReviewSalvageabilityMinScore !== null ||
@@ -1970,6 +2011,12 @@ function parseGateConfig(value: JsonValue | undefined, warnings: string[]): Focu
     gate.claCheckRunAppSlug !== null ||
     gate.expectedCiContexts !== null ||
     gate.advisoryCheckRuns !== null ||
+    gate.aiReviewEffort !== null ||
+    gate.aiReviewSelfConsistencyRuns !== null ||
+    gate.guardrailEscalationProvider !== null ||
+    gate.guardrailEscalationModel !== null ||
+    gate.guardrailEscalationEffort !== null ||
+    gate.guardrailEscalationSelfConsistencyRuns !== null ||
     gate.ignoredCheckRuns !== null ||
     gate.aiJudgmentBlockersMode !== null ||
     gate.copycatMode !== null ||
@@ -2029,13 +2076,17 @@ export function gateConfigToJson(gate: FocusManifestGateConfig): JsonValue {
     gate.aiReviewLowConfidenceDisposition !== null ||
     gate.aiReviewCombine !== null ||
     gate.aiReviewOnMerge !== null ||
-    gate.aiReviewReviewers !== null
+    gate.aiReviewReviewers !== null ||
+    gate.aiReviewEffort !== null ||
+    gate.aiReviewSelfConsistencyRuns !== null
   ) {
     const aiReview: Record<string, JsonValue> = {};
     if (gate.aiReviewMode !== null) aiReview.mode = gate.aiReviewMode;
     if (gate.aiReviewByok !== null) aiReview.byok = gate.aiReviewByok;
     if (gate.aiReviewProvider !== null) aiReview.provider = gate.aiReviewProvider;
     if (gate.aiReviewModel !== null) aiReview.model = gate.aiReviewModel;
+    if (gate.aiReviewEffort !== null) aiReview.effort = gate.aiReviewEffort;
+    if (gate.aiReviewSelfConsistencyRuns !== null) aiReview.selfConsistencyRuns = gate.aiReviewSelfConsistencyRuns;
     if (gate.aiReviewAllAuthors !== null) aiReview.allAuthors = gate.aiReviewAllAuthors;
     if (gate.aiReviewCloseConfidence !== null) aiReview.closeConfidence = gate.aiReviewCloseConfidence;
     if (gate.aiReviewSalvageabilityMinScore !== null) aiReview.salvageabilityMinScore = gate.aiReviewSalvageabilityMinScore;
@@ -2049,6 +2100,20 @@ export function gateConfigToJson(gate: FocusManifestGateConfig): JsonValue {
     }
     out.aiReview = aiReview;
   }
+  // #9821: guardrail escalation round-trips as its own nested mapping, emitted only when something is set.
+  if (
+    gate.guardrailEscalationProvider !== null ||
+    gate.guardrailEscalationModel !== null ||
+    gate.guardrailEscalationEffort !== null ||
+    gate.guardrailEscalationSelfConsistencyRuns !== null
+  ) {
+    const escalation: Record<string, JsonValue> = {};
+    if (gate.guardrailEscalationProvider !== null) escalation.provider = gate.guardrailEscalationProvider;
+    if (gate.guardrailEscalationModel !== null) escalation.model = gate.guardrailEscalationModel;
+    if (gate.guardrailEscalationEffort !== null) escalation.effort = gate.guardrailEscalationEffort;
+    if (gate.guardrailEscalationSelfConsistencyRuns !== null) escalation.selfConsistencyRuns = gate.guardrailEscalationSelfConsistencyRuns;
+    out.guardrailEscalation = escalation;
+  }
   if (gate.mergeReadiness !== null) out.mergeReadiness = gate.mergeReadiness;
   if (gate.manifestPolicy !== null) out.manifestPolicy = gate.manifestPolicy;
   if (gate.selfAuthoredLinkedIssue !== null) out.selfAuthoredLinkedIssue = gate.selfAuthoredLinkedIssue;

packages/loopover-engine/src/types/manifest-deps-types.ts

@@ -296,6 +296,19 @@ export type RepositorySettings = {
   /** Config-as-code model override for the BYOK advisory write-up (e.g. "claude-3-5-sonnet-latest").
    *  `null` = use the key record's model, else a conservative per-provider default. */
   aiReviewModel?: string | null | undefined;
+  /** `gate.aiReview.effort` (#9821): reasoning effort for the review pass (low | medium | high | xhigh | max).
+   *  Per-repo parity with the global CLAUDE_AI_EFFORT / CODEX_AI_EFFORT env vars. Unset ⇒ the env default. */
+  aiReviewEffort?: "low" | "medium" | "high" | "xhigh" | "max" | null | undefined;
+  /** `gate.aiReview.selfConsistencyRuns` (#9821): TOTAL evaluations per review, primary included. Per-repo
+   *  parity with AI_REVIEW_SELF_CONSISTENCY_RUNS; clamped downstream to {0,2,3}. Unset ⇒ the env default. */
+  aiReviewSelfConsistencyRuns?: number | null | undefined;
+  /** `gate.guardrailEscalation.*` (#9808/#9821): review settings used INSTEAD of the repo defaults when a PR
+   *  touches a hardGuardrailGlobs path, so a guarded path buys MORE SCRUTINY rather than a manual hold. Each
+   *  field falls through to the repo/global value when unset. */
+  guardrailEscalationProvider?: "anthropic" | "openai" | null | undefined;
+  guardrailEscalationModel?: string | null | undefined;
+  guardrailEscalationEffort?: "low" | "medium" | "high" | "xhigh" | "max" | null | undefined;
+  guardrailEscalationSelfConsistencyRuns?: number | null | undefined;
   /** Review EVERY PR's author, not only confirmed Gittensor contributors. Only meaningful when
    *  {@link aiReviewConfirmedContributorsOnly} is also `true` (that field opts INTO confirmed-only
    *  scoping in the first place — see its own doc comment for the full invariant: AI review runs for