phase-loop-runtime 0.5.0__tar.gz → 0.6.0__tar.gz

{phase_loop_runtime-0.5.0 → phase_loop_runtime-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phase-loop-runtime
-Version: 0.5.0
+Version: 0.6.0
 Summary: Harness-neutral phase-loop orchestration runtime and CLI
 Author: ViperJuice
 License-Expression: Apache-2.0

{phase_loop_runtime-0.5.0 → phase_loop_runtime-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "phase-loop-runtime"  # PyPI dist name; NOT "agent-harness" (an unrelated third-party PyPI project)
-version = "0.5.0"
+version = "0.6.0"
 description = "Harness-neutral phase-loop orchestration runtime and CLI"
 readme = "README.md"
 requires-python = ">=3.10"

{phase_loop_runtime-0.5.0 → phase_loop_runtime-0.6.0}/src/phase_loop_runtime/__init__.py

@@ -18,4 +18,4 @@ __all__ = [
     "state_ops",
 ]
 
-__version__ = "0.5.0"
+__version__ = "0.6.0"

{phase_loop_runtime-0.5.0 → phase_loop_runtime-0.6.0}/src/phase_loop_runtime/_contract_docs/phase-loop/pi-loop-control.md

@@ -148,7 +148,7 @@ pi-agent-watch \
   --repo /path/to/repo \
   --roadmap specs/phase-plans-v1.md \
   --provider openai-codex \
-  --model gpt-5.5 \
+  --model gpt-5.6-sol \
   --thinking high \
   --phase-executor claude \
   --claude-execution-mode agent_team \

{phase_loop_runtime-0.5.0 → phase_loop_runtime-0.6.0}/src/phase_loop_runtime/_contract_docs/phase-loop/runtime-boundary.md

@@ -129,7 +129,7 @@ roots. See `docs/phase-loop/spec-discovery-roots.md`.
 The following modules under `phase_loop_runtime.*` are considered public:
 
 - `phase_loop_runtime.cli`: CLI entrypoint and parser definition.
-- `phase_loop_runtime.conformance`: Named conformance-check surface (the six L0 consiliency gates) for actor-side self-check and the CR-fence.
+- `phase_loop_runtime.conformance`: Named conformance-check surface for actor-side self-check and the CR-fence. Covers the SHAPE / GOVERNANCE tier (the six L0 consiliency gates, `scan_consiliency_gates`) and the CERT / SCHEMA tier (`validate_certificate` — structural conformance of a declared parity certificate to the contract-distributed `certificate` schema; NOT authority / provenance / signing, which stays in gp). It also carries the OBSERVABILITY / EMISSION tier (`reconcile_git_grounded_projection` and `GitGroundedProjection`): a consent-gated, producer-agnostic reconciler that turns raw git reality (read via `git_discipline`, classified against the `pipeline_ref_classes` contract SoT) into a `raw-sha256` digest-bound projection body the Portal's projection-index verify path re-verifies at render; it emits, it does not sign or own Portal ingest.
 - `phase_loop_runtime.discovery`: Roadmap and repository resolution.
 - `phase_loop_runtime.handoff`: TUI handoff generation and metadata.
 - `phase_loop_runtime.models`: Core data models, schemas, and literals.

{phase_loop_runtime-0.5.0 → phase_loop_runtime-0.6.0}/src/phase_loop_runtime/advisor_board/CONTRACTS.md

@@ -44,7 +44,7 @@ equivalence is proven by a test (not asserted in prose).
   `seat_vendor_family(seat)`, model-first with a harness-lane fallback.
   Byte-consistent with `governed_review.author_vendor_for_model` (:60-75) and
   `_EXECUTOR_VENDOR` (:47-53). Two same-vendor seats on different harnesses
-  (`gpt-5.5` on `codex` and on `opencode`) project to the same family, so the
+  (`gpt-5.6-sol` on `codex` and on `opencode`) project to the same family, so the
   governed reviewer≠author disjointness survives model-first. ABDHOME rewires the
   governed gates onto *this* canonical function (not a copy).
 
@@ -179,7 +179,7 @@ the real matrix at `load_boards()` time (`tests/test_advisor_board_config.py`,
   implementer stays Sonnet. The `default` board (`fixtures.DEFAULT_BOARD`) is
   byte-pinned to this Fable `invoke_panel` panel by the golden proof
   (`tests/test_advisor_board_golden.py`); the sole sanctioned delta stays `seat_key`.
-- **`code-review` = three frontier vendors, always.** codex `gpt-5.5`,
+- **`code-review` = three frontier vendors, always.** codex `gpt-5.6-sol`,
   `Gemini 3.1 Pro`, and `claude-fable-5`, each on the `adversarial` lens (supersedes
   the prior two-seat codex+sonnet composition).
 - **Divergent-thinking boards keep Sonnet.** `brainstorm` / `doc-edit` /
@@ -190,7 +190,7 @@ the real matrix at `load_boards()` time (`tests/test_advisor_board_config.py`,
   (`schema.py`), so the legal lenses/purposes need no enum extension.
 - **Catch-alls for unmodeled tasks (`general`, `solo`).** So the board library is not
   limited to the pre-modeled domains: `general` is the domain-agnostic top-tier PANEL
-  (three frontier vendors — gpt-5.5/adversarial, Gemini 3.1 Pro/alternative,
+  (three frontier vendors — gpt-5.6-sol/adversarial, Gemini 3.1 Pro/alternative,
   claude-fable-5/completeness — hand it any task + brief), and `solo` is the
   single-MEMBER form (one `claude-fable-5` seat) for a quick top-end opinion when a
   panel is overkill. A ONE-seat board validates + resolves through `invoke_board` like

{phase_loop_runtime-0.5.0 → phase_loop_runtime-0.6.0}/src/phase_loop_runtime/advisor_board/__init__.py

@@ -79,7 +79,16 @@ from .matrix import (
     DefaultCompatibilityMatrix,
     default_matrix,
 )
+from .composition import (
+    DEFAULT_TARGET_SEATS,
+    FLOOR_SEATS,
+    LENS_CYCLE,
+    BoardIndependence,
+    board_independence,
+    compose_review_board,
+)
 from .presets import (
+    CODE_REVIEW_BOARD,
     DEFAULT_BOARD_NAME,
     PRESET_NAMES,
     PRESETS,
@@ -216,7 +225,15 @@ __all__ = [
     "PRESETS",
     "PRESET_NAMES",
     "DEFAULT_BOARD_NAME",
+    "CODE_REVIEW_BOARD",
     "get_preset",
+    # composition (availability-aware 4-vendor board)
+    "compose_review_board",
+    "board_independence",
+    "BoardIndependence",
+    "LENS_CYCLE",
+    "DEFAULT_TARGET_SEATS",
+    "FLOOR_SEATS",
     "BoardConfig",
     "BoardConfigError",
     "load_boards",

phase_loop_runtime-0.6.0/src/phase_loop_runtime/advisor_board/composition.py

@@ -0,0 +1,180 @@
+"""Availability-aware board composition — the 4-vendor default review panel.
+
+The ``code-review`` board's IDEAL shape is one seat per frontier vendor, each at
+its MAX thinking and each carrying a DISTINCT review lens:
+
+    grok    grok-4.5         max   lens=adversarial
+    claude  claude-fable-5   max   lens=correctness
+    codex   gpt-5.6-sol      max   lens=red-team
+    gemini  Gemini 3.1 Pro   high  lens=alternative-approach   (high == its ceiling)
+
+The load-bearing behavior is the **availability-aware fallback**: a panel must
+NEVER collapse to one or two reviewers just because one or two vendors are down.
+``compose_review_board`` detects the available vendors (via the advisor-board's
+canonical PATH probe — ``registries.DEFAULT_HARNESS_REGISTRY.is_available``, the
+SAME probe the matrix uses, so it is registration-driven and covers grok) and
+composes a board of ``target`` independent seats (default 4, HARD FLOOR 3):
+
+* one vendor-pure seat per available vendor first (its primary lens, max thinking);
+* then BACKFILL the remaining seats onto the available vendors, round-robin, each
+  with a DIFFERENT lens drawn from the lens cycle — so two available providers
+  still yield a full 4-seat board, and ONE available provider yields 4
+  distinct-lens seats on that provider.
+
+With at least one vendor up the board ALWAYS reaches ``target`` (the lens cycle is
+longer than the floor), so the floor is a structural safety net, never a cliff.
+Seats are emitted in a deterministic order (fixed vendor order, then round-robin
+backfill) so the composed board is snapshot-stable. No two seats ever share the
+same ``(vendor, model, lens)`` — lens-uniqueness per vendor guarantees it.
+
+Backfill stays on the vendor's own HOMEBREW lane (same model, same lane, next
+lens) — never a breadth/omnigent lane that would skip-with-warning without a
+gateway, which would defeat the point of keeping the reviewer count up.
+"""
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Callable
+from typing import NamedTuple
+
+from .registries import DEFAULT_HARNESS_REGISTRY
+from .schema import Board, Seat, vendor_family
+
+# Ideal per-vendor seat, in deterministic composition order. Each vendor runs at
+# its MAX thinking (gemini's ceiling is ``high``) with a distinct primary lens.
+_VENDOR_ORDER: tuple[str, ...] = ("grok", "claude", "codex", "gemini")
+_VENDOR_SEAT: dict[str, dict[str, str]] = {
+    "grok": {"model": "grok-4.5", "harness": "grok", "effort": "max", "lens": "adversarial"},
+    "claude": {"model": "claude-fable-5", "harness": "claude", "effort": "max", "lens": "correctness"},
+    "codex": {"model": "gpt-5.6-sol", "harness": "codex", "effort": "max", "lens": "red-team"},
+    "gemini": {"model": "Gemini 3.1 Pro", "harness": "gemini", "effort": "high", "lens": "alternative-approach"},
+}
+
+# Distinct lenses the backfill cycles through (each vendor's primary lens is drawn
+# from this set, so backfill naturally hands a vendor a lens it does not yet hold).
+# Longer than the floor so a single available vendor can always fill to target with
+# distinct lenses.
+LENS_CYCLE: tuple[str, ...] = (
+    "adversarial",
+    "correctness",
+    "red-team",
+    "opposing-counsel",
+    "conservative",
+    "alternative-approach",
+)
+
+DEFAULT_TARGET_SEATS = 4
+FLOOR_SEATS = 3
+
+
+def _seat_for(vendor: str, lens: str) -> Seat:
+    spec = _VENDOR_SEAT[vendor]
+    return Seat(model=spec["model"], effort=spec["effort"], harness=spec["harness"], lens=lens)
+
+
+def compose_review_board(
+    *,
+    is_available: Callable[[str], bool] | None = None,
+    target: int = DEFAULT_TARGET_SEATS,
+    floor: int = FLOOR_SEATS,
+    name: str = "code-review",
+    purpose: str = "code-review",
+) -> Board:
+    """Compose the availability-aware review board.
+
+    ``is_available(vendor) -> bool`` decides which vendors are up; it defaults to
+    the advisor-board's canonical PATH probe
+    (``DEFAULT_HARNESS_REGISTRY.is_available``) so composition is registration-
+    driven and grok is probed exactly like codex/gemini/claude. Inject it in tests
+    to simulate 4/3/2/1 vendors up.
+
+    Returns a ``Board`` of exactly ``target`` seats whenever ≥1 vendor is available
+    (never fewer than ``floor``); an empty board only when NO vendor is available.
+    """
+    if target < floor:
+        raise ValueError(f"target {target} is below the floor {floor}")
+    probe = is_available if is_available is not None else DEFAULT_HARNESS_REGISTRY.is_available
+    available = [v for v in _VENDOR_ORDER if probe(v)]
+    if not available:
+        # Nothing to compose — the caller's run degrades wholesale. (The floor is a
+        # count of INDEPENDENT reviewers to seat on AVAILABLE vendors; with zero up
+        # there is no reviewer to seat, so an empty board is the honest result.)
+        return Board(name=name, purpose=purpose, seats=())
+
+    seats: list[Seat] = []
+    used_keys: set[tuple[str, str, str]] = set()
+    used_lenses: dict[str, set[str]] = defaultdict(set)
+
+    def _add(vendor: str, lens: str) -> bool:
+        spec = _VENDOR_SEAT[vendor]
+        key = (vendor, spec["model"], lens)
+        if key in used_keys:
+            return False
+        seats.append(_seat_for(vendor, lens))
+        used_keys.add(key)
+        used_lenses[vendor].add(lens)
+        return True
+
+    # Phase 1 — one vendor-pure seat per available vendor (its primary lens).
+    for vendor in available:
+        _add(vendor, _VENDOR_SEAT[vendor]["lens"])
+
+    # Phase 2 — backfill to target, round-robin across available vendors, each next
+    # seat carrying the vendor's next UNUSED lens from the cycle. A vendor that has
+    # exhausted the lens cycle is skipped; the loop stops if no vendor can add a new
+    # distinct seat (unreachable with target ≤ len(LENS_CYCLE) and ≥1 vendor).
+    rr = 0
+    while len(seats) < target:
+        progressed = False
+        for _ in range(len(available)):
+            vendor = available[rr % len(available)]
+            rr += 1
+            next_lens = next((l for l in LENS_CYCLE if l not in used_lenses[vendor]), None)
+            if next_lens is not None and _add(vendor, next_lens):
+                progressed = True
+                break
+        if not progressed:
+            break  # every available vendor exhausted its lens cycle
+
+    return Board(name=name, purpose=purpose, seats=tuple(seats))
+
+
+class BoardIndependence(NamedTuple):
+    """The cross-vendor independence of a composed board — the governance signal a
+    consumer reads (e.g. gp's ``degraded_independence`` gate: auto_merge_disabled +
+    human_signoff) so it never trusts a same-vendor backfilled panel as if it were
+    cross-vendor independent."""
+
+    level: str            # "independent" | "degraded" | "none"
+    distinct_vendors: int
+    seats: int
+
+
+def board_independence(board: Board) -> BoardIndependence:
+    """Report whether ``board`` is cross-vendor ``independent`` or ``degraded``.
+
+    ``independent`` ONLY when every seat is a distinct vendor family (no backfill).
+    Any repeated vendor family means correlated blind spots → ``degraded`` (e.g. a
+    1-vendor board of 4 lens-varied seats). An empty board is ``none``. This is the
+    field the availability-aware fallback was missing: the 4-vendor CR (grok +
+    codex + gemini + claude, unanimous) flagged that a backfilled board looked
+    identical to a true cross-vendor one, so a governed gate could not fire on the
+    correlated-blind-spot risk."""
+    families = [vendor_family(seat.model, seat.harness) for seat in board.seats]
+    distinct = len(set(families))
+    n = len(families)
+    if n == 0:
+        level = "none"
+    elif distinct == n:
+        level = "independent"
+    else:
+        level = "degraded"
+    return BoardIndependence(level=level, distinct_vendors=distinct, seats=n)
+
+
+__all__ = [
+    "compose_review_board",
+    "LENS_CYCLE",
+    "DEFAULT_TARGET_SEATS",
+    "FLOOR_SEATS",
+]

{phase_loop_runtime-0.5.0 → phase_loop_runtime-0.6.0}/src/phase_loop_runtime/advisor_board/config.py

@@ -13,7 +13,7 @@ built-in ``presets``. Contract:
   top-level, board, or seat key raises ``BoardConfigError`` naming the key.
 * Every board (presets AND user boards) is validated through the compatibility
   matrix at load time, so an invalid ``(model, harness)`` pairing (e.g.
-  ``claude:gpt-5.5``) or an over-ceiling effort is rejected at CONFIG TIME with an
+  ``claude:gpt-5.6-sol``) or an over-ceiling effort is rejected at CONFIG TIME with an
   actionable message (``validation.validate_board``).
 
 A missing config file is not an error: the built-in presets load on their own.
@@ -31,6 +31,7 @@ except ModuleNotFoundError:  # Python 3.10 — the requires-python floor
     import tomli as tomllib  # type: ignore[no-redef]
 
 from .validation import SeatValidationError, validate_board
+from .composition import compose_review_board
 from .presets import DEFAULT_BOARD_NAME, PRESETS
 from .schema import (
     AUTH_LANES,
@@ -166,6 +167,7 @@ def load_boards(
     env: Mapping[str, str] | None = None,
     matrix: Any | None = None,
     validate: bool = True,
+    is_available: "Callable[[str], bool] | None" = None,
 ) -> BoardConfig:
     """Load the board config, layering user boards over the built-in presets.
 
@@ -174,10 +176,26 @@ def load_boards(
     False`` only for shape-parsing without availability (kept for tests). Raises
     ``BoardConfigError`` for any unknown key, malformed value, or matrix-invalid
     board — never a silent drop.
+
+    The ``code-review`` board is composed AVAILABILITY-AWARE (down vendors are
+    backfilled with distinct lenses onto available vendors, so a convened panel
+    never collapses to 1–2 reviewers) via ``composition.compose_review_board``.
+    ``is_available(vendor) -> bool`` decides which vendors are up; when omitted it
+    is taken from a probe-backed ``matrix`` (its harness registry probe, so the
+    availability view is single-sourced) and otherwise defaults to the advisor-
+    board PATH probe. Composition happens BEFORE the user overlay, so a
+    user-defined ``code-review`` board still wins.
     """
     boards: dict[str, Board] = dict(PRESETS)
     default_board = DEFAULT_BOARD_NAME
 
+    # Availability-aware code-review (before the user overlay so a user override wins).
+    compose_probe = is_available
+    if compose_probe is None and matrix is not None:
+        compose_probe = getattr(getattr(matrix, "harnesses", None), "is_available", None)
+    composed_review = compose_review_board(is_available=compose_probe)
+    boards[composed_review.name] = composed_review
+
     cfg_path = path if path is not None else board_config_path(env)
     if cfg_path.exists():
         with open(cfg_path, "rb") as fh:

{phase_loop_runtime-0.5.0 → phase_loop_runtime-0.6.0}/src/phase_loop_runtime/advisor_board/fixtures/advisor-boards.example.toml

@@ -14,7 +14,7 @@ default_board = "default"
 
 # The default board reproduces today's 3-leg panel (byte-for-byte back-compat).
 # Its three seats, in panel-leg order, render to today's exact CLI invocations:
-#   codex  gpt-5.5          effort=max  -> -c model_reasoning_effort=xhigh
+#   codex  gpt-5.6-sol          effort=max  -> -c model_reasoning_effort=xhigh
 #   gemini "Gemini 3.1 Pro" effort=high -> model "Gemini 3.1 Pro (High)"
 #   claude claude-sonnet-5  effort=max  -> --effort max
 [[boards]]
@@ -23,7 +23,7 @@ purpose = "premerge-review"
 allow_api_key_fallback = false
 
   [[boards.seats]]
-  model = "gpt-5.5"
+  model = "gpt-5.6-sol"
   effort = "max"
   harness = "codex"        # optional; omit to resolve via default_lane(model)
   auth = "subscription"    # subscription (default) | api_key
@@ -48,7 +48,7 @@ purpose = "code-review"
 allow_api_key_fallback = false
 
   [[boards.seats]]
-  model = "gpt-5.5"
+  model = "gpt-5.6-sol"
   effort = "max"
   harness = "codex"
 

{phase_loop_runtime-0.5.0 → phase_loop_runtime-0.6.0}/src/phase_loop_runtime/advisor_board/fixtures.py

@@ -27,7 +27,7 @@ CANONICAL_LEG_ORDER: tuple[str, ...] = ("codex", "gemini", "claude")
 # The default board's three seats — model-first, effort split out of the model
 # name. These reconstruct today's ``DEFAULT_LEG_MODELS`` under
 # ``harness_mapping.render_seat_invocation``:
-#   codex  gpt-5.5           + effort max  -> ``-c model_reasoning_effort=xhigh``
+#   codex  gpt-5.6-sol           + effort max  -> ``-c model_reasoning_effort=xhigh``
 #   gemini "Gemini 3.1 Pro"  + effort high -> model ``"Gemini 3.1 Pro (High)"``
 #   claude claude-fable-5    + effort max  -> ``--effort max``
 #
@@ -36,7 +36,7 @@ CANONICAL_LEG_ORDER: tuple[str, ...] = ("codex", "gemini", "claude")
 # Fable, not on the implementer model ``claude-sonnet-5``. This is byte-pinned to
 # ``panel_invoker.DEFAULT_LEG_MODELS["claude"]`` (also Fable) by the golden proof.
 DEFAULT_SEATS: tuple[Seat, ...] = (
-    Seat(model="gpt-5.5", effort="max", harness="codex",
+    Seat(model="gpt-5.6-sol", effort="max", harness="codex",
          auth=AUTH_SUBSCRIPTION, backing=BACKING_HOMEBREW),
     Seat(model="Gemini 3.1 Pro", effort="high", harness="gemini",
          auth=AUTH_SUBSCRIPTION, backing=BACKING_HOMEBREW),
@@ -54,7 +54,7 @@ DEFAULT_BOARD: Board = Board(
 # Golden literals the default seats must reproduce (cross-checked in the
 # back-compat test against the live ``panel_invoker`` constants).
 DEFAULT_SEAT_RENDERED_MODEL: dict[str, str] = {
-    "codex": "gpt-5.5",
+    "codex": "gpt-5.6-sol",
     "gemini": "Gemini 3.1 Pro (High)",
     "claude": "claude-fable-5",
 }
@@ -65,17 +65,20 @@ DEFAULT_SEAT_EFFORT_ARGS: dict[str, tuple[str, ...]] = {
 }
 
 # Canonical (model x harness) pairs ABDREG's matrix + ABDRESOLVE's validation test
-# against. Same-vendor-across-harness (gpt-5.5 on codex and opencode) is VALID and
-# projects to one family; a cross-vendor mismatch (gpt-5.5 on claude) is INVALID.
+# against. Same-vendor-across-harness (gpt-5.6-sol on codex and opencode) is VALID and
+# projects to one family; a cross-vendor mismatch (gpt-5.6-sol on claude) is INVALID.
 CANONICAL_VALID_PAIRS: tuple[tuple[str, str], ...] = (
-    ("gpt-5.5", "codex"),
-    ("gpt-5.5", "opencode"),
+    ("gpt-5.6-sol", "codex"),
+    ("gpt-5.6-sol", "opencode"),
     ("claude-sonnet-5", "claude"),
     ("Gemini 3.1 Pro", "gemini"),
+    ("grok-4.5", "grok"),  # xAI-family model on the grok lane (4-vendor board)
 )
 CANONICAL_INVALID_PAIRS: tuple[tuple[str, str], ...] = (
-    ("gpt-5.5", "claude"),        # openai-family model on the claude lane
+    ("gpt-5.6-sol", "claude"),        # openai-family model on the claude lane
     ("claude-sonnet-5", "codex"),  # anthropic model on the codex lane
+    ("grok-4.5", "claude"),        # xAI-family model on the claude lane
+    ("gpt-5.6-sol", "grok"),       # openai-family model on the grok lane
 )
 
 # A two-same-vendor-seat board: exercises result re-keying (leg -> seat) and the
@@ -85,7 +88,7 @@ TWO_SAME_VENDOR_BOARD: Board = Board(
     name="two-openai",
     purpose="brainstorm",
     seats=(
-        Seat(model="gpt-5.5", effort="high", harness="codex"),
-        Seat(model="gpt-5.5", effort="high", harness="opencode"),
+        Seat(model="gpt-5.6-sol", effort="high", harness="codex"),
+        Seat(model="gpt-5.6-sol", effort="high", harness="opencode"),
     ),
 )

{phase_loop_runtime-0.5.0 → phase_loop_runtime-0.6.0}/src/phase_loop_runtime/advisor_board/harness_mapping.py

@@ -64,6 +64,17 @@ _CODEX_EFFORT: dict[str, str] = {
     "max": "xhigh",
 }
 
+# canonical effort -> grok ``--reasoning-effort`` token. The grok CLI accepts
+# ``none, minimal, low, medium, high, xhigh, max`` (verified via ``grok --help`` /
+# an out-of-range probe), so canonical ``max`` maps straight to grok's own ``max``
+# ceiling — the panel's grok seat runs at grok-4.5's maximum reasoning.
+_GROK_EFFORT: dict[str, str] = {
+    "low": "low",
+    "medium": "medium",
+    "high": "high",
+    "max": "max",
+}
+
 # canonical effort -> the ``(Word)`` token agy/gemini bakes into the model name
 # (panel_invoker.py:1016 uses ``(High)``).
 _GEMINI_EFFORT_WORD: dict[str, str] = {
@@ -102,8 +113,9 @@ def _require_effort(effort: str) -> None:
 def render_seat_invocation(harness: str, model: str, effort: str) -> SeatInvocation:
     """Freeze: turn a canonical ``(harness, model, effort)`` into its CLI invocation.
 
-    Only the built-3 homebrew lanes (claude / codex / gemini) are frozen here —
-    they are what the ``default`` board's back-compat proof rides on. Breadth
+    Only the homebrew lanes (claude / codex / gemini / grok) are frozen here —
+    claude / codex / gemini are what the ``default`` board's back-compat proof
+    rides on; grok joins them for the 4-vendor ``code-review`` board. Breadth
     lanes (opencode / pi / cursor / amp) raise ``EffortMappingError`` until
     ABDREG/ABDHOME/ABDOMNI populate them; a board with an unmapped lane degrades
     skip-with-warning, never silently drops effort.
@@ -120,6 +132,11 @@ def render_seat_invocation(harness: str, model: str, effort: str) -> SeatInvocat
     if lane == "gemini":
         # panel_invoker.py:1016 -> effort baked into ``--model "<base> (Word)"``
         return SeatInvocation(lane, render_gemini_model(model, effort), (), MECH_MODEL_NAME)
+    if lane == "grok":
+        # grok headless -> ``--reasoning-effort <token>`` (alias ``--effort``); the
+        # model is passed verbatim via ``-m``. Same flag mechanism as claude.
+        token = _GROK_EFFORT[effort]
+        return SeatInvocation(lane, model, ("--reasoning-effort", token), MECH_FLAG)
     raise EffortMappingError(
         f"effort mapping for harness {harness!r} is populated in ABDREG/ABDHOME/ABDOMNI"
     )

{phase_loop_runtime-0.5.0 → phase_loop_runtime-0.6.0}/src/phase_loop_runtime/advisor_board/matrix.py

@@ -15,7 +15,7 @@ Populates the frozen ``CompatibilityMatrix`` interface (registries.py:101-115):
 Validity is model-first: a pairing is valid iff the harness's lane vendor-family
 matches the model's vendor-family (the FROZEN ``schema.vendor_family`` projection
 that also keeps the governed reviewer≠author disjointness intact). That makes
-``gpt-5.5`` valid on both ``codex`` and ``opencode`` (same family) but invalid on
+``gpt-5.6-sol`` valid on both ``codex`` and ``opencode`` (same family) but invalid on
 ``claude`` — exactly ``fixtures.CANONICAL_VALID_PAIRS`` /
 ``CANONICAL_INVALID_PAIRS``.
 

{phase_loop_runtime-0.5.0 → phase_loop_runtime-0.6.0}/src/phase_loop_runtime/advisor_board/presets.py

@@ -6,8 +6,9 @@ Nine built-in presets, each a named, purpose-tagged, open-ended seat list:
                     the back-compat keystone holds by construction: the default
                     board reconstructs today's exact three seats (the claude seat
                     on Fable, ``claude-fable-5``).
-* ``code-review`` — three frontier vendors, each adversarial: codex ``gpt-5.5``,
-                    ``Gemini 3.1 Pro``, and ``claude-fable-5``.
+* ``code-review`` — the 4-vendor cross-vendor board (grok / claude / codex /
+                    gemini) at max thinking, distinct lenses, composed
+                    availability-aware (``composition.compose_review_board``).
 * ``brainstorm``  — multi-vendor divergent thinking, lens-differentiated.
 * ``doc-edit``    — a lighter documentation-editing board.
 * ``legal-review`` / ``legal-strategy-review`` / ``legal-brainstorm`` — the legal
@@ -32,21 +33,20 @@ strings (``schema.py``): the legal lenses/purposes below need no enum extension.
 """
 from __future__ import annotations
 
+from .composition import compose_review_board
 from .fixtures import DEFAULT_BOARD
 from .schema import Board, Seat
 
-# code-review: review-class = three frontier vendors, always. Each seat carries the
-# adversarial lens (find-the-bug framing); the claude seat is Fable, not the
-# implementer. This supersedes the old two-seat (codex + sonnet) composition.
-CODE_REVIEW_BOARD: Board = Board(
-    name="code-review",
-    purpose="code-review",
-    seats=(
-        Seat(model="gpt-5.5", effort="max", harness="codex", lens="adversarial"),
-        Seat(model="Gemini 3.1 Pro", effort="high", harness="gemini", lens="adversarial"),
-        Seat(model="claude-fable-5", effort="max", harness="claude", lens="adversarial"),
-    ),
-)
+# code-review: review-class = the 4-vendor cross-vendor board, each vendor at MAX
+# thinking with a DISTINCT lens (grok=adversarial, claude=correctness,
+# codex=red-team, gemini=alternative-approach). This is the IDEAL (all-vendors-up)
+# shape; the live panel composes it AVAILABILITY-AWARE via
+# ``composition.compose_review_board`` — down vendors are backfilled with distinct
+# lenses onto available vendors so the reviewer count never drops below the floor.
+# The static preset here is the all-available composition (so a snapshot / config
+# validation sees the canonical 4-seat board); it supersedes the old three-seat
+# adversarial board.
+CODE_REVIEW_BOARD: Board = compose_review_board(is_available=lambda _vendor: True)
 
 # brainstorm: divergent, multi-vendor, each seat a different thinking lens.
 BRAINSTORM_BOARD: Board = Board(
@@ -54,7 +54,7 @@ BRAINSTORM_BOARD: Board = Board(
     purpose="brainstorm",
     seats=(
         Seat(model="claude-sonnet-5", effort="high", harness="claude", lens="adversarial"),
-        Seat(model="gpt-5.5", effort="high", harness="codex", lens="supportive"),
+        Seat(model="gpt-5.6-sol", effort="high", harness="codex", lens="supportive"),
         Seat(model="Gemini 3.1 Pro", effort="high", harness="gemini", lens="lateral"),
     ),
 )
@@ -65,7 +65,7 @@ DOC_EDIT_BOARD: Board = Board(
     purpose="doc-edit",
     seats=(
         Seat(model="claude-sonnet-5", effort="medium", harness="claude", lens="copyedit"),
-        Seat(model="gpt-5.5", effort="medium", harness="codex", lens="structure"),
+        Seat(model="gpt-5.6-sol", effort="medium", harness="codex", lens="structure"),
     ),
 )
 
@@ -83,7 +83,7 @@ LEGAL_REVIEW_BOARD: Board = Board(
     name="legal-review",
     purpose="legal-review",
     seats=(
-        Seat(model="gpt-5.5", effort="max", harness="codex", lens="opposing-counsel"),
+        Seat(model="gpt-5.6-sol", effort="max", harness="codex", lens="opposing-counsel"),
         Seat(model="Gemini 3.1 Pro", effort="high", harness="gemini", lens="risk-liability"),
         Seat(model="claude-fable-5", effort="max", harness="claude", lens="authority-verification"),
     ),
@@ -95,7 +95,7 @@ LEGAL_STRATEGY_REVIEW_BOARD: Board = Board(
     name="legal-strategy-review",
     purpose="legal-strategy-review",
     seats=(
-        Seat(model="gpt-5.5", effort="max", harness="codex", lens="red-team"),
+        Seat(model="gpt-5.6-sol", effort="max", harness="codex", lens="red-team"),
         Seat(model="Gemini 3.1 Pro", effort="high", harness="gemini", lens="alternatives"),
         Seat(model="claude-fable-5", effort="max", harness="claude", lens="downside-ethics"),
     ),
@@ -108,7 +108,7 @@ LEGAL_BRAINSTORM_BOARD: Board = Board(
     purpose="legal-brainstorm",
     seats=(
         Seat(model="claude-sonnet-5", effort="high", harness="claude", lens="aggressive"),
-        Seat(model="gpt-5.5", effort="high", harness="codex", lens="conservative"),
+        Seat(model="gpt-5.6-sol", effort="high", harness="codex", lens="conservative"),
         Seat(model="Gemini 3.1 Pro", effort="high", harness="gemini", lens="creative"),
     ),
 )
@@ -127,7 +127,7 @@ GENERAL_BOARD: Board = Board(
     name="general",
     purpose="general",
     seats=(
-        Seat(model="gpt-5.5", effort="max", harness="codex", lens="adversarial"),
+        Seat(model="gpt-5.6-sol", effort="max", harness="codex", lens="adversarial"),
         Seat(model="Gemini 3.1 Pro", effort="high", harness="gemini", lens="alternative"),
         Seat(model="claude-fable-5", effort="max", harness="claude", lens="completeness"),
     ),

{phase_loop_runtime-0.5.0 → phase_loop_runtime-0.6.0}/src/phase_loop_runtime/advisor_board/registries.py

@@ -104,7 +104,7 @@ class CompatibilityMatrix(Protocol):
 
     ``is_valid(model, harness)`` -> ``(ok, AuthAvailability)``: ``ok`` is whether
     the pairing is *expressible at all* (an invalid pairing such as
-    ``claude:gpt-5.5`` is rejected at config time with a clear message); the
+    ``claude:gpt-5.6-sol`` is rejected at config time with a clear message); the
     ``AuthAvailability`` reports which lanes are actually usable so a valid-but-
     unauthed seat degrades rather than blocks. ``default_lane`` is the harness a
     bare ``model`` seat resolves onto.
@@ -184,21 +184,26 @@ class UnknownHarnessError(KeyError):
 
 # --- harness registry data --------------------------------------------------
 
-# The six harnesses. claude / codex / gemini are the built-3 (homebrew, native +
-# TUI legs, ABDHOME); opencode / pi / cursor are breadth — registered here
+# The registered harnesses. claude / codex / gemini / grok are the homebrew built-4
+# (native + TUI legs, ABDHOME); opencode / pi / cursor are breadth — registered here
 # regardless, but their default transport is ``omnigent`` (routed via
 # omniagent-plus -> Omnigent per ABDOMNI; NOT hand-written homebrew adapters).
-# ``cli`` is the availability-probe binary: codex -> ``codex``, gemini -> ``agy``
-# (panel_invoker._LEG_CLI), cursor -> ``cursor-agent`` (so cursor is gated on the
-# cursor-agent binary being present). All six support both credential lanes; the
-# subscription lane is the default and the api-key lane is reachable only behind a
-# board opt-in (never-silent-key).
+# ``cli`` is the availability-probe binary: codex -> ``codex``, gemini -> ``agy``,
+# grok -> ``grok`` (panel_invoker._LEG_CLI), cursor -> ``cursor-agent`` (so cursor is
+# gated on the cursor-agent binary being present). claude / codex / gemini support
+# both credential lanes; the subscription lane is the default and the api-key lane is
+# reachable only behind a board opt-in (never-silent-key). grok is registered
+# SUBSCRIPTION-ONLY (its headless CLI drives a Grok subscription login; no vendor
+# api-key var is wired for it — see ``backing.VENDOR_API_KEY_VARS``), so a grok seat
+# never touches the api-key lane.
 _BOTH_LANES: tuple[str, ...] = (AUTH_SUBSCRIPTION, AUTH_API_KEY)
+_SUBSCRIPTION_ONLY: tuple[str, ...] = (AUTH_SUBSCRIPTION,)
 
 _HARNESS_SPECS: tuple[HarnessSpec, ...] = (
     HarnessSpec(name="claude", cli="claude", auth_lanes=_BOTH_LANES, backing=BACKING_HOMEBREW),
     HarnessSpec(name="codex", cli="codex", auth_lanes=_BOTH_LANES, backing=BACKING_HOMEBREW),
     HarnessSpec(name="gemini", cli="agy", auth_lanes=_BOTH_LANES, backing=BACKING_HOMEBREW),
+    HarnessSpec(name="grok", cli="grok", auth_lanes=_SUBSCRIPTION_ONLY, backing=BACKING_HOMEBREW),
     HarnessSpec(name="opencode", cli="opencode", auth_lanes=_BOTH_LANES, backing=BACKING_OMNIGENT),
     HarnessSpec(name="pi", cli="pi", auth_lanes=_BOTH_LANES, backing=BACKING_OMNIGENT),
     HarnessSpec(name="cursor", cli="cursor-agent", auth_lanes=_BOTH_LANES, backing=BACKING_OMNIGENT),
@@ -243,18 +248,19 @@ class DefaultHarnessRegistry:
 # from the governed-gate mapping). ``runnable_by`` is derived from that family
 # across the six harnesses (a harness runs a model iff its lane vendor-family
 # matches). ``default_lane`` is PINNED to a built-3 leg so a bare seat resolves
-# onto the native lane — e.g. ``gpt-5.5`` is runnable by both ``codex`` and
-# ``opencode`` but a bare ``gpt-5.5`` seat MUST resolve to ``codex`` or the
+# onto the native lane — e.g. ``gpt-5.6-sol`` is runnable by both ``codex`` and
+# ``opencode`` but a bare ``gpt-5.6-sol`` seat MUST resolve to ``codex`` or the
 # default board's back-compat breaks. ``effort_ceiling`` defaults to the ladder
 # max; lower it only where there is concrete evidence a model caps out below max
 # (none of the built-3 do — codex's ``xhigh`` IS canonical ``max``).
 _MODEL_DEFS: tuple[tuple[str, str, str], ...] = (
-    ("gpt-5.5", "codex", "max"),
+    ("gpt-5.6-sol", "codex", "max"),
     ("claude-sonnet-5", "claude", "max"),
     ("claude-opus-4-8", "claude", "max"),
     ("claude-haiku-4-5", "claude", "max"),
     ("claude-fable-5", "claude", "max"),
     ("Gemini 3.1 Pro", "gemini", "max"),
+    ("grok-4.5", "grok", "max"),
 )