phase-loop-runtime 0.6.1__tar.gz → 0.7.0__tar.gz

{phase_loop_runtime-0.6.1 → phase_loop_runtime-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phase-loop-runtime
-Version: 0.6.1
+Version: 0.7.0
 Summary: Harness-neutral phase-loop orchestration runtime and CLI
 Author: ViperJuice
 License-Expression: Apache-2.0
@@ -20,6 +20,9 @@ Requires-Dist: pydantic<3,>=2
 Requires-Dist: PyYAML<7,>=6
 Requires-Dist: consiliency-contract<0.7,>=0.6.5
 Requires-Dist: jsonschema<5,>=4
+Requires-Dist: packaging>=21
+Requires-Dist: websockets<16,>=12
+Requires-Dist: rfc8785<0.2,>=0.1.4
 Requires-Dist: tomli<3,>=2; python_version < "3.11"
 
 # phase-loop-runtime

{phase_loop_runtime-0.6.1 → phase_loop_runtime-0.7.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.6.1"
+version = "0.7.0"
 description = "Harness-neutral phase-loop orchestration runtime and CLI"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -44,6 +44,16 @@ dependencies = [
     # guarantees the contract-owned vocabulary (incl. governance_contracts) is live.
     "consiliency-contract>=0.6.5,<0.7",
     "jsonschema>=4,<5",
+    # `phase-loop doctor` (IF-0-AHADOPT-2) compares consumer pins to registry
+    # latest with PEP 440 version ordering. Declared so the BOM produces real
+    # stale|current verdicts on the isolated `uv tool install` path (where pip —
+    # and its transitive packaging — is not present); the doctor still degrades to
+    # `unknown` rather than crash if it is somehow absent.
+    "packaging>=21",
+    # Governed task-message resolver: authenticated Codex app-server transport
+    # plus contract-identical RFC 8785 approval-body hashing.
+    "websockets>=12,<16",
+    "rfc8785>=0.1.4,<0.2",
     # Advisor Board config loader (ABDREG) parses advisor-boards.toml. tomllib is
     # stdlib on 3.11+; on the 3.10 requires-python floor it is absent, so pull in
     # the tomli backport there (import shim in advisor_board/config.py).

{phase_loop_runtime-0.6.1 → phase_loop_runtime-0.7.0}/src/phase_loop_runtime/__init__.py

@@ -18,4 +18,4 @@ __all__ = [
     "state_ops",
 ]
 
-__version__ = "0.6.1"
+__version__ = "0.7.0"

{phase_loop_runtime-0.6.1 → phase_loop_runtime-0.7.0}/src/phase_loop_runtime/advisor_board/CONTRACTS.md

@@ -255,6 +255,19 @@ the golden proves byte-identity):
   `claude` seats) now runs two concurrent same-lane CLI/PTY sessions — a scenario this
   fan-out newly enables and nothing yet tests. The `default` board has one claude seat,
   so it is unaffected.
+- **Opt-in streaming delivery (REVIEWGOV IF-0-REVIEWGOV-2).** `_run_legs_ordered` (and
+  the `invoke_panel` / `invoke_board` entry points) take optional, keyword-only,
+  default-`None` `on_leg_complete` (a per-leg callback) and `stream_dir` /
+  `review_dir` (incremental per-leg verdict files). When BOTH are `None` the path is
+  byte-for-byte the historical one — block on the futures in submission order — so the
+  golden is untouched. When EITHER is set, results are collected via `as_completed` so
+  each leg is delivered the MOMENT it lands (callback + a `leg-<i>-<label>.verdict.json`
+  file written into the dir), while the **consolidated return is still re-sorted to
+  submission order** (`result[i]` ↔ `items[i]`). The side-channel is **fail-open**: a
+  raising callback or an unwritable dir is swallowed (logged), never breaking the pool
+  or failing a leg. Proven by a SINGLE shared out-of-order-completion fixture used by
+  both the default-ordering (golden) and fast-before-slow (streaming) tests, so the
+  golden cannot pass trivially.
 
 ## ABDREF — "Reference, don't inline" ingestion · `panel_invoker._resolve_artifact` / `_resolve_brief`
 

{phase_loop_runtime-0.6.1 → phase_loop_runtime-0.7.0}/src/phase_loop_runtime/advisor_board/__init__.py

@@ -86,6 +86,7 @@ from .composition import (
     BoardIndependence,
     board_independence,
     compose_review_board,
+    default_board_auth_ok,
 )
 from .presets import (
     CODE_REVIEW_BOARD,
@@ -229,6 +230,7 @@ __all__ = [
     "get_preset",
     # composition (availability-aware 4-vendor board)
     "compose_review_board",
+    "default_board_auth_ok",
     "board_independence",
     "BoardIndependence",
     "LENS_CYCLE",

{phase_loop_runtime-0.6.1 → phase_loop_runtime-0.7.0}/src/phase_loop_runtime/advisor_board/composition.py

@@ -72,9 +72,33 @@ def _seat_for(vendor: str, lens: str) -> Seat:
     return Seat(model=spec["model"], effort=spec["effort"], harness=spec["harness"], lens=lens)
 
 
+def default_board_auth_ok(vendor: str) -> bool:
+    """Production auth gate for a board vendor (REVIEWGOV-W1 / #151).
+
+    Reuses the executor's OWN cached, timeout-bounded, fail-closed ``auth_ok`` — the
+    closure ``capability_registry`` binds onto each record, which wraps
+    ``executor_availability.auth_ok_for`` over that record's
+    ``auth_preflight_probes`` (the same probes ``run_auth_preflight`` uses). So the
+    board's auth verdict is single-sourced with the dispatch path's, cached across
+    the board's seats, and never re-implements probing. A board vendor with no
+    registered capability record, or whose gate raises, fails CLOSED (treated as
+    unauthed → dropped → backfilled). The board vendors (grok/claude/codex/gemini)
+    map 1:1 onto executor names. Import is function-local to avoid the
+    ``advisor_board`` ↔ ``capability_registry`` import cycle."""
+    from ..capability_registry import capability_registry
+
+    try:
+        gate = capability_registry().get(vendor)
+        auth_ok = getattr(gate, "auth_ok", None) if gate is not None else None
+        return bool(auth_ok()) if auth_ok is not None else False
+    except Exception:
+        return False
+
+
 def compose_review_board(
     *,
     is_available: Callable[[str], bool] | None = None,
+    auth_ok: Callable[[str], bool] | None = None,
     target: int = DEFAULT_TARGET_SEATS,
     floor: int = FLOOR_SEATS,
     name: str = "code-review",
@@ -82,19 +106,49 @@ def compose_review_board(
 ) -> 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.
+    A vendor is seated only when it is BOTH reachable AND authenticated —
+    composition gates on ``is_available ∧ auth_ok`` (REVIEWGOV IF-0-REVIEWGOV-1 /
+    #151). A PATH-present-but-unauthenticated vendor (e.g. a ``grok`` binary on PATH
+    with no logged-in session) is treated as **down**: it is dropped and its seat is
+    backfilled onto an authenticated vendor with a distinct lens, exactly like a
+    PATH-absent vendor. This closes the hole where the board composed on PATH alone
+    and seated a vendor whose leg would then fail-closed to DEGRADED.
+
+    ``is_available(vendor) -> bool`` decides reachability; 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.
+
+    ``auth_ok(vendor) -> bool`` decides authentication; it defaults to
+    ``default_board_auth_ok`` (the cached, timeout-bounded, fail-closed
+    ``auth_ok_for`` gate), so the production default is genuinely auth-aware.
+
+    **Test affordance (documented coupling, not the general contract):** when
+    ``is_available`` is INJECTED but ``auth_ok`` is not, auth defaults to
+    pass-through (every vendor treated authed) so an availability-SIMULATION caller
+    fully owns the gate and never shells out to the real auth probe. Inject
+    ``auth_ok`` explicitly to simulate the auth dimension. The all-vendors-up static
+    presets (``presets.CODE_REVIEW_BOARD``, ``resolver._STANDIN_CODE_REVIEW``) rely
+    on this so their module-import composition stays hermetic. Any NON-test caller
+    that injects ``is_available`` alone therefore opts OUT of auth gating — pass
+    ``auth_ok`` (e.g. ``default_board_auth_ok``) to keep it.
 
     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.
+    and authed (never fewer than ``floor``); an empty board only when NO vendor is
+    both up and authed.
     """
     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)]
+    avail_probe = is_available if is_available is not None else DEFAULT_HARNESS_REGISTRY.is_available
+    if auth_ok is not None:
+        auth_probe = auth_ok
+    elif is_available is not None:
+        # Injected availability owns the gate: auth defaults to pass-through so a
+        # simulation caller never shells out (see docstring test affordance).
+        auth_probe = lambda _vendor: True  # noqa: E731
+    else:
+        auth_probe = default_board_auth_ok
+    available = [v for v in _VENDOR_ORDER if avail_probe(v) and auth_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
@@ -174,6 +228,7 @@ def board_independence(board: Board) -> BoardIndependence:
 
 __all__ = [
     "compose_review_board",
+    "default_board_auth_ok",
     "LENS_CYCLE",
     "DEFAULT_TARGET_SEATS",
     "FLOOR_SEATS",

{phase_loop_runtime-0.6.1 → phase_loop_runtime-0.7.0}/src/phase_loop_runtime/advisor_board/config.py

@@ -31,7 +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 .composition import compose_review_board, default_board_auth_ok
 from .presets import DEFAULT_BOARD_NAME, PRESETS
 from .schema import (
     AUTH_LANES,
@@ -168,6 +168,7 @@ def load_boards(
     matrix: Any | None = None,
     validate: bool = True,
     is_available: "Callable[[str], bool] | None" = None,
+    auth_ok: "Callable[[str], bool] | None" = None,
 ) -> BoardConfig:
     """Load the board config, layering user boards over the built-in presets.
 
@@ -185,6 +186,16 @@ def load_boards(
     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.
+
+    ``auth_ok(vendor) -> bool`` (REVIEWGOV-W1 / #151) additionally gates the
+    composed ``code-review`` board on AUTHENTICATION so a PATH-present-but-unauthed
+    vendor is dropped and backfilled. When omitted it defaults to
+    ``composition.default_board_auth_ok`` — the cached, timeout-bounded, fail-closed
+    ``auth_ok_for`` gate — so the LIVE convening path is genuinely auth-aware (the
+    real fix for #151). The gate only runs for vendors that pass the availability
+    (PATH) probe, so a host with no vendor CLI installed short-circuits without
+    shelling out. Inject ``auth_ok`` (e.g. ``lambda _v: True``) to isolate the
+    availability dimension in a test.
     """
     boards: dict[str, Board] = dict(PRESETS)
     default_board = DEFAULT_BOARD_NAME
@@ -193,7 +204,14 @@ def load_boards(
     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)
+    # #151: the LIVE convening path is auth-aware by DEFAULT — a PATH-present but
+    # unauthenticated vendor is dropped and backfilled. Pass an explicit ``auth_ok``
+    # so the composer never falls through to its is_available-injected pass-through
+    # affordance (which exists only for the static presets / simulation tests). The
+    # gate short-circuits for vendors that fail the availability probe, so a host
+    # with no vendor CLI never shells out.
+    compose_auth = auth_ok if auth_ok is not None else default_board_auth_ok
+    composed_review = compose_review_board(is_available=compose_probe, auth_ok=compose_auth)
     boards[composed_review.name] = composed_review
 
     cfg_path = path if path is not None else board_config_path(env)

{phase_loop_runtime-0.6.1 → phase_loop_runtime-0.7.0}/src/phase_loop_runtime/capability_registry.py

@@ -122,6 +122,9 @@ DEFAULT_CAPABILITY_REGISTRY = {
         subagent_posture="native",
         live_available=True,
         dry_run_available=True,
+        # tty-only: the claude leg drives the interactive TUI and needs a real
+        # controlling terminal, so it must never be auto-picked headlessly.
+        headless_launchable=False,
         live_proof_gate="disposable_proof_required",
         promotion_status="proof_gated",
         promotion_requirements=(
@@ -241,6 +244,52 @@ DEFAULT_CAPABILITY_REGISTRY = {
         output_capture_format="terminal_summary",
         default_model_profiles={action: _ACTION_DEFAULT_PROFILES[action] for action in ("roadmap", "plan", "execute", "repair", "review")},
     ),
+    "grok": ExecutorCapabilityRecord(
+        executor="grok",
+        supported_actions=("roadmap", "plan", "execute", "repair", "review"),
+        # GROKEXEC: grok runs headless (`grok -p`) with `--output-format plain`, so
+        # like the agy/gemini leg it has NO structured-output flag on this path (the
+        # closeout is prompt-injected + text-parsed). Its permission model is
+        # all-or-nothing per-run (`--permission-mode`), so `explicit_approval_controls`
+        # is dropped, mirroring gemini. `skill_bundle_injection` is ALSO dropped: grok
+        # ships no bespoke phase-loop skill bundle, so it is driven purely by the
+        # staged context file (`context_file_instructions`) — claiming bundle injection
+        # would be dishonest (no grok-* skills exist to inject).
+        capabilities=(
+            "live_launch",
+            "dry_run",
+            "inline_instructions",
+            "context_file_instructions",
+        ),
+        strengths=("xAI-family reasoning model", "context-file friendly", "authenticated local CLI"),
+        # grok write actions auto-approve via `--permission-mode bypassPermissions`;
+        # `review` is HARD read-only via a `--tools` allow-list of read/search
+        # built-ins only (headless grok auto-approves writes regardless of
+        # permission-mode/sandbox, so tool restriction is the only real lever).
+        limits=(
+            "requires local grok CLI subscription auth",
+            "grok headless auto-approves writes; write actions run bypassPermissions, review is read-only via a read-only --tools allow-list",
+            "grok --output-format plain emits no structured JSON; closeout is prompt-injected and text-parsed",
+        ),
+        injection_mode="context_file",
+        permission_posture="explicit",
+        subagent_posture="limited",
+        live_available=True,
+        dry_run_available=True,
+        live_proof_gate="disposable_proof_required",
+        promotion_status="proof_gated",
+        promotion_requirements=(
+            "fake harness parity regression proof",
+            "disposable live roadmap proof",
+            "launch.json",
+            "terminal-summary.json",
+        ),
+        auth_preflight_mode="metadata_only",
+        auth_preflight_probes=("grok --version", "grok --help"),
+        timeout_posture="runner_managed",
+        output_capture_format="terminal_summary",
+        default_model_profiles={action: _ACTION_DEFAULT_PROFILES[action] for action in ("roadmap", "plan", "execute", "repair", "review")},
+    ),
     "opencode": ExecutorCapabilityRecord(
         executor="opencode",
         supported_actions=("roadmap", "plan", "execute", "repair", "review"),
@@ -354,6 +403,8 @@ DEFAULT_CAPABILITY_REGISTRY = {
         subagent_posture="none",
         live_available=False,
         dry_run_available=True,
+        # No headless launch surface at all (operator handoff, not a spawned CLI).
+        headless_launchable=False,
         promotion_status="manual_only",
         promotion_requirements=("manual import", "shared automation handoff"),
         timeout_posture="unknown",
@@ -436,6 +487,18 @@ DEFAULT_PROVIDER_POLICY_CAPABILITIES = {
             "thinkingConfig.thinkingLevel is carried by custom aliases and is not exposed as a CLI flag.",
         ),
     ),
+    "grok": ProviderPolicyCapability(
+        provider="xai",
+        executor="grok",
+        supported_work_units=_ALL_WORK_UNITS,
+        supported_efforts=_ALL_EFFORTS,
+        unsupported_policy_behavior=_FAIL_CLOSED,
+        default_effort="medium",
+        effort_map={effort: effort for effort in _ALL_EFFORTS},
+        notes=(
+            "grok's `--reasoning-effort` CLI flag accepts a superset of NORMALIZED_EFFORT_LEVELS (its own set adds `none`), so every normalized effort passes through directly with no clamp.",
+        ),
+    ),
     "gemini-api": ProviderPolicyCapability(
         provider="gemini-api-openai-compatible",
         executor="command",
@@ -508,8 +571,74 @@ DEFAULT_PROVIDER_POLICY_CAPABILITIES = {
 }
 
 
+_BOUND_CAPABILITY_REGISTRY: dict[str, ExecutorCapabilityRecord] | None = None
+
+
+def _provider_backing_for(executor: str):
+    """EXECREG (IF-0-EXECREG-1): the ``provider_backing`` seam hook, wired to the
+    ``AgentRuntimeProvider`` seam (``agent_runtime_provider.py``). The registry maps
+    each executor to its ``AgentRuntimeProvider`` backing; none is registered yet,
+    so every executor resolves to ``None`` — nullable, no behavior change. A future
+    backing swap (TUI -> official API, per north-star Principle 3) is a binding here,
+    not a dispatch edit. Function-local import keeps this off the module import path
+    (and out of any cycle)."""
+    from .agent_runtime_provider import AgentRuntimeProvider
+
+    # executor -> registered AgentRuntimeProvider backing (empty until B5/backings land).
+    provider_registry: dict[str, AgentRuntimeProvider] = {}
+    return provider_registry.get(executor)
+
+
+def _bind_capability_records(
+    base: dict[str, ExecutorCapabilityRecord]
+) -> dict[str, ExecutorCapabilityRecord]:
+    """Attach the EXECREG callables to each base record. Function-local imports
+    break the launcher<->capability_registry import cycle (launcher imports this
+    module at top level). The cache/memo for auth/availability lives in
+    ``executor_availability`` (module level), never on the frozen record."""
+    from .launcher import LAUNCH_COMMAND_BUILDERS, SESSION_TRANSCRIPT_HOOKS
+    from .executor_availability import auth_ok_for, is_executor_available
+
+    bound: dict[str, ExecutorCapabilityRecord] = {}
+    for name, record in base.items():
+        bound[name] = record.bind_runtime(
+            build_command=LAUNCH_COMMAND_BUILDERS.get(name),
+            is_available=(lambda executor=name: is_executor_available(executor)),
+            auth_ok=(
+                lambda executor=name, probes=record.auth_preflight_probes: auth_ok_for(
+                    executor, probes
+                )
+            ),
+            provider_backing=_provider_backing_for(name),
+            # EXECREG session-preservation seam: a metadata-only transcript hook per
+            # executor (registry-driven, like build_command). Only executors that
+            # persist a discoverable session (grok) register one; the rest resolve
+            # to None — dormant until AUTOSEL/observability wires them.
+            get_session_transcript=SESSION_TRANSCRIPT_HOOKS.get(name),
+        )
+    return bound
+
+
+_BOUND_CACHE_SOURCE: dict[str, ExecutorCapabilityRecord] | None = None
+
+
 def capability_registry() -> dict[str, ExecutorCapabilityRecord]:
-    return DEFAULT_CAPABILITY_REGISTRY
+    """The executor capability registry, with EXECREG runtime callables bound onto
+    each record (``build_command`` / ``is_available`` / ``auth_ok`` /
+    ``provider_backing`` / ``get_session_transcript``). Bound lazily and cached
+    keyed on the identity of ``DEFAULT_CAPABILITY_REGISTRY`` — so the binding cost is
+    paid once in the common case, but a test (or any caller) that REPLACES
+    ``DEFAULT_CAPABILITY_REGISTRY`` (e.g. ``patch(..., patched_registry)``) is
+    honored: the identity changes, so the cache rebinds against the new source
+    instead of returning a stale snapshot. Metadata is identical to the source
+    (record equality is unaffected — the callables are ClassVar bindings, not
+    fields)."""
+    global _BOUND_CAPABILITY_REGISTRY, _BOUND_CACHE_SOURCE
+    source = DEFAULT_CAPABILITY_REGISTRY
+    if _BOUND_CAPABILITY_REGISTRY is None or _BOUND_CACHE_SOURCE is not source:
+        _BOUND_CAPABILITY_REGISTRY = _bind_capability_records(source)
+        _BOUND_CACHE_SOURCE = source
+    return _BOUND_CAPABILITY_REGISTRY
 
 
 def provider_policy_capabilities() -> dict[str, ProviderPolicyCapability]:
@@ -633,7 +762,18 @@ def resolve_dispatch_decision(
     operator: DispatchHints | None = None,
     plan: DispatchHints | None = None,
     roadmap: DispatchHints | None = None,
+    default_executor: str | None = None,
 ) -> DispatchDecision:
+    # AUTOSEL (IF-0-AUTOSEL-2): ``default_executor`` replaces the bare codex seed.
+    # It is the PRIMARY ``preferred`` only when no operator/plan/roadmap hint names
+    # one; when a preferred hint IS set the seed is demoted to a TRAILING fallback
+    # candidate (last in ``candidate_order``). ``None`` reproduces legacy behavior
+    # exactly (seed = ``default_executor_for_action(action)`` == codex in both roles),
+    # so callers that set ``preferred_executors`` explicitly (repair pivot, work-unit
+    # rotation, delegation broker) are unaffected — they pass ``None`` and the trailing
+    # candidate stays legacy codex. The runner only passes a non-None seed when there
+    # is NO preferred hint, so an AUTOSEL pick never displaces an operator's choice.
+    seed_default = default_executor or default_executor_for_action(action)
     registry = registry or capability_registry()
     if action == "maintain-skills":
         return DispatchDecision(
@@ -648,9 +788,9 @@ def resolve_dispatch_decision(
     allowed = merged.allowed_executors or tuple(
         executor for executor, record in registry.items() if action in record.supported_actions
     )
-    preferred = merged.preferred_executors or (default_executor_for_action(action),)
+    preferred = merged.preferred_executors or (seed_default,)
     fallback = tuple(executor for executor in merged.fallback_executors if executor not in preferred)
-    candidate_order = _dedupe((*preferred, *fallback, *allowed, default_executor_for_action(action)))
+    candidate_order = _dedupe((*preferred, *fallback, *allowed, seed_default))
     considered: list[str] = []
     degraded = active_degraded_executors(repo) if repo is not None and not dry_run else set()
     degraded_viable: list[str] = []
@@ -665,6 +805,7 @@ def resolve_dispatch_decision(
                     tuple(considered),
                     "disabled_executor",
                     f"Dispatch policy rejected `{executor}` for `{action}` because it is disabled by hints.",
+                    seed_default=seed_default,
                 )
             continue
         if executor not in allowed:
@@ -675,6 +816,7 @@ def resolve_dispatch_decision(
                     tuple(considered),
                     "executor_not_allowed",
                     f"Dispatch policy rejected `{executor}` for `{action}` because it is outside the allowed executor set.",
+                    seed_default=seed_default,
                 )
             continue
         record = registry.get(executor)
@@ -686,6 +828,7 @@ def resolve_dispatch_decision(
                     tuple(considered),
                     "unsupported_action",
                     f"Dispatch policy rejected `{executor}` for `{action}` because the registry does not support that action.",
+                    seed_default=seed_default,
                 )
             continue
         missing = tuple(capability for capability in merged.required_capabilities if capability not in record.capabilities)
@@ -697,6 +840,7 @@ def resolve_dispatch_decision(
                     tuple(considered),
                     "missing_required_capabilities",
                     f"Dispatch policy rejected `{executor}` for `{action}` because it lacks required capabilities: {', '.join(missing)}.",
+                    seed_default=seed_default,
                 )
             continue
         if dry_run:
@@ -710,6 +854,7 @@ def resolve_dispatch_decision(
                     tuple(considered),
                     "live_launch_unavailable",
                     f"Dispatch policy selected `{executor}` for `{action}`, but that executor is currently dry-run-only.",
+                    seed_default=seed_default,
                 )
             if executor in preferred and fallback:
                 continue
@@ -738,6 +883,7 @@ def resolve_dispatch_decision(
             tuple(considered or candidate_order),
             "all_candidates_session_degraded",
             f"Dispatch policy could not resolve a live executor for `{action}` because all otherwise viable candidates are session-degraded.",
+            seed_default=seed_default,
         )
 
     return _blocked_decision(
@@ -746,6 +892,7 @@ def resolve_dispatch_decision(
         tuple(considered or candidate_order),
         "no_allowed_executor",
         f"Dispatch policy could not resolve an executor for `{action}` with the current hints and registry.",
+        seed_default=seed_default,
     )
 
 
@@ -818,12 +965,17 @@ def _blocked_decision(
     considered: tuple[str, ...],
     blocked_reason: str,
     blocked_summary: str,
+    *,
+    seed_default: str | None = None,
 ) -> DispatchDecision:
+    # AUTOSEL: the reported preferred set must match the seed actually resolved
+    # (grok CR #1) — an AUTOSEL seed of e.g. grok must not be reported as codex on
+    # a blocked decision. ``None`` reproduces the legacy codex default.
     return DispatchDecision(
         action=action,
         selected_executor=None,
         source=merged.source,
-        preferred_executors=merged.preferred_executors or (default_executor_for_action(action),),
+        preferred_executors=merged.preferred_executors or (seed_default or default_executor_for_action(action),),
         allowed_executors=merged.allowed_executors,
         fallback_executors=merged.fallback_executors,
         disabled_executors=merged.disabled_executors,