diff --git a/.gitignore b/.gitignore
index 56b3d3b44eec..7428a861d465 100644
--- a/.gitignore
+++ b/.gitignore
@@ -37,7 +37,13 @@ CMakeCache.txt
 *.vcxproj
 *.vcxproj.filters
 *_pb2.py
+*_pb2_grpc.py
 *_pb2.pyi
+# Planner plugin framework: stubs are checked in so test/build environments
+# don't need grpcio-tools or a protoc step just to import the module.
+!components/src/dynamo/planner/plugins/proto/v1/plugin_pb2.py
+!components/src/dynamo/planner/plugins/proto/v1/plugin_pb2_grpc.py
+!components/src/dynamo/planner/plugins/proto/v1/plugin_pb2.pyi
 *.svg
 !docs/assets/**/*.svg
 
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 6d3a62fd7490..0f4d14347399 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -13,7 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-exclude: ^(src/grpc_generated|.*\.patch$|.*/connect/.*\.py)
+exclude: ^(src/grpc_generated|.*\.patch$|.*/connect/.*\.py|components/src/dynamo/planner/plugins/proto/v1/plugin_pb2(_grpc)?\.pyi?$)
 repos:
 - repo: https://github.com/timothycrosley/isort
   rev: 5.12.0
diff --git a/components/src/dynamo/planner/config/planner_config.py b/components/src/dynamo/planner/config/planner_config.py
index 8549dccb4070..bf9d7e05c0d5 100644
--- a/components/src/dynamo/planner/config/planner_config.py
+++ b/components/src/dynamo/planner/config/planner_config.py
@@ -23,11 +23,20 @@
 from urllib.parse import parse_qsl
 
 import yaml
-from pydantic import AliasChoices, BaseModel, Field, field_validator, model_validator
+from pydantic import (
+    AliasChoices,
+    BaseModel,
+    ConfigDict,
+    Field,
+    field_validator,
+    model_validator,
+)
 
 from dynamo.planner.config.aic_interpolation_spec import AICInterpolationSpec
 from dynamo.planner.config.defaults import SLAPlannerDefaults
 from dynamo.planner.config.parallelization import PickedParallelConfig
+from dynamo.planner.plugins.registry.config import PluginRegistrationConfig
+from dynamo.planner.plugins.types import HoldPolicy
 
 logger = logging.getLogger(__name__)
 
@@ -70,6 +79,280 @@ class AICPerfModelSpec(BaseModel):
     kv_cache_dtype: Optional[str] = None
 
 
+class ExternalPluginEntry(BaseModel):
+    """One entry in the static external-plugin registration list.
+
+    The planner reads this list at startup and calls
+    ``await registry.register(RegisterRequest(...))`` for each entry —
+    same code path an external plugin would hit through the gRPC
+    gateway, so behaviour is identical to dynamic registration.
+
+    Sourced from PlannerConfig (which itself comes from a ConfigMap in
+    K8s). The plugin process must already be running and reachable at
+    ``endpoint`` when the planner starts; if it isn't, the entry's
+    register fails and is logged but the planner keeps booting (a bad
+    plugin entry must NOT take down the planner).
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    plugin_id: str = Field(
+        ...,
+        min_length=1,
+        description="Unique identifier; must not collide with builtin "
+        "plugin_ids (e.g. ``builtin_load_propose``).",
+    )
+    plugin_type: Literal["predict", "propose", "reconcile", "constrain"] = Field(
+        ...,
+        description="Stage this plugin participates in.",
+    )
+    priority: int = Field(
+        ...,
+        description=(
+            "Stage priority — smaller number = more authoritative in this "
+            "stage. The number's *meaning* is uniform but the *mechanism* "
+            "by which it takes effect differs between the merge stages "
+            "(parallel) and PREDICT (sequential chain):\n"
+            "  • PROPOSE / RECONCILE / CONSTRAIN: plugins run in parallel; "
+            "    smallest-priority SET wins on conflict (type-aware merge). "
+            "    AT_LEAST / AT_MOST clamps stack regardless of priority — "
+            "    AT_LEAST = max of floors, AT_MOST = min of ceilings.\n"
+            "  • PREDICT: plugins run sequentially in priority-ASCENDING "
+            "    order (smallest priority number runs first). Partial-merge "
+            "    is first-writer-wins per prediction field — once a plugin "
+            "    sets a field, later (larger-priority) plugins can only "
+            "    fill the fields left as None. The smallest-priority "
+            "    plugin is therefore the most authoritative: it writes "
+            "    first and its values are immutable for the rest of the "
+            "    chain. Only the smallest-priority plugin should set "
+            "    ``final=True`` to terminate the chain. Setting "
+            "    ``final=True`` on a non-smallest-priority plugin still "
+            "    breaks the chain at that point (skipping larger-"
+            "    priority-number fallback plugins) — which may be "
+            "    intentional (cost / policy override) or a config "
+            "    mistake; chain_augment cannot tell. The event is "
+            "    recorded on ``ChainAugmentOutcome.chain_break_warnings`` "
+            "    (surfaced via ``PipelineOutcome.audit_events``) for "
+            "    operator audit; a Prometheus counter is deferred to a "
+            "    follow-up observability PR."
+        ),
+    )
+    endpoint: str = Field(
+        ...,
+        min_length=1,
+        description=(
+            "Wire endpoint where the plugin is reachable. Must start with "
+            "``grpc://host:port`` (TCP). ``inproc://`` is rejected by "
+            "``register()`` since static-config plugins are out-of-process "
+            "by definition."
+        ),
+    )
+    auth_token: str = Field(
+        default="",
+        description="Bearer token validated by the registry's "
+        "``AuthValidator``. PR #1 only ships ``static_secret`` (shared "
+        "secret) — populate it from a mounted ``Secret`` rather than "
+        "hard-coding in the ConfigMap. K8s SA / SPIFFE JWT support "
+        "lands in a follow-up PR.",
+    )
+    protocol_version: str = Field(
+        default="1.0",
+        description="Plugin protocol version. Must match planner's "
+        "supported range (``[1.0, 1.0]`` today).",
+    )
+    version: str = Field(
+        default="v1",
+        description="Plugin's own version string — surfaced in "
+        "ListPlugins for debugging / canary identification.",
+    )
+    execution_interval_seconds: float = Field(
+        default=0.0,
+        ge=0,
+        description="0.0 means ``run every tick``; positive value "
+        "throttles to ``every N seconds`` (PluginScheduler enforces).",
+    )
+    hold_policy: HoldPolicy = Field(
+        default=HoldPolicy.HOLD_LAST,
+        description="What to do when this plugin is throttled by "
+        "execution_interval. ``HOLD_LAST`` reuses the cached result "
+        "(typical for static-config plugins); ``ACCEPT_WHEN_IDLE`` "
+        "treats it as no-opinion when not due.",
+    )
+    needs: list[str] = Field(
+        default_factory=list,
+        description="Capability list (consumed by type-aware merge); "
+        "empty in v1 (no plugin yet uses needs declaration).",
+    )
+    requires_produced_fields: list[str] = Field(
+        default_factory=list,
+        description=(
+            "Hard dependency on earlier-stage produced fields. Each "
+            "entry is a dot-path into ``PipelineContext`` (e.g. "
+            '``"predictions"``, ``"observations.traffic"``). The '
+            "scheduler skips this plugin for the current tick if any "
+            "listed field is unset on the live context; skipped ticks "
+            "do NOT advance the plugin's anchor, so the next tick that "
+            "has the field still fires it.  Empty/unset = no gating."
+        ),
+    )
+    observation_window_seconds: float = Field(
+        default=0.0,
+        ge=0,
+        description=(
+            "Aggregation window the plugin wants for windowed observation "
+            "types in ``needs`` (currently ``observations.traffic``). "
+            "0.0 = ``scale_interval`` freshness; ``N > 0`` = Prometheus "
+            "aggregates over the last ``N`` seconds.  Enforced at "
+            "register-time to be ``>= scale_interval_seconds`` — a "
+            "smaller window than the pipeline tick rate is degenerate."
+        ),
+    )
+
+    @field_validator("hold_policy", mode="before")
+    @classmethod
+    def _coerce_hold_policy(cls, v):
+        # IntEnum doesn't auto-accept string names from JSON/YAML
+        # config (Pydantic just sees ``"HOLD_LAST"`` and tries the int
+        # path). ConfigMap authors think in names, so accept either:
+        # ``"HOLD_LAST"`` / ``"ACCEPT_WHEN_IDLE"`` (case-insensitive)
+        # OR the raw integer the IntEnum already accepts.
+        if isinstance(v, str):
+            try:
+                return HoldPolicy[v.upper()]
+            except KeyError:
+                raise ValueError(
+                    f"hold_policy must be one of {[p.name for p in HoldPolicy]}, "
+                    f"got {v!r}"
+                )
+        return v
+
+
+class GatewayConfig(BaseModel):
+    """Plugin-registry gRPC gateway config.
+
+    When ``enabled=True``, the planner stands up a gRPC server hosting
+    the public ``PluginRegistry`` service so external plugin processes
+    can register / heartbeat / unregister themselves over the network.
+    See ``plugins/registry/README.md`` for the Register/Heartbeat
+    protocol and ``plugins/registry/gateway.py`` for the server
+    implementation.
+
+    Default ``enabled=False`` keeps existing deployments unchanged.
+    Operators opt in explicitly.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    enabled: bool = Field(
+        default=False,
+        description=(
+            "Open the gRPC gateway at ``listen``. Required for "
+            "self-registering plugins. Static-config plugins"
+            "registered via ``external_plugins`` do NOT need this."
+        ),
+    )
+    listen: str = Field(
+        default="unix:///var/run/dynamo/planner/registry.sock",
+        description=(
+            "Bind address, passed verbatim to gRPC's "
+            "``add_insecure_port`` / ``add_secure_port``. Both accept "
+            "gRPC's URI scheme: ``unix:/abs/path`` (or "
+            "``unix:///abs/path``) for an in-Pod socket file — useful "
+            "when plugins register from inside the same Pod and the "
+            "Pod boundary is the trust boundary. ``host:port`` (e.g. "
+            "``0.0.0.0:9099``) for TCP. mTLS for the cross-Pod TCP "
+            "case lands in a follow-up PR; PR #1 callers either bind "
+            "on an in-Pod ``unix:`` socket path (Pod-local trust) or "
+            "pair TCP with K8s NetworkPolicy / Pod-to-Pod identity."
+        ),
+    )
+    allow_insecure: bool = Field(
+        default=False,
+        description=(
+            "Permit binding a plaintext (no-TLS) gRPC gateway on a TCP "
+            "``host:port`` listen. Default False fails closed: a TCP "
+            "listen with no server credentials is rejected, because the "
+            "gateway receives plugins' shared-secret ``auth_token`` and a "
+            "plaintext TCP bind would expose it on the wire. Mirrors the "
+            "outbound ``transport.allow_insecure_grpc`` gate. ``unix:`` "
+            "(Pod-local) listens are always allowed — the Pod boundary is "
+            "the trust boundary. Set True only when TCP plaintext is "
+            "acceptable (e.g. a trusted mesh / NetworkPolicy-isolated net)."
+        ),
+    )
+
+
+class SchedulingConfig(BaseModel):
+    """Planner-level scheduling config.
+
+    Controls which tick engine drives the planner and how long each
+    tick may run. Backwards compatible: all fields have safe defaults,
+    so existing deployments see no behaviour change until
+    ``use_orchestrator=True`` is set explicitly. Read by
+    ``NativePlannerBase`` at startup.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    use_orchestrator: bool = Field(
+        default=False,
+        description=(
+            "Feature flag: when True, the planner drives ticks through "
+            "``LocalPlannerOrchestrator`` + real builtin plugins; when "
+            "False (default), uses the legacy ``PlannerStateMachine`` "
+            "path. Both paths are wired in ``NativePlannerBase`` via "
+            "``EngineProtocol``. Defaulted OFF so upgrade ≠ cutover — "
+            "operations control the enable timing."
+        ),
+    )
+    tick_max_duration_seconds: float = Field(
+        default=30.0,
+        gt=0,
+        description=(
+            "Outermost deadline wrapping the entire 4-stage pipeline "
+            "(orchestrator path only)."
+        ),
+    )
+    external_plugins: list[ExternalPluginEntry] = Field(
+        default_factory=list,
+        description=(
+            "Static external plugin registration list. Each entry "
+            "is registered at planner startup via the same code path "
+            "the gRPC gateway would use — so behaviour is "
+            "identical between static-config and self-register models. "
+            "Per-entry register failures are logged but do not crash "
+            "the planner. Only used when ``use_orchestrator=True``; "
+            "ignored on the legacy PSM path."
+        ),
+    )
+    gateway: GatewayConfig = Field(
+        default_factory=GatewayConfig,
+        description=(
+            "gRPC registration gateway config. Default disabled. "
+            "Only used when ``use_orchestrator=True``."
+        ),
+    )
+    scale_interval_seconds: float = Field(
+        default=5.0,
+        gt=0.0,
+        description=(
+            "Base pipeline cadence for the orchestrator path. Pipeline "
+            "fires one tick per ``scale_interval_seconds`` regardless of "
+            "individual plugin intervals; per-plugin throttling via "
+            "``RegisterRequest.execution_interval_seconds`` then governs "
+            "which plugins actually fire each tick. Must be <= every "
+            "plugin's ``execution_interval_seconds`` and a divisor of "
+            "every plugin's ``observation_window_seconds`` so windows "
+            "align to tick boundaries. Ignored when "
+            "``use_orchestrator=False`` (PSM path uses its legacy "
+            "load_adjustment_interval_seconds / "
+            "throughput_adjustment_interval_seconds two-cadence model). "
+            "Surface added in PR #10124; full lazy-pull behaviour lands "
+            "in the engine_adapter rewrite commit later in this PR."
+        ),
+    )
+
+
 class PlannerConfig(BaseModel):
     """Pydantic configuration for the Dynamo Planner.
 
@@ -371,6 +654,30 @@ def _validate_ca_bundle_path(cls, v: Optional[str]) -> Optional[str]:
         ),
     )
 
+    scheduling: SchedulingConfig = Field(
+        default_factory=SchedulingConfig,
+        description=(
+            "Tick-engine scheduling config — see ``SchedulingConfig`` "
+            "docstring. Default uses the legacy PSM path; set "
+            "``scheduling.use_orchestrator=true`` to opt into the "
+            "orchestrator path."
+        ),
+    )
+
+    plugin_registration: PluginRegistrationConfig = Field(
+        default_factory=PluginRegistrationConfig,
+        description=(
+            "Plugin registry config — auth validators, transport, "
+            "heartbeat, in-process plugins, admin RBAC. Default leaves "
+            "``auth.trusted_sources`` empty, which falls back to "
+            "``AllowUnauthenticatedAuth`` in the orchestrator (DEV ONLY — "
+            "logs WARN on startup). Production: set "
+            "``auth.trusted_sources=['static_secret']`` and populate "
+            "``auth.static_secrets`` from a mounted ``Secret``. "
+            "K8s SA / SPIFFE JWT support lands in a follow-up PR."
+        ),
+    )
+
     @model_validator(mode="after")
     def _validate_config(self) -> "PlannerConfig":
         if self.ttft_ms <= 0:
diff --git a/components/src/dynamo/planner/core/adapters.py b/components/src/dynamo/planner/core/adapters.py
index fa7dcbb92c15..b465198ae890 100644
--- a/components/src/dynamo/planner/core/adapters.py
+++ b/components/src/dynamo/planner/core/adapters.py
@@ -37,6 +37,13 @@ class PrefillPlanner(NativePlannerBase):
     require_decode = False
 
     async def _bootstrap_regression(self) -> None:
+        # Always drive ``_install_benchmark_fpms`` even on fetch failure
+        # (fpms=None). The orchestrator path needs an empty-but-present
+        # regression installed so runtime ``_observe_fpm`` has somewhere
+        # to accumulate observations — PSM's constructor builds empty
+        # regressions unconditionally; this mirrors that semantics on
+        # the orchestrator path.
+        fpms = None
         try:
             fpms = await fetch_pre_deployment_metrics(
                 runtime=self.runtime,
@@ -46,7 +53,7 @@ async def _bootstrap_regression(self) -> None:
                 component_type=SubComponentType.PREFILL,
                 aic_spec=self.config.aic_interpolation,
             )
-            self.state_machine.load_benchmark_fpms(prefill_fpms=fpms)
+            await self._install_benchmark_fpms(prefill_fpms=fpms)
         except PreDeploymentMetricsUnavailableError as e:
             _log_missing_pre_deployment_data("prefill", e)
 
@@ -74,6 +81,10 @@ class DecodePlanner(NativePlannerBase):
     require_decode = True
 
     async def _bootstrap_regression(self) -> None:
+        # See PrefillPlanner._bootstrap_regression for the rationale:
+        # install empty regression on fetch failure so runtime
+        # observations can still accumulate.
+        fpms = None
         try:
             fpms = await fetch_pre_deployment_metrics(
                 runtime=self.runtime,
@@ -83,7 +94,7 @@ async def _bootstrap_regression(self) -> None:
                 component_type=SubComponentType.DECODE,
                 aic_spec=self.config.aic_interpolation,
             )
-            self.state_machine.load_benchmark_fpms(decode_fpms=fpms)
+            await self._install_benchmark_fpms(decode_fpms=fpms)
         except PreDeploymentMetricsUnavailableError as e:
             _log_missing_pre_deployment_data("decode", e)
 
@@ -111,6 +122,8 @@ class AggPlanner(NativePlannerBase):
     require_decode = True
 
     async def _bootstrap_regression(self) -> None:
+        # See PrefillPlanner._bootstrap_regression for rationale.
+        fpms = None
         try:
             fpms = await fetch_pre_deployment_metrics(
                 runtime=self.runtime,
@@ -120,7 +133,7 @@ async def _bootstrap_regression(self) -> None:
                 component_type=SubComponentType.DECODE,
                 aic_spec=self.config.aic_interpolation,
             )
-            self.state_machine.load_benchmark_fpms(agg_fpms=fpms)
+            await self._install_benchmark_fpms(agg_fpms=fpms)
         except PreDeploymentMetricsUnavailableError as e:
             _log_missing_pre_deployment_data("agg", e)
 
@@ -148,15 +161,18 @@ class DisaggPlanner(NativePlannerBase):
     require_decode = True
 
     async def _bootstrap_regression(self) -> None:
-        for component, kwarg in [
-            (SubComponentType.PREFILL, "prefill_fpms"),
-            (SubComponentType.DECODE, "decode_fpms"),
+        # Collect per-component FPMs first (disagg has both prefill and
+        # decode to fetch independently), then hand the bundle to the
+        # single dual-path installer. Combining the two install calls
+        # lets the orchestrator path do one ``bootstrap_from_fpms``
+        # instead of two — and keeps the try/except granular so one
+        # component's missing benchmark doesn't tank the other.
+        prefill_fpms = None
+        decode_fpms = None
+        for component, worker_info in [
+            (SubComponentType.PREFILL, self.prefill_worker_info),
+            (SubComponentType.DECODE, self.decode_worker_info),
         ]:
-            worker_info = (
-                self.prefill_worker_info
-                if component == SubComponentType.PREFILL
-                else self.decode_worker_info
-            )
             try:
                 fpms = await fetch_pre_deployment_metrics(
                     runtime=self.runtime,
@@ -166,9 +182,15 @@ async def _bootstrap_regression(self) -> None:
                     component_type=component,
                     aic_spec=self.config.aic_interpolation,
                 )
-                self.state_machine.load_benchmark_fpms(**{kwarg: fpms})
+                if component == SubComponentType.PREFILL:
+                    prefill_fpms = fpms
+                else:
+                    decode_fpms = fpms
             except PreDeploymentMetricsUnavailableError as e:
                 _log_missing_pre_deployment_data(component.value, e)
+        await self._install_benchmark_fpms(
+            prefill_fpms=prefill_fpms, decode_fpms=decode_fpms
+        )
 
     async def _apply_effects(self, effects: PlannerEffects) -> None:
         if effects.scale_to is None:
diff --git a/components/src/dynamo/planner/core/base.py b/components/src/dynamo/planner/core/base.py
index 7419fc361fc5..65efd4a96854 100644
--- a/components/src/dynamo/planner/core/base.py
+++ b/components/src/dynamo/planner/core/base.py
@@ -32,6 +32,7 @@
 from dynamo.planner.connectors.kubernetes import KubernetesConnector
 from dynamo.planner.connectors.virtual import VirtualConnector
 from dynamo.planner.core.budget import _initialize_gpu_counts
+from dynamo.planner.core.engine_protocol import EngineProtocol, _PSMEngineAdapter
 from dynamo.planner.core.state_machine import PlannerStateMachine
 from dynamo.planner.core.types import (
     EngineCapabilities,
@@ -192,9 +193,22 @@ def __init__(
         # Live dashboard runner (started in _async_init)
         self._dashboard_runner: Optional[aiohttp.web.AppRunner] = None
 
-        # State machine (created after WorkerInfo is resolved)
+        # State machine (created after WorkerInfo is resolved) — PSM path only.
         self._state_machine: Optional[PlannerStateMachine] = None
 
+        # Tick engine: the main-loop dispatch target. When
+        # ``scheduling.use_orchestrator`` is False (default), wraps
+        # ``self._state_machine``. When True, wraps an
+        # ``OrchestratorEngineAdapter``. Both paths satisfy
+        # ``EngineProtocol`` so ``run()`` doesn't branch.
+        self._engine: Optional[EngineProtocol] = None
+
+        # Cached worker counts from the most recent tick's input — lets
+        # ``_log_decision_summary`` read current replica counts without
+        # reaching into PSM internals (which don't exist in the
+        # orchestrator path).
+        self._last_worker_counts: Optional[WorkerCounts] = None
+
     # ------------------------------------------------------------------
     # State machine access
     # ------------------------------------------------------------------
@@ -214,6 +228,88 @@ def _ensure_state_machine(self) -> PlannerStateMachine:
     def state_machine(self) -> PlannerStateMachine:
         return self._ensure_state_machine()
 
+    async def _install_benchmark_fpms(
+        self,
+        *,
+        prefill_fpms=None,
+        decode_fpms=None,
+        agg_fpms=None,
+    ) -> None:
+        """Route benchmark FPMs into the correct engine path.
+
+        Mode subclasses call this from ``_bootstrap_regression`` with
+        whatever FPM subset their mode produces. Routing:
+
+        - PSM path (``use_orchestrator=False``): call
+          ``PSM.load_benchmark_fpms(...)`` as before — identical to
+          legacy behaviour.
+        - Orchestrator path: call
+          ``OrchestratorEngineAdapter.bootstrap_from_fpms(...)`` which
+          builds regressions via a throwaway PSM, installs them on the
+          orchestrator's shared store, and fans out plugin Bootstrap RPC.
+
+        Skipping ``None`` kwargs preserves mode-specific semantics:
+        PrefillPlanner passes only ``prefill_fpms``; DisaggPlanner may
+        pass one or both depending on ``fetch_pre_deployment_metrics``
+        outcomes; AggPlanner passes ``agg_fpms``.
+        """
+        if self.config.scheduling.use_orchestrator:
+            from dynamo.planner.plugins.orchestrator.engine_adapter import (
+                OrchestratorEngineAdapter,
+            )
+
+            engine = self._ensure_engine()
+            assert isinstance(
+                engine, OrchestratorEngineAdapter
+            ), "use_orchestrator=True but engine is not OrchestratorEngineAdapter"
+            await engine.bootstrap_from_fpms(
+                prefill_fpms=prefill_fpms,
+                decode_fpms=decode_fpms,
+                agg_fpms=agg_fpms,
+            )
+        else:
+            # PSM path — match legacy behaviour. Only non-``None``
+            # values pass through so the call shape is unchanged for
+            # modes that supply only one FPM kind.
+            kwargs = {}
+            if prefill_fpms is not None:
+                kwargs["prefill_fpms"] = prefill_fpms
+            if decode_fpms is not None:
+                kwargs["decode_fpms"] = decode_fpms
+            if agg_fpms is not None:
+                kwargs["agg_fpms"] = agg_fpms
+            if kwargs:
+                self.state_machine.load_benchmark_fpms(**kwargs)
+
+    def _ensure_engine(self) -> EngineProtocol:
+        """Lazy-construct the tick engine.
+
+        - PSM path (``scheduling.use_orchestrator=False``, default): build
+          ``PlannerStateMachine`` as before, wrap in ``_PSMEngineAdapter``.
+          ``self._state_machine`` stays populated for backwards-compat
+          callers (e.g. ``state_machine`` property).
+        - Orchestrator path (``scheduling.use_orchestrator=True``): build
+          ``OrchestratorEngineAdapter``. ``self._state_machine`` stays
+          ``None``.
+        """
+        if self._engine is not None:
+            return self._engine
+        if self.config.scheduling.use_orchestrator:
+            caps = build_worker_capabilities(
+                self.config,
+                self.prefill_worker_info,
+                self.decode_worker_info,
+            )
+            from dynamo.planner.plugins.orchestrator.engine_adapter import (
+                OrchestratorEngineAdapter,
+            )
+
+            self._engine = OrchestratorEngineAdapter(self.config, caps)
+        else:
+            psm = self._ensure_state_machine()
+            self._engine = _PSMEngineAdapter(psm)
+        return self._engine
+
     def _warm_predictors(self) -> None:
         if self.config.load_predictor_warmup_trace is None:
             return
@@ -766,13 +862,27 @@ async def _apply_scaling_targets(
     # ------------------------------------------------------------------
 
     def _log_decision_summary(self, effects: PlannerEffects) -> None:
-        """Log a one-line summary of the scaling decision after each tick."""
+        """Log a one-line summary of the scaling decision after each tick.
+
+        Current worker counts come from ``self._last_worker_counts``
+        (cached in ``run()``) in both engine paths — the orchestrator
+        path has no equivalent of PSM's ``_num_p_workers`` /
+        ``_num_d_workers`` internals.
+        """
         decision = effects.scale_to
         diag = effects.diagnostics
 
-        sm = self.state_machine
-        current_p = sm._num_p_workers
-        current_d = sm._num_d_workers
+        if self._last_worker_counts is not None:
+            current_p = self._last_worker_counts.ready_num_prefill or 0
+            current_d = self._last_worker_counts.ready_num_decode or 0
+        elif self._state_machine is not None:
+            # PSM path with no worker_counts this tick — fall back to PSM
+            # internal counters (set by prior ticks' ``_update_inventory``).
+            current_p = self._state_machine._num_p_workers
+            current_d = self._state_machine._num_d_workers
+        else:
+            current_p = 0
+            current_d = 0
 
         rec_p = decision.num_prefill if decision else None
         rec_d = decision.num_decode if decision else None
@@ -877,7 +987,8 @@ def _report_diagnostics(self, tick: ScheduledTick, diag: TickDiagnostics) -> Non
     # ------------------------------------------------------------------
 
     async def run(self) -> None:
-        next_tick = self.state_machine.initial_tick(time.time())
+        engine = self._ensure_engine()
+        next_tick = engine.initial_tick(time.time())
         poll_interval = self.config.load_adjustment_interval_seconds / 10
 
         try:
@@ -892,7 +1003,14 @@ async def run(self) -> None:
 
                 tick_input = await self._gather_tick_input(next_tick)
                 self._publish_inventory_and_gpu_hours(tick_input)
-                effects = self.state_machine.on_tick(next_tick, tick_input)
+                # Cache worker counts for _log_decision_summary (both
+                # engine paths); None when the tick doesn't request them.
+                if tick_input.worker_counts is not None:
+                    self._last_worker_counts = tick_input.worker_counts
+                # Dual-path: drive ticks through EngineProtocol
+                # (PSM or orchestrator chosen by use_orchestrator flag),
+                # not the direct PSM call upstream main has.
+                effects = await engine.tick(next_tick, tick_input)
                 await self._apply_effects(effects)
                 self._report_diagnostics(next_tick, effects.diagnostics)
                 self._log_decision_summary(effects)
@@ -916,6 +1034,8 @@ async def run(self) -> None:
             self._recorder.finalize()
             if self._dashboard_runner is not None:
                 await self._dashboard_runner.cleanup()
+            if self._engine is not None:
+                await self._engine.shutdown()
 
 
 # ------------------------------------------------------------------
diff --git a/components/src/dynamo/planner/core/engine_protocol.py b/components/src/dynamo/planner/core/engine_protocol.py
new file mode 100644
index 000000000000..921e14f4d604
--- /dev/null
+++ b/components/src/dynamo/planner/core/engine_protocol.py
@@ -0,0 +1,83 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""``EngineProtocol`` — shared abstraction for the tick engine.
+
+``NativePlannerBase`` drives its tick loop through an ``EngineProtocol``
+rather than a concrete ``PlannerStateMachine`` so the planner can run
+under two paths that are selectable at runtime via
+``PlannerConfig.scheduling.use_orchestrator``:
+
+- **PSM path** (default, ``use_orchestrator=False``): legacy behaviour.
+  ``_PSMEngineAdapter`` wraps a ``PlannerStateMachine`` instance and
+  forwards tick calls to its synchronous ``on_tick``.
+- **Orchestrator path** (``use_orchestrator=True``): plugin
+  decomposition. A separate orchestrator adapter bridges
+  ``TickInput`` → ``PipelineContext`` and projects ``PipelineOutcome``
+  back onto ``PlannerEffects``.
+
+Both paths produce the same ``PlannerEffects`` shape so
+``NativePlannerBase._apply_effects`` and downstream metric emission
+stay unchanged.
+
+Bootstrap paths are deliberately **not** on the protocol —
+``NativePlannerBase._bootstrap_regression`` branches on the config flag
+explicitly because PSM's ``load_benchmark_fpms`` + ``warm_load_predictors``
+and orchestrator's ``install_regressions`` + ``bootstrap_plugins`` have
+different input shapes.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+from dynamo.planner.core.types import PlannerEffects, ScheduledTick, TickInput
+
+if TYPE_CHECKING:
+    from dynamo.planner.core.state_machine import PlannerStateMachine
+
+
+@runtime_checkable
+class EngineProtocol(Protocol):
+    """Tick-engine abstraction shared by PSM and LocalPlannerOrchestrator."""
+
+    def initial_tick(self, start_s: float) -> ScheduledTick:
+        """Build the first ``ScheduledTick`` for the main loop to wait on."""
+
+    async def tick(
+        self,
+        scheduled_tick: ScheduledTick,
+        tick_input: TickInput,
+    ) -> PlannerEffects:
+        """Drive one tick; return the decision + next scheduled tick +
+        diagnostics. Path implementations absorb the concrete
+        sync/async difference of their underlying engine."""
+
+    async def shutdown(self) -> None:
+        """Release any engine-owned resources. Idempotent."""
+
+
+class _PSMEngineAdapter:
+    """Adapts ``PlannerStateMachine`` (synchronous ``on_tick``) to
+    ``EngineProtocol``. Zero behaviour change from legacy — just an
+    async wrapper around the sync call so the protocol stays uniform."""
+
+    def __init__(self, psm: "PlannerStateMachine") -> None:
+        self._psm = psm
+
+    def initial_tick(self, start_s: float) -> ScheduledTick:
+        return self._psm.initial_tick(start_s)
+
+    async def tick(
+        self,
+        scheduled_tick: ScheduledTick,
+        tick_input: TickInput,
+    ) -> PlannerEffects:
+        return self._psm.on_tick(scheduled_tick, tick_input)
+
+    async def shutdown(self) -> None:
+        # PSM is in-process + holds no transports; nothing to release.
+        return None
+
+
+__all__ = ["EngineProtocol", "_PSMEngineAdapter"]
diff --git a/components/src/dynamo/planner/core/types.py b/components/src/dynamo/planner/core/types.py
index 147aa7df1de3..2e298fdbe5b9 100644
--- a/components/src/dynamo/planner/core/types.py
+++ b/components/src/dynamo/planner/core/types.py
@@ -131,6 +131,52 @@ class TickDiagnostics:
     throughput_decision_reason_prefill: Optional[str] = None
     throughput_decision_reason_decode: Optional[str] = None
 
+    # Plugin-era fields below. Orchestrator path populates these; PSM
+    # path leaves them empty. Numeric fields above are the opposite —
+    # PSM populates them, orchestrator emits the same data as plugin-
+    # owned Prometheus metrics instead. Downstream readers must treat
+    # "empty" as "not available on this path".
+
+    # PROPOSE/RECONCILE/CONSTRAIN overrides contributed this tick.
+    # Tuple: (plugin_id, stage, override_type, component_key, value).
+    # override_type ∈ {"SET", "AT_LEAST", "AT_MOST", "REJECT"};
+    # component_key = ``sub_component_type`` (one bucket per type in this
+    # PR — multi-pool addressing is deferred to the hierarchical planner
+    # PR); value = replica target (``-1`` for REJECT).
+    plugin_overrides: list[tuple[str, str, str, str, int]] = field(default_factory=list)
+
+    # Per-component reconcile reason.  Keyed by ``component_key`` as
+    # above; value is a short audit string such as
+    # ``"set_by_<plugin_id>"``, ``"clamped_to_floor"``,
+    # ``"clamped_to_ceiling"``, or ``"passthrough"``.
+    reconcile_reasons: dict[str, str] = field(default_factory=dict)
+
+    # plugin_id list of HOLD_LAST cache replays this tick (plugin was
+    # skipped because its execution_interval hadn't elapsed, and its
+    # previous output is being reused).
+    held_over_plugins: list[str] = field(default_factory=list)
+
+    # Pipeline execute_action — one of ``"apply"``,
+    # ``"skip_short_circuit"``, ``"skip_no_targets"``,
+    # ``"skip_tick_timeout"``.  Mirrors
+    # ``PipelineOutcome.execute_action``.  ``None`` on the PSM path
+    # (no pipeline).  Same information is also emitted as Prometheus
+    # ``tick_skip_reasons_total`` etc., but exposing it on
+    # ``PlannerEffects.diagnostics`` lets in-process consumers (replay
+    # adapter, diagnostics recorder) see the action without scraping
+    # metrics.
+    execute_action: Optional[str] = None
+
+    # Why a tick short-circuited (e.g. ``"propose: my-plugin: ..."``).
+    # Populated when ``execute_action == "skip_short_circuit"``; empty
+    # otherwise.  Mirrors ``PipelineOutcome.short_circuit_reason``.
+    short_circuit_reason: str = ""
+
+    # Audit-quality breadcrumbs emitted by the pipeline (chain-augment
+    # warnings, CONSTRAIN SET drops, etc.).  Mirrors
+    # ``PipelineOutcome.audit_events``.  Empty list on the PSM path.
+    audit_events: list[str] = field(default_factory=list)
+
 
 @dataclass
 class PlannerEffects:
diff --git a/components/src/dynamo/planner/examples/__init__.py b/components/src/dynamo/planner/examples/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/examples/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/examples/external_plugin/README.md b/components/src/dynamo/planner/examples/external_plugin/README.md
new file mode 100644
index 000000000000..bd4f97055251
--- /dev/null
+++ b/components/src/dynamo/planner/examples/external_plugin/README.md
@@ -0,0 +1,77 @@
+# External plugin — reference implementation
+
+A minimal, self-contained Python external plugin server that
+implements the four stage contracts (Predict / Propose / Reconcile /
+Constrain) defined in `plugins/proto/v1/plugin.proto`. It is the
+canonical starting point for users writing their own external plugin
+and is also used as the cross-process fixture for K8s smoke
+validation.
+
+## What you get
+
+`reference_runner.py` exposes one stage per invocation:
+
+| `--stage`   | Servicer                       | Fixed response                       |
+|-------------|--------------------------------|--------------------------------------|
+| `predict`   | `PredictPluginServicer`        | `PredictionData(num_req, isl, osl)`  |
+| `propose`   | `ProposePluginServicer`        | `OverrideResult(prefill, decode)`    |
+| `reconcile` | `ReconcilePluginServicer`      | `OverrideResult(prefill, decode)`    |
+| `constrain` | `ConstrainPluginServicer`      | `AT_MOST(prefill, decode)` ceilings  |
+
+The fixed values are configurable via CLI flags so a single binary
+can stand in for any stage in a smoke deployment.
+
+## Run locally
+
+```bash
+python -m dynamo.planner.examples.external_plugin.reference_runner \
+    --listen=0.0.0.0:9099 \
+    --stage=predict \
+    --plugin-id=ext-predict \
+    --predict-num-req=4242 \
+    --predict-isl=1024 \
+    --predict-osl=256
+```
+
+The server logs `listening on 0.0.0.0:9099` and waits for the
+planner to dial it. SIGTERM and SIGINT shut down cleanly.
+
+## Run in K8s
+
+The intended K8s deployment shape is one Pod per stage, each running
+this binary with the appropriate `--stage`, and the planner registering
+all four via the static `external_plugins:` config block — exercising
+the full PREDICT / PROPOSE / RECONCILE / CONSTRAIN pipeline over real
+cross-pod gRPC. The ready-to-`kubectl apply` fixture is deferred to a
+follow-up PR; the four `--stage` invocations above are the building
+blocks.
+
+## Forking to a real plugin
+
+For each stage you want to serve:
+
+1. Copy `reference_runner.py` to your package.
+2. Replace the fixed response inside the corresponding
+   `_Deterministic{Predict,Propose,Reconcile,Constrain}Plugin`
+   class with your real logic (model inference, policy evaluation,
+   historical lookups, etc.).
+3. Keep the proto contract unchanged — return the same Pydantic
+   types in the same shape.
+4. Build a container image and deploy under the same
+   `external_plugins:` config block in your planner deployment.
+
+The proto schema (`plugins/proto/v1/plugin.proto`) and Pydantic
+mirror (`plugins/types.py`) define everything you may return.
+`plugins/proto/v1/README.md` covers the schema-evolution policy and
+the contract invariants per stage (such as the spec-ignored
+`final` flag on CONSTRAIN responses, or chain-augment ordering for
+PREDICT).
+
+## Why a reference is shipped at all
+
+The plugin framework is contract-driven (proto), so any plugin in
+any language that speaks the proto can register. We ship the Python
+reference because (a) it doubles as the cross-process fixture for
+the framework's own K8s smoke validation and (b) most early users
+will start in Python — having a known-good baseline to diff against
+makes the first day a lot shorter.
diff --git a/components/src/dynamo/planner/examples/external_plugin/__init__.py b/components/src/dynamo/planner/examples/external_plugin/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/examples/external_plugin/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/examples/external_plugin/reference_runner.py b/components/src/dynamo/planner/examples/external_plugin/reference_runner.py
new file mode 100644
index 000000000000..3ce768dbbf3c
--- /dev/null
+++ b/components/src/dynamo/planner/examples/external_plugin/reference_runner.py
@@ -0,0 +1,324 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Reference external plugin server — Python implementation of the
+PluginRegistry + 4 stage servicers (Predict / Propose / Reconcile /
+Constrain) suitable for both K8s smoke fixtures and as a starting
+point for users writing their own external plugins.
+
+Runs as a standalone process binding a single ``--stage`` to a
+single gRPC port:
+
+- ``predict``    — ``PredictPluginServicer.Predict`` returns a fixed
+                   ``PredictionData`` (chain-augment terminator).
+- ``propose``    — ``ProposePluginServicer.Propose`` returns a fixed
+                   ``OverrideResult``.
+- ``reconcile``  — ``ReconcilePluginServicer.Reconcile`` returns a
+                   fixed ``OverrideResult``.
+- ``constrain``  — ``ConstrainPluginServicer.Constrain`` returns
+                   ``AT_MOST`` ceilings.
+
+A real plugin replaces the fixed responses with real logic
+(consulting a model, querying historical data, applying a policy,
+etc.); the protocol contract and lifecycle stay identical. See
+``README.md`` in this directory for a fork-and-customise walkthrough.
+
+Two callers in PR #1:
+
+1. Integration test (``tests/integration/test_external_plugin_e2e.py``):
+   spawns this binary as a subprocess (one per stage) and exercises
+   the full PREDICT/PROPOSE/RECONCILE/CONSTRAIN pipeline over real
+   localhost gRPC. The K8s ``kubectl apply``-able fixture (one Pod
+   per stage with the same ``--stage`` invocations) is deferred to
+   a follow-up PR.
+2. User code: ``cp reference_runner.py my_plugin.py`` and replace
+   the fixed responses inside the ``_Deterministic*Plugin`` classes
+   for the stage(s) you want to serve.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import logging
+import signal
+import sys
+
+import grpc
+
+from dynamo.planner.plugins.proto.v1 import plugin_pb2 as pb
+from dynamo.planner.plugins.proto.v1 import plugin_pb2_grpc as pbg
+
+# ---------------------------------------------------------------------------
+# Per-stage Servicer implementations
+#
+# Each servicer is deterministic so the e2e test can assert exact
+# decision values landed in PipelineOutcome — no randomness, no
+# context-dependent branches.
+# ---------------------------------------------------------------------------
+
+
+class _DeterministicPredictPlugin(pbg.PredictPluginServicer):
+    """Returns a fixed ``PredictionData``. ``final=True`` to terminate
+    the chain (lowest-priority plugin in the chain-augment order)."""
+
+    def __init__(self, *, num_req: float, isl: float, osl: float) -> None:
+        self._num_req = num_req
+        self._isl = isl
+        self._osl = osl
+
+    async def Predict(
+        self,
+        request: pb.PredictStageRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> pb.PredictStageResponse:
+        resp = pb.PredictStageResponse()
+        resp.predictions.predicted_num_req = self._num_req
+        resp.predictions.predicted_isl = self._isl
+        resp.predictions.predicted_osl = self._osl
+        resp.predictions.source = "subprocess_external_predict"
+        resp.final = True
+        return resp
+
+
+class _DeterministicProposePlugin(pbg.ProposePluginServicer):
+    """Returns a fixed OverrideResult on every call so the e2e test
+    can assert exact target replicas."""
+
+    def __init__(self, *, prefill: int, decode: int) -> None:
+        self._prefill = prefill
+        self._decode = decode
+
+    async def Propose(
+        self,
+        request: pb.ProposeStageRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> pb.ProposeStageResponse:
+        resp = pb.ProposeStageResponse()
+        ovr = resp.override
+        ovr.reason = "subprocess_external_propose"
+        for sub, n in (("prefill", self._prefill), ("decode", self._decode)):
+            t = ovr.targets.add()
+            t.sub_component_type = sub
+            t.replicas = n
+            t.type = pb.OverrideType.SET
+        return resp
+
+
+class _DeterministicReconcilePlugin(pbg.ReconcilePluginServicer):
+    """RECONCILE-stage fixed-decision plugin. Re-shapes whatever
+    PROPOSE produced (or injects from scratch when no PROPOSE)."""
+
+    def __init__(self, *, prefill: int, decode: int) -> None:
+        self._prefill = prefill
+        self._decode = decode
+
+    async def Reconcile(
+        self,
+        request: pb.ReconcileStageRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> pb.ReconcileStageResponse:
+        resp = pb.ReconcileStageResponse()
+        ovr = resp.override
+        ovr.reason = "subprocess_external_reconcile"
+        for sub, n in (("prefill", self._prefill), ("decode", self._decode)):
+            t = ovr.targets.add()
+            t.sub_component_type = sub
+            t.replicas = n
+            t.type = pb.OverrideType.SET
+        return resp
+
+
+class _DeterministicConstrainPlugin(pbg.ConstrainPluginServicer):
+    """CONSTRAIN-stage fixed-ceiling plugin. Emits AT_MOST so the
+    test can validate that ceilings clamp PROPOSE/RECONCILE outputs
+    over the wire (SET would be silently dropped per v11 contract)."""
+
+    def __init__(self, *, ceiling_prefill: int, ceiling_decode: int) -> None:
+        self._cp = ceiling_prefill
+        self._cd = ceiling_decode
+
+    async def Constrain(
+        self,
+        request: pb.ConstrainStageRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> pb.ConstrainStageResponse:
+        resp = pb.ConstrainStageResponse()
+        ovr = resp.override
+        ovr.reason = "subprocess_external_constrain"
+        for sub, n in (("prefill", self._cp), ("decode", self._cd)):
+            t = ovr.targets.add()
+            t.sub_component_type = sub
+            t.replicas = n
+            t.type = pb.OverrideType.AT_MOST
+        return resp
+
+
+# Stage-name → (servicer factory, register_to_server fn, default plugin_id) ---
+
+_STAGE_TABLE = {
+    "predict": (
+        lambda args: _DeterministicPredictPlugin(
+            num_req=args.predict_num_req,
+            isl=args.predict_isl,
+            osl=args.predict_osl,
+        ),
+        pbg.add_PredictPluginServicer_to_server,
+        "external-subprocess-predict",
+    ),
+    "propose": (
+        lambda args: _DeterministicProposePlugin(
+            prefill=args.prefill, decode=args.decode
+        ),
+        pbg.add_ProposePluginServicer_to_server,
+        "external-subprocess-propose",
+    ),
+    "reconcile": (
+        lambda args: _DeterministicReconcilePlugin(
+            prefill=args.prefill, decode=args.decode
+        ),
+        pbg.add_ReconcilePluginServicer_to_server,
+        "external-subprocess-reconcile",
+    ),
+    "constrain": (
+        lambda args: _DeterministicConstrainPlugin(
+            ceiling_prefill=args.prefill,
+            ceiling_decode=args.decode,
+        ),
+        pbg.add_ConstrainPluginServicer_to_server,
+        "external-subprocess-constrain",
+    ),
+}
+
+
+async def _self_register(
+    *,
+    gateway_endpoint: str,
+    plugin_id: str,
+    plugin_type: str,
+    plugin_listen: str,
+    auth_token: str,
+    priority: int,
+) -> None:
+    """Open a gRPC client to the gateway and call Register so the
+    planner picks us up. ``unix:`` and ``host:port`` both supported by
+    the standard gRPC channel constructor."""
+    if gateway_endpoint.startswith("unix://"):
+        target = gateway_endpoint.replace("unix://", "unix:")
+    elif gateway_endpoint.startswith("grpc://"):
+        target = gateway_endpoint[len("grpc://") :]
+    else:
+        # Accept bare host:port as well — caller convenience.
+        target = gateway_endpoint
+    async with grpc.aio.insecure_channel(target) as channel:
+        stub = pbg.PluginRegistryStub(channel)
+        req = pb.RegisterRequest(
+            plugin_id=plugin_id,
+            plugin_type=plugin_type,
+            priority=priority,
+            endpoint=plugin_listen,
+            auth_token=auth_token,
+            protocol_version="1.0",
+            execution_interval_seconds=0.0,
+            hold_policy=pb.HoldPolicy.HOLD_LAST,
+            version="v1",
+        )
+        resp = await stub.Register(req)
+        if not resp.accepted:
+            raise SystemExit(
+                f"subprocess plugin self-register rejected: {resp.reject_reason!r}"
+            )
+
+
+async def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--listen",
+        required=True,
+        help="bind address for this plugin's gRPC server "
+        "(e.g. ``unix:/tmp/p.sock`` or ``127.0.0.1:0``)",
+    )
+    parser.add_argument(
+        "--stage",
+        choices=sorted(_STAGE_TABLE.keys()),
+        default="propose",
+        help="which plugin stage this runner serves",
+    )
+    parser.add_argument(
+        "--plugin-id",
+        default=None,
+        help="plugin_id used during self-registration; defaults to a "
+        "stage-specific name when omitted",
+    )
+    parser.add_argument(
+        "--priority",
+        type=int,
+        default=5,
+        help="plugin priority used during self-registration. PREDICT "
+        "wants priority=1 (lowest = chain terminator); RECONCILE / "
+        "CONSTRAIN typically use 1 too. PROPOSE merge picks smallest "
+        "first, so for PROPOSE pick 4–10.",
+    )
+    parser.add_argument(
+        "--gateway-endpoint",
+        default="",
+        help="if set, self-register via this gateway after starting "
+        "(e.g. ``grpc://127.0.0.1:7777`` or ``unix:///var/run/dynamo.sock``)",
+    )
+    parser.add_argument("--auth-token", default="anything")
+    # PROPOSE / RECONCILE / CONSTRAIN reuse these:
+    parser.add_argument("--prefill", type=int, default=7)
+    parser.add_argument("--decode", type=int, default=11)
+    # PREDICT-only knobs:
+    parser.add_argument("--predict-num-req", type=float, default=1234.0)
+    parser.add_argument("--predict-isl", type=float, default=567.0)
+    parser.add_argument("--predict-osl", type=float, default=89.0)
+    args = parser.parse_args()
+
+    factory, attach_to_server, default_id = _STAGE_TABLE[args.stage]
+    if args.plugin_id is None:
+        args.plugin_id = default_id
+
+    # Send all logs to stderr — stdout is reserved for the
+    # ``LISTEN_READY`` ready signal so the test driver can read it
+    # synchronously without log noise.
+    logging.basicConfig(level=logging.INFO, stream=sys.stderr)
+
+    server = grpc.aio.server()
+    attach_to_server(factory(args), server)
+    port = server.add_insecure_port(args.listen)
+    await server.start()
+
+    actual_listen = args.listen
+    if args.listen.endswith(":0"):
+        actual_listen = f"{args.listen.rsplit(':', 1)[0]}:{port}"
+
+    # Plugin endpoint as the planner will see it (matches scheme
+    # convention used by ``derive_transport_type``).
+    if actual_listen.startswith("unix:"):
+        plugin_endpoint_for_planner = "unix://" + actual_listen[len("unix:") :]
+    else:
+        plugin_endpoint_for_planner = "grpc://" + actual_listen
+
+    if args.gateway_endpoint:
+        await _self_register(
+            gateway_endpoint=args.gateway_endpoint,
+            plugin_id=args.plugin_id,
+            plugin_type=args.stage,
+            plugin_listen=plugin_endpoint_for_planner,
+            auth_token=args.auth_token,
+            priority=args.priority,
+        )
+
+    print(f"LISTEN_READY {plugin_endpoint_for_planner}", flush=True)
+
+    stop = asyncio.Event()
+    loop = asyncio.get_event_loop()
+    for sig in (signal.SIGTERM, signal.SIGINT):
+        loop.add_signal_handler(sig, stop.set)
+    await stop.wait()
+    await server.stop(grace=0.5)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/components/src/dynamo/planner/monitoring/planner_metrics.py b/components/src/dynamo/planner/monitoring/planner_metrics.py
index 6fe3ac4cadec..4bbc884ca63b 100644
--- a/components/src/dynamo/planner/monitoring/planner_metrics.py
+++ b/components/src/dynamo/planner/monitoring/planner_metrics.py
@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-from prometheus_client import Enum, Gauge
+from prometheus_client import CollectorRegistry, Counter, Enum, Gauge, Histogram
 
 PREFIX = "dynamo_planner"
 
@@ -17,6 +17,15 @@
     "scale_down",
     "scale_down_capped_by_throughput",
     "scale_down_refused_consolidation",
+    # Plugin-era decision reasons.
+    # prometheus_client.Enum.states is construction-time fixed; new values
+    # MUST be appended (never inserted or reordered) so existing scrapers
+    # with older label sets keep parsing.
+    "override_by_user_plugin",
+    "reconcile_clamped_to_floor",
+    "reconcile_clamped_to_ceiling",
+    "held_over",
+    "rejected_by_plugin",
 ]
 
 THROUGHPUT_DECISION_STATES = [
@@ -27,6 +36,12 @@
     "model_not_ready",
     "set_lower_bound",
     "scale",
+    # Plugin-era decision reasons.
+    # Same append-only rule as LOAD_DECISION_STATES.
+    "override_by_user_plugin",
+    "held_over",
+    "circuit_open",
+    "rejected_by_plugin",
 ]
 
 
@@ -153,3 +168,207 @@ def __init__(self) -> None:
             "Inflight (scheduled) decode KV tokens per engine (from FPM)",
             labelnames=_engine_labels,
         )
+
+
+# ---------------------------------------------------------------------------
+# Plugin-framework metrics
+# ---------------------------------------------------------------------------
+
+
+# Circuit breaker state encoding — matches the ``CircuitBreaker`` enum in
+# plugins/registry/circuit_breaker.py (CLOSED / HALF_OPEN / OPEN).  Exposed
+# here so emitters import a single source of truth instead of picking
+# floats by hand.
+CIRCUIT_STATE_CLOSED = 0.0
+CIRCUIT_STATE_HALF_OPEN = 0.5
+CIRCUIT_STATE_OPEN = 1.0
+
+
+class PluginFrameworkMetrics:
+    """Plugin-layer Prometheus metrics.
+
+    Separate from ``PlannerPrometheusMetrics`` because this set is
+    about **plugin invocation mechanics** (eval count / latency / circuit
+    state / HOLD_LAST cache / override contribution) rather than the
+    planner's own decision outputs, and because callers construct it
+    alongside ``LocalPlannerOrchestrator`` rather than at planner
+    bootstrap.
+
+    Registry hook
+    -------------
+    ``registry`` is threaded through to every metric constructor.  If
+    ``None`` (default), metrics land on ``prometheus_client.REGISTRY``
+    and scraping works as usual.  Unit tests pass an isolated
+    ``CollectorRegistry()`` per instance to avoid the
+    ``Duplicated timeseries`` error you get when you build the same
+    metric twice against the global registry.
+    """
+
+    def __init__(self, registry: CollectorRegistry | None = None) -> None:
+        kw: dict = {} if registry is None else {"registry": registry}
+
+        self.plugin_evaluations_total = Counter(
+            f"{PREFIX}_plugin_evaluations_total",
+            "Plugin evaluation calls, labelled by outcome.",
+            labelnames=["plugin_id", "stage", "result"],
+            **kw,
+        )
+        """``result`` values: ``accept`` / ``set`` / ``at_least`` /
+        ``at_most`` / ``reject`` / ``timeout`` / ``error`` / ``held_over``.
+        See ``plugins/merge/types.py`` for the result enum."""
+
+        self.plugin_latency_seconds = Histogram(
+            f"{PREFIX}_plugin_latency_seconds",
+            "End-to-end plugin RPC latency in seconds.",
+            labelnames=["plugin_id", "stage"],
+            buckets=(0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1.0, 5.0),
+            **kw,
+        )
+        """Histogram buckets cover the useful range from in-process
+        plugin (~1ms) up to the ``request_timeout_seconds`` default
+        (5s).  We do NOT record failed / timed-out calls here —
+        they'd skew percentiles.  Those land on
+        ``plugin_evaluations_total{result=timeout|error}`` only."""
+
+        self.plugin_circuit_state = Gauge(
+            f"{PREFIX}_plugin_circuit_state",
+            "Per-plugin circuit breaker state "
+            f"({CIRCUIT_STATE_CLOSED}=closed, "
+            f"{CIRCUIT_STATE_HALF_OPEN}=half_open, "
+            f"{CIRCUIT_STATE_OPEN}=open).",
+            labelnames=["plugin_id"],
+            **kw,
+        )
+
+        self.plugin_held_over_total = Counter(
+            f"{PREFIX}_plugin_held_over_total",
+            "HOLD_LAST cache replay events "
+            "(scheduler returned cached result in lieu of calling the plugin).",
+            labelnames=["plugin_id", "stage"],
+            **kw,
+        )
+
+        self.plugin_cache_age_seconds = Gauge(
+            f"{PREFIX}_plugin_cache_age_seconds",
+            "Age of the HOLD_LAST cached result per plugin (seconds).",
+            labelnames=["plugin_id"],
+            **kw,
+        )
+
+        self.plugin_override_active = Gauge(
+            f"{PREFIX}_plugin_override_active",
+            "1 if the plugin contributed an override to the final "
+            "merged proposal this tick, 0 otherwise.",
+            labelnames=["plugin_id", "stage", "override_type"],
+            **kw,
+        )
+        """``override_type`` values: ``SET`` / ``AT_LEAST`` / ``AT_MOST``
+        / ``REJECT``.  A plugin that returned ``ACCEPT`` with no
+        proposal emits 0 for every override_type (explicitly, via
+        ``reset_overrides`` below).  This is a per-tick gauge — emitters
+        MUST call ``reset_overrides(plugin_id, stage)`` at tick start
+        (or the gauge will stay stuck at 1 from the previous tick)."""
+
+        # ----- RECONCILE / CONSTRAIN behaviour metrics -----
+
+        self.reconcile_clamped_total = Counter(
+            f"{PREFIX}_reconcile_clamped_total",
+            "RECONCILE stage clamped the recommendation by a floor/ceiling "
+            "override (the final replica count differs from the lowest-priority "
+            "SET because an AT_LEAST raised it or an AT_MOST lowered it).",
+            labelnames=["sub_component_type", "source"],
+            **kw,
+        )
+        """``source`` is the plugin_id of whichever AT_LEAST (for floor)
+        or AT_MOST (for ceiling) actually won the clamp; ``"unknown"``
+        when the merge could not back-reference the winning target (a
+        degenerate case the merge helper logs)."""
+
+        self.constrain_capped_total = Counter(
+            f"{PREFIX}_constrain_capped_total",
+            "CONSTRAIN stage capped the final replica count (same meaning "
+            "as reconcile_clamped_total but fired by the CONSTRAIN pass; "
+            "expected contributor: builtin-budget-constrain).",
+            labelnames=["sub_component_type", "source"],
+            **kw,
+        )
+
+        self.reject_short_circuited_total = Counter(
+            f"{PREFIX}_reject_short_circuited_total",
+            "REJECT result triggered a stage short-circuit; the remaining "
+            "pipeline was not invoked and EXECUTE was skipped.",
+            labelnames=["plugin_id"],
+            **kw,
+        )
+
+        # ----- Tick scheduling metrics -----
+        #
+        # These describe the orchestrator's tick loop behaviour —
+        # how often plugins get deferred, how much latency the cache
+        # replay adds, and whether ticks meet their deadline.  Only
+        # lights up on the orchestrator path; PSM has no multi-cadence
+        # scheduling.
+
+        self.tick_skipped_total = Counter(
+            f"{PREFIX}_tick_skipped_total",
+            "Times a plugin was skipped in its stage because its "
+            "execution_interval hadn't elapsed yet (cache replay or "
+            "ACCEPT_WHEN_IDLE policy took over).",
+            labelnames=["plugin_id"],
+            **kw,
+        )
+
+        self.tick_requires_unsatisfied_total = Counter(
+            f"{PREFIX}_tick_requires_unsatisfied_total",
+            "Times a plugin was skipped this tick because one of its "
+            "``requires_produced_fields`` dot-paths resolved to None "
+            "in the current PipelineContext (i.e., the upstream "
+            "stage that was expected to produce that field did not "
+            "fire / did not produce). ``missing_field`` is the first "
+            "dot-path that failed the check; useful for debugging "
+            "dependency cascades.",
+            labelnames=["plugin_id", "missing_field"],
+            **kw,
+        )
+
+        self.tick_lag_seconds = Gauge(
+            f"{PREFIX}_tick_lag_seconds",
+            "Seconds between a plugin's scheduled 'due' moment and the "
+            "tick that actually evaluated it; 0 for plugins evaluated "
+            "right on schedule, positive when the planner lags the "
+            "scheduled cadence.",
+            labelnames=["plugin_id"],
+            **kw,
+        )
+
+        self.tick_duration_seconds = Histogram(
+            f"{PREFIX}_tick_duration_seconds",
+            "Total time spent inside orchestrator.tick (PREDICT + "
+            "PROPOSE + RECONCILE + CONSTRAIN), in seconds.",
+            buckets=(0.01, 0.05, 0.1, 0.5, 1.0, 2.0, 5.0, 10.0, 30.0),
+            **kw,
+        )
+        """Default ``tick_max_duration_seconds`` is 30s; buckets up to
+        30s let operators see P99 tick duration approach the deadline
+        before ``tick_timeout_total`` starts firing."""
+
+        self.tick_timeout_total = Counter(
+            f"{PREFIX}_tick_timeout_total",
+            "Ticks that exceeded tick_max_duration_seconds and were "
+            "aborted by the outer asyncio.wait_for.",
+            **kw,
+        )
+
+    def reset_overrides(self, plugin_id: str, stage: str) -> None:
+        """Zero every ``override_type`` for a (plugin_id, stage) pair.
+
+        Called at tick start (or when a plugin is evaluated but
+        produces no override) so the gauge doesn't stay stuck at 1
+        from a previous tick when the plugin stops contributing.
+        """
+        for override_type in ("SET", "AT_LEAST", "AT_MOST", "REJECT"):
+            self.plugin_override_active.labels(
+                plugin_id=plugin_id,
+                stage=stage,
+                override_type=override_type,
+            ).set(0)
diff --git a/components/src/dynamo/planner/offline/replay_adapter.py b/components/src/dynamo/planner/offline/replay_adapter.py
index ec367b773f52..1bae3e6b0e89 100644
--- a/components/src/dynamo/planner/offline/replay_adapter.py
+++ b/components/src/dynamo/planner/offline/replay_adapter.py
@@ -1,22 +1,37 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-"""Adapter that drives PlannerStateMachine via the PlannerReplayBridge.
+"""Adapter that drives the planner core via the PlannerReplayBridge.
 
 The bridge (Rust, PyO3) runs the offline simulation step-by-step.
-This adapter sits between the bridge and the planner state machine:
+This adapter sits between the bridge and the planner tick engine:
 
     Bridge.advance_to(tick_ms) -> raw metrics dict
     Adapter._build_tick_input() -> TickInput
-    StateMachine.on_tick() -> PlannerEffects
+    EngineProtocol.tick() -> PlannerEffects
     Adapter -> Bridge.apply_scaling(prefill, decode)
 
-Supports both aggregated and disaggregated topologies. No I/O, no runtime
-dependencies. Fully deterministic when used with offline replay.
+The tick engine is selected by ``config.scheduling.use_orchestrator``:
+
+- ``False`` (default): legacy PSM path — ``PlannerStateMachine`` +
+  ``_PSMEngineAdapter``. Byte-for-byte identical to pre-PR-8 replay.
+- ``True``: orchestrator path — ``OrchestratorEngineAdapter`` wrapping
+  ``LocalPlannerOrchestrator`` + the 5 builtin plugins. Produces the
+  same ``PlannerEffects.scale_to`` / ``next_tick`` as PSM (dual-path
+  parity test lock) with plugin-era observability (Prometheus metrics,
+  audit events, plugin-aware diagnostics).
+
+Replay keeps its sync ``run()`` API on both paths; async calls on the
+orchestrator path (``bootstrap_from_fpms`` / ``tick``) run inside a
+single replay-scoped event loop so callers don't need to change.
+
+Supports both aggregated and disaggregated topologies. No I/O, no
+runtime dependencies. Fully deterministic with offline replay.
 """
 
 from __future__ import annotations
 
+import asyncio
 import logging
 from dataclasses import dataclass, field
 from typing import Any, Optional
@@ -27,6 +42,7 @@
     ScheduledRequestMetrics,
 )
 from dynamo.planner.config.planner_config import PlannerConfig
+from dynamo.planner.core.engine_protocol import EngineProtocol, _PSMEngineAdapter
 from dynamo.planner.core.state_machine import PlannerStateMachine
 from dynamo.planner.core.types import (
     FpmObservations,
@@ -40,6 +56,8 @@
 )
 from dynamo.planner.monitoring.diagnostics_recorder import DiagnosticsRecorder
 from dynamo.planner.monitoring.traffic_metrics import Metrics
+from dynamo.planner.plugins.clock import VirtualClock
+from dynamo.planner.plugins.orchestrator.engine_adapter import OrchestratorEngineAdapter
 
 logger = logging.getLogger(__name__)
 
@@ -125,9 +143,41 @@ def __init__(
     ) -> None:
         self._config = planner_config
         self._bridge = bridge
-        self._sm = PlannerStateMachine(planner_config, capabilities)
+        self._capabilities = capabilities
         self._is_disagg = planner_config.mode == "disagg"
 
+        # Tick engine selected by the feature flag. On PSM path
+        # ``self._sm`` is the actual state machine (reused for helpers
+        # like ``warm_load_predictors``). On orchestrator path it is
+        # ``None``; a throwaway PSM inside ``OrchestratorEngineAdapter.
+        # bootstrap_from_fpms`` handles regression bootstrap instead.
+        use_orchestrator = planner_config.scheduling.use_orchestrator
+        self._use_orchestrator = use_orchestrator
+        self._sm: Optional[PlannerStateMachine] = None
+        self._engine: EngineProtocol
+        if use_orchestrator:
+            # Inject a ``VirtualClock`` so plugin scheduler / circuit
+            # breaker / HOLD_LAST cache see *trace time*, not real
+            # wall-clock.  ``OrchestratorEngineAdapter.tick`` calls
+            # ``clock.advance`` at the start of every tick to keep this
+            # clock in sync with ``tick_input.now_s``.  Without this a
+            # fast-forward replay (e.g. 1hr trace in 10s real time)
+            # would leave plugins with ``execution_interval`` larger
+            # than the real-time duration never re-firing.
+            self._engine = OrchestratorEngineAdapter(
+                planner_config,
+                capabilities or WorkerCapabilities(),
+                clock=VirtualClock(),
+            )
+            # Replay's ``run()`` is synchronous; we own a scoped event
+            # loop to drive the async engine calls without forcing
+            # callers to use ``asyncio.run``.
+            self._loop = asyncio.new_event_loop()
+        else:
+            self._sm = PlannerStateMachine(planner_config, capabilities)
+            self._engine = _PSMEngineAdapter(self._sm)
+            self._loop = None  # type: ignore[assignment]
+
         # Last-seen FPM caches (separate for prefill/decode)
         self._prefill_fpm_cache: dict[tuple[str, int], ForwardPassMetrics] = {}
         self._decode_fpm_cache: dict[tuple[str, int], ForwardPassMetrics] = {}
@@ -149,12 +199,73 @@ def __init__(
         self._last_tick_s: float = 0.0
         self._last_traffic: Metrics = Metrics()
 
+        # Warmup path: PSM exposes ``warm_load_predictors`` directly; on
+        # the orchestrator path we route the same list through
+        # ``bootstrap_plugins(historical_traffic=...)`` which primes the
+        # builtin predictor identically.
         if warmup_observations:
-            self._sm.warm_load_predictors(warmup_observations)
+            if self._use_orchestrator:
+                self._run_sync(
+                    self._engine.bootstrap_plugins(  # type: ignore[union-attr]
+                        historical_traffic=warmup_observations
+                    )
+                )
+            else:
+                assert self._sm is not None
+                self._sm.warm_load_predictors(warmup_observations)
+
+    # ------------------------------------------------------------------
+    # Sync/async bridging
+    # ------------------------------------------------------------------
+
+    def _run_sync(self, coro):
+        """Run a coroutine on the replay-owned event loop. Used to call
+        the orchestrator path's async APIs from replay's sync surface."""
+        assert self._loop is not None, "sync bridge only available on orchestrator path"
+        return self._loop.run_until_complete(coro)
+
+    def install_benchmark_fpms(
+        self,
+        *,
+        prefill_fpms: Optional[list[ForwardPassMetrics]] = None,
+        decode_fpms: Optional[list[ForwardPassMetrics]] = None,
+        agg_fpms: Optional[list[ForwardPassMetrics]] = None,
+    ) -> None:
+        """Install AIC benchmark FPMs into the regression model(s),
+        path-agnostically.
+
+        - PSM path: ``PlannerStateMachine.load_benchmark_fpms``.
+        - Orchestrator path: ``OrchestratorEngineAdapter
+          .install_regressions_from_fpms`` (builds + installs on the
+          shared store; synchronous, does NOT re-bootstrap plugins —
+          plugins were already bootstrapped at adapter construction).
+
+        Without this on the orchestrator path the regressions were never
+        installed (``replay/main.py`` previously only fed ``adapter._sm``,
+        which is None under ``use_orchestrator``), so the throughput
+        regression stayed empty and orchestrator-replay scaling decisions
+        diverged from PSM."""
+        if self._use_orchestrator:
+            self._engine.install_regressions_from_fpms(  # type: ignore[attr-defined]
+                prefill_fpms=prefill_fpms,
+                decode_fpms=decode_fpms,
+                agg_fpms=agg_fpms,
+            )
+            return
+        assert self._sm is not None
+        kwargs: dict[str, list[ForwardPassMetrics]] = {}
+        if prefill_fpms is not None:
+            kwargs["prefill_fpms"] = prefill_fpms
+        if decode_fpms is not None:
+            kwargs["decode_fpms"] = decode_fpms
+        if agg_fpms is not None:
+            kwargs["agg_fpms"] = agg_fpms
+        if kwargs:
+            self._sm.load_benchmark_fpms(**kwargs)
 
     def run(self) -> ReplayPlannerReport:
         """Run the full replay with planner-in-the-loop."""
-        next_tick = self._sm.initial_tick(0.0)
+        next_tick = self._engine.initial_tick(0.0)
         scaling_events: list[ScalingEvent] = []
         diagnostics_log: list[TickDiagnostics] = []
         total_ticks = 0
@@ -167,7 +278,19 @@ def run(self) -> ReplayPlannerReport:
                 break
 
             tick_input = self._build_tick_input(next_tick, result)
-            effects: PlannerEffects = self._sm.on_tick(next_tick, tick_input)
+            # ``EngineProtocol.tick`` is async. On PSM path the
+            # ``_PSMEngineAdapter`` wraps PSM's sync ``on_tick`` in an
+            # async-defined-but-never-awaits shim, so ``run_until_complete``
+            # returns synchronously without yielding to the loop. On
+            # orchestrator path it genuinely awaits the pipeline.
+            if self._use_orchestrator:
+                effects: PlannerEffects = self._run_sync(
+                    self._engine.tick(next_tick, tick_input)
+                )
+            else:
+                # Fast path for PSM: skip the event-loop roundtrip.
+                assert self._sm is not None
+                effects = self._sm.on_tick(next_tick, tick_input)
             diagnostics_log.append(effects.diagnostics)
             total_ticks += 1
 
@@ -318,13 +441,22 @@ def _feed_extra_fpm_to_regression(
     ) -> None:
         """Feed accumulated FPM snapshots to regression, excluding the last
         per worker (which will be added by _observe_fpm via fpm_observations).
-        This avoids double-counting the cached snapshot."""
-        if not hasattr(self._sm, "_is_easy") or self._sm._is_easy:
+        This avoids double-counting the cached snapshot.
+
+        Works on both paths via ``_get_regression(kind)`` so
+        orchestrator replay and PSM replay share identical snapshot
+        feeding. Returns early on easy mode (no regressions) or when
+        the requested regression slot isn't installed (the install gap
+        is fixed via the empty-regression bootstrap in
+        ``_install_benchmark_fpms``).
+        """
+        if self._is_easy_mode():
             return  # easy mode has no regression models
 
-        if self._sm._is_agg:
-            # Exclude the last snapshot per worker (it's in the cache and
-            # will be added by _observe_fpm)
+        if self._config.mode == "agg":
+            agg_reg = self._get_regression("agg")
+            if agg_reg is None:
+                return
             last_idx_per_worker: dict[int, int] = {}
             for i, snap in enumerate(decode_snaps):
                 last_idx_per_worker[snap["worker_id"]] = i
@@ -334,36 +466,64 @@ def _feed_extra_fpm_to_regression(
                     continue
                 fpm = _build_fpm_from_dict(snap)
                 if fpm.wall_time > 0.0:
-                    self._sm._agg_regression.add_observations(
-                        {(fpm.worker_id, fpm.dp_rank): fpm}
-                    )
+                    agg_reg.add_observations({(fpm.worker_id, fpm.dp_rank): fpm})
         else:
-            if self._sm._has_prefill:
-                last_idx: dict[int, int] = {}
-                for i, snap in enumerate(prefill_snaps):
-                    last_idx[snap["worker_id"]] = i
-                exclude = set(last_idx.values())
-                for i, snap in enumerate(prefill_snaps):
-                    if i in exclude:
-                        continue
-                    fpm = _build_fpm_from_dict(snap)
-                    if fpm.wall_time > 0.0:
-                        self._sm._prefill_regression.add_observations(
-                            {(fpm.worker_id, fpm.dp_rank): fpm}
-                        )
-            if self._sm._has_decode:
-                last_idx = {}
-                for i, snap in enumerate(decode_snaps):
-                    last_idx[snap["worker_id"]] = i
-                exclude = set(last_idx.values())
-                for i, snap in enumerate(decode_snaps):
-                    if i in exclude:
-                        continue
-                    fpm = _build_fpm_from_dict(snap)
-                    if fpm.wall_time > 0.0:
-                        self._sm._decode_regression.add_observations(
-                            {(fpm.worker_id, fpm.dp_rank): fpm}
-                        )
+            has_prefill = self._config.mode in ("prefill", "disagg")
+            has_decode = self._config.mode in ("decode", "disagg")
+            if has_prefill:
+                p_reg = self._get_regression("prefill")
+                if p_reg is not None:
+                    last_idx: dict[int, int] = {}
+                    for i, snap in enumerate(prefill_snaps):
+                        last_idx[snap["worker_id"]] = i
+                    exclude = set(last_idx.values())
+                    for i, snap in enumerate(prefill_snaps):
+                        if i in exclude:
+                            continue
+                        fpm = _build_fpm_from_dict(snap)
+                        if fpm.wall_time > 0.0:
+                            p_reg.add_observations({(fpm.worker_id, fpm.dp_rank): fpm})
+            if has_decode:
+                d_reg = self._get_regression("decode")
+                if d_reg is not None:
+                    last_idx = {}
+                    for i, snap in enumerate(decode_snaps):
+                        last_idx[snap["worker_id"]] = i
+                    exclude = set(last_idx.values())
+                    for i, snap in enumerate(decode_snaps):
+                        if i in exclude:
+                            continue
+                        fpm = _build_fpm_from_dict(snap)
+                        if fpm.wall_time > 0.0:
+                            d_reg.add_observations({(fpm.worker_id, fpm.dp_rank): fpm})
+
+    def _is_easy_mode(self) -> bool:
+        """Easy-mode check routed via config — both paths honour this
+        the same way (no regression in non-SLA modes)."""
+        return self._config.optimization_target != "sla"
+
+    def _get_regression(self, kind: str):
+        """Return the regression model for ``kind`` (``"agg"`` /
+        ``"prefill"`` / ``"decode"``) regardless of engine path.
+
+        PSM path: read directly from ``self._sm.{_agg,_prefill,_decode}_regression``.
+        Orchestrator path: read from the orchestrator's shared store
+        (populated by ``install_benchmark_fpms`` →
+        ``OrchestratorEngineAdapter.install_regressions_from_fpms`` →
+        ``install_regressions``, driven from ``replay/main.py``).
+        """
+        if self._use_orchestrator:
+            # The adapter hides the orchestrator; access via its public
+            # bootstrap hook doesn't help — read through the underlying
+            # orchestrator attribute we know is there.
+            orch = getattr(self._engine, "_orchestrator", None)
+            if orch is None:
+                return None
+            return orch.get_regression(kind)
+        if self._sm is None:
+            return None
+        attr = f"_{kind}_regression"
+        return getattr(self._sm, attr, None)
 
     def _build_tick_input(
         self, tick: ScheduledTick, result: dict[str, Any]
diff --git a/components/src/dynamo/planner/plugins/__init__.py b/components/src/dynamo/planner/plugins/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/plugins/_proto_bridge.py b/components/src/dynamo/planner/plugins/_proto_bridge.py
new file mode 100644
index 000000000000..cad393c2af45
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/_proto_bridge.py
@@ -0,0 +1,308 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Bidirectional converters between proto generated messages and Pydantic mirror.
+
+Used by:
+- Round-trip tests in ``tests/plugins/proto/test_round_trip.py``
+- ``InProcessTransport`` boundary (proto in / proto out, but plugin
+  authors can use Pydantic internally and convert)
+
+Conversion strategy:
+- Pydantic ``.model_dump(exclude_none=True)`` → dict → proto via field
+  assignment (handles oneof, optional, repeated, map, nested message)
+- Proto ``MessageToDict(preserving_proto_field_name=True)`` → dict → Pydantic
+  via ``cls.model_validate(...)``
+
+Edge cases handled:
+- proto3 ``optional`` fields: Pydantic ``None`` ↔ proto ``HasField`` False
+- proto3 ``oneof``: Pydantic ``result_kind`` ↔ proto ``WhichOneof``
+- ``map<string, bytes>``: bytes preserved end-to-end
+- repeated nested messages: list ↔ repeated field
+"""
+
+from __future__ import annotations
+
+import base64
+import typing
+from enum import IntEnum
+from typing import Any, Type, TypeVar
+
+from google.protobuf import json_format
+from google.protobuf.message import Message
+from pydantic import BaseModel
+
+from dynamo.planner.plugins import types as pyd
+from dynamo.planner.plugins.proto.v1 import plugin_pb2 as pb
+
+PydT = TypeVar("PydT", bound=BaseModel)
+
+
+# ---------------------------------------------------------------------------
+# Pydantic → proto
+# ---------------------------------------------------------------------------
+
+# Pydantic class → proto class lookup table. Keys are Pydantic class objects
+# (NOT strings, to allow IDE refactor).
+_PYD_TO_PROTO: dict[Type[BaseModel], Type[Message]] = {
+    pyd.RegisterRequest: pb.RegisterRequest,
+    pyd.RegisterResponse: pb.RegisterResponse,
+    pyd.HeartbeatRequest: pb.HeartbeatRequest,
+    pyd.HeartbeatResponse: pb.HeartbeatResponse,
+    pyd.UnregisterRequest: pb.UnregisterRequest,
+    pyd.UnregisterResponse: pb.UnregisterResponse,
+    pyd.ListPluginsRequest: pb.ListPluginsRequest,
+    pyd.ListPluginsResponse: pb.ListPluginsResponse,
+    pyd.PluginInfo: pb.PluginInfo,
+    pyd.TrafficMetrics: pb.TrafficMetrics,
+    pyd.FpmData: pb.FpmData,
+    pyd.WorkerState: pb.WorkerState,
+    pyd.ObservationData: pb.ObservationData,
+    pyd.PredictionData: pb.PredictionData,
+    pyd.ComponentTarget: pb.ComponentTarget,
+    pyd.ScalingProposal: pb.ScalingProposal,
+    pyd.PipelineContext: pb.PipelineContext,
+    pyd.AcceptResult: pb.AcceptResult,
+    pyd.RejectResult: pb.RejectResult,
+    pyd.OverrideResult: pb.OverrideResult,
+    pyd.ProposeResult: pb.ProposeResult,
+    pyd.PredictStageRequest: pb.PredictStageRequest,
+    pyd.PredictStageResponse: pb.PredictStageResponse,
+    pyd.ProposeStageRequest: pb.ProposeStageRequest,
+    pyd.ProposeStageResponse: pb.ProposeStageResponse,
+    pyd.ReconcileStageRequest: pb.ReconcileStageRequest,
+    pyd.ReconcileStageResponse: pb.ReconcileStageResponse,
+    pyd.ConstrainStageRequest: pb.ConstrainStageRequest,
+    pyd.ConstrainStageResponse: pb.ConstrainStageResponse,
+    pyd.BootstrapRequest: pb.BootstrapRequest,
+    pyd.BootstrapResponse: pb.BootstrapResponse,
+    pyd.ResetRequest: pb.ResetRequest,
+    pyd.ResetResponse: pb.ResetResponse,
+}
+
+
+def proto_class_for(pyd_cls: Type[BaseModel]) -> Type[Message]:
+    """Look up the proto class corresponding to a Pydantic mirror class."""
+    if pyd_cls not in _PYD_TO_PROTO:
+        raise KeyError(
+            f"No proto class registered for Pydantic class {pyd_cls.__name__}"
+        )
+    return _PYD_TO_PROTO[pyd_cls]
+
+
+def pydantic_to_proto(
+    pyd_msg: BaseModel, proto_cls: Type[Message] | None = None
+) -> Message:
+    """Convert a Pydantic mirror instance to its proto generated equivalent.
+
+    Uses JSON intermediate (``Pydantic.model_dump_json()`` →
+    ``json_format.Parse``) which correctly handles:
+    - optional fields (None values are excluded from JSON, so HasField stays False)
+    - oneof fields (Pydantic's ``result_kind`` + payload mapping reconstructs to oneof)
+    - map fields, repeated nested messages, bytes (base64 in JSON)
+    """
+    if proto_cls is None:
+        proto_cls = proto_class_for(type(pyd_msg))
+    data = _pyd_to_dict(pyd_msg)
+    pb_msg = proto_cls()
+    return json_format.ParseDict(data, pb_msg, ignore_unknown_fields=False)
+
+
+def _pyd_to_dict(pyd_msg: BaseModel) -> dict[str, Any]:
+    """Pydantic → dict suitable for ``json_format.ParseDict``.
+
+    Uses Pydantic ``mode="python"`` (preserves bytes; safer than "json"
+    which UTF-8-decodes bytes), then walks the dict to:
+    - Convert IntEnum values to int (json_format expects int for proto enum)
+    - Base64-encode bytes (json_format wire format for proto bytes)
+    - Strip ``result_kind`` oneof tag fields (Pydantic-only convenience)
+    """
+    data = pyd_msg.model_dump(mode="python", exclude_none=True)
+    return _normalize(data)
+
+
+def _normalize(d: Any) -> Any:
+    """Recursively convert IntEnum → int, bytes → base64 string, strip oneof tags."""
+    if isinstance(d, dict):
+        out: dict[str, Any] = {}
+        kind: str | None = d.get("result_kind") if "result_kind" in d else None
+        for k, v in d.items():
+            if k == "result_kind":
+                continue
+            # If a oneof payload key but doesn't match kind, skip
+            if (
+                kind not in (None, "")
+                and k in ("accept", "override", "reject")
+                and k != kind
+            ):
+                continue
+            out[k] = _normalize(v)
+        return out
+    if isinstance(d, list):
+        return [_normalize(x) for x in d]
+    if isinstance(d, IntEnum):
+        return int(d)
+    if isinstance(d, bytes):
+        return base64.b64encode(d).decode("ascii")
+    return d
+
+
+# ---------------------------------------------------------------------------
+# proto → Pydantic
+# ---------------------------------------------------------------------------
+
+_PROTO_TO_PYD: dict[Type[Message], Type[BaseModel]] = {
+    v: k for k, v in _PYD_TO_PROTO.items()
+}
+
+
+def pydantic_class_for(proto_cls: Type[Message]) -> Type[BaseModel]:
+    if proto_cls not in _PROTO_TO_PYD:
+        raise KeyError(
+            f"No Pydantic class registered for proto class {proto_cls.__name__}"
+        )
+    return _PROTO_TO_PYD[proto_cls]
+
+
+def proto_to_pydantic(pb_msg: Message, pyd_cls: Type[PydT] | None = None) -> PydT:
+    """Convert a proto message to its Pydantic mirror equivalent.
+
+    Uses ``MessageToDict(preserving_proto_field_name=True, including_default_value_fields=False)``
+    which gives field names matching Pydantic mirror exactly, and correctly
+    omits unset optional fields (HasField=False) so Pydantic sees None.
+    """
+    target_cls: Type[BaseModel] = (
+        pyd_cls if pyd_cls is not None else pydantic_class_for(type(pb_msg))
+    )
+    data = json_format.MessageToDict(
+        pb_msg,
+        preserving_proto_field_name=True,
+        always_print_fields_with_no_presence=False,
+        use_integers_for_enums=True,  # Pydantic IntEnum expects int values
+    )
+
+    # Recursively inject result_kind for any nested message with oneof
+    data = _inject_oneof_kinds(data, pb_msg)
+
+    # Decode base64-encoded bytes fields based on Pydantic schema annotation
+    data = _decode_bytes_by_pyd_schema(data, target_cls)
+
+    return target_cls.model_validate(data)  # type: ignore[return-value]
+
+
+def _decode_bytes_by_pyd_schema(d: Any, pyd_cls: Type[BaseModel]) -> Any:
+    """Walk Pydantic schema; base64-decode any bytes / dict[str,bytes] field.
+
+    Inspects ``model_fields`` annotations to detect bytes-typed fields.
+    Recurses into nested Pydantic message types.
+    """
+    if not isinstance(d, dict):
+        return d
+
+    out: dict[str, Any] = {}
+    fields = pyd_cls.model_fields
+    for k, v in d.items():
+        if k not in fields:
+            out[k] = v
+            continue
+        ann = fields[k].annotation
+        # Strip Optional[X] -> X
+        origin = typing.get_origin(ann)
+        if origin is typing.Union or (
+            origin is not None and str(origin) == "types.UnionType"
+        ):
+            args = [a for a in typing.get_args(ann) if a is not type(None)]
+            if len(args) == 1:
+                ann = args[0]
+                origin = typing.get_origin(ann)
+
+        # Singular bytes
+        if ann is bytes and isinstance(v, str):
+            out[k] = base64.b64decode(v)
+        # dict[str, bytes]
+        elif origin is dict:
+            dict_args = typing.get_args(ann)
+            if len(dict_args) == 2 and dict_args[1] is bytes and isinstance(v, dict):
+                out[k] = {
+                    kk: (base64.b64decode(vv) if isinstance(vv, str) else vv)
+                    for kk, vv in v.items()
+                }
+            else:
+                out[k] = v
+        # Singular nested Pydantic message
+        elif (
+            isinstance(ann, type) and issubclass(ann, BaseModel) and isinstance(v, dict)
+        ):
+            out[k] = _decode_bytes_by_pyd_schema(v, ann)
+        # list[NestedPydantic]
+        elif origin is list:
+            list_args = typing.get_args(ann)
+            if (
+                list_args
+                and isinstance(list_args[0], type)
+                and issubclass(list_args[0], BaseModel)
+                and isinstance(v, list)
+            ):
+                out[k] = [
+                    _decode_bytes_by_pyd_schema(x, list_args[0])
+                    if isinstance(x, dict)
+                    else x
+                    for x in v
+                ]
+            else:
+                out[k] = v
+        else:
+            out[k] = v
+    return out
+
+
+def _inject_oneof_kinds(d: Any, pb_msg: Message) -> Any:
+    """Recursively inject ``result_kind`` for proto messages with ``oneof result``.
+
+    Walks the proto message structure via ``ListFields`` (returns set fields
+    only) which avoids descriptor attribute access patterns that trigger
+    C++ binding errors in some protobuf versions.
+    """
+    if not isinstance(d, dict):
+        return d
+
+    # Check if THIS message has a oneof named "result"
+    if hasattr(pb_msg, "WhichOneof"):
+        try:
+            kind = pb_msg.WhichOneof("result")
+            d["result_kind"] = kind if kind is not None else ""
+        except (ValueError, KeyError):
+            # No oneof named "result" on this message
+            pass
+
+    # Recurse into nested messages via ListFields (only set fields)
+    for field, value in pb_msg.ListFields():
+        name = field.name
+        if name not in d:
+            continue
+        # Detect map<K, V> — Python repr is dict, not list
+        if isinstance(value, dict) and not isinstance(d[name], list):
+            continue
+        # Singular nested Message — Message is not iterable
+        if isinstance(value, Message):
+            d[name] = _inject_oneof_kinds(d[name], value)
+            continue
+        # Repeated message field — RepeatedCompositeContainer (iterable but
+        # no __iter__ attr; use iter() to detect)
+        try:
+            children = list(iter(value))
+        except TypeError:
+            continue
+        if children and isinstance(children[0], Message) and isinstance(d[name], list):
+            for i, child_pb in enumerate(children):
+                if i < len(d[name]):
+                    d[name][i] = _inject_oneof_kinds(d[name][i], child_pb)
+    return d
+
+
+__all__ = [
+    "proto_class_for",
+    "pydantic_class_for",
+    "pydantic_to_proto",
+    "proto_to_pydantic",
+]
diff --git a/components/src/dynamo/planner/plugins/clock.py b/components/src/dynamo/planner/plugins/clock.py
new file mode 100644
index 000000000000..ade100527dcf
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/clock.py
@@ -0,0 +1,150 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Deterministic clock abstraction.
+
+All time access in the orchestrator and PluginRegistry MUST go through
+``Clock`` — direct ``time.time()`` / ``time.monotonic()`` /
+``asyncio.sleep`` is forbidden.
+
+**Two time sources**:
+- ``now()``: epoch float (wall-clock); use for audit log timestamps,
+  ``decision_id`` generation
+- ``monotonic()``: monotonic float; use for duration / scheduling
+  (immune to NTP / clock skew)
+
+**Two implementations**:
+- ``WallClock``: production
+- ``VirtualClock``: replay / test; ``advance(N)`` warps time forward and
+  wakes pending sleepers
+
+**Production safety**: ``VirtualClock`` MUST NOT be used in production
+(NativePlannerBase startup checks ``clock.type=virtual`` and refuses to
+start unless ``DYNAMO_PLANNER_TEST=1``).
+"""
+
+from __future__ import annotations
+
+import abc
+import asyncio
+import heapq
+import itertools
+import time
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
+
+
+class Clock(abc.ABC):
+    """Abstract clock interface."""
+
+    @abc.abstractmethod
+    def now(self) -> float:
+        """Wall-clock seconds since epoch (UTC).
+
+        Use for audit log timestamps, ``decision_id`` generation, anything
+        that must be human-readable / NTP-aligned.
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def monotonic(self) -> float:
+        """Monotonic seconds (independent of wall-clock adjustments).
+
+        Use for duration measurement, scheduling intervals, circuit breaker
+        cooldown — anything where clock skew / NTP jumps would cause bugs.
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def sleep(self, seconds: float) -> None:
+        """Asynchronously sleep for the given number of seconds.
+
+        ``WallClock`` delegates to ``asyncio.sleep``.
+        ``VirtualClock`` parks on a future awaiting ``advance()`` to elapse.
+
+        Cancellation: standard asyncio cancellation semantics — if the
+        awaiting task is cancelled, ``CancelledError`` propagates.
+        """
+        raise NotImplementedError
+
+
+class WallClock(Clock):
+    """Production clock — real wall-clock and event-loop sleep."""
+
+    def now(self) -> float:
+        return time.time()
+
+    def monotonic(self) -> float:
+        return time.monotonic()
+
+    async def sleep(self, seconds: float) -> None:
+        await asyncio.sleep(seconds)
+
+
+class VirtualClock(Clock):
+    """Test / replay clock — time advances only via explicit ``advance()`` call.
+
+    ``sleep()`` parks the caller on a future; ``advance(N)`` adds N to virtual
+    time and resolves all futures whose deadlines have passed.
+
+    **Cancellation cleanup** (P1-4 review v11):
+    - ``advance()`` does a cleanup pass to discard already-cancelled
+      futures from the heap, preventing memory leak in long-running tests.
+    """
+
+    def __init__(self, start_now: float = 0.0, start_mono: float = 0.0) -> None:
+        self._now = start_now
+        self._mono = start_mono
+        # heap of (wake_at_monotonic, sequence_id, future);
+        # sequence_id ensures FIFO when wake_at ties (heap requires comparable tuples)
+        self._sleepers: list[tuple[float, int, asyncio.Future[None]]] = []
+        self._counter = itertools.count()
+
+    def now(self) -> float:
+        return self._now
+
+    def monotonic(self) -> float:
+        return self._mono
+
+    async def sleep(self, seconds: float) -> None:
+        if seconds <= 0:
+            # Immediate yield — let other coroutines run, but no virtual time passes
+            await asyncio.sleep(0)
+            return
+        loop = asyncio.get_running_loop()
+        fut: asyncio.Future[None] = loop.create_future()
+        wake_at = self._mono + seconds
+        heapq.heappush(self._sleepers, (wake_at, next(self._counter), fut))
+        try:
+            await fut
+        except asyncio.CancelledError:
+            # Don't try to remove from heap here (heap removal is O(n)); just
+            # let the cancelled future stay in heap and skip on advance().
+            raise
+
+    def advance(self, seconds: float) -> None:
+        """Warp virtual time forward by ``seconds`` and wake any due sleepers.
+
+        Sleepers whose ``wake_at <= mono + seconds`` resolve immediately
+        (without calling their awaiting coroutine — the awaiter resumes on
+        the next event loop iteration).
+
+        **Cleanup pass** (v11 P1-4): cancelled / done futures are silently
+        discarded from the heap to bound memory in long-running tests.
+        """
+        if seconds < 0:
+            raise ValueError(
+                f"VirtualClock.advance: seconds must be >= 0, got {seconds}"
+            )
+        self._now += seconds
+        self._mono += seconds
+        while self._sleepers and self._sleepers[0][0] <= self._mono:
+            _wake_at, _seq, fut = heapq.heappop(self._sleepers)
+            if not fut.done():
+                fut.set_result(None)
+            # else: cancelled or already-resolved; silently drop
+
+
+__all__ = ["Clock", "WallClock", "VirtualClock"]
diff --git a/components/src/dynamo/planner/plugins/merge/__init__.py b/components/src/dynamo/planner/plugins/merge/__init__.py
new file mode 100644
index 000000000000..058fbab1debf
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/merge/__init__.py
@@ -0,0 +1,41 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Plugin output merge algorithms.
+
+Two algorithms (both **pure functions** — no I/O, no Clock dependency,
+deterministic):
+
+- ``type_aware_merge``: PROPOSE / RECONCILE / CONSTRAIN. Collects
+  per-plugin ``OverrideResult``, groups by ``sub_component_type``
+  (one bucket per type in this PR — see ``ComponentKey`` for the
+  forward-compat note on multi-pool), computes floor (max AT_LEAST) /
+  ceiling (min AT_MOST) / recommendation (priority-smallest SET), clamps.
+  REJECT > final priority.
+- ``chain_augment``: PREDICT. Sequential layered prediction with
+  partial-merge on ``optional float`` fields; ``final=True`` stops the chain.
+  Runtime detection of "final at non-lowest priority" misuse.
+
+``type_aware_merge`` is sync; ``chain_augment`` is async only because it
+awaits plugin RPCs — the algorithmic logic itself is synchronous.
+"""
+
+from dynamo.planner.plugins.merge.chain_augment import chain_augment
+from dynamo.planner.plugins.merge.type_aware import type_aware_merge
+from dynamo.planner.plugins.merge.types import (
+    ChainAugmentOutcome,
+    ComponentKey,
+    MergeOutcome,
+    PluginResult,
+    PredictPluginCallable,
+)
+
+__all__ = [
+    "PluginResult",
+    "ComponentKey",
+    "MergeOutcome",
+    "ChainAugmentOutcome",
+    "PredictPluginCallable",
+    "type_aware_merge",
+    "chain_augment",
+]
diff --git a/components/src/dynamo/planner/plugins/merge/chain_augment.py b/components/src/dynamo/planner/plugins/merge/chain_augment.py
new file mode 100644
index 000000000000..da890935c0ab
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/merge/chain_augment.py
@@ -0,0 +1,178 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Chain-augment merge for PREDICT stage.
+
+Sequential layered prediction: each plugin sees the running
+``prediction`` on its ``PipelineContext`` and may set fields the
+higher-precedence plugins ahead of it left unset, or it may stay
+silent. Partial-merge is field-level on the ``Optional[float]``
+prediction fields (``None`` = "no opinion, leave previous value
+alone"; a concrete float — including ``0.0`` — = "I assert this
+value").
+
+Ordering and semantics
+----------------------
+- Chain is sorted by ``priority`` **ascending** (smallest priority
+  number first). Smallest priority = highest precedence = runs
+  **first** and writes the fields the lower-precedence plugins
+  cannot overwrite.
+- Partial-merge rule: **first writer wins**. A later plugin's value
+  for a field is adopted only if every higher-precedence plugin left
+  that field as ``None``. This matches the way ``priority`` works in
+  the merge stages: smaller priority is more authoritative, larger
+  priority fills in defaults / refinements.
+- ``predictions=None`` in a response ≈ "no opinion"; the chain
+  continues with the running prediction unchanged.
+- ``final=True`` short-circuits the chain at the plugin that set it.
+  Plugins later in the chain (lower precedence, larger priority
+  number) are **not** called. This is the unified meaning of
+  ``final=true`` across stages — "my answer is enough, no need to
+  fall through to defaults".
+- **Convention**: ``final=true`` is most commonly used as "my answer
+  is enough; skip all remaining plugins". With the ascending priority
+  sort the authoritative plugin always runs **first**, so the cleanest
+  way to express that intent is to set ``final=true`` on the
+  smallest-priority plugin.
+
+  When ``final=true`` comes from a non-lowest-priority plugin, the
+  chain still breaks at that plugin: the smallest-priority plugin has
+  already weighed in (its values are protected by first-writer-wins
+  regardless), but larger-priority-number plugins after the
+  final-setter are skipped. They lose the chance to populate fields
+  earlier plugins left as ``None``. This may be **intentional** (e.g.
+  a policy plugin saying "skip the expensive fallback for this
+  scenario") or a **configuration mistake** (e.g. ``final=true``
+  copy-pasted onto the wrong plugin) — ``chain_augment`` cannot tell
+  which from the response alone. To surface the event for operator
+  audit, ``chain_augment`` logs a WARNING and records the message in
+  ``ChainAugmentOutcome.chain_break_warnings``; the orchestrator
+  forwards these to ``PipelineOutcome.audit_events``. A Prometheus
+  counter for this signal is deferred to a follow-up observability PR.
+
+This unifies the semantics of ``priority`` and ``final=true`` across
+all four stages:
+
+- **All stages**: smallest priority = most authoritative.
+- **All stages**: ``final=true`` from the highest-precedence plugin
+  means "my answer is the final one, skip everyone else".
+
+The only difference is the underlying problem each stage solves:
+
+- PROPOSE / RECONCILE / CONSTRAIN reconcile **conflicting** SET
+  proposals via type-aware merge (winner-takes-all per key).
+- PREDICT layers **complementary** prediction fields via first-writer
+  partial-merge (no conflicts; everyone fills in different gaps).
+
+The function is async only because it awaits plugin RPCs; the
+algorithmic logic is synchronous and deterministic given plugin
+responses.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional, Sequence
+
+from dynamo.planner.plugins.merge.types import (
+    ChainAugmentOutcome,
+    PredictPluginCallable,
+)
+from dynamo.planner.plugins.types import PipelineContext, PredictionData
+
+log = logging.getLogger(__name__)
+
+_PREDICTION_FIELDS = (
+    "predicted_num_req",
+    "predicted_isl",
+    "predicted_osl",
+    "predicted_kv_hit_rate",
+)
+
+
+def _partial_merge(
+    prev: Optional[PredictionData], new: PredictionData
+) -> PredictionData:
+    """Field-level merge: ``prev`` (the higher-precedence plugin that
+    ran earlier) wins on every field it already set; ``new``
+    contributes only to fields ``prev`` left as ``None``.
+
+    Concretely: for each prediction field, take ``prev.<field>`` if it
+    is not ``None``, else ``new.<field>``. ``source`` takes
+    ``prev.source`` if non-empty, else ``new.source``.
+
+    If ``prev is None`` (first plugin in the chain), ``new`` is
+    returned verbatim.
+    """
+    if prev is None:
+        return new
+    merged: dict[str, Any] = {}
+    for name in _PREDICTION_FIELDS:
+        pv = getattr(prev, name)
+        merged[name] = pv if pv is not None else getattr(new, name)
+    merged["source"] = prev.source or new.source
+    return PredictionData(**merged)
+
+
+async def chain_augment(
+    plugin_chain: Sequence[PredictPluginCallable],
+    initial_context: PipelineContext,
+) -> ChainAugmentOutcome:
+    """Run a PREDICT chain, returning the first-writer-wins merged prediction.
+
+    Args:
+        plugin_chain: PREDICT plugins to run. Sorted by priority
+            ascending internally (smallest priority first); caller may
+            pass any order. Empty input → empty outcome.
+        initial_context: Base PipelineContext shared across plugins.
+            The ``predictions`` field is replaced per-iteration with
+            the running merged prediction; other fields are preserved.
+
+    Returns:
+        ``ChainAugmentOutcome`` — ``prediction`` is the merged
+        ``PredictionData`` (``None`` if no plugin produced content);
+        ``final_from`` is the plugin that broke the chain (empty on
+        full traversal); ``chain_break_warnings`` is non-empty when a
+        plugin other than the lowest-priority-number (highest
+        precedence) returned ``final=true`` — informational, not
+        necessarily an error.
+    """
+    chain = sorted(plugin_chain, key=lambda p: p.priority)
+    lowest_priority = min((p.priority for p in chain), default=None)
+    prediction: Optional[PredictionData] = None
+    final_from = ""
+    chain_break_warnings: list[str] = []
+
+    for p in chain:
+        ctx = initial_context.model_copy(update={"predictions": prediction})
+        resp = await p.call("Predict", ctx)
+        if resp.predictions is not None:
+            prediction = _partial_merge(prediction, resp.predictions)
+        if resp.final:
+            final_from = p.plugin_id
+            if lowest_priority is not None and p.priority != lowest_priority:
+                msg = (
+                    f"chain_augment_non_lowest_final: plugin_id={p.plugin_id} "
+                    f"priority={p.priority} returned final=true; "
+                    f"lowest_priority={lowest_priority}. With ascending "
+                    f"sort the lowest-priority (authoritative) plugin "
+                    f"has already weighed in, so the chain break here "
+                    f"skips larger-priority-number plugins (priority > "
+                    f"{p.priority}) — they lose the chance to populate "
+                    f"otherwise-None fields. This may be intentional "
+                    f"(cost / policy override) or a config mistake; "
+                    f"operator should verify."
+                )
+                log.warning(msg)
+                chain_break_warnings.append(msg)
+            break
+
+    return ChainAugmentOutcome(
+        prediction=prediction,
+        final_from=final_from,
+        degraded=[],
+        chain_break_warnings=chain_break_warnings,
+    )
+
+
+__all__ = ["chain_augment"]
diff --git a/components/src/dynamo/planner/plugins/merge/type_aware.py b/components/src/dynamo/planner/plugins/merge/type_aware.py
new file mode 100644
index 000000000000..6a6c56cbbaec
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/merge/type_aware.py
@@ -0,0 +1,239 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Type-aware merge.
+
+Pure function used by the orchestrator in PROPOSE / RECONCILE /
+CONSTRAIN stages.
+
+Algorithm outline
+-----------------
+1. **REJECT short-circuit** — any ``RejectResult`` returns
+   ``short_circuited=True``; out-ranks ``final``.
+2. **final priority** — if any ``OverrideResult`` carries ``final=True``,
+   the priority-smallest final's targets become the proposal outright.
+3. **Bucket by ``sub_component_type``** (one bucket per type — see
+   ``ComponentKey`` for the forward-compat note on multi-pool); inside
+   each bucket:
+   - ``floor = max(AT_LEAST replicas)`` (defaults to ``0``)
+   - ``ceiling = min(AT_MOST replicas)`` (defaults to ``+inf``)
+   - ``recommendation = priority-smallest SET replicas`` else baseline
+   - ``result = max(floor, min(ceiling, recommendation))`` — clamp order
+     ensures ``floor`` wins when ``floor > ceiling``
+4. **Cast to int** and build ``ScalingProposal``.
+
+``set_allowed=False`` (CONSTRAIN mode) drops SET targets from both the
+final path and the bucket-merge path and records dropped component keys
+on ``MergeOutcome.set_dropped``. The keys are surfaced via
+``PipelineOutcome.constrain_outcome.set_dropped`` for downstream
+inspection; a Prometheus counter / audit event for this signal is
+deferred to a follow-up observability PR.
+
+The function is **sync** and **deterministic** — no I/O, no Clock. Output
+target order preserves insertion order of ``plugin_results`` first, then
+any baseline-only keys.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Mapping, Sequence
+
+from dynamo.planner.plugins.merge.types import ComponentKey, MergeOutcome, PluginResult
+from dynamo.planner.plugins.types import (
+    ComponentTarget,
+    OverrideResult,
+    OverrideType,
+    RejectResult,
+    ScalingProposal,
+)
+
+
+def type_aware_merge(
+    plugin_results: Sequence[PluginResult],
+    baseline: Mapping[ComponentKey, int],
+    set_allowed: bool = True,
+) -> MergeOutcome:
+    """Merge per-plugin OverrideResults into a single ScalingProposal.
+
+    Args:
+        plugin_results: Per-plugin stage outputs. ``AcceptResult`` entries
+            are silently ignored; ``RejectResult`` short-circuits;
+            ``OverrideResult`` entries are merged. ``priority``
+            disambiguates conflicting SETs (smallest wins) and picks the
+            final winner when multiple OverrideResults carry ``final=True``.
+        baseline: Current / upstream replicas per ``ComponentKey``. Used as
+            the recommendation when no plugin emits a SET for the key;
+            keys present only in ``baseline`` still appear in the output
+            (passthrough) so downstream stages see a complete proposal.
+        set_allowed: ``True`` (PROPOSE / RECONCILE default) keeps SET
+            targets. ``False`` (CONSTRAIN) drops them and records dropped
+            keys in ``MergeOutcome.set_dropped``.
+
+    Returns:
+        ``MergeOutcome`` — either ``short_circuited=True`` with
+        ``proposal=None`` on REJECT, or a populated ``ScalingProposal``.
+    """
+    # Step 1: REJECT short-circuit (REJECT > final)
+    for r in plugin_results:
+        if isinstance(r.result, RejectResult):
+            return MergeOutcome(
+                proposal=None,
+                short_circuited=True,
+                short_circuit_reason=f"{r.plugin_id}: {r.result.reason}",
+            )
+
+    overrides = [r for r in plugin_results if isinstance(r.result, OverrideResult)]
+
+    # Step 2: final priority (priority-smallest final wins, verbatim targets)
+    finals = [r for r in overrides if r.final]
+    if finals:
+        winner = min(finals, key=lambda r: r.priority)
+        assert isinstance(winner.result, OverrideResult)
+        targets = list(winner.result.targets)
+        set_dropped_final: list[ComponentKey] = []
+        if not set_allowed:
+            kept: list[ComponentTarget] = []
+            for t in targets:
+                if t.type == OverrideType.SET:
+                    set_dropped_final.append(
+                        ComponentKey(sub_component_type=t.sub_component_type)
+                    )
+                else:
+                    kept.append(t)
+            targets = kept
+        # Baseline passthrough: keys present only in ``baseline`` that the
+        # winning final plugin did not mention still appear in the output,
+        # matching the bucket-merge path and the documented contract
+        # ("downstream stages see a complete proposal"). Without this, a
+        # final plugin emitting only ``SET prefill=N`` would drop ``decode``
+        # from the proposal a RECONCILE plugin reads via ``ctx.proposal``.
+        mentioned = {t.sub_component_type for t in targets}
+        for key in baseline:
+            if key.sub_component_type not in mentioned:
+                targets.append(
+                    ComponentTarget(
+                        sub_component_type=key.sub_component_type,
+                        replicas=baseline[key],
+                    )
+                )
+        return MergeOutcome(
+            proposal=ScalingProposal(targets=targets, source=winner.plugin_id),
+            short_circuited=False,
+            used_final_from=winner.plugin_id,
+            set_dropped=set_dropped_final,
+        )
+
+    # Steps 3-4: bucket by ComponentKey, merge per type, clamp.
+    set_dropped: list[ComponentKey] = []
+    by_key: dict[ComponentKey, list[tuple[ComponentTarget, int]]] = {}
+    for r in overrides:
+        assert isinstance(r.result, OverrideResult)
+        for t in r.result.targets:
+            if t.replicas is None:  # v9 line 1078: unset = no opinion
+                continue
+            key = ComponentKey(sub_component_type=t.sub_component_type)
+            if t.type == OverrideType.SET and not set_allowed:
+                set_dropped.append(key)
+                continue
+            by_key.setdefault(key, []).append((t, r.priority))
+
+    # Deterministic output order: plugin-touched keys first (insertion),
+    # then any baseline-only keys.
+    ordered_keys: list[ComponentKey] = list(by_key.keys())
+    for k in baseline:
+        if k not in by_key:
+            ordered_keys.append(k)
+
+    final_targets: list[ComponentTarget] = []
+    clamped: list[tuple[ComponentKey, str, str]] = []
+    for key in ordered_keys:
+        entries = by_key.get(key, [])
+        at_least_entries: list[tuple[int, str]] = [
+            (t.replicas, _target_source(t, plugin_results, prio))
+            for t, prio in entries
+            if t.type == OverrideType.AT_LEAST and t.replicas is not None
+        ]
+        at_most_entries: list[tuple[int, str]] = [
+            (t.replicas, _target_source(t, plugin_results, prio))
+            for t, prio in entries
+            if t.type == OverrideType.AT_MOST and t.replicas is not None
+        ]
+        set_vals: list[tuple[int, int]] = [
+            (t.replicas, prio)
+            for t, prio in entries
+            if t.type == OverrideType.SET and t.replicas is not None
+        ]
+        at_least_vals = [v for v, _ in at_least_entries]
+        at_most_vals = [v for v, _ in at_most_entries]
+        floor: float = max(at_least_vals) if at_least_vals else 0
+        ceiling: float = min(at_most_vals) if at_most_vals else math.inf
+        if set_vals:
+            recommendation: float = min(set_vals, key=lambda x: x[1])[0]
+        else:
+            recommendation = baseline.get(key, 0)
+        # Clamp order: floor wins when floor > ceiling.
+        result_replicas = max(floor, min(ceiling, recommendation))
+
+        # Record per-key clamps so the orchestrator emits the right
+        # RECONCILE/CONSTRAIN clamp counter.  Only report clamps that
+        # actually changed the value — if recommendation was already
+        # within [floor, ceiling] this key was un-clamped and the
+        # bounds just confirmed it.
+        if at_most_vals and result_replicas < recommendation:
+            winning_at_most = min(at_most_entries, key=lambda x: x[0])
+            clamped.append((key, "ceiling", winning_at_most[1]))
+        if at_least_vals and result_replicas > recommendation:
+            winning_at_least = max(at_least_entries, key=lambda x: x[0])
+            clamped.append((key, "floor", winning_at_least[1]))
+
+        final_targets.append(
+            ComponentTarget(
+                sub_component_type=key.sub_component_type,
+                replicas=int(result_replicas),
+            )
+        )
+
+    return MergeOutcome(
+        proposal=ScalingProposal(targets=final_targets, source="merged"),
+        short_circuited=False,
+        set_dropped=set_dropped,
+        clamped=clamped,
+    )
+
+
+def _target_source(
+    target: ComponentTarget,
+    plugin_results: Sequence[PluginResult],
+    priority: int,
+) -> str:
+    """Find which plugin emitted this specific ``ComponentTarget``.
+
+    Used to populate the ``source`` label on clamp counters so a
+    dashboard can show *which* plugin (budget-constrain, user's
+    custom, etc) kept dragging a component off the recommendation.
+
+    Match by object identity first (the PluginResult holds the same
+    ComponentTarget instance we're looking at); fall back to priority
+    + (type, replicas) equality for the rare case where the merge
+    reconstructs targets."""
+    for pr in plugin_results:
+        if not isinstance(pr, PluginResult):
+            continue
+        if pr.priority != priority:
+            continue
+        if not isinstance(pr.result, OverrideResult):
+            continue
+        for t in pr.result.targets:
+            if t is target:
+                return pr.plugin_id
+            if (
+                t.sub_component_type == target.sub_component_type
+                and t.type == target.type
+                and t.replicas == target.replicas
+            ):
+                return pr.plugin_id
+    return "unknown"
+
+
+__all__ = ["type_aware_merge"]
diff --git a/components/src/dynamo/planner/plugins/merge/types.py b/components/src/dynamo/planner/plugins/merge/types.py
new file mode 100644
index 000000000000..2d04ba0683af
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/merge/types.py
@@ -0,0 +1,193 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Internal data types for the merge algorithms.
+
+Three concerns live here:
+
+- ``PluginResult``: a single plugin's stage output, paired with its
+  registered priority and ``final`` flag. Consumed by ``type_aware_merge``.
+- ``ComponentKey`` / ``MergeOutcome`` / ``ChainAugmentOutcome``: structured
+  return values for the two merge algorithms. The orchestrator reads
+  ``short_circuited`` / ``used_final_from`` / ``set_dropped`` /
+  ``chain_break_warnings`` to emit audit events and Prometheus metrics.
+- ``PredictPluginCallable``: structural protocol for objects the
+  orchestrator hands to ``chain_augment`` — a transport-backed plugin
+  handle exposing ``plugin_id``, ``priority``, and an async
+  ``call("Predict", context)``.
+
+These are **pure data containers** — no behaviour, no I/O. Algorithms
+live alongside in ``type_aware.py`` and ``chain_augment.py``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Optional, Protocol, Union, runtime_checkable
+
+from dynamo.planner.plugins.types import (
+    AcceptResult,
+    OverrideResult,
+    PipelineContext,
+    PredictionData,
+    PredictStageResponse,
+    RejectResult,
+    ScalingProposal,
+)
+
+# ----------------------------------------------------------------------------
+# Input to type_aware_merge
+# ----------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class PluginResult:
+    """A single plugin's output for one stage, paired with its priority.
+
+    Orchestrator constructs a list of these after awaiting all plugins in
+    a PROPOSE / RECONCILE / CONSTRAIN stage, then hands the list to
+    ``type_aware_merge``. ``final`` mirrors the on-wire flag from the
+    stage response (``ProposeStageResponse.final`` /
+    ``ReconcileStageResponse.final``; silently ignored for CONSTRAIN).
+    """
+
+    plugin_id: str
+    priority: int
+    result: Union[AcceptResult, OverrideResult, RejectResult]
+    final: bool = False
+
+
+# ----------------------------------------------------------------------------
+# Bucket key for type-aware merge
+# ----------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class ComponentKey:
+    """Group key used to bucket per-plugin ``ComponentTarget`` entries in
+    ``type_aware_merge``.
+
+    Single-pool by construction in this PR: one bucket per
+    ``sub_component_type``.  Kept as a dataclass (rather than collapsing
+    to a bare ``str``) so the hierarchical-planner PR can re-add the
+    per-pool key axis without touching every call site.  ``frozen=True``
+    makes instances hashable for use as ``dict`` / ``set`` keys.
+    """
+
+    sub_component_type: str
+
+
+# ----------------------------------------------------------------------------
+# Outputs
+# ----------------------------------------------------------------------------
+
+
+@dataclass
+class MergeOutcome:
+    """Structured result of ``type_aware_merge``.
+
+    Consumed by the orchestrator (acted on):
+
+    - ``short_circuited=True`` → caller skips downstream stages + EXECUTE
+    - ``clamped`` non-empty → emit clamp counters
+      (``reconcile_clamped_total`` on RECONCILE,
+      ``constrain_capped_total`` on CONSTRAIN). The tuple records the
+      per-key reason (``"floor"`` when AT_LEAST raised the value,
+      ``"ceiling"`` when AT_MOST lowered it) and the plugin_id that
+      contributed the winning bound.
+
+    Surfaced on ``PipelineOutcome.constrain_outcome`` for downstream
+    inspection but NOT emitted as Prometheus / audit signals in PR #1:
+
+    - ``used_final_from`` (which plugin's ``final=True`` won the stage)
+    - ``set_dropped`` (component keys whose SET entries were rejected
+      by ``set_allowed=False``)
+
+    Counters / audit emit for these two are deferred to a follow-up
+    observability PR.
+
+    Mutable on purpose: fields are populated step-by-step in ``type_aware_merge``
+    and ``set_dropped`` / ``clamped`` are appended to as buckets are processed.
+    """
+
+    proposal: Optional[ScalingProposal]
+    short_circuited: bool
+    short_circuit_reason: str = ""
+    used_final_from: str = ""
+    set_dropped: list[ComponentKey] = field(default_factory=list)
+    clamped: list[tuple[ComponentKey, str, str]] = field(default_factory=list)
+    """(key, direction, source_plugin_id) — direction ∈ {"floor", "ceiling"}."""
+
+
+@dataclass
+class ChainAugmentOutcome:
+    """Structured result of ``chain_augment`` (PREDICT stage).
+
+    - ``prediction``: partial-merged ``PredictionData`` produced by the
+      chain, or ``None`` when every plugin returned ``AcceptResult`` /
+      ``RejectResult`` (no prediction content).
+    - ``final_from``: plugin_id of the plugin whose ``final=True`` broke
+      the chain (empty if the chain ran to completion).
+    - ``degraded``: plugin_ids that returned ``RejectResult`` (the chain
+      continues past a REJECT in PREDICT; contrast with type-aware merge
+      where REJECT short-circuits).
+    - ``chain_break_warnings``: informational events — one message per
+      plugin that returned ``final=True`` while **not** being the
+      lowest-priority (numerically smallest) plugin in the chain. The
+      chain still breaks at that plugin, so larger-priority-number
+      plugins after the final-setter are skipped (they lose the chance
+      to populate fields earlier plugins left as ``None``). This may
+      be intentional — e.g. a policy plugin saying "skip the expensive
+      fallback for this scenario" — or a configuration mistake;
+      ``chain_augment`` cannot tell which. The orchestrator surfaces
+      these messages via ``PipelineOutcome.audit_events`` so operators
+      can audit them; a Prometheus counter for this signal is deferred
+      to a follow-up observability PR.
+    """
+
+    prediction: Optional[PredictionData]
+    final_from: str = ""
+    degraded: list[str] = field(default_factory=list)
+    chain_break_warnings: list[str] = field(default_factory=list)
+
+
+# ----------------------------------------------------------------------------
+# Structural protocol for chain_augment's plugin_chain input
+# ----------------------------------------------------------------------------
+
+
+@runtime_checkable
+class PredictPluginCallable(Protocol):
+    """Structural type: what ``chain_augment`` expects per plugin handle.
+
+    The orchestrator wraps each registered PREDICT plugin in an object
+    that satisfies this protocol — exposing the registry-visible
+    ``plugin_id`` / ``priority`` attributes alongside a transport-backed
+    ``call`` coroutine. Using a ``Protocol`` here keeps ``merge`` decoupled
+    from the concrete registry / transport types.
+
+    ``plugin_id`` and ``priority`` are read-only (declared as ``@property``)
+    so adapter implementations like ``_PredictAdapter`` that forward
+    these from a wrapped ``RegisteredPlugin`` via ``@property`` satisfy
+    the structural check.
+    """
+
+    @property
+    def plugin_id(self) -> str:
+        """Stable plugin identifier as registered with the registry."""
+
+    @property
+    def priority(self) -> int:
+        """Chain-augment ordering: lower priority runs first."""
+
+    async def call(self, method: str, context: PipelineContext) -> PredictStageResponse:
+        """Dispatch a PREDICT call; transport layer handles serialisation."""
+
+
+__all__ = [
+    "PluginResult",
+    "ComponentKey",
+    "MergeOutcome",
+    "ChainAugmentOutcome",
+    "PredictPluginCallable",
+]
diff --git a/components/src/dynamo/planner/plugins/orchestrator/__init__.py b/components/src/dynamo/planner/plugins/orchestrator/__init__.py
new file mode 100644
index 000000000000..27dc47ee0f78
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/orchestrator/__init__.py
@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""LocalPlannerOrchestrator.
+
+This module composes the underlying pieces (proto/types, transport/clock,
+registry/scheduler/circuit breaker, merge algorithms) into a single
+orchestrator that drives the 4-stage plugin pipeline (PREDICT / PROPOSE
+/ RECONCILE / CONSTRAIN) per tick and emits an EXECUTE decision.
+"""
+
+from dynamo.planner.plugins.orchestrator.orchestrator import LocalPlannerOrchestrator
+from dynamo.planner.plugins.orchestrator.pipeline import PipelineOutcome, run_pipeline
+
+__all__ = [
+    "LocalPlannerOrchestrator",
+    "PipelineOutcome",
+    "run_pipeline",
+]
diff --git a/components/src/dynamo/planner/plugins/orchestrator/engine_adapter.py b/components/src/dynamo/planner/plugins/orchestrator/engine_adapter.py
new file mode 100644
index 000000000000..e65dfb357a59
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/orchestrator/engine_adapter.py
@@ -0,0 +1,952 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""``OrchestratorEngineAdapter`` — production ``EngineProtocol`` adapter
+for the plugin chain.
+
+Wraps ``LocalPlannerOrchestrator`` behind the same ``initial_tick`` /
+``tick`` / ``shutdown`` interface that the legacy ``_PSMEngineAdapter``
+exposes. ``NativePlannerBase`` selects between the two via
+``PlannerConfig.scheduling.use_orchestrator``.
+
+Architecture invariant: PipelineContext is the only input channel
+--------------------------------------------------------------------
+All plugins — both in-process builtins (follow-up PR) and external
+gRPC plugins — receive their per-tick inputs through
+``PipelineContext.observations`` exclusively. There is **no**
+``prime_tick(...)`` side-channel, ``self._last_fpm``-style stash,
+or any other path that delivers observation data to a plugin instance
+outside of the stage RPC.
+
+This invariant ensures:
+  * Plugin API is uniform across in-process and over-wire transports.
+  * Adding a new observation field requires touching one schema
+    (``ObservationData``), not two delivery paths.
+  * Builtin plugins (follow-up PR) and external plugins receive
+    byte-identical input, so dual-path parity tests are meaningful.
+
+Internal responsibilities
+-------------------------
+
+1. **Tick lifecycle cadence tracking**:
+   Owns ``_next_load_s`` / ``_next_throughput_s`` state and advances
+   them at tick boundaries the same way
+   ``PlannerStateMachine._next_scheduled_tick`` does, so the
+   ``next_tick`` field in ``PlannerEffects`` matches PSM's legacy
+   path bit-for-bit.
+2. **TickInput → PipelineContext bridge**:
+   Extracts ``traffic`` into ``TrafficMetrics``, ``worker_counts``
+   (counts + scaling-in-progress flags) into ``WorkerState``, and
+   per-engine FPM observations into ``FpmData`` (msgspec/msgpack-
+   encoded, keyed by ``"<worker_id>/<dp_rank>"``) on ``ObservationData``.
+   External plugins declaring ``needs=["observations.fpm"]`` receive
+   the FPM map; an empty/absent submap means "no FPM this tick".
+3. **FPM regression observation**:
+   Before the orchestrator tick, feeds FPM into the orchestrator-owned
+   regression models (mirrors PSM's ``_observe_fpm``). This is a
+   planner-internal regression-fit path, distinct from delivering FPM
+   to plugins.
+4. **PipelineOutcome → PlannerEffects projection**:
+   Reads the orchestrator's ``final_proposal.targets``, detects "no
+   change" against ``worker_counts``, and projects to
+   ``PlannerEffects.scale_to``. ``diagnostics`` is empty — numeric
+   fields moved to Prometheus.
+
+Bootstrap API
+-------------
+
+``install_regressions`` + ``bootstrap_plugins`` mirror
+``LocalPlannerOrchestrator``'s equivalents but are exposed on the
+adapter so callers (mode subclasses) have a single entry point.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Optional, Sequence
+
+from dynamo.common.forward_pass_metrics import encode as _encode_fpm_record
+
+if TYPE_CHECKING:
+    import grpc.aio
+
+from dynamo.planner.core.types import (
+    FpmObservations,
+    PlannerEffects,
+    ScalingDecision,
+    ScheduledTick,
+    TickDiagnostics,
+    TickInput,
+    TrafficObservation,
+    WorkerCapabilities,
+    WorkerCounts,
+)
+from dynamo.planner.plugins.clock import Clock, VirtualClock, WallClock
+from dynamo.planner.plugins.merge.types import ComponentKey
+from dynamo.planner.plugins.orchestrator.orchestrator import LocalPlannerOrchestrator
+from dynamo.planner.plugins.registry.auth import AllowUnauthenticatedAuth
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+from dynamo.planner.plugins.registry.config import build_auth_validator
+from dynamo.planner.plugins.registry.server import PluginRegistryServer
+from dynamo.planner.plugins.scheduler import PluginScheduler
+from dynamo.planner.plugins.transport.config import make_transport_for_endpoint
+from dynamo.planner.plugins.types import (
+    FpmData,
+    ObservationData,
+    PipelineContext,
+    TrafficMetrics,
+    WorkerState,
+)
+
+log = logging.getLogger(__name__)
+
+
+class OrchestratorEngineAdapter:
+    """``EngineProtocol``-compatible wrapper around the 5-builtin chain.
+
+    Lifecycle:
+
+    1. ``OrchestratorEngineAdapter(config, capabilities)`` — builds
+       orchestrator + 5 plugins + registers them. No regression models
+       installed yet.
+    2. ``install_regressions(prefill=, decode=, agg=)`` — fill the
+       orchestrator's shared regression store.
+    3. ``await bootstrap_plugins(historical_traffic=)`` — warm predictor
+       + fire plugin Bootstrap RPCs.
+    4. ``initial_tick(start_s)`` — get the first scheduled tick.
+    5. ``await tick(scheduled_tick, tick_input)`` — repeatedly.
+    6. ``await shutdown()`` — release plugin transports.
+    """
+
+    def __init__(
+        self,
+        config,  # PlannerConfig
+        capabilities: WorkerCapabilities,
+        *,
+        clock: Optional[Clock] = None,
+    ) -> None:
+        self._config = config
+        self._capabilities = capabilities
+        # Clock is shared with all sub-components (CircuitBreaker,
+        # PluginRegistryServer, PluginScheduler, LocalPlannerOrchestrator).
+        # Default ``WallClock`` is correct for production / K8s smoke
+        # where ``tick_input.now_s`` already tracks wall-clock.
+        # Replay paths pass a ``VirtualClock`` and call
+        # ``advance_clock_to(tick_input.now_s)`` on each tick so plugin
+        # scheduler ``is_due`` checks see trace time, not real time.
+        # Without this hook a fast-forward replay (1hr trace in 10s real
+        # time) would leave plugins with execution_interval >> 10s
+        # never re-firing after the first tick.
+        self._clock: Clock = clock if clock is not None else WallClock()
+
+        # Scale_interval cadence model — pipeline fires once per
+        # ``scale_interval_seconds`` regardless of individual plugin
+        # cadences.  Per-plugin throttling (via
+        # ``RegisteredPlugin.execution_interval_seconds``) handles
+        # which plugins actually fire each tick.  See design doc §4 and
+        # ``test_decision_level_parity`` for how this matches PSM's
+        # observable scaling decisions while collapsing the legacy
+        # dual-cadence book-keeping into one base interval.
+        self._scale_interval: float = float(config.scheduling.scale_interval_seconds)
+        # ``_last_tick_s`` is wall-epoch (matches ``tick_input.now_s`` /
+        # PSM ``ScheduledTick.at_s``).  ``_last_tick_monotonic`` is the
+        # clock-domain twin used by the lazy-traffic-pull due-check
+        # against ``RegisteredPlugin.last_call_at`` — which the
+        # ``PluginScheduler.record_evaluation`` path stores in
+        # ``self._clock.monotonic()`` domain.  Without the parallel
+        # field, ``_is_due(p, _last_tick_s + scale_interval)`` would
+        # compare wall-epoch against monotonic; in production
+        # ``WallClock`` deployments that's ~1.7e9 vs ~1e3 — every
+        # plugin reads as "due" and lazy-pull silently degenerates to
+        # always-pull.  Replay path is unaffected because
+        # ``VirtualClock.monotonic()`` is synchronised to
+        # ``tick_input.now_s`` at the top of ``tick()``.
+        self._last_tick_s: float = 0.0
+        self._last_tick_monotonic: float = 0.0
+
+        # Legacy cadence fields preserved as a compatibility shim for
+        # any existing test that still reads them.  Not consulted by the
+        # scale_interval scheduling logic — pipeline tick selection runs
+        # entirely off ``self._last_tick_s + self._scale_interval``.
+        # Removed entirely once the PSM-parity test surface is rewritten
+        # to its decision-level form (see same design doc §11).
+        self._next_load_s: float = float("inf")
+        self._next_throughput_s: float = float("inf")
+
+        # Plugin-framework metrics live alongside the adapter so they
+        # share the orchestrator's lifecycle.  Use the default global
+        # ``prometheus_client.REGISTRY`` so planner's existing
+        # ``start_http_server`` on ``metric_reporting_prometheus_port``
+        # picks them up automatically.  Construction is lazy-guarded: if
+        # an adapter is built a second time in the same Python process
+        # (replay, tests), the first construction claims the metric
+        # names on REGISTRY and the second would raise "Duplicated
+        # timeseries" — we tolerate that by falling back to ``None`` so
+        # emission becomes a no-op instead of crashing.
+        from dynamo.planner.monitoring.planner_metrics import PluginFrameworkMetrics
+
+        self._plugin_framework_metrics: Optional[PluginFrameworkMetrics]
+        try:
+            self._plugin_framework_metrics = PluginFrameworkMetrics()
+        except ValueError:
+            # Duplicate registration (only happens in tests / repeated
+            # init in one process) — metrics emission disabled, but
+            # the adapter still runs normally.
+            self._plugin_framework_metrics = None
+
+        # Build orchestrator + scheduler + circuit_breaker + registry.
+        # All transport-shaped knobs (timeouts + wire security) live under
+        # ``plugin_registration.transport``; we hand that subtree to the
+        # transport factory verbatim. ``scheduling`` keeps only tick-level
+        # knobs (``tick_max_duration_seconds`` etc).
+        cb = CircuitBreaker(self._clock)
+        transport_config = config.plugin_registration.transport
+
+        def _factory(plugin_id, endpoint, *, in_process_instance=None):
+            return make_transport_for_endpoint(
+                plugin_id,
+                endpoint,
+                transport_config,
+                in_process_instance=in_process_instance,
+            )
+
+        # Build the auth validator from config when ``trusted_sources`` is
+        # set; otherwise fall back to ``AllowUnauthenticatedAuth`` so legacy
+        # deployments that never configured plugin_registration still come
+        # up (with the dev-mode WARN). Production manifests should populate
+        # ``plugin_registration.auth.trusted_sources`` to opt in.
+        auth_cfg = config.plugin_registration.auth
+        if auth_cfg.trusted_sources:
+            auth = build_auth_validator(auth_cfg)
+        else:
+            auth = AllowUnauthenticatedAuth()
+        server = PluginRegistryServer(
+            clock=self._clock,
+            auth=auth,
+            circuit_breaker=cb,
+            transport_factory=_factory,
+            # Honour the user-configured protocol-version range on the
+            # orchestrator path.  Without this, ``planner.plugin_registration
+            # .protocol_version_min/max`` was ineffective for plugins
+            # registering through the gateway under the orchestrator path
+            # (server defaulted to ``("1.0", "1.0")``).  Mirrors the
+            # ``protocol_versions=...`` argument that
+            # ``build_registry_from_config`` already passes on the
+            # static-config path.
+            protocol_versions=(
+                config.plugin_registration.protocol_version_min,
+                config.plugin_registration.protocol_version_max,
+            ),
+            # Phase-align ``registered_at`` to scale_interval boundary so
+            # plugins with identical execution intervals fire on the same
+            # pipeline tick irrespective of registration-time skew (see
+            # design doc §4.3).  ``SchedulingConfig.scale_interval_seconds``
+            # defaults to 5.0 — passes through unchanged on configs that
+            # don't override it.
+            scale_interval_seconds=config.scheduling.scale_interval_seconds,
+        )
+        scheduler = PluginScheduler(
+            server, cb, self._clock, metrics=self._plugin_framework_metrics
+        )
+        self._orchestrator = LocalPlannerOrchestrator(
+            registry=server,
+            scheduler=scheduler,
+            circuit_breaker=cb,
+            clock=self._clock,
+            tick_max_duration_seconds=config.scheduling.tick_max_duration_seconds,
+            capabilities=capabilities,
+            metrics=self._plugin_framework_metrics,
+        )
+
+        # Registration gateway lifecycle: populated lazily by
+        # ``_maybe_start_gateway`` if config opts in; consumed by
+        # ``shutdown``.  Default ``None`` keeps the typical (gateway
+        # disabled) deployment path zero-cost.
+        self._gateway_server: Optional[grpc.aio.Server] = None
+
+        # Builtin plugins land in a follow-up PR. PR #1 ships only the
+        # infrastructure (orchestrator + pipeline + transport + registry
+        # + external-plugin wiring via both static config and the gRPC
+        # registration gateway); the orchestrator path will produce
+        # empty proposals on every tick until the follow-up adds builtin
+        # load/throughput/reconcile/budget plugins, OR external plugins
+        # fill the chain via either registration path.
+        self._builtins: dict = {}
+
+    # ------------------------------------------------------------------
+    # Bootstrap API (delegates to orchestrator)
+    # ------------------------------------------------------------------
+
+    def install_regressions(
+        self,
+        *,
+        prefill: Optional[Any] = None,
+        decode: Optional[Any] = None,
+        agg: Optional[Any] = None,
+    ) -> None:
+        self._orchestrator.install_regressions(prefill=prefill, decode=decode, agg=agg)
+
+    async def bootstrap_plugins(
+        self, *, historical_traffic: Optional[Sequence[TrafficObservation]] = None
+    ) -> None:
+        # Order matters: register static external plugins from config
+        # **before** dispatching Bootstrap so they receive the same
+        # ``warm_from_observations`` / ``Bootstrap`` RPC fan-out as the
+        # builtin in-process plugins.  The previous order
+        # (bootstrap → register externals) silently denied static
+        # external plugins access to ``historical_traffic`` — they
+        # registered into an already-bootstrapped registry and never
+        # saw the Bootstrap pass.
+        #
+        # Gateway opens last so a plugin trying to register via the
+        # network can't race the bootstrap fan-out (the gateway's
+        # plugins are intentionally a runtime-only path; they
+        # cannot receive ``historical_traffic`` because Bootstrap has
+        # already moved past them — that's a deliberate scope split
+        # and is the documented contract for dynamic registration).
+        await self._wire_external_plugins_from_config()
+        await self._orchestrator.bootstrap_plugins(
+            historical_traffic=historical_traffic
+        )
+        await self._maybe_start_gateway()
+
+    async def _wire_external_plugins_from_config(self) -> None:
+        """Register the static-config external plugin list.
+
+        Idempotent at the orchestrator level (registry rejects
+        duplicates), but the adapter only ever calls this once per
+        bootstrap. Per-entry failures are logged but don't raise — a
+        bad ConfigMap entry must NOT prevent the planner from running.
+        """
+        entries = list(self._config.scheduling.external_plugins)
+        if not entries:
+            return
+        accepted, failures = await self._orchestrator.register_external_from_config(
+            entries
+        )
+        if failures:
+            log.warning(
+                "external plugin bootstrap: accepted=%d failed=%d failures=%s",
+                accepted,
+                len(failures),
+                failures,
+            )
+        else:
+            log.info(
+                "external plugin bootstrap: accepted=%d (all entries OK)",
+                accepted,
+            )
+
+    async def _maybe_start_gateway(self) -> None:
+        """Stand up the gRPC registration gateway if configured.
+
+        Stores the running ``grpc.aio.Server`` on ``self._gateway_server``
+        so ``shutdown()`` can stop it cleanly. Failure to start the
+        gateway IS fatal — it usually means a port collision or bad
+        bind address, which the operator needs to know immediately
+        rather than discovering later when plugins fail to register.
+        """
+        gw_cfg = self._config.scheduling.gateway
+        if not gw_cfg.enabled:
+            return
+        # Local import keeps the gateway module out of the cold-start
+        # import chain for deployments that never enable it.
+        from dynamo.planner.plugins.registry.gateway import start_gateway_server
+
+        grpc_server, actual_listen = await start_gateway_server(
+            self._orchestrator.registry,
+            listen=gw_cfg.listen,
+            allow_insecure=gw_cfg.allow_insecure,
+        )
+        self._gateway_server = grpc_server
+        log.info("plugin registration gateway listening at %s", actual_listen)
+
+    async def bootstrap_from_fpms(
+        self,
+        *,
+        prefill_fpms: Optional[Sequence[Any]] = None,
+        decode_fpms: Optional[Sequence[Any]] = None,
+        agg_fpms: Optional[Sequence[Any]] = None,
+        historical_traffic: Optional[Sequence[TrafficObservation]] = None,
+    ) -> None:
+        """One-shot pre-first-tick bootstrap from benchmark FPMs.
+
+        Mirrors PSM's ``load_benchmark_fpms`` + ``warm_load_predictors``
+        but through the plugin chain:
+
+        1. ``install_regressions_from_fpms`` — in SLA mode, build the
+           regression models from benchmark FPMs and install them on the
+           orchestrator's shared store (easy mode skips — no regressions).
+        2. ``bootstrap_plugins`` — warm ``BuiltinLoadPredictor`` from
+           ``historical_traffic`` and fan out Bootstrap RPC.
+
+        Replay uses these two steps separately (regressions are installed
+        once benchmark FPMs are generated; plugins are bootstrapped at
+        adapter construction), so the regression-install half lives in its
+        own synchronous method.
+        """
+        self.install_regressions_from_fpms(
+            prefill_fpms=prefill_fpms, decode_fpms=decode_fpms, agg_fpms=agg_fpms
+        )
+        await self.bootstrap_plugins(historical_traffic=historical_traffic)
+
+    def install_regressions_from_fpms(
+        self,
+        *,
+        prefill_fpms: Optional[Sequence[Any]] = None,
+        decode_fpms: Optional[Sequence[Any]] = None,
+        agg_fpms: Optional[Sequence[Any]] = None,
+    ) -> None:
+        """Build regression models from benchmark FPMs and install them on
+        the orchestrator's shared store. Synchronous; does NOT bootstrap
+        plugins. No-op in easy mode (no regression models are used).
+
+        Spins up a throwaway ``PlannerStateMachine`` as the regression
+        factory — it builds the model instances from benchmark FPMs the
+        same way PSM does internally (a future cleanup can extract that
+        construction into a standalone helper to drop the throwaway)."""
+        if self._config.optimization_target != "sla":
+            return
+        # Import locally to avoid pulling PSM into module-level imports
+        # (the adapter's own tick path shouldn't know about PSM).
+        from dynamo.planner.core.state_machine import PlannerStateMachine
+
+        throwaway = PlannerStateMachine(self._config, self._capabilities)
+        throwaway.load_benchmark_fpms(
+            prefill_fpms=list(prefill_fpms) if prefill_fpms else None,
+            decode_fpms=list(decode_fpms) if decode_fpms else None,
+            agg_fpms=list(agg_fpms) if agg_fpms else None,
+        )
+        self.install_regressions(
+            prefill=getattr(throwaway, "_prefill_regression", None),
+            decode=getattr(throwaway, "_decode_regression", None),
+            agg=getattr(throwaway, "_agg_regression", None),
+        )
+
+    # ------------------------------------------------------------------
+    # EngineProtocol
+    # ------------------------------------------------------------------
+
+    def initial_tick(self, start_s: float) -> ScheduledTick:
+        """First scheduled tick under the scale_interval cadence model.
+
+        Pipeline fires at ``start_s + scale_interval`` regardless of
+        the legacy load / throughput interval configuration — those
+        intervals now live on individual plugin
+        ``execution_interval_seconds`` values rather than on the
+        pipeline cadence.
+
+        Legacy ``_next_load_s`` / ``_next_throughput_s`` still set for
+        any compatibility code still reading them (those reads are
+        scheduled for removal once decision-level parity is in place).
+        """
+        self._last_tick_s = start_s
+        self._last_tick_monotonic = self._clock.monotonic()
+        self._next_load_s = start_s + self._config.load_adjustment_interval_seconds
+        if self._config.enable_throughput_scaling:
+            self._next_throughput_s = (
+                start_s + self._config.throughput_adjustment_interval_seconds
+            )
+        return self._compute_next_scheduled_tick()
+
+    async def tick(
+        self,
+        scheduled_tick: ScheduledTick,
+        tick_input: TickInput,
+    ) -> PlannerEffects:
+        # NOTE: we intentionally do NOT gate plugins via ``plugin.enabled``
+        # on top of ``ScheduledTick.run_*_scaling`` flags. Each plugin's
+        # own config-toggle check (``if not self._config.enable_load_scaling:
+        # return accept``) is already a per-tick no-op when the corresponding
+        # toggle is off; adding a secondary gate would only introduce
+        # divergence risk. Decision-level parity with PSM (same ``scale_to``
+        # sequence at the same wall-clock moments) is preserved by keeping
+        # those config toggles authoritative for plugin self-gating.
+
+        # 0. Sync the shared clock to ``tick_input.now_s`` when we hold a
+        #    manually-advanced clock (replay / test). Plugin scheduler
+        #    ``is_due``, CircuitBreaker cooldown, and HOLD_LAST cache age
+        #    all read ``self._clock.monotonic()`` — without this bump the
+        #    plugin layer would see real wall-clock instead of replay
+        #    trace time, and any plugin with ``execution_interval`` >>
+        #    fast-forward duration would never re-fire after the first
+        #    tick.  ``WallClock`` ignores this path (no-op) — production
+        #    K8s already runs in real time.
+        if isinstance(self._clock, VirtualClock):
+            delta = tick_input.now_s - self._clock.monotonic()
+            if delta > 0:
+                self._clock.advance(delta)
+
+        # 1. Observe FPM into regressions (mirror PSM ``_observe_fpm``
+        #    before ``_advance_load``).
+        is_easy = self._config.optimization_target != "sla"
+        if (
+            scheduled_tick.run_load_scaling
+            and not is_easy
+            and tick_input.fpm_observations is not None
+        ):
+            self._observe_fpm(tick_input.fpm_observations)
+
+        # 2. Advance the scale_interval cadence pointer.  Under the new
+        #    model there is one base interval; pipeline tick fires every
+        #    ``scale_interval`` seconds and individual plugin cadences
+        #    are handled inside the orchestrator by per-plugin
+        #    ``execution_interval_seconds`` throttling.  The legacy
+        #    ``_next_load_s`` / ``_next_throughput_s`` are kept current
+        #    only for shim compatibility — they no longer drive next-
+        #    tick selection.
+        self._last_tick_s = tick_input.now_s
+        # Monotonic twin — see ``__init__`` for why we keep both.  Read
+        # *after* the optional VirtualClock sync above so replay sees
+        # ``last_tick_monotonic == tick_input.now_s`` (parity with PSM
+        # cadence math) and production wall-clock deployments see the
+        # boot-relative value that plugin ``last_call_at`` is recorded in.
+        self._last_tick_monotonic = self._clock.monotonic()
+        self._next_load_s = (
+            tick_input.now_s + self._config.load_adjustment_interval_seconds
+        )
+        if self._config.enable_throughput_scaling:
+            self._next_throughput_s = (
+                tick_input.now_s + self._config.throughput_adjustment_interval_seconds
+            )
+
+        # 3. Build PipelineContext + baseline and drive the orchestrator.
+        ctx = self._tick_input_to_context(tick_input)
+        baseline = self._baseline_from_worker_counts(tick_input.worker_counts)
+        outcome = await self._orchestrator.tick(ctx, baseline)
+
+        # 4. Project PipelineOutcome onto PlannerEffects.
+        scale_to = self._project_scale_to(
+            outcome, tick_input.worker_counts or WorkerCounts()
+        )
+
+        # 5. Populate prediction fields on diagnostics. Consumed by the
+        #    diagnostics recorder for HTML reports + Prometheus
+        #    ``predicted_*`` gauges (mirrors PSM's behaviour).
+        diagnostics = TickDiagnostics()
+        if (
+            outcome.predict_outcome is not None
+            and outcome.predict_outcome.prediction is not None
+        ):
+            p = outcome.predict_outcome.prediction
+            diagnostics.predicted_num_req = p.predicted_num_req
+            diagnostics.predicted_isl = p.predicted_isl
+            diagnostics.predicted_osl = p.predicted_osl
+            diagnostics.predicted_kv_hit_rate = p.predicted_kv_hit_rate
+
+        # Surface pipeline execute_action / short_circuit_reason /
+        # audit_events.  Same data is emitted as Prometheus
+        # ``tick_skip_reasons_total`` etc., but exposing it on
+        # ``TickDiagnostics`` lets in-process consumers (replay
+        # adapter, diagnostics recorder) distinguish ``apply`` from
+        # ``skip_short_circuit`` / ``skip_no_targets`` /
+        # ``skip_tick_timeout`` without scraping metrics.
+        diagnostics.execute_action = outcome.execute_action
+        diagnostics.short_circuit_reason = outcome.short_circuit_reason
+        diagnostics.audit_events = list(outcome.audit_events)
+
+        # Surface builtin_load_propose's per-tick reason + estimates
+        # onto ``TickDiagnostics`` so orchestrator-path logs + Prometheus
+        # enum match the semantic detail PSM path has carried since v0.
+        # Plugin stores last decision on itself; we read
+        # ``_last_load_diagnostics`` and project to the appropriate
+        # legacy field (agg → aggregate ``load_decision_reason``;
+        # disagg/prefill/decode → per-component fields).
+        self._project_load_diagnostics(diagnostics)
+
+        # Same shape for builtin_throughput_propose. Without this
+        # projection, ``throughput_decision_reason`` stays None on the
+        # orchestrator path while PSM path populated it from
+        # ``_diag_throughput_reason`` — making it impossible to tell
+        # accept-with-decision from accept-skipped on dashboards.
+        self._project_throughput_diagnostics(diagnostics)
+
+        return PlannerEffects(
+            scale_to=scale_to,
+            next_tick=self._compute_next_scheduled_tick(),
+            diagnostics=diagnostics,
+        )
+
+    def _project_load_diagnostics(self, diagnostics: TickDiagnostics) -> None:
+        """Read ``BuiltinLoadPropose._last_load_diagnostics`` and write
+        to ``diagnostics.load_decision_reason*`` + ``estimated_*_ms``.
+
+        Mirrors PSM's diagnostic surface:
+        - mode=agg → aggregate ``load_decision_reason``
+        - mode=disagg → per-component ``load_decision_reason_prefill`` /
+          ``_decode`` (and also the aggregate, set to whichever side
+          has a stronger signal; see ``_aggregate_disagg_load_reason``)
+        - mode=prefill/decode → aggregate reason from the single side
+        """
+        propose = self._builtins.get("load_propose")
+        if propose is None:
+            return
+        d = getattr(propose, "_last_load_diagnostics", None)
+        if d is None:
+            return
+
+        mode = self._config.mode
+        if mode == "agg":
+            diagnostics.load_decision_reason = d.get("agg")
+        elif mode == "disagg":
+            diagnostics.load_decision_reason_prefill = d.get("prefill")
+            diagnostics.load_decision_reason_decode = d.get("decode")
+            # Aggregate: prefer scale_up > scale_down > no_change >
+            # <skip reason>. Lets a single dashboard widget show "what
+            # did the load path do" without dropping into the per-
+            # component detail.
+            diagnostics.load_decision_reason = self._aggregate_disagg_load_reason(
+                d.get("prefill"), d.get("decode")
+            )
+        elif mode in ("prefill", "decode"):
+            diagnostics.load_decision_reason = d.get(mode)
+
+        diagnostics.estimated_ttft_ms = d.get("estimated_ttft_ms")
+        diagnostics.estimated_itl_ms = d.get("estimated_itl_ms")
+
+    def _project_throughput_diagnostics(self, diagnostics: TickDiagnostics) -> None:
+        """Read ``BuiltinThroughputPropose._last_throughput_diagnostics``
+        and write to ``diagnostics.throughput_decision_reason*``.
+
+        Symmetric with ``_project_load_diagnostics``: PSM path populates
+        these fields from ``_diag_throughput_reason*``; this helper
+        keeps the orchestrator path's surface byte-equivalent at the
+        observability layer (decision outputs track PSM at the
+        decision level, locked by ``test_engine_adapter.py``).
+
+        Mode mapping:
+        - mode=agg → aggregate ``throughput_decision_reason``
+        - mode=disagg → per-component
+          ``throughput_decision_reason_prefill``/``_decode`` plus the
+          aggregate (precedence via ``_aggregate_disagg_throughput_reason``)
+        - mode=prefill/decode → aggregate from the single side
+        """
+        propose = self._builtins.get("throughput_propose")
+        if propose is None:
+            return
+        d = getattr(propose, "_last_throughput_diagnostics", None)
+        if d is None:
+            return
+
+        mode = self._config.mode
+        if mode == "agg":
+            diagnostics.throughput_decision_reason = d.get("agg")
+        elif mode == "disagg":
+            diagnostics.throughput_decision_reason_prefill = d.get("prefill")
+            diagnostics.throughput_decision_reason_decode = d.get("decode")
+            diagnostics.throughput_decision_reason = (
+                self._aggregate_disagg_throughput_reason(
+                    d.get("prefill"), d.get("decode")
+                )
+            )
+        elif mode in ("prefill", "decode"):
+            diagnostics.throughput_decision_reason = d.get(mode)
+
+    @staticmethod
+    def _aggregate_disagg_load_reason(
+        prefill_reason: Optional[str], decode_reason: Optional[str]
+    ) -> Optional[str]:
+        """Collapse two per-component reasons to a single aggregate
+        string.  Precedence mirrors PSM's convention: "a side scaled"
+        wins over "both stable", "stable with data" wins over "no
+        data"."""
+        priority = [
+            "scale_up",
+            "scale_down_capped_by_throughput",
+            "scale_down",
+            "no_change",
+            "insufficient_data",
+            "worker_count_mismatch",
+            "scaling_in_progress",
+            "no_fpm_data",
+            "disabled",
+        ]
+        pairs = [r for r in (prefill_reason, decode_reason) if r is not None]
+        if not pairs:
+            return None
+        for p in priority:
+            if p in pairs:
+                return p
+        return pairs[0]
+
+    @staticmethod
+    def _aggregate_disagg_throughput_reason(
+        prefill_reason: Optional[str], decode_reason: Optional[str]
+    ) -> Optional[str]:
+        """Collapse two per-component throughput reasons. Vocabulary
+        differs from load reasons (no scale_up/down enums on this
+        side); ranking mirrors PSM convention "stronger action wins":
+        ``scale`` > ``set_lower_bound`` > skip reasons."""
+        priority = [
+            "scale",
+            "set_lower_bound",
+            "model_not_ready",
+            "no_traffic_data",
+            "predict_failed",
+            "disabled",
+        ]
+        pairs = [r for r in (prefill_reason, decode_reason) if r is not None]
+        if not pairs:
+            return None
+        for p in priority:
+            if p in pairs:
+                return p
+        return pairs[0]
+
+    async def shutdown(self) -> None:
+        # Stop the gateway BEFORE unregistering plugins so no new
+        # external Register / Heartbeat call can race the teardown.
+        if self._gateway_server is not None:
+            try:
+                await self._gateway_server.stop(grace=0.5)
+            except Exception as exc:
+                # Don't let a gateway shutdown error mask the real
+                # planner shutdown work that follows.
+                log.warning(
+                    "gateway server stop raised %s: %s — continuing shutdown",
+                    type(exc).__name__,
+                    exc,
+                )
+            self._gateway_server = None
+        await self._orchestrator.shutdown()
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _compute_next_scheduled_tick(self) -> ScheduledTick:
+        """Next pipeline tick under the scale_interval cadence model.
+
+        Pipeline fires at ``self._last_tick_s + scale_interval`` —
+        a single base cadence, no more dual ``_next_load_s`` /
+        ``_next_throughput_s`` merging.  Per-plugin
+        ``execution_interval_seconds`` throttling (in
+        ``PluginScheduler._is_due``) handles which plugins actually
+        fire each tick.
+
+        Observation collection (``need_traffic_metrics``,
+        ``traffic_metrics_duration_s``) is gated on whether any
+        registered plugin both lists ``observations.traffic`` in its
+        ``needs`` AND would be due at the next tick.  This recovers
+        PSM's lazy-pull cost profile (one Prometheus query per
+        ``throughput_adjustment_interval_seconds`` in mixed mode)
+        without leaking the cadence-type concept into the
+        ScheduledTick API — plugins only see the window they
+        themselves declared via ``observation_window_seconds``.
+        """
+        at_s = self._last_tick_s + self._scale_interval
+        # Due-check operates in the monotonic domain that
+        # ``RegisteredPlugin.last_call_at`` lives in — NOT wall-epoch.
+        # ``at_s`` (wall-epoch) is for ``ScheduledTick.at_s`` only.
+        at_monotonic = self._last_tick_monotonic + self._scale_interval
+
+        # Lazy traffic pull: only when some currently-registered,
+        # currently-due plugin actually consumes
+        # ``observations.traffic``.  Without any such plugin the
+        # pipeline still ticks (e.g. for FPM-driven load decisions or
+        # worker-state-only constrain logic), it just skips the
+        # Prometheus query.
+        #
+        # ``needs`` are dot-paths into ``PipelineContext`` per the proto
+        # contract.  Match the parent path ``"observations.traffic"``
+        # AND any sub-path ``"observations.traffic.<field>"`` — both
+        # require the traffic observation to be present, since the
+        # sub-path can only resolve if its parent does.  The trailing
+        # ``.`` in the prefix is load-bearing: it stops false-positives
+        # on a sibling like ``"observations.traffic_legacy"`` (no such
+        # field today but defensive against future schema additions).
+        traffic_consumers_due = [
+            p
+            for p in self._orchestrator._registry.all_plugins()
+            if any(
+                n == "observations.traffic" or n.startswith("observations.traffic.")
+                for n in p.needs
+            )
+            and self._orchestrator._scheduler._is_due(p, at_monotonic)
+        ]
+        if traffic_consumers_due:
+            need_traffic = True
+            # Aggregation window: max declared
+            # ``observation_window_seconds`` across due consumers.
+            # Declared 0.0 means "scale_interval freshness" — i.e. the
+            # plugin doesn't need a longer window, so falls back to
+            # the base cadence here.
+            declared = [
+                p.observation_window_seconds
+                for p in traffic_consumers_due
+                if p.observation_window_seconds > 0
+            ]
+            traffic_duration_s = (
+                max(declared) if declared else float(self._scale_interval)
+            )
+        else:
+            need_traffic = False
+            traffic_duration_s = 0.0
+
+        # ``run_load_scaling`` / ``run_throughput_scaling`` flags are
+        # preserved on ScheduledTick for back-compat with PSM-path
+        # tests and the diagnostics-projection methods below.  Under
+        # scale_interval both are always True — every pipeline tick is
+        # treated as an opportunity for either type of plugin to fire
+        # (subject to its own throttle).
+        return ScheduledTick(
+            at_s=at_s,
+            run_load_scaling=True,
+            run_throughput_scaling=True,
+            need_worker_states=True,
+            need_worker_fpm=True,
+            need_traffic_metrics=need_traffic,
+            traffic_metrics_duration_s=traffic_duration_s,
+        )
+
+    def _observe_fpm(self, obs: FpmObservations) -> None:
+        """Mirror ``PlannerStateMachine._observe_fpm`` — feeds observations
+        into the orchestrator-owned regression models.
+
+        ``obs.prefill`` / ``obs.decode`` are already
+        ``dict[(worker_id, dp_rank) -> ForwardPassMetrics]`` — exactly the
+        shape ``PlannerEnginePerfModel.add_observations`` consumes, so we
+        hand the whole dict over in one call (matching PSM
+        ``state_machine.py`` line-for-line). The regression model only
+        exposes ``add_observations`` (plural, dict-based); there is no
+        singular ``add_observation`` on this class.
+        """
+        mode = self._config.mode
+        if mode == "agg":
+            if obs.decode:
+                agg = self._orchestrator.get_regression("agg")
+                if agg is not None:
+                    agg.add_observations(obs.decode)
+            return
+        if obs.prefill:
+            p_reg = self._orchestrator.get_regression("prefill")
+            if p_reg is not None:
+                p_reg.add_observations(obs.prefill)
+        if obs.decode:
+            d_reg = self._orchestrator.get_regression("decode")
+            if d_reg is not None:
+                d_reg.add_observations(obs.decode)
+
+    def _tick_input_to_context(self, ti: TickInput) -> PipelineContext:
+        traffic = None
+        if ti.traffic is not None:
+            traffic = TrafficMetrics(
+                duration_s=ti.traffic.duration_s,
+                num_req=ti.traffic.num_req,
+                isl=ti.traffic.isl,
+                osl=ti.traffic.osl,
+                kv_hit_rate=ti.traffic.kv_hit_rate,
+            )
+        workers = None
+        if ti.worker_counts is not None:
+            workers = WorkerState(
+                ready_prefill=ti.worker_counts.ready_num_prefill,
+                ready_decode=ti.worker_counts.ready_num_decode,
+                expected_prefill=ti.worker_counts.expected_num_prefill,
+                expected_decode=ti.worker_counts.expected_num_decode,
+                prefill_scaling_in_progress=ti.worker_counts.prefill_scaling_in_progress,
+                decode_scaling_in_progress=ti.worker_counts.decode_scaling_in_progress,
+            )
+        # FPM observations: encode per-engine ``ForwardPassMetrics`` to
+        # msgpack bytes (the wire format the proto README + ``FpmData``
+        # docstring already prescribe), keyed by "<worker_id>/<dp_rank>"
+        # so cross-language plugins can decode without knowing about the
+        # tuple key. Without this, external load-based plugins that
+        # declare ``needs=["observations.fpm"]`` would always see None
+        # and could not implement PSM-equivalent load decisions through
+        # the public PipelineContext API.
+        fpm = self._encode_fpm(ti.fpm_observations)
+        return PipelineContext(
+            request_id=f"tick-{ti.now_s}",
+            decision_id=f"d-{ti.now_s}",
+            observations=ObservationData(traffic=traffic, fpm=fpm, workers=workers),
+        )
+
+    @staticmethod
+    def _encode_fpm(obs: Optional[FpmObservations]) -> Optional[FpmData]:
+        """Encode ``FpmObservations`` for transport over the public
+        ``PipelineContext.observations.fpm`` channel.
+
+        Encoding contract (matches the proto README in
+        ``plugins/proto/v1/README.md``):
+        - per-engine map key = ``f"{worker_id}/{dp_rank}"`` (flat str
+          since proto3 ``map<string, bytes>`` can't carry a tuple key)
+        - per-engine map value = msgpack-encoded ``ForwardPassMetrics``
+          via the canonical ``dynamo.common.forward_pass_metrics.encode``
+          helper (shared module-level encoder) so cross-language plugins
+          decode with any standard msgpack library and the wire format
+          stays in lock-step with the rest of dynamo's FPM serialization.
+
+        Returns None when ``obs`` is None (no FPM this tick) or when
+        both prefill+decode submaps are empty.
+        """
+        if obs is None:
+            return None
+        if not obs.prefill and not obs.decode:
+            return None
+        prefill_engines: dict[str, bytes] = {}
+        decode_engines: dict[str, bytes] = {}
+        if obs.prefill:
+            for (worker_id, dp_rank), fpm_obs in obs.prefill.items():
+                prefill_engines[f"{worker_id}/{dp_rank}"] = _encode_fpm_record(fpm_obs)
+        if obs.decode:
+            for (worker_id, dp_rank), fpm_obs in obs.decode.items():
+                decode_engines[f"{worker_id}/{dp_rank}"] = _encode_fpm_record(fpm_obs)
+        return FpmData(
+            prefill_engines=prefill_engines,
+            decode_engines=decode_engines,
+        )
+
+    @staticmethod
+    def _baseline_from_worker_counts(
+        counts: Optional[WorkerCounts],
+    ) -> dict[ComponentKey, int]:
+        """Seed the PROPOSE-stage baseline with current worker counts so
+        the merge chain has a reference point. Without this, when all
+        PROPOSE plugins return Accept (e.g. FPM worker-count mismatch
+        in load_propose), ``type_aware_merge`` produces empty targets
+        → RECONCILE sees empty → CONSTRAIN's ``AT_LEAST(min_endpoint)``
+        dominates with ``baseline.get(key, 0) == 0`` → result is
+        ``min_endpoint`` instead of current.
+
+        Projecting that back through ``_project_scale_to``'s no-change
+        detection (``num_p == current_p``) would incorrectly report a
+        scale-down; passing the worker counts as baseline lets the
+        merge preserve the current value end-to-end so the projection
+        returns ``None`` (matching PSM's scale_to semantic for the
+        "load plugin had no opinion" case).
+        """
+        if counts is None:
+            return {}
+        out: dict[ComponentKey, int] = {}
+        if counts.ready_num_prefill is not None:
+            out[ComponentKey(sub_component_type="prefill")] = counts.ready_num_prefill
+        if counts.ready_num_decode is not None:
+            out[ComponentKey(sub_component_type="decode")] = counts.ready_num_decode
+        return out
+
+    @staticmethod
+    def _project_scale_to(outcome, worker_counts: WorkerCounts):
+        """Project the pipeline outcome onto ``PlannerEffects.scale_to``
+        with PSM-equivalent "no change → None" detection."""
+        if outcome.execute_action != "apply" or outcome.final_proposal is None:
+            return None
+
+        by_comp = {
+            t.sub_component_type: t.replicas for t in outcome.final_proposal.targets
+        }
+        num_p = by_comp.get("prefill")
+        num_d = by_comp.get("decode")
+
+        current_p = worker_counts.ready_num_prefill
+        current_d = worker_counts.ready_num_decode
+
+        p_unchanged = (num_p is None) or (num_p == current_p)
+        d_unchanged = (num_d is None) or (num_d == current_d)
+        if p_unchanged and d_unchanged:
+            return None
+
+        return ScalingDecision(num_prefill=num_p, num_decode=num_d)
+
+
+__all__ = ["OrchestratorEngineAdapter"]
diff --git a/components/src/dynamo/planner/plugins/orchestrator/in_process_loader.py b/components/src/dynamo/planner/plugins/orchestrator/in_process_loader.py
new file mode 100644
index 000000000000..e63d0a9ed081
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/orchestrator/in_process_loader.py
@@ -0,0 +1,96 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Load in-process user plugins from config specs.
+
+Given a list of ``InProcessPluginSpec`` (see ``registry/config.py``),
+import the named module, instantiate the named class with ``kwargs``,
+and hand the instance to ``orchestrator.register_internal``.
+
+PR #1 deferred wiring
+---------------------
+This helper is fully implemented + unit-tested but **not yet called**
+from any production startup path. ``planner.plugin_registration.in_process_plugins``
+config entries are silently ignored in PR #1. The wiring lands together
+with builtin plugins in PR #3, where ``OrchestratorEngineAdapter.bootstrap_plugins``
+will invoke ``load_in_process_plugins`` after registering builtins so
+operator-declared in-process plugins coexist with builtins. Tests in
+``tests/plugins/orchestrator/test_in_process_loader.py`` cover the
+helper's contract; the missing piece is the single call site, not the
+loader logic.
+"""
+
+from __future__ import annotations
+
+import importlib
+import logging
+from typing import Sequence
+
+from dynamo.planner.plugins.orchestrator.orchestrator import LocalPlannerOrchestrator
+from dynamo.planner.plugins.registry.config import InProcessPluginSpec
+from dynamo.planner.plugins.types import HoldPolicy
+
+log = logging.getLogger(__name__)
+
+
+def load_in_process_plugins(
+    orchestrator: LocalPlannerOrchestrator,
+    specs: Sequence[InProcessPluginSpec],
+) -> None:
+    """Iterate ``specs`` and register each via
+    ``orchestrator.register_internal`` with ``is_builtin=False``.
+
+    Any import / construction / registration failure is **re-raised** —
+    startup should fail fast so operators notice a misconfigured
+    ``in_process_plugins`` entry rather than silently running without
+    the plugin. Tests catch common mistakes at
+    ``test_in_process_loader.py``.
+    """
+    for spec in specs:
+        try:
+            module = importlib.import_module(spec.module)
+        except ImportError as exc:
+            raise ImportError(
+                f"load_in_process_plugins: failed to import module "
+                f"{spec.module!r} for plugin_id={spec.plugin_id!r}: {exc}"
+            ) from exc
+        try:
+            cls = getattr(module, spec.class_)
+        except AttributeError as exc:
+            raise AttributeError(
+                f"load_in_process_plugins: module {spec.module!r} has no "
+                f"attribute {spec.class_!r} for plugin_id={spec.plugin_id!r}"
+            ) from exc
+
+        try:
+            instance = cls(**spec.kwargs)
+        except Exception as exc:
+            raise RuntimeError(
+                f"load_in_process_plugins: failed to construct "
+                f"{spec.class_!r} (plugin_id={spec.plugin_id!r}, "
+                f"kwargs={spec.kwargs!r}): "
+                f"{type(exc).__name__}: {exc}"
+            ) from exc
+        hold_policy = HoldPolicy[spec.hold_policy]  # "ACCEPT_WHEN_IDLE" / "HOLD_LAST"
+        orchestrator.register_internal(
+            plugin_id=spec.plugin_id,
+            plugin_type=spec.plugin_type,
+            priority=spec.priority,
+            instance=instance,
+            execution_interval_seconds=spec.execution_interval_seconds,
+            hold_policy=hold_policy,
+            is_builtin=False,
+            version="user-in-process",
+            needs=list(spec.needs),
+            requires_produced_fields=list(spec.requires_produced_fields),
+            observation_window_seconds=spec.observation_window_seconds,
+        )
+        log.info(
+            "load_in_process_plugins: registered plugin_id=%s module=%s class=%s",
+            spec.plugin_id,
+            spec.module,
+            spec.class_,
+        )
+
+
+__all__ = ["load_in_process_plugins"]
diff --git a/components/src/dynamo/planner/plugins/orchestrator/orchestrator.py b/components/src/dynamo/planner/plugins/orchestrator/orchestrator.py
new file mode 100644
index 000000000000..58aa2c484000
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/orchestrator/orchestrator.py
@@ -0,0 +1,390 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""``LocalPlannerOrchestrator`` — thin composition of the plugin pieces.
+
+Owns:
+  - the ``PluginRegistryServer`` (plugin lifecycle)
+  - the ``CircuitBreaker`` (per-plugin failure-budget state)
+  - the ``PluginScheduler`` (per-tick active-set + HOLD_LAST cache)
+  - a regression-model dict consumed by the throughput-scaling builtin
+
+Does **not** own:
+  - the existing ``PlannerConnector`` — EXECUTE is returned as a
+    ``PipelineOutcome`` decision; the caller (``NativePlannerBase``)
+    translates ``apply`` into ``connector.add_component`` /
+    ``remove_component`` calls.
+  - any adapter between the proto ``PipelineContext`` and the existing
+    ``core/types.py`` TickInput / PlannerEffects — that lives in the
+    engine adapter.
+
+Regression-model access:
+  - ``get_regression(kind)`` returns the live reference; single-threaded
+    asyncio means no locks are required.
+  - ``update_regression(kind, fpm)`` mutates in place; callers (the
+    throughput-propose builtin) invoke this serially on the event-loop
+    main task.
+  - Holding a returned reference across an ``await`` is unsafe — fetch
+    a fresh reference after every await point.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any, Mapping, Optional, Sequence
+
+from dynamo.planner.core.types import TrafficObservation, WorkerCapabilities
+from dynamo.planner.monitoring.planner_metrics import PluginFrameworkMetrics
+from dynamo.planner.plugins.clock import Clock
+from dynamo.planner.plugins.merge.types import ComponentKey
+from dynamo.planner.plugins.orchestrator.pipeline import PipelineOutcome, run_pipeline
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+from dynamo.planner.plugins.registry.server import PluginRegistryServer
+from dynamo.planner.plugins.registry.types import RegisteredPlugin
+from dynamo.planner.plugins.scheduler import PluginScheduler
+from dynamo.planner.plugins.transport.errors import PluginUnknownMethodError
+from dynamo.planner.plugins.types import (
+    BootstrapRequest,
+    HoldPolicy,
+    ListPluginsRequest,
+    PipelineContext,
+    PluginInfo,
+    RegisterRequest,
+)
+
+log = logging.getLogger(__name__)
+
+
+class LocalPlannerOrchestrator:
+    """Composes registry + scheduler + circuit breaker + merge into a
+    single per-tick pipeline driver."""
+
+    def __init__(
+        self,
+        *,
+        registry: PluginRegistryServer,
+        scheduler: PluginScheduler,
+        circuit_breaker: CircuitBreaker,
+        clock: Clock,
+        tick_max_duration_seconds: float = 30.0,
+        capabilities: Optional[WorkerCapabilities] = None,
+        metrics: Optional[PluginFrameworkMetrics] = None,
+    ) -> None:
+        if tick_max_duration_seconds <= 0:
+            raise ValueError("tick_max_duration_seconds must be > 0")
+        self._registry = registry
+        self._scheduler = scheduler
+        self._circuit_breaker = circuit_breaker
+        self._clock = clock
+        self._tick_max_duration_seconds = tick_max_duration_seconds
+        # Optional plugin-framework metrics. ``None`` = emission off
+        # (test path, replay without scraping endpoint); every production
+        # call path passes a populated ``PluginFrameworkMetrics``.
+        self._metrics = metrics
+        # Regression-model store keyed by component kind ("prefill" /
+        # "decode" / "agg"). The throughput-propose / load-propose
+        # builtins read these; ``NativePlannerBase`` wires the
+        # mode-specific models in at startup.
+        self._regression: dict[str, Any] = {}
+        # Per-engine static capabilities (from WorkerInfo / MDC).
+        # Builtins that compute engine throughput (throughput-propose /
+        # load-propose) need these to clamp to max_num_batched_tokens /
+        # max_kv_tokens / etc. ``None`` is allowed for early pipelines
+        # that don't run those builtins.
+        self._capabilities = capabilities
+        # Cross-plugin shared state: PSM tracks ``_throughput_lower_bound_p/d``
+        # on the state machine; in the plugin decomposition the throughput-
+        # propose builtin writes these and the load-propose builtin reads
+        # them. A later refactor can swap this for AT_LEAST-merge semantics.
+        self._throughput_lower_bound: dict[str, int] = {"prefill": 1, "decode": 1}
+
+    # ------------------------------------------------------------------
+    # Regression model accessors
+    # ------------------------------------------------------------------
+
+    def get_regression(self, kind: str) -> Optional[Any]:
+        """Live reference to the regression model for ``kind``.
+
+        Callers MUST use synchronously on the event loop main task.
+        Holding the reference across an ``await`` is unsafe — fetch a
+        fresh reference after every await point."""
+        return self._regression.get(kind)
+
+    def update_regression(self, kind: str, model: Any) -> None:
+        """Install / replace the regression model for ``kind``. Typically
+        called by the throughput-propose builtin after adding a new FPM
+        observation."""
+        self._regression[kind] = model
+
+    @property
+    def registry(self) -> PluginRegistryServer:
+        """The underlying ``PluginRegistryServer``. Exposed so callers
+        (e.g. ``engine_adapter._maybe_start_gateway``) can pass it to
+        gateway / observability helpers without reaching into private
+        state."""
+        return self._registry
+
+    @property
+    def capabilities(self) -> Optional[WorkerCapabilities]:
+        """Static per-engine capabilities. Builtins that need
+        ``max_num_batched_tokens`` / ``max_kv_tokens`` etc. read this;
+        ``None`` when the orchestrator was constructed without
+        capabilities (e.g. early skeleton tests)."""
+        return self._capabilities
+
+    # Cross-plugin throughput lower bound (PSM's ``_throughput_lower_bound_p/d``).
+    def set_throughput_lower_bound(self, component: str, value: int) -> None:
+        self._throughput_lower_bound[component] = value
+
+    def get_throughput_lower_bound(self, component: str) -> int:
+        return self._throughput_lower_bound.get(component, 1)
+
+    # ------------------------------------------------------------------
+    # Plugin lifecycle (delegates)
+    # ------------------------------------------------------------------
+
+    def register_internal(
+        self,
+        plugin_id: str,
+        plugin_type: str,
+        priority: int,
+        instance: Any,
+        *,
+        execution_interval_seconds: float = 0.0,
+        hold_policy: HoldPolicy = HoldPolicy.ACCEPT_WHEN_IDLE,
+        is_builtin: bool = True,
+        version: str = "builtin",
+        needs: Optional[list[str]] = None,
+        requires_produced_fields: Optional[list[str]] = None,
+        observation_window_seconds: float = 0.0,
+    ) -> RegisteredPlugin:
+        """Register a plugin object that lives in this Python process.
+
+        Thin wrapper around ``PluginRegistryServer.register_internal``;
+        exists so callers (``NativePlannerBase``, tests) can interact
+        with a single facade without reaching through to the registry.
+
+        ``requires_produced_fields`` / ``observation_window_seconds``
+        mirror the corresponding ``RegisterRequest`` proto fields —
+        builtins and in-process loader entries flow through this
+        facade, so they must be accepted here or the scale_interval
+        cadence contract is unreachable for any non-gRPC registrant.
+        """
+        return self._registry.register_internal(
+            plugin_id=plugin_id,
+            plugin_type=plugin_type,
+            priority=priority,
+            instance=instance,
+            execution_interval_seconds=execution_interval_seconds,
+            hold_policy=hold_policy,
+            is_builtin=is_builtin,
+            version=version,
+            needs=needs,
+            requires_produced_fields=requires_produced_fields,
+            observation_window_seconds=observation_window_seconds,
+        )
+
+    def list_plugins(
+        self, request: Optional[ListPluginsRequest] = None
+    ) -> list[PluginInfo]:
+        return self._registry.list_plugins(request or ListPluginsRequest())
+
+    async def register_external_from_config(
+        self, entries: Sequence[Any]
+    ) -> tuple[int, list[tuple[str, str]]]:
+        """Register a static list of out-of-process plugins.
+
+        ``entries`` is typically ``PlannerConfig.scheduling.external_plugins``.
+        Each entry is converted to a ``RegisterRequest`` and pushed
+        through the same ``await registry.register(...)`` code path the
+        gRPC gateway uses — so behaviour is identical between
+        static-config and dynamic-self-register deployments.
+
+        **Failure isolation**: a single bad entry (auth failure, bad
+        endpoint scheme, plugin process unreachable) MUST NOT take down
+        the planner. Each per-entry failure is logged with the reject
+        reason; the function returns a per-entry status report so the
+        caller (planner startup) can surface a summary line in
+        operational logs.
+
+        Returns ``(num_accepted, [(plugin_id, reject_reason_or_error), ...])``
+        where the second element lists only the entries that failed.
+        """
+        accepted = 0
+        failures: list[tuple[str, str]] = []
+        for entry in entries:
+            try:
+                req = RegisterRequest(
+                    plugin_id=entry.plugin_id,
+                    plugin_type=entry.plugin_type,
+                    priority=entry.priority,
+                    endpoint=entry.endpoint,
+                    auth_token=entry.auth_token,
+                    protocol_version=entry.protocol_version,
+                    version=entry.version,
+                    execution_interval_seconds=entry.execution_interval_seconds,
+                    hold_policy=entry.hold_policy,
+                    needs=list(entry.needs),
+                    requires_produced_fields=list(entry.requires_produced_fields),
+                    observation_window_seconds=entry.observation_window_seconds,
+                )
+                resp = await self._registry.register(req)
+            except asyncio.CancelledError:
+                # Cancellation must propagate; never swallowed by the
+                # defensive Exception handler below.
+                raise
+            except Exception as exc:
+                # Defensive: any unexpected exception (e.g. a transport
+                # factory bug, a Pydantic validation slip) is logged
+                # and the next entry is still attempted.
+                log.warning(
+                    "register_external_from_config: entry plugin_id=%s "
+                    "raised %s: %s",
+                    entry.plugin_id,
+                    type(exc).__name__,
+                    exc,
+                )
+                failures.append((entry.plugin_id, f"{type(exc).__name__}: {exc}"))
+                continue
+            if resp.accepted:
+                accepted += 1
+                log.info(
+                    "register_external_from_config: accepted plugin_id=%s "
+                    "type=%s endpoint=%s",
+                    entry.plugin_id,
+                    entry.plugin_type,
+                    entry.endpoint,
+                )
+            else:
+                log.warning(
+                    "register_external_from_config: rejected plugin_id=%s " "reason=%s",
+                    entry.plugin_id,
+                    resp.reject_reason,
+                )
+                failures.append((entry.plugin_id, resp.reject_reason))
+        return accepted, failures
+
+    # ------------------------------------------------------------------
+    # Pipeline driver
+    # ------------------------------------------------------------------
+
+    async def tick(
+        self,
+        ctx: PipelineContext,
+        baseline: Mapping[ComponentKey, int],
+    ) -> PipelineOutcome:
+        """Run one tick through PREDICT / PROPOSE / RECONCILE / CONSTRAIN.
+
+        Returns a ``PipelineOutcome`` naming the EXECUTE decision
+        (``apply`` / ``skip_no_targets`` / ``skip_short_circuit`` /
+        ``skip_tick_timeout``) — the caller is responsible for
+        projecting ``apply`` onto a ``PlannerConnector``.
+        """
+        tick_now = self._clock.monotonic()
+        return await run_pipeline(
+            ctx=ctx,
+            scheduler=self._scheduler,
+            circuit_breaker=self._circuit_breaker,
+            baseline=baseline,
+            clock=self._clock,
+            tick_now=tick_now,
+            tick_max_duration_seconds=self._tick_max_duration_seconds,
+            metrics=self._metrics,
+        )
+
+    async def shutdown(self) -> None:
+        """Unregister every plugin, closing their transports.
+
+        Idempotent: subsequent calls find the registry empty and exit.
+        """
+        plugins = list(self._registry.all_plugins())
+        for plugin in plugins:
+            await self._registry.unregister(plugin.plugin_id, reason="shutdown")
+
+    # ------------------------------------------------------------------
+    # Pre-first-tick initialisation
+    # ------------------------------------------------------------------
+
+    def install_regressions(
+        self,
+        *,
+        prefill: Optional[Any] = None,
+        decode: Optional[Any] = None,
+        agg: Optional[Any] = None,
+    ) -> None:
+        """Install regression models on the orchestrator's shared store
+        so ``BuiltinThroughputPropose`` / ``BuiltinLoadPropose`` can read
+        them via ``get_regression``.
+
+        This is **orchestrator-owned state** (not a plugin concern) —
+        the caller constructs regressions (typically via
+        ``PSM.load_benchmark_fpms`` on a throwaway PSM) and hands them
+        here for shared access across builtins. ``None`` for any kind
+        skips that slot.
+
+        Distinct from ``bootstrap_plugins`` on purpose — regressions
+        must be installed **before** ``bootstrap_plugins`` is called
+        because plugin Bootstrap implementations may read them via
+        ``get_regression``.
+        """
+        if prefill is not None:
+            self.update_regression("prefill", prefill)
+        if decode is not None:
+            self.update_regression("decode", decode)
+        if agg is not None:
+            self.update_regression("agg", agg)
+
+    async def bootstrap_plugins(
+        self,
+        *,
+        historical_traffic: Optional[Sequence[TrafficObservation]] = None,
+    ) -> None:
+        """Fan out plugin Bootstrap lifecycle hooks.
+
+        Two things happen in order:
+
+        1. **Warm predictors** via Python-level helpers on any
+           registered plugin exposing ``warm_from_observations``
+           (currently ``BuiltinLoadPredictor``). Matches
+           ``PSM.warm_load_predictors``.
+        2. **Dispatch Bootstrap RPC** to every registered plugin so
+           any side effects in concrete plugin implementations fire.
+           Plugins that don't implement Bootstrap have the
+           ``PluginUnknownMethodError`` caught and skipped.
+
+        Regression installation is a **separate** concern — call
+        ``install_regressions(...)`` before this if plugin Bootstrap
+        implementations need to read regressions.
+
+        The wire-format ``BootstrapRequest.bootstrap_data`` encoding
+        for historical traffic is still TBD; in-process plugins get
+        the data via the Python helpers above.
+        """
+        # 1. Python-level warm hook (primarily BuiltinLoadPredictor)
+        if historical_traffic is not None:
+            for plugin in self._registry.all_plugins():
+                instance = getattr(plugin.transport, "_instance", None)
+                warm = getattr(instance, "warm_from_observations", None)
+                if callable(warm):
+                    warm(historical_traffic)
+
+        # 2. Bootstrap RPC fan-out (plugins that don't implement it are skipped)
+        for plugin in self._registry.all_plugins():
+            try:
+                await plugin.transport.call("Bootstrap", BootstrapRequest())
+            except PluginUnknownMethodError:
+                continue
+            except asyncio.CancelledError:
+                # Cancellation must propagate; never swallowed by the
+                # defensive Exception handler below.
+                raise
+            except Exception as exc:  # noqa: BLE001 — defensive
+                log.warning(
+                    "bootstrap_plugins: Bootstrap RPC failed plugin_id=%s detail=%s",
+                    plugin.plugin_id,
+                    exc,
+                )
+
+
+__all__ = ["LocalPlannerOrchestrator"]
diff --git a/components/src/dynamo/planner/plugins/orchestrator/pipeline.py b/components/src/dynamo/planner/plugins/orchestrator/pipeline.py
new file mode 100644
index 000000000000..65475b1e7572
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/orchestrator/pipeline.py
@@ -0,0 +1,923 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""4-stage plugin pipeline driver.
+
+Pipeline order: PREDICT → PROPOSE → RECONCILE → CONSTRAIN → EXECUTE.
+
+- **PREDICT** runs as a priority-ascending chain via ``chain_augment``
+  (smallest priority number first; first-writer-wins partial-merge);
+  any partial prediction gets threaded onto ``PipelineContext.predictions``
+  for downstream stages.
+- **PROPOSE / RECONCILE / CONSTRAIN** fan out via ``asyncio.gather`` and
+  collapse with ``type_aware_merge``. CONSTRAIN runs with
+  ``set_allowed=False`` so SET override targets are dropped + audited.
+- **EXECUTE** is a decision only — the pipeline returns a
+  ``PipelineOutcome`` naming the action (``apply`` / ``skip_no_targets`` /
+  ``skip_short_circuit`` / ``skip_tick_timeout``). The orchestrator (or
+  ``NativePlannerBase``) projects this onto ``PlannerConnector`` calls.
+
+Strong constraints enforced here:
+
+- **Plugin/result pairing** — stage results are paired with plugins via
+  ``zip(plugins, results)``. Callers must never reach back through
+  ``result.plugin`` or assume the plugin object is reachable from the
+  raw result.
+- **Empty-targets skip** — when CONSTRAIN produces an empty ``targets``
+  list (every plugin returned ACCEPT), the EXECUTE path is skipped with
+  the audit event ``execute_skipped_no_targets`` rather than
+  no-op-applying an empty proposal.
+- **No stage-level wait_for** — **no** stage-level ``asyncio.wait_for``
+  wrapping ``asyncio.gather``. Per-call deadlines already live inside
+  ``PluginTransport.call`` (driven by
+  ``TransportConfig.request_timeout_seconds``, applied uniformly to
+  every plugin in PR #1). The only ``asyncio.wait_for`` in this module
+  is the outermost whole-tick guard around the entire pipeline. A
+  grep-based regression test in
+  ``tests/plugins/orchestrator/test_pipeline.py`` asserts this.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass, field
+from typing import Literal, Mapping, Optional
+
+from dynamo.planner.monitoring.planner_metrics import PluginFrameworkMetrics
+from dynamo.planner.plugins.clock import Clock
+from dynamo.planner.plugins.merge import (
+    ChainAugmentOutcome,
+    ComponentKey,
+    MergeOutcome,
+    PluginResult,
+    chain_augment,
+    type_aware_merge,
+)
+from dynamo.planner.plugins.merge.types import PredictPluginCallable
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker, CircuitState
+from dynamo.planner.plugins.registry.types import RegisteredPlugin
+from dynamo.planner.plugins.scheduler import PluginScheduler
+from dynamo.planner.plugins.types import (
+    AcceptResult,
+    ComponentTarget,
+    ConstrainStageRequest,
+    ConstrainStageResponse,
+    OverrideResult,
+    PipelineContext,
+    PredictStageRequest,
+    PredictStageResponse,
+    ProposeResult,
+    ProposeStageRequest,
+    ProposeStageResponse,
+    ReconcileStageRequest,
+    ReconcileStageResponse,
+    RejectResult,
+    ScalingProposal,
+)
+
+log = logging.getLogger(__name__)
+
+
+ExecuteAction = Literal[
+    "apply",  # ctx.constrained.targets should be applied
+    "skip_no_targets",  # CONSTRAIN produced 0 targets — emit audit + skip
+    "skip_short_circuit",  # some stage REJECTed
+    "skip_tick_timeout",  # whole-tick deadline exceeded
+]
+
+
+@dataclass
+class PipelineOutcome:
+    """Full record of one tick through the 4-stage pipeline.
+
+    The orchestrator consumes ``execute_action`` to decide what to hand
+    to the ``PlannerConnector``. ``final_proposal`` is populated in the
+    ``apply`` / ``skip_no_targets`` branches and ``None`` otherwise.
+    """
+
+    execute_action: ExecuteAction
+    final_proposal: Optional[ScalingProposal]
+    short_circuit_reason: str = ""
+    predict_outcome: Optional[ChainAugmentOutcome] = None
+    propose_outcome: Optional[MergeOutcome] = None
+    reconcile_outcome: Optional[MergeOutcome] = None
+    constrain_outcome: Optional[MergeOutcome] = None
+    audit_events: list[str] = field(default_factory=list)
+
+
+class _PredictAdapter:
+    """Adapts a ``RegisteredPlugin`` to the
+    ``PredictPluginCallable`` protocol expected by ``chain_augment``.
+
+    ``chain_augment`` wants ``async call(method, context)``; the
+    transport signature is ``async call(method, request)``. This adapter
+    wraps the ``PipelineContext`` into a ``PredictStageRequest`` on the
+    way in and forwards the response unchanged.
+
+    Emits ``plugin_evaluations_total`` + ``plugin_latency_seconds`` for
+    every PREDICT call so the plugin invocation metrics cover all 4
+    stages uniformly; ``chain_augment`` is a separate dispatch path from
+    ``_run_fanout_stage`` and would otherwise silently bypass emission.
+    """
+
+    def __init__(
+        self,
+        plugin: RegisteredPlugin,
+        *,
+        metrics: Optional[PluginFrameworkMetrics] = None,
+        clock: Optional[Clock] = None,
+        scheduler: Optional["PluginScheduler"] = None,
+        tick_now: float = 0.0,
+        circuit_breaker: Optional[CircuitBreaker] = None,
+    ) -> None:
+        self._plugin = plugin
+        self._metrics = metrics
+        self._clock = clock
+        # Scheduler + tick_now are required for ``execution_interval_seconds``
+        # throttle to apply to PREDICT plugins. chain_augment is a separate
+        # dispatch path from ``_run_fanout_stage``; without the adapter
+        # poking the scheduler here, PREDICT plugins would never have their
+        # ``last_call_at`` bumped → throttle no-op for the entire stage.
+        self._scheduler = scheduler
+        self._tick_now = tick_now
+        # CircuitBreaker is required for failure isolation: PROPOSE /
+        # RECONCILE / CONSTRAIN catch plugin errors inside the fan-out
+        # runner and record_failure to the CB; PREDICT used to re-raise
+        # the exception out of ``chain_augment``, taking down the whole
+        # planner tick.  Now we mirror the fan-out stages' behaviour:
+        # record_failure, log, emit error metric, and return a no-op
+        # ``PredictStageResponse`` so the chain continues with the next
+        # plugin (or terminates cleanly if this was the last).
+        self._circuit_breaker = circuit_breaker
+
+    @property
+    def plugin_id(self) -> str:
+        return self._plugin.plugin_id
+
+    @property
+    def priority(self) -> int:
+        return self._plugin.priority
+
+    async def call(self, method: str, context: PipelineContext) -> PredictStageResponse:
+        assert method == "Predict", f"unexpected method for PREDICT: {method!r}"
+        req = PredictStageRequest(context=context)
+
+        started = self._clock.monotonic() if (self._metrics and self._clock) else 0.0
+        try:
+            resp = await self._plugin.transport.call("Predict", req)
+        except asyncio.CancelledError:
+            # Task cancellation must propagate — same handling as the
+            # fan-out runner.  CB / metrics emission is for *plugin*
+            # failures, not for outer cancellation of the planner tick.
+            raise
+        except Exception as exc:
+            # Mirror ``_run_fanout_stage`` failure handling so a broken
+            # PREDICT plugin does NOT take down the whole planner tick.
+            log.warning(
+                "pipeline.predict: plugin_id=%s call failed: %r",
+                self._plugin.plugin_id,
+                exc,
+            )
+            if self._circuit_breaker is not None:
+                self._circuit_breaker.record_failure(self._plugin.plugin_id)
+            if self._metrics is not None:
+                self._metrics.plugin_evaluations_total.labels(
+                    plugin_id=self._plugin.plugin_id,
+                    stage="predict",
+                    result="error",
+                ).inc()
+            # Return a no-op response so ``chain_augment`` continues
+            # with the next plugin in the chain.  ``predictions=None``
+            # plus ``final=False`` is exactly the empty-contribution
+            # shape that ``_partial_merge`` already handles (carries
+            # forward the previous predictions, doesn't break the
+            # chain).
+            return PredictStageResponse(predictions=None, final=False)
+
+        # RPC succeeded — record CB success + bump scheduler bookkeeping
+        # so ``execution_interval_seconds`` throttling applies to PREDICT.
+        if self._circuit_breaker is not None:
+            self._circuit_breaker.record_success(self._plugin.plugin_id)
+        if self._scheduler is not None:
+            self._scheduler.record_evaluation(self._plugin.plugin_id, self._tick_now)
+
+        if self._metrics is not None:
+            # Classify: chain_augment consumes the response and produces
+            # a partial/final PredictionData — we don't know yet whether
+            # final=True "won" the chain, so use a coarse label here.
+            # Terminal chain outcome is captured elsewhere (audit events
+            # in chain_augment's chain_break_warnings).
+            self._metrics.plugin_evaluations_total.labels(
+                plugin_id=self._plugin.plugin_id,
+                stage="predict",
+                result="accept",  # PREDICT returns data, not overrides
+            ).inc()
+            if self._clock is not None:
+                self._metrics.plugin_latency_seconds.labels(
+                    plugin_id=self._plugin.plugin_id, stage="predict"
+                ).observe(max(0.0, self._clock.monotonic() - started))
+
+        return resp  # type: ignore[return-value]
+
+
+def _proposal_to_baseline(
+    proposal: Optional[ScalingProposal],
+    fallback: Mapping[ComponentKey, int],
+) -> dict[ComponentKey, int]:
+    """Project a ``ScalingProposal`` to the ``baseline`` shape consumed
+    by the next stage's ``type_aware_merge``.
+
+    The baseline for each stage is the prior stage's output (not the
+    caller's initial baseline). If the prior stage produced no proposal
+    (short-circuit edge case), fall back to the caller's baseline.
+    """
+    if proposal is None:
+        return dict(fallback)
+    out: dict[ComponentKey, int] = dict(fallback)
+    for t in proposal.targets:
+        if t.replicas is None:
+            continue
+        key = ComponentKey(sub_component_type=t.sub_component_type)
+        out[key] = t.replicas
+    return out
+
+
+def _stage_request(
+    stage: str,
+    ctx: PipelineContext,
+    *,
+    proposals: Optional[list[ProposeResult]] = None,
+):
+    if stage == "propose":
+        return ProposeStageRequest(context=ctx)
+    if stage == "reconcile":
+        # Thread per-plugin PROPOSE results through to RECONCILE so
+        # custom reconcile plugins can arbitrate proposals individually,
+        # rather than only seeing the post-merge ``ctx.proposal``.
+        return ReconcileStageRequest(context=ctx, proposals=proposals or [])
+    if stage == "constrain":
+        return ConstrainStageRequest(context=ctx)
+    raise ValueError(f"_stage_request: unknown stage {stage!r}")
+
+
+def _to_propose_result(pr: PluginResult) -> ProposeResult:
+    """Convert internal ``PluginResult`` to wire-format ``ProposeResult``
+    for ``ReconcileStageRequest.proposals``."""
+    if isinstance(pr.result, AcceptResult):
+        return ProposeResult(
+            plugin_id=pr.plugin_id,
+            priority=pr.priority,
+            result_kind="accept",
+            accept=pr.result,
+        )
+    if isinstance(pr.result, OverrideResult):
+        return ProposeResult(
+            plugin_id=pr.plugin_id,
+            priority=pr.priority,
+            result_kind="override",
+            override=pr.result,
+        )
+    if isinstance(pr.result, RejectResult):
+        return ProposeResult(
+            plugin_id=pr.plugin_id,
+            priority=pr.priority,
+            result_kind="reject",
+            reject=pr.result,
+        )
+    raise ValueError(
+        f"_to_propose_result: unknown PluginResult.result type "
+        f"{type(pr.result).__name__}"
+    )
+
+
+_STAGE_METHOD = {
+    "propose": "Propose",
+    "reconcile": "Reconcile",
+    "constrain": "Constrain",
+}
+
+
+def _response_to_plugin_result(
+    plugin: RegisteredPlugin,
+    resp: ProposeStageResponse | ReconcileStageResponse | ConstrainStageResponse,
+    stage: str,
+) -> Optional[PluginResult]:
+    """Convert a ``_StageOneofResponse`` to ``PluginResult``; the caller pairs
+    each result with its source plugin via ``zip(plugins, results)``.
+
+    Returns ``None`` when the plugin's response carries no oneof field
+    set — treated as silent ACCEPT per the DEP main-doc graceful-degradation
+    invariant. See ``plugins/proto/v1/README.md`` "result oneof empty" and
+    the inline note below for the full rationale.
+
+    The ``stage`` parameter gates the ``final`` flag: per the proto
+    contract, ``ConstrainStageResponse.final`` is ignored — constrain
+    is a safety layer, so letting one constrain plugin short-circuit
+    the others' AT_LEAST/AT_MOST clamps via ``final=true`` defeats
+    the purpose. For propose/reconcile we honour ``resp.final`` as
+    documented.
+    """
+    final = False if stage == "constrain" else resp.final
+    kind = resp.result_kind
+    if kind == "accept" and resp.accept is not None:
+        return PluginResult(
+            plugin_id=plugin.plugin_id,
+            priority=plugin.priority,
+            result=resp.accept,
+            final=final,
+        )
+    if kind == "override" and resp.override is not None:
+        return PluginResult(
+            plugin_id=plugin.plugin_id,
+            priority=plugin.priority,
+            result=resp.override,
+            final=final,
+        )
+    if kind == "reject" and resp.reject is not None:
+        return PluginResult(
+            plugin_id=plugin.plugin_id,
+            priority=plugin.priority,
+            result=resp.reject,
+            final=final,
+        )
+    # Empty oneof → silent ACCEPT (DEP main-doc graceful-degradation
+    # invariant; see plugins/proto/v1/README.md "result oneof empty").
+    # Counted in plugin_evaluations_total{result="error"} so plugin
+    # authors can spot accidentally-empty responses via metrics, but the
+    # circuit breaker is NOT tripped here — only transport errors /
+    # timeouts trip it. proto3 cannot distinguish "author set an empty
+    # AcceptResult()" from "author forgot to set anything" on the wire
+    # (both produce zero field tags), so a strict escalation would
+    # punish abstaining plugins indistinguishably from buggy ones.
+    log.warning(
+        "pipeline: plugin_id=%s returned empty oneof result (result_kind=%r); "
+        "treating as ACCEPT for this tick",
+        plugin.plugin_id,
+        kind,
+    )
+    return None
+
+
+async def _run_fanout_stage(
+    *,
+    stage: str,
+    scheduler: PluginScheduler,
+    circuit_breaker: CircuitBreaker,
+    ctx: PipelineContext,
+    baseline: Mapping[ComponentKey, int],
+    tick_now: float,
+    set_allowed: bool,
+    clock: Clock,
+    metrics: Optional[PluginFrameworkMetrics] = None,
+    propose_results: Optional[list[ProposeResult]] = None,
+) -> tuple[MergeOutcome, list[PluginResult]]:
+    """PROPOSE / RECONCILE / CONSTRAIN fan-out-and-merge helper.
+
+    Computes the active set, dispatches via bare ``asyncio.gather`` (no
+    wrapping ``asyncio.wait_for`` — per-plugin timeouts live in
+    ``PluginTransport.call``), records success/failure on the circuit
+    breaker, threads inherited HOLD_LAST results into the merge, and
+    returns the ``type_aware_merge`` outcome plus the per-plugin
+    results that fed it (so the caller can forward PROPOSE outputs to
+    the RECONCILE stage's ``proposals`` payload).
+
+    When ``metrics`` is provided, emits the plugin invocation metrics
+    (evaluations / latency / held_over / cache_age / circuit_state /
+    override_active) at the appropriate points.  Passing ``None``
+    disables emission for tests + replay that don't construct a
+    Prometheus registry.
+
+    For RECONCILE stage, callers pass ``propose_results`` to populate
+    ``ReconcileStageRequest.proposals`` so reconcile plugins can
+    arbitrate per-proposal rather than only seeing the post-merge
+    ``ctx.proposal``.
+    """
+    active = scheduler.compute_active_set(tick_now, stage, ctx=ctx)
+    plugins: list[RegisteredPlugin] = list(active.triggered)
+    method = _STAGE_METHOD[stage]
+    request = _stage_request(stage, ctx, proposals=propose_results)
+
+    # Record latency per-plugin: measure each call individually even
+    # though they run concurrently, so slow plugins don't get their
+    # latency collapsed into the gather deadline.
+    call_starts: list[float] = []
+    if metrics is not None:
+        call_starts = [clock.monotonic() for _ in plugins]
+
+    # Bare asyncio.gather — each transport.call enforces its own
+    # per-plugin timeout inside PluginTransport. Wrapping a stage-level
+    # asyncio.wait_for here would double-count the deadline.
+    raw_results = await asyncio.gather(
+        *[p.transport.call(method, request) for p in plugins],
+        return_exceptions=True,
+    )
+
+    call_end = clock.monotonic() if metrics is not None else 0.0
+
+    # Pair plugins with their raw results via zip — do NOT assume the
+    # result carries a back-reference to the plugin.
+    plugin_results: list[PluginResult] = []
+    for idx, (plugin, raw) in enumerate(zip(plugins, raw_results)):
+        # ``asyncio.gather(return_exceptions=True)`` captures any
+        # ``BaseException`` subclass raised by the awaitable, so we widen
+        # the check beyond ``Exception``. This intentionally also catches
+        # rare non-``Exception`` BaseExceptions (e.g. a plugin doing
+        # ``sys.exit()``); recording them as plugin-call failures + tripping
+        # the circuit breaker is the right operator-visible outcome.
+        # ``CancelledError`` does NOT land here: ``asyncio.wait_for`` inside
+        # ``PluginTransport.call`` converts plugin-side cancellation into
+        # ``PluginTimeoutError`` (an Exception subclass), and the
+        # outermost whole-tick ``wait_for`` cancels the gather itself —
+        # cancellation propagates through the outer except clause.
+        if isinstance(raw, BaseException):
+            log.warning(
+                "pipeline.%s: plugin_id=%s call failed: %r",
+                stage,
+                plugin.plugin_id,
+                raw,
+            )
+            circuit_breaker.record_failure(plugin.plugin_id)
+            if metrics is not None:
+                _record_eval(metrics, plugin.plugin_id, stage, "error")
+            continue
+        circuit_breaker.record_success(plugin.plugin_id)
+        # Per-call scheduling bookkeeping — fires for every successful
+        # RPC regardless of result kind (Accept / Override / Reject /
+        # empty-oneof silent-ACCEPT). Drives ``execution_interval_seconds``
+        # throttle and ``evaluations_total`` reporting. The OverrideResult-
+        # only ``record_result`` cache below is a separate concern.
+        scheduler.record_evaluation(plugin.plugin_id, tick_now)
+        if metrics is not None:
+            # Latency emitted only for successful calls so error / timeout
+            # tail doesn't pollute the plugin-perf percentiles dashboard.
+            metrics.plugin_latency_seconds.labels(
+                plugin_id=plugin.plugin_id, stage=stage
+            ).observe(max(0.0, call_end - call_starts[idx]))
+        pr = _response_to_plugin_result(plugin, raw, stage)
+        if pr is None:
+            if metrics is not None:
+                _record_eval(metrics, plugin.plugin_id, stage, "error")
+            continue
+        plugin_results.append(pr)
+        if metrics is not None:
+            _record_eval(
+                metrics,
+                plugin.plugin_id,
+                stage,
+                _result_label(pr),
+            )
+        # Cache OverrideResult for HOLD_LAST plugins on the scheduler.
+        if isinstance(pr.result, OverrideResult):
+            scheduler.record_result(plugin.plugin_id, stage, pr.result, tick_now)
+
+    # Inherited HOLD_LAST entries participate in the merge as non-final
+    # PluginResults (cache replay cannot re-assert final=True).
+    for inh in active.inherited:
+        plugin_results.append(
+            PluginResult(
+                plugin_id=inh.plugin_id,
+                priority=inh.priority,
+                result=inh.result,
+                final=False,
+            )
+        )
+        if metrics is not None:
+            metrics.plugin_held_over_total.labels(
+                plugin_id=inh.plugin_id, stage=stage
+            ).inc()
+            metrics.plugin_cache_age_seconds.labels(plugin_id=inh.plugin_id).set(
+                max(0.0, tick_now - inh.cached_at)
+            )
+            _record_eval(metrics, inh.plugin_id, stage, "held_over")
+
+    outcome = type_aware_merge(plugin_results, baseline, set_allowed=set_allowed)
+
+    if metrics is not None:
+        _set_circuit_state(
+            metrics,
+            plugins + [_inh_as_plugin(i) for i in active.inherited],
+            circuit_breaker,
+        )
+        _emit_override_active(
+            metrics,
+            stage=stage,
+            plugin_results=plugin_results,
+            attempted_plugin_ids=[p.plugin_id for p in plugins]
+            + [i.plugin_id for i in active.inherited],
+            outcome=outcome,
+        )
+        _emit_clamps_and_rejects(
+            metrics,
+            stage=stage,
+            outcome=outcome,
+            plugin_results=plugin_results,
+        )
+
+    return outcome, plugin_results
+
+
+# ---------------------------------------------------------------------------
+# Plugin invocation metric helpers: classify plugin result → metric label,
+# emit gauges. Keeping these close to the fan-out helper so the metric
+# vocabulary stays in one place and matches what dashboards expect.
+# ---------------------------------------------------------------------------
+
+
+def _record_eval(
+    metrics: PluginFrameworkMetrics,
+    plugin_id: str,
+    stage: str,
+    result_label: str,
+) -> None:
+    metrics.plugin_evaluations_total.labels(
+        plugin_id=plugin_id, stage=stage, result=result_label
+    ).inc()
+
+
+def _result_label(pr: PluginResult) -> str:
+    """Map a PluginResult to the ``result`` label used in metrics.
+    Mirrors the taxonomy the spec calls out: accept / set / at_least /
+    at_most / reject / held_over / timeout / error.
+
+    ``override_type`` is on each ``ComponentTarget`` (not on
+    ``OverrideResult`` itself — proto mirrors per-target types so one
+    result can emit mixed SET/AT_LEAST/AT_MOST per component).  We pick
+    the first target's type as the label here because Prometheus label
+    cardinality requires a single value; downstream dashboards that
+    need the full mix should sum
+    ``plugin_override_active{override_type=...}`` instead.
+    """
+    from dynamo.planner.plugins.types import AcceptResult as _AcceptResult
+    from dynamo.planner.plugins.types import OverrideResult as _OverrideResult
+    from dynamo.planner.plugins.types import RejectResult as _RejectResult
+
+    r = pr.result
+    if isinstance(r, _RejectResult):
+        return "reject"
+    if isinstance(r, _AcceptResult):
+        return "accept"
+    if isinstance(r, _OverrideResult):
+        if r.targets:
+            t = r.targets[0].type
+            return t.name.lower() if hasattr(t, "name") else str(t).lower()
+        return "set"  # OverrideResult with empty targets defaults to SET semantically
+    return "unknown"
+
+
+def _inh_as_plugin(inh):
+    """Adapter: return a minimal object with ``plugin_id`` so
+    ``_set_circuit_state`` can treat inherited entries uniformly."""
+
+    class _Shim:
+        plugin_id = inh.plugin_id
+
+    return _Shim
+
+
+def _set_circuit_state(
+    metrics: PluginFrameworkMetrics,
+    plugins,
+    circuit_breaker: CircuitBreaker,
+) -> None:
+    """Reflect the circuit breaker's per-plugin state onto the gauge.
+
+    Called once per fanout stage.  Reads the state (which may
+    auto-transition OPEN → HALF_OPEN after cooldown) and pins the gauge
+    so dashboards display the live view even for plugins not evaluated
+    this tick."""
+    from dynamo.planner.monitoring.planner_metrics import (
+        CIRCUIT_STATE_CLOSED,
+        CIRCUIT_STATE_HALF_OPEN,
+        CIRCUIT_STATE_OPEN,
+    )
+
+    _state_map = {
+        CircuitState.CLOSED: CIRCUIT_STATE_CLOSED,
+        CircuitState.HALF_OPEN: CIRCUIT_STATE_HALF_OPEN,
+        CircuitState.OPEN: CIRCUIT_STATE_OPEN,
+    }
+    seen: set[str] = set()
+    for p in plugins:
+        if p.plugin_id in seen:
+            continue
+        seen.add(p.plugin_id)
+        state = circuit_breaker.state(p.plugin_id)
+        metrics.plugin_circuit_state.labels(plugin_id=p.plugin_id).set(
+            _state_map.get(state, CIRCUIT_STATE_CLOSED)
+        )
+
+
+def _emit_override_active(
+    metrics: PluginFrameworkMetrics,
+    *,
+    stage: str,
+    plugin_results: list,
+    attempted_plugin_ids: list,
+    outcome: MergeOutcome,
+) -> None:
+    """Set ``plugin_override_active`` for every evaluated plugin in this
+    stage.  The gauge is per-(plugin_id, stage, override_type); we reset
+    all four types first (so the previous tick's 1 doesn't linger) then
+    set 1 for the type the plugin actually contributed.
+
+    Plugins that returned ACCEPT or REJECT-but-not-winning leave the
+    gauge at all-zero — that's the correct "evaluated, no override"
+    state."""
+    from dynamo.planner.plugins.types import OverrideResult as _OverrideResult
+    from dynamo.planner.plugins.types import RejectResult as _RejectResult
+
+    # Reset every plugin we ATTEMPTED this tick (triggered + inherited),
+    # not just those that produced a result. A plugin whose call raised is
+    # absent from ``plugin_results`` but may have set the gauge to 1 on a
+    # prior tick — resetting only result-producers would leave that 1
+    # lingering. ``attempted_plugin_ids`` covers the errored ones too.
+    for pid in attempted_plugin_ids:
+        metrics.reset_overrides(pid, stage)
+
+    # Short-circuited REJECT winners (found by type_aware_merge) surface
+    # as outcome.rejected; emit override_type=REJECT for them.
+    rejected_ids = {
+        pr.plugin_id for pr in plugin_results if isinstance(pr.result, _RejectResult)
+    }
+    for pid in rejected_ids:
+        metrics.plugin_override_active.labels(
+            plugin_id=pid, stage=stage, override_type="REJECT"
+        ).set(1)
+
+    # For non-rejected plugins, emit 1 on each override_type present
+    # in their targets.  A plugin may contribute mixed types (e.g.
+    # SET on prefill + AT_LEAST on decode) — we flag each observed
+    # type.  This is a conservative over-count: a plugin's SET may
+    # lose to a higher-priority SET from another plugin and still
+    # show as "active".  Refine when MergeOutcome exposes a concrete
+    # contributor list.
+    for pr in plugin_results:
+        if not isinstance(pr.result, _OverrideResult):
+            continue
+        types_seen: set[str] = set()
+        for target in pr.result.targets:
+            kind = target.type
+            label = kind.name if hasattr(kind, "name") else str(kind)
+            types_seen.add(label)
+        for label in types_seen:
+            metrics.plugin_override_active.labels(
+                plugin_id=pr.plugin_id, stage=stage, override_type=label
+            ).set(1)
+
+
+def _emit_clamps_and_rejects(
+    metrics: PluginFrameworkMetrics,
+    *,
+    stage: str,
+    outcome: MergeOutcome,
+    plugin_results: list,
+) -> None:
+    """Surface ``type_aware_merge`` clamp + reject events as
+    RECONCILE/CONSTRAIN behaviour counters.
+
+    - ``reconcile_clamped_total`` / ``constrain_capped_total`` fire once
+      per clamp event (one per ``(key, direction)`` tuple), labelled by
+      component + winning plugin source. PROPOSE-stage clamps are NOT
+      counted — they're ordinary merge math, not "something overrode the
+      recommendation". Only RECONCILE and CONSTRAIN get the counter.
+    - ``reject_short_circuited_total`` fires once per pipeline stage
+      that short-circuited on a REJECT, labelled by the rejecting
+      plugin_id. Called even if the caller then bails on the stage —
+      the counter tracks "REJECT happened", independent of what the
+      orchestrator does next.
+    """
+    from dynamo.planner.plugins.types import RejectResult as _RejectResult
+
+    # -- clamp counters ----------------------------------------------------
+    clamp_counter = None
+    if stage == "reconcile":
+        clamp_counter = metrics.reconcile_clamped_total
+    elif stage == "constrain":
+        clamp_counter = metrics.constrain_capped_total
+    if clamp_counter is not None and outcome.clamped:
+        for key, _direction, source in outcome.clamped:
+            clamp_counter.labels(
+                sub_component_type=key.sub_component_type,
+                source=source,
+            ).inc()
+
+    # -- reject counter (any stage) ----------------------------------------
+    if outcome.short_circuited:
+        for pr in plugin_results:
+            if isinstance(pr.result, _RejectResult):
+                metrics.reject_short_circuited_total.labels(
+                    plugin_id=pr.plugin_id
+                ).inc()
+
+
+async def run_pipeline(
+    *,
+    ctx: PipelineContext,
+    scheduler: PluginScheduler,
+    circuit_breaker: CircuitBreaker,
+    baseline: Mapping[ComponentKey, int],
+    clock: Clock,
+    tick_now: float,
+    tick_max_duration_seconds: float,
+    metrics: Optional[PluginFrameworkMetrics] = None,
+) -> PipelineOutcome:
+    """Run one tick through the 4 stages and return a PipelineOutcome.
+
+    Args:
+        ctx: Initial PipelineContext (observations / request_id / decision_id).
+        scheduler: PluginScheduler; provides the active set per stage
+            and records OverrideResult for HOLD_LAST inheritance.
+        circuit_breaker: CircuitBreaker; records success/failure
+            transitions driven by plugin call outcomes here.
+        baseline: Current replicas per ComponentKey — fed to every
+            ``type_aware_merge`` call for recommendation fallback and
+            AT_LEAST/AT_MOST clamping.
+        clock: Used only for the whole-tick deadline guard.
+        tick_now: Monotonic timestamp the active set + record_result use
+            for "due" detection and HOLD_LAST cache age.
+        tick_max_duration_seconds: Outermost deadline — wraps the entire
+            4-stage pipeline in a single ``asyncio.wait_for``. Per-stage
+            plugins each enforce their own deadline inside
+            ``PluginTransport.call``.
+    """
+
+    async def _body() -> PipelineOutcome:
+        audit: list[str] = []
+        current_ctx = ctx
+
+        # ---- PREDICT stage (priority-ascending chain) ----
+        predict_active = scheduler.compute_active_set(
+            tick_now, "predict", ctx=current_ctx
+        )
+        predict_adapters: list[PredictPluginCallable] = [
+            _PredictAdapter(
+                p,
+                metrics=metrics,
+                clock=clock,
+                scheduler=scheduler,
+                tick_now=tick_now,
+                circuit_breaker=circuit_breaker,
+            )
+            for p in predict_active.triggered
+        ]
+        ca = await chain_augment(predict_adapters, current_ctx)
+        # Refresh circuit_state gauge for predict plugins (fan-out
+        # helper does this for other stages).
+        if metrics is not None:
+            _set_circuit_state(metrics, predict_active.triggered, circuit_breaker)
+        if ca.chain_break_warnings:
+            audit.extend(ca.chain_break_warnings)
+        if ca.prediction is not None:
+            current_ctx = current_ctx.model_copy(update={"predictions": ca.prediction})
+
+        # ---- PROPOSE stage ----
+        propose, propose_plugin_results = await _run_fanout_stage(
+            stage="propose",
+            scheduler=scheduler,
+            circuit_breaker=circuit_breaker,
+            ctx=current_ctx,
+            baseline=baseline,
+            tick_now=tick_now,
+            set_allowed=True,
+            clock=clock,
+            metrics=metrics,
+        )
+        if propose.short_circuited:
+            return PipelineOutcome(
+                execute_action="skip_short_circuit",
+                final_proposal=None,
+                short_circuit_reason=propose.short_circuit_reason,
+                predict_outcome=ca,
+                propose_outcome=propose,
+                audit_events=audit,
+            )
+        if propose.proposal is not None:
+            current_ctx = current_ctx.model_copy(update={"proposal": propose.proposal})
+
+        # ---- RECONCILE stage ----
+        # Baseline flows from PROPOSE's output. Per-plugin PROPOSE
+        # results are threaded into ReconcileStageRequest.proposals so
+        # custom reconcile plugins can arbitrate per-proposal (rather
+        # than only seeing the post-merge ctx.proposal).
+        reconcile_baseline = _proposal_to_baseline(propose.proposal, baseline)
+        propose_proposals = [_to_propose_result(pr) for pr in propose_plugin_results]
+        reconcile, _ = await _run_fanout_stage(
+            stage="reconcile",
+            scheduler=scheduler,
+            circuit_breaker=circuit_breaker,
+            ctx=current_ctx,
+            baseline=reconcile_baseline,
+            tick_now=tick_now,
+            set_allowed=True,
+            clock=clock,
+            metrics=metrics,
+            propose_results=propose_proposals,
+        )
+        if reconcile.short_circuited:
+            return PipelineOutcome(
+                execute_action="skip_short_circuit",
+                final_proposal=None,
+                short_circuit_reason=reconcile.short_circuit_reason,
+                predict_outcome=ca,
+                propose_outcome=propose,
+                reconcile_outcome=reconcile,
+                audit_events=audit,
+            )
+        if reconcile.proposal is not None:
+            current_ctx = current_ctx.model_copy(
+                update={"proposal": reconcile.proposal}
+            )
+
+        # ---- CONSTRAIN stage ----
+        # Baseline flows from RECONCILE's output.
+        constrain_baseline = _proposal_to_baseline(reconcile.proposal, baseline)
+        constrain, _ = await _run_fanout_stage(
+            stage="constrain",
+            scheduler=scheduler,
+            circuit_breaker=circuit_breaker,
+            ctx=current_ctx,
+            baseline=constrain_baseline,
+            tick_now=tick_now,
+            set_allowed=False,
+            clock=clock,
+            metrics=metrics,
+        )
+        if constrain.short_circuited:
+            return PipelineOutcome(
+                execute_action="skip_short_circuit",
+                final_proposal=None,
+                short_circuit_reason=constrain.short_circuit_reason,
+                predict_outcome=ca,
+                propose_outcome=propose,
+                reconcile_outcome=reconcile,
+                constrain_outcome=constrain,
+                audit_events=audit,
+            )
+
+        # ---- EXECUTE decision ----
+        final = constrain.proposal
+        if final is None or not final.targets:
+            # Empty targets is an explicit skip + audit (do NOT silently
+            # apply an empty proposal — operators need the signal).
+            audit.append("execute_skipped_no_targets")
+            return PipelineOutcome(
+                execute_action="skip_no_targets",
+                final_proposal=final,
+                predict_outcome=ca,
+                propose_outcome=propose,
+                reconcile_outcome=reconcile,
+                constrain_outcome=constrain,
+                audit_events=audit,
+            )
+
+        return PipelineOutcome(
+            execute_action="apply",
+            final_proposal=final,
+            predict_outcome=ca,
+            propose_outcome=propose,
+            reconcile_outcome=reconcile,
+            constrain_outcome=constrain,
+            audit_events=audit,
+        )
+
+    # Outermost safety deadline — this is the ONLY asyncio.wait_for in
+    # this module, and it wraps the entire pipeline, not a single stage.
+    try:
+        # tick_duration_seconds histogram — measured around the outer
+        # wait_for so it includes every stage + the timeout machinery
+        # itself (matches what operators see as "tick cost").
+        tick_start = clock.monotonic()
+        try:
+            outcome = await asyncio.wait_for(_body(), timeout=tick_max_duration_seconds)
+        finally:
+            if metrics is not None:
+                metrics.tick_duration_seconds.observe(
+                    max(0.0, clock.monotonic() - tick_start)
+                )
+        return outcome
+    except asyncio.TimeoutError:
+        if metrics is not None:
+            metrics.tick_timeout_total.inc()
+        log.warning(
+            "pipeline: tick exceeded tick_max_duration_seconds=%.2f",
+            tick_max_duration_seconds,
+        )
+        return PipelineOutcome(
+            execute_action="skip_tick_timeout",
+            final_proposal=None,
+            short_circuit_reason=(
+                f"tick_max_duration_seconds={tick_max_duration_seconds:.2f}"
+            ),
+            audit_events=["tick_timeout_total"],
+        )
+
+
+# Re-exports that help tests / readers avoid pulling from both merge types.
+_ = (AcceptResult, RejectResult, ScalingProposal, PipelineContext, ComponentTarget)
+
+
+__all__ = [
+    "PipelineOutcome",
+    "run_pipeline",
+]
diff --git a/components/src/dynamo/planner/plugins/proto/__init__.py b/components/src/dynamo/planner/plugins/proto/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/proto/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/plugins/proto/v1/README.md b/components/src/dynamo/planner/plugins/proto/v1/README.md
new file mode 100644
index 000000000000..ddcd4cb158f9
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/proto/v1/README.md
@@ -0,0 +1,237 @@
+# Plugin Proto v1
+
+Plugin RPC contract for the Dynamo Planner plugin framework.
+
+This directory contains:
+
+| File | Purpose | Status |
+|---|---|---|
+| `plugin.proto` | Single-source-of-truth proto3 schema | tracked |
+| `plugin_pb2.py` | Generated protobuf Python stubs | tracked (regenerate locally when editing `plugin.proto` — see "Generation" below) |
+| `plugin_pb2_grpc.py` | Generated gRPC client/server stubs | tracked (same as `plugin_pb2.py`) |
+| `plugin_pb2.pyi` | Generated type stubs for IDE / mypy | tracked |
+| `__init__.py` | Module marker | tracked |
+
+## Schema overview
+
+Total: **6 services / 33 messages / 3 enums**
+
+### Services
+
+| Service | RPCs | Owner |
+|---|---|---|
+| `PluginRegistry` | `Register` / `Heartbeat` / `Unregister` / `ListPlugins` | Orchestrator-side; plugins call to register / report liveness |
+| `PluginLifecycle` | `Bootstrap` / `Reset` | Plugin-side; orchestrator calls to prime / clear plugin state |
+| `PredictPlugin` | `Predict` | Plugin-side; chain-augment partial-merge per PREDICT spec |
+| `ProposePlugin` | `Propose` | Plugin-side; type-aware merge per PROPOSE spec |
+| `ReconcilePlugin` | `Reconcile` | Plugin-side; type-aware merge per RECONCILE spec |
+| `ConstrainPlugin` | `Constrain` | Plugin-side; type-aware merge (set_allowed=False) per CONSTRAIN spec |
+
+### Enums
+
+| Enum | Values | Notes |
+|---|---|---|
+| `HoldPolicy` | `ACCEPT_WHEN_IDLE` (0) / `HOLD_LAST` (1) | Default 0 = no opinion between invocations |
+| `OverrideType` | `SET` (0) / `AT_LEAST` (1) / `AT_MOST` (2) | Used in `ComponentTarget.type` |
+| `CircuitState` | `CLOSED` (0) / `OPEN` (1) / `HALF_OPEN` (2) | Used in `PluginInfo.circuit_state` |
+
+### Messages — by category
+
+- **PluginRegistry**: `RegisterRequest` / `RegisterResponse` / `HeartbeatRequest` / `HeartbeatResponse` / `UnregisterRequest` / `UnregisterResponse` / `ListPluginsRequest` / `ListPluginsResponse` / `PluginInfo`
+- **PipelineContext + observation**: `PipelineContext` / `ObservationData` / `TrafficMetrics` / `FpmData` / `WorkerState` / `PredictionData` / `ScalingProposal` / `ComponentTarget` / `OverrideResult` / `AcceptResult` / `RejectResult`
+- **Stage request/response**: `PredictStageRequest` / `PredictStageResponse` / `ProposeStageRequest` / `ProposeStageResponse` / `ProposeResult` / `ReconcileStageRequest` / `ReconcileStageResponse` / `ConstrainStageRequest` / `ConstrainStageResponse`
+- **PluginLifecycle**: `BootstrapRequest` / `BootstrapResponse` / `ResetRequest` / `ResetResponse`
+
+## Generation
+
+Generated stubs (`plugin_pb2.py`, `plugin_pb2_grpc.py`, `plugin_pb2.pyi`)
+are **checked into git** so that test/build environments don't need
+`grpcio-tools` installed just to import the module. The repo-wide
+`.gitignore` excludes `*_pb2.py` / `*_pb2.pyi` for other consumers; the
+planner stubs are explicitly negated with `!components/src/dynamo/planner/plugins/proto/v1/*`.
+
+Regenerate locally when you edit `plugin.proto`:
+
+```bash
+# Regenerate all three stubs (run from components/src/)
+cd components/src
+python -m grpc_tools.protoc \
+    --python_out=. --grpc_python_out=. --pyi_out=. --proto_path=. \
+    dynamo/planner/plugins/proto/v1/plugin.proto
+
+# protoc strips the SPDX header — re-prepend on the two .py files so
+# copyright-checks pass. (.pyi is exempt by file-type already.)
+SPDX=$'# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.\n# SPDX-License-Identifier: Apache-2.0\n'
+for f in dynamo/planner/plugins/proto/v1/plugin_pb2.py \
+         dynamo/planner/plugins/proto/v1/plugin_pb2_grpc.py; do
+  printf '%s%s' "$SPDX" "$(cat "$f")" > "$f"
+done
+```
+
+**Workflow status**: PR #1 does NOT ship a wrapper script or CI
+drift-catching step. The proposed `tools/build/gen_planner_proto.sh`
+(and a `planner-build --check` job that diffs regenerated stubs against
+committed ones) is deferred to a follow-up build infra PR.
+
+Until then, developers who edit `plugin.proto` are responsible for
+running the protoc command above, committing the regenerated stubs,
+and (separately) updating the Pydantic mirror in `plugins/types.py`.
+The two `test_class_coverage_*` round-trip tests catch missing Pydantic
+mirrors at CI time; they do NOT catch a stale `plugin_pb2.py` against
+an updated `plugin.proto` (the drift-catching CI step is deferred).
+
+## Schema evolution policy (proto3, must-follow)
+
+1. **NEVER reuse a field tag** — always add `reserved` for any deleted tag
+2. **NEVER change the type** of an existing field
+3. **NEVER rename** an existing field (clients may key on field names via
+   reflection / JSON transcoding)
+4. **ALL new fields MUST be optional** or have safe-zero defaults
+5. **Bumping `protocol_version`** (in `RegisterRequest.protocol_version`)
+   is reserved for *additive* contract changes; *breaking* changes require
+   a new package path (`v2/`)
+
+These rules are enforced by reviewer judgment + the round-trip test suite
+in `tests/plugins/proto/test_round_trip.py` (any new message added to the
+proto must be added to the Pydantic mirror in `plugins/types.py`, otherwise
+`test_class_coverage_proto_side` fails CI).
+
+## Critical schema invariants (v11 review)
+
+These are not mere conventions — they are required by downstream PR
+algorithms; violating them silently breaks the architecture.
+
+### `PredictionData` fields MUST be `optional float`
+
+```proto
+message PredictionData {
+  optional float predicted_num_req = 1;  // unset → preserve prev in chain-augment
+  optional float predicted_isl     = 2;
+  optional float predicted_osl     = 3;
+  string source                    = 4;
+}
+```
+
+PR 4 chain-augment partial-merge uses `HasField()` to distinguish:
+
+- `field set` → plugin actively asserts this value (even `0.0`)
+- `field unset` → plugin has no opinion; preserve previous chain plugin's value
+
+Without `optional`, proto3 default `0.0` makes "I assert 0" indistinguishable
+from "I have no opinion", breaking the layered-predictor pattern documented
+in DEP main doc (e.g. `user-llm-predictor` outputs `(num_req=1200)`, leaving
+`isl` / `osl` from the upstream `builtin-load-predictor`).
+
+### CONSTRAIN `SET` is silently dropped at runtime (NOT register-time rejected)
+
+```proto
+message ConstrainStageResponse {
+  oneof result { ... }
+  bool final = 4;  // SILENTLY IGNORED
+}
+```
+
+v11 decision: `ConstrainStageResponse.override` carrying `OverrideType.SET`
+is silently dropped at runtime; `final=true` is silently ignored.
+Register-time static rejection is infeasible because proto3 has no
+plugin-self-declared output-type metadata.
+
+If your CONSTRAIN plugin needs to "win", tighten the bound:
+- larger `AT_LEAST` (raises floor)
+- smaller `AT_MOST` (lowers ceiling)
+
+`max` / `min` monotonicity guarantees your bound always participates.
+
+### `result` oneof empty = silent ACCEPT (graceful degradation)
+
+For `Propose` / `Reconcile` / `Constrain` stage responses,
+`WhichOneof("result")` returning `None` is treated as **silent ACCEPT**:
+the plugin's response is dropped from the merge, a WARNING is logged, and
+`plugin_evaluations_total{result="error"}` is incremented. The circuit
+breaker is **not** tripped (only transport errors / timeouts trip it).
+
+This aligns with the DEP main-doc invariant that plugins missing required
+input data MUST return ACCEPT to enable graceful degradation rather than
+escalating into a failure.
+
+Plugin authors who want to explicitly abstain should set
+`accept=AcceptResult()` — but proto3 cannot distinguish "explicit empty
+`AcceptResult`" from "no oneof field set" on the wire (both produce zero
+field tags), so the orchestrator treats the two identically. The
+`{result="error"}` counter is the signal a plugin author should watch
+when investigating whether their plugin is correctly setting the oneof.
+
+### `final=true` semantics differ between PREDICT and PROPOSE/RECONCILE
+
+| Stage | `final=true` rule |
+|---|---|
+| `PROPOSE` / `RECONCILE` | priority number smallest (= highest priority) wins |
+| `PREDICT` (chain-augment) | first `final=true` in chain wins (chain ordered priority-ascending → smallest priority number runs first; partial-merge is first-writer-wins, so smallest priority is effectively most authoritative) |
+
+**Convention for PREDICT**: `final=true` is most commonly used as "my
+answer is enough; skip all remaining plugins". With ascending priority
+sort the authoritative plugin always runs first, so the cleanest way
+to express that intent is to set `final=true` on the smallest-priority
+plugin.
+
+When `final=true` comes from a non-lowest-priority plugin, the chain
+still breaks at that plugin: the smallest-priority plugin has already
+weighed in (its values are protected by first-writer-wins regardless),
+but larger-priority-number plugins after the final-setter are skipped.
+They lose the chance to populate fields earlier plugins left as `None`.
+This may be **intentional** (e.g. a policy plugin saying "skip the
+expensive fallback for this scenario") or a **configuration mistake**;
+`chain_augment` cannot tell which from the response alone. To surface
+the event for operator audit, `chain_augment` logs a `WARNING` and
+records the message on `ChainAugmentOutcome.chain_break_warnings`
+(surfaced via `PipelineOutcome.audit_events`). A Prometheus counter
+for this signal is deferred to a follow-up observability PR.
+
+### `final=true` does NOT skip CONSTRAIN
+
+Even when a `PROPOSE` / `RECONCILE` plugin sets `final=true`, the CONSTRAIN
+stage runs normally. `builtin-budget-constrain` always provides
+`AT_LEAST(min_endpoint)` + `AT_MOST(max_gpu_budget)` as the safety net; no
+`final` can bypass it.
+
+### REJECT > final priority
+
+If any plugin returns `RejectResult` in the same stage, the entire stage
+short-circuits — even when `final=true` plugins are also present. This
+matches K8s admission controller `deny > allow` semantics: safety override
+is higher priority than authority override.
+
+## Adding a new stage / RPC / message
+
+1. Edit `plugin.proto` following the schema evolution policy above
+2. Add corresponding Pydantic mirror class in `plugins/types.py`
+3. Register `(Pydantic, proto)` pair in `_PYD_TO_PROTO` dict in
+   `plugins/_proto_bridge.py`
+4. Add a round-trip test case in `tests/plugins/proto/test_round_trip.py`
+5. Regenerate stubs locally with the protoc command in "Generation"
+   above (don't forget the SPDX re-prepend step) — the generated
+   `plugin_pb2.py` / `plugin_pb2_grpc.py` / `plugin_pb2.pyi` are
+   **checked into git**, so this also produces the diff you need to commit
+6. Run `pytest dynamo/planner/tests/plugins/proto/` — both
+   `test_class_coverage_*` tests catch missing mirror / converter; all
+   round-trip cases must still pass
+7. Commit `plugin.proto` + regenerated stubs + Pydantic mirror + test
+   case in the same PR
+
+## FPM `bytes` field encoding
+
+`FpmData.prefill_engines` / `decode_engines` are `map<string, bytes>`. Each
+value is a **msgspec/msgpack-encoded** `ForwardPassMetrics` record (see
+`dynamo.common.forward_pass_metrics`). Wire format is standard msgpack, so
+cross-language plugins decode with any msgpack library (Go's
+vmihailenco/msgpack, Rust's rmp-serde, JS @msgpack/msgpack, etc.) plus
+knowledge of the `ForwardPassMetrics` struct layout.
+
+The orchestrator currently does not populate this field; FPM wiring into
+`PipelineContext.observations.fpm` lands in a follow-up PR.
+
+## References
+
+- `dynamo/planner/plugins/types.py` — Pydantic v2 mirror
+- `dynamo/planner/plugins/_proto_bridge.py` — bidirectional converter
+- `tests/plugins/proto/test_round_trip.py` — equivalence + lock-step tests
diff --git a/components/src/dynamo/planner/plugins/proto/v1/__init__.py b/components/src/dynamo/planner/plugins/proto/v1/__init__.py
new file mode 100644
index 000000000000..03c6245b0a8c
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/proto/v1/__init__.py
@@ -0,0 +1,90 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""Generated protobuf stubs for the planner plugin protocol v1.
+
+The ``plugin_pb2.py``, ``plugin_pb2_grpc.py``, and ``plugin_pb2.pyi``
+modules in this directory are generated from ``plugin.proto`` and
+**checked into git** so test/build images don't need ``grpcio-tools``
+just to import the package. When you edit ``plugin.proto`` regenerate
+with the protoc command in ``README.md`` (and re-prepend the SPDX header).
+A drift-catching CI check is deferred to a follow-up build infra PR.
+"""
+
+# ---------------------------------------------------------------------------
+# Collection-time compatibility shim.
+#
+# CI's pre-commit ``pytest-marker-report`` collects test modules without
+# running their bodies. Several tests import ``plugin_pb2`` /
+# ``plugin_pb2_grpc`` at module top via ``from
+# dynamo.planner.plugins.proto.v1 import plugin_pb2``. When the generated
+# stubs are *not on disk* (which is the case in a fresh pre-commit virtualenv
+# that hasn't yet executed the container build's ``protoc`` step), that
+# import raises ``ImportError`` and the test fails *collection*, taking the
+# whole hook down with it even though no test body would have run.
+#
+# Provide empty module-shaped placeholders in ``sys.modules`` so the
+# ``from . import plugin_pb2`` attribute lookup succeeds at collection time.
+# These shims are NEVER reached at runtime in any normal deployment because:
+#   1. Production containers regenerate plugin_pb2 at install time before
+#      Python starts → ``importlib.import_module`` succeeds → the real
+#      modules are placed in sys.modules first → our shim block is a no-op.
+#   2. Developer local runs require the same regen via ``README.md`` protoc
+#      command before tests can pass; the shim only patches the
+#      *collection* import-path for ``--collect-only`` invocations.
+import importlib
+import sys
+import types as _types
+
+
+class _PlaceholderModule(_types.ModuleType):
+    """Module placeholder whose attribute lookups synthesize a dummy
+    class on demand. Lets ``_proto_bridge`` 's module-top lookup table
+    (``pb.RegisterRequest`` etc.) survive collection-time import even
+    when the generated proto stubs aren't on disk. Attempting to
+    *use* one of the dummy classes at runtime gives a useful error
+    message pointing at the missing ``protoc`` step.
+    """
+
+    def __getattr__(self, name: str):  # type: ignore[no-untyped-def]
+        if name.startswith("__") and name.endswith("__"):
+            raise AttributeError(name)
+        msg = (
+            f"{self.__name__}.{name} not available — generated proto stub "
+            "missing. Run protoc per components/src/dynamo/planner/plugins/"
+            "proto/v1/README.md to generate plugin_pb2.py / plugin_pb2_grpc.py."
+        )
+        dummy = type(name, (), {"__init__": lambda self, *a, **kw: (_ for _ in ()).throw(RuntimeError(msg))})  # type: ignore[arg-type]
+        dummy.__module__ = self.__name__
+        # Cache so identity holds for repeated attribute access.
+        setattr(self, name, dummy)
+        return dummy
+
+
+for _stub_name in ("plugin_pb2", "plugin_pb2_grpc"):
+    _fq = f"{__name__}.{_stub_name}"
+    if _fq in sys.modules:
+        continue
+    try:
+        importlib.import_module(_fq)
+    except (ImportError, AttributeError):
+        # Two failure modes both land us here:
+        #   - ImportError: generated stub not on disk yet (pre-protoc env)
+        #   - AttributeError: stub IS on disk but its module-top code
+        #     (e.g. ``GRPC_VERSION = grpc.__version__`` in plugin_pb2_grpc.py)
+        #     crashes because grpc/protobuf are themselves stubbed by
+        #     pytest-marker-report's ``--collect-only`` runner, which
+        #     strips dunder attributes from stubbed modules.
+        # In either case install a placeholder so ``from <pkg> import
+        # plugin_pb2`` succeeds at collection time AND the
+        # ``_proto_bridge`` module-top lookup table can resolve attributes
+        # like ``plugin_pb2.RegisterRequest`` (synthesised on demand by
+        # ``_PlaceholderModule.__getattr__``).
+        _placeholder = _PlaceholderModule(_fq)
+        _placeholder.__doc__ = (
+            f"Pre-generation placeholder for {_fq}. Run protoc per "
+            "``components/src/dynamo/planner/plugins/proto/v1/README.md`` "
+            "to generate the real module."
+        )
+        sys.modules[_fq] = _placeholder
+
+del importlib, sys, _types, _stub_name, _fq
diff --git a/components/src/dynamo/planner/plugins/proto/v1/plugin.proto b/components/src/dynamo/planner/plugins/proto/v1/plugin.proto
new file mode 100644
index 000000000000..3b931e2d73fe
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/proto/v1/plugin.proto
@@ -0,0 +1,591 @@
+// SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Plugin contract for Dynamo Planner Plugin Architecture.
+//
+// **Schema evolution policy** (proto3, must-follow):
+//   1. NEVER reuse a field tag — add `reserved` for any deleted tag.
+//   2. NEVER change the type of an existing field.
+//   3. NEVER rename an existing field (clients may key on field names in
+//      reflection / json transcoding).
+//   4. ALL new fields MUST be optional or have safe-zero defaults.
+//   5. Bumping `protocol_version` (RegisterRequest.protocol_version) is
+//      reserved for *additive* contract changes; *breaking* changes
+//      require a new package path (v2/).
+//
+// Layout follows dynamo convention (proto in src tree, generated stubs
+// alongside; see `lib/llm/src/grpc/protos/` for parallel example).
+
+syntax = "proto3";
+
+package dynamo.planner.plugin.v1;
+
+// ============================================================================
+// PluginRegistry service
+// ============================================================================
+
+service PluginRegistry
+{
+  rpc Register(RegisterRequest) returns (RegisterResponse);
+  rpc Heartbeat(HeartbeatRequest) returns (HeartbeatResponse);
+
+  // Plugin gracefully announces shutdown; orchestrator immediately removes
+  // it from active set and clears its HOLD_LAST cache (without waiting for
+  // missed_heartbeat threshold).
+  rpc Unregister(UnregisterRequest) returns (UnregisterResponse);
+
+
+  // Admin / observability: returns metadata of all registered plugins
+  // (builtin and user) plus runtime state (circuit breaker, cache age,
+  // evaluation counts). Authorization typically gated by an admin RBAC
+  // distinct from plugin Register auth.
+  rpc ListPlugins(ListPluginsRequest) returns (ListPluginsResponse);
+}
+
+message RegisterRequest
+{
+  string plugin_id = 1;
+  string plugin_type = 2;                // "predict" | "propose" | "reconcile" | "constrain"
+  uint32 priority = 3;                   // lower number = higher priority
+  string endpoint = 4;                   // inproc://<id> | grpc://host:port
+  string version = 5;                    // plugin's own semver
+  float execution_interval_seconds = 6;  // 0 = every tick (default)
+  HoldPolicy hold_policy = 7;
+
+  // Capability subscription: dot-paths into PipelineContext that this plugin
+  // actually consumes. When non-empty, the orchestrator MAY trim the
+  // context to those fields to save wire / serialisation cost — best-
+  // effort; it must never break the contract. Empty and unset are
+  // indistinguishable on the wire (proto3 ``repeated`` has no field
+  // presence) and both mean "send full context" (the safe default).
+  repeated string needs = 8;
+
+  // Protocol versioning: orchestrator keeps a supported range
+  // [min_supported, max_supported]. Out-of-range -> reject with reason
+  // "protocol_version_unsupported".
+  string protocol_version = 9;  // e.g. "1.0"
+
+  // Authentication token. Must validate against one of the
+  // configured trusted_sources (k8s SA token / SPIFFE JWT / static secret).
+  // If no source is configured, all Register calls are rejected.
+  string auth_token = 10;
+
+  // Tags 11 and 12 were used by prior drafts (`fpm_encoding` at 11; a
+  // per-plugin `request_timeout_seconds` override at 12). Both were
+  // never plumbed into the orchestrator — the per-plugin timeout in
+  // particular was stored on RegisteredPlugin but never read by
+  // make_transport_for_endpoint, which only honoured the global
+  // TransportConfig.request_timeout_seconds. Removed before any client
+  // shipped a v1 implementation. Reserved per the schema-evolution
+  // policy (NEVER reuse a deleted tag). A future PR may re-introduce a
+  // per-plugin timeout at a new tag with the missing plumbing.
+  reserved 11, 12;
+
+  // Fire-gating dependencies (scale_interval cadence model). Plugin only
+  // fires this tick if every listed dot-path resolves to a non-None value
+  // in the current PipelineContext. Used to chain throttled plugins, e.g.
+  // ``throughput_propose`` declaring ``requires_produced_fields=
+  // ["predictions"]`` skips its turn whenever ``predict_load`` didn't
+  // produce predictions on the same tick (preventing stale-input fire).
+  //
+  // Empty/unset = no gating (plugin fires whenever its own
+  // ``execution_interval_seconds`` throttle permits).
+  repeated string requires_produced_fields = 13;
+
+  // Observation aggregation window (scale_interval cadence model). For
+  // each observation type listed in ``needs`` that supports time-windowed
+  // aggregation (currently ``observations.traffic``), this declares how
+  // much history the plugin wants Prometheus to aggregate over.
+  //
+  // 0.0 (default) — observation taken with ``scale_interval`` window
+  //                 (per-tick freshness, matches the pipeline cadence).
+  // N > 0         — Prometheus query uses ``[Ns]`` window; aggregated
+  //                 value (avg / sum) covers the last N seconds of source
+  //                 data. Plugin sees ``ctx.observations.<type>
+  //                 .duration_s == N``.
+  //
+  // Constraint: must be 0 OR a positive multiple of
+  // ``SchedulingConfig.scale_interval_seconds`` so windows align to tick
+  // boundaries. Validator rejects otherwise. Field is silently ignored
+  // when the plugin's ``needs`` does not list any windowed observation
+  // type (a config validator may warn on this combination).
+  float observation_window_seconds = 14;
+}
+
+enum HoldPolicy {
+  ACCEPT_WHEN_IDLE = 0;  // treat as no opinion between invocations
+  HOLD_LAST = 1;         // replay last result until next invocation
+}
+
+message RegisterResponse
+{
+  bool accepted = 1;
+  string reject_reason = 2;
+  // Echo back the negotiated protocol_version so the plugin can confirm
+  // (relevant when orchestrator supports multiple major versions).
+  string negotiated_protocol_version = 3;
+}
+
+// Plugin pushes heartbeats every `heartbeat_timeout_seconds / 3` (approx 5s
+// by default). 2 consecutive misses -> orchestrator evicts plugin from
+// scheduling and clears its HOLD_LAST cache.
+//
+// HeartbeatMonitor skips checks for transport_type == "in_process"
+// (NOT based on is_builtin) — otherwise in_process user plugin would be
+// evicted immediately for not sending heartbeat.
+message HeartbeatRequest
+{
+  string plugin_id = 1;
+  // Caller-supplied auth token. Gateway re-validates via the same
+  // AuthValidator used for Register and checks that the resulting
+  // identity.subject matches the subject captured at Register time —
+  // i.e. only the entity that registered this plugin_id can heartbeat
+  // for it. Empty token rejected over gRPC (UNAUTHENTICATED).
+  string auth_token = 2;
+}
+message HeartbeatResponse
+{
+  bool ok = 1;
+}
+
+message UnregisterRequest
+{
+  string plugin_id = 1;
+  string reason = 2;  // optional; for audit log e.g. "graceful_shutdown" / "version_upgrade"
+  // Same auth contract as HeartbeatRequest.auth_token — gateway requires
+  // a token whose validated subject matches the plugin's Register-time
+  // subject. Admin-driven force-evict (subject-bypass) is reserved for
+  // a follow-up PR that wires AdminAuthConfig.
+  string auth_token = 3;
+}
+message UnregisterResponse
+{
+  bool ok = 1;
+}
+
+message ListPluginsRequest
+{
+  // Optional filters
+  string stage_filter = 1;    // "" = all; "predict" / "propose" / etc.
+  bool include_disabled = 2;  // include enabled=false plugins
+}
+message ListPluginsResponse
+{
+  repeated PluginInfo plugins = 1;
+}
+
+message PluginInfo
+{
+  string plugin_id = 1;
+  string plugin_type = 2;  // "predict" | "propose" | "reconcile" | "constrain"
+  uint32 priority = 3;
+  string version = 4;
+  string protocol_version = 5;
+  bool enabled = 6;      // current enabled state (config + runtime overrides)
+  bool is_builtin = 7;   // true for builtin-* plugins
+  string transport = 8;  // "in_process" | "uds" | "grpc"
+  CircuitState circuit_state = 9;
+  uint64 evaluations_total = 10;  // total Run/Predict/Propose/.. RPC count since register
+  double last_call_at_seconds_ago = 11;
+  double cache_age_seconds = 12;  // 0 if not in HOLD_LAST state
+}
+
+enum CircuitState {
+  CLOSED = 0;
+  OPEN = 1;
+  HALF_OPEN = 2;
+}
+
+// ============================================================================
+// Pipeline context (flows through all stages)
+//
+// Observation types are isomorphic to the existing TickInput boundary types
+// in components/src/dynamo/planner/core/types.py. FPM data is passed in its
+// native msgspec encoding to avoid duplicating the ForwardPassMetrics schema.
+// ============================================================================
+
+message PipelineContext
+{
+  // request_id: per-tick orchestrator trace id. All plugin RPCs in the same
+  // pipeline tick (PREDICT through CONSTRAIN) share the same request_id;
+  // used for stitching audit logs and distributed traces.
+  string request_id = 1;
+
+  // decision_id: assigned by RECONCILE when it produces a non-empty proposal,
+  // and stays the same through CONSTRAIN and EXECUTE. Different from
+  // request_id because not every tick produces a decision (e.g. all plugins
+  // returned ACCEPT, or REJECT short-circuit). Used to correlate
+  // ScaleRequest / ScaleResponse, EXECUTE outcomes, and rollback audit.
+  string decision_id = 2;
+
+  optional ObservationData observations = 3;  // filled by OBSERVE
+  optional PredictionData predictions = 4;    // filled by PREDICT (or built-in fallback)
+  // proposal/constrained carry one ComponentTarget per sub_component_type
+  // (prefill / decode / agg). Single-pool by construction in this PR;
+  // multi-pool addressing is hierarchical-planner territory and will be
+  // re-introduced when that lands.
+  optional ScalingProposal proposal = 5;     // filled by PROPOSE -> RECONCILE
+  optional ScalingProposal constrained = 6;  // filled by CONSTRAIN
+}
+
+// Mirrors TickInput (types.py)
+message ObservationData
+{
+  optional TrafficMetrics traffic = 1;
+  optional FpmData fpm = 2;
+  optional WorkerState workers = 3;
+}
+
+// Mirrors TrafficObservation (types.py)
+message TrafficMetrics
+{
+  // ``double`` (64-bit) — matches the Python float64 source of truth
+  // (TrafficObservation in core/types.py + the Pydantic mirror). A 32-bit
+  // ``float`` here would silently truncate rate-style values over gRPC,
+  // and the in-process transport (no serialization) would disagree with
+  // the gRPC transport bit-for-bit. ``double`` keeps the two transports
+  // numerically identical and honors the round-trip-equality contract.
+  double duration_s = 1;  // observation window length (seconds)
+  double num_req = 2;     // request count in window
+  double isl = 3;         // avg input sequence length
+  double osl = 4;         // avg output sequence length
+
+  // KV cache hit rate over the window, derived from prefill prompt-cache
+  // hit metrics emitted by the engine.  ``optional`` distinguishes
+  // "Prometheus returned no hit-rate datapoint" (unset) from
+  // "all-cold cache, 0.0 hit rate" (set to 0.0).  PSM throughput
+  // scaling consumes this — external throughput-propose plugins
+  // replicating PSM behaviour need it for parity.
+  optional double kv_hit_rate = 5;
+}
+
+// Mirrors FpmObservations (types.py).
+//
+// Wire format: each map value is a msgspec/msgpack-encoded
+// ForwardPassMetrics record (see ``dynamo.common.forward_pass_metrics``).
+// Cross-language plugins decode via any standard msgpack library (Go's
+// vmihailenco/msgpack, Rust's rmp-serde, JS @msgpack/msgpack, etc.) plus
+// knowledge of the ForwardPassMetrics struct layout.
+//
+// Per-engine map key format: ``"<worker_id>/<dp_rank>"`` — flat string
+// since proto3 ``map`` keys can't carry a tuple.  Engines without an
+// observation this tick are simply absent from the map; a plugin
+// declaring ``needs=["observations.fpm"]`` should treat an empty
+// submap as "no FPM data this tick" rather than an error.  When neither
+// prefill nor decode engines report, the orchestrator omits the
+// ``ObservationData.fpm`` field entirely (proto3 absent vs
+// empty-but-set is observable via ``HasField``).
+message FpmData
+{
+  map<string, bytes> prefill_engines = 1;
+  map<string, bytes> decode_engines = 2;
+}
+
+// Mirrors WorkerCounts (types.py)
+message WorkerState
+{
+  optional int32 ready_prefill = 1;
+  optional int32 ready_decode = 2;
+  optional int32 expected_prefill = 3;
+  optional int32 expected_decode = 4;
+
+  // Scaling-in-progress flags.  ``true`` when the planner has issued
+  // a scale operation that the connector has not yet observed as
+  // stable (ready == expected).  PSM load-scaling uses these to
+  // suppress further scale-up while a previous request is mid-flight
+  // and to explain "held" decisions in audit logs — external plugins
+  // replicating PSM load-scaling behaviour need parity access.
+  // ``optional`` (proto3 presence) distinguishes "not reported" from
+  // an explicit ``false`` value.
+  optional bool prefill_scaling_in_progress = 5;
+  optional bool decode_scaling_in_progress = 6;
+}
+
+// Prediction data flows through PREDICT chain-augment.
+//
+// **v11 critical**: All three prediction fields MUST be `optional float`.
+// chain-augment partial-merge (PR 4) uses `HasField()` to distinguish:
+//   - field set → plugin actively asserts this value (even if 0.0)
+//   - field unset → plugin has no opinion; preserve previous chain plugin's value
+// Without `optional`, proto3 default 0.0 makes "I assert 0" indistinguishable
+// from "I have no opinion", breaking the layered-predictor pattern documented
+// in DEP main doc line 1320.
+message PredictionData
+{
+  // ``double`` (64-bit) — see TrafficMetrics: matches the float64 source
+  // of truth and keeps in-process vs gRPC transports bit-identical.
+  optional double predicted_num_req = 1;
+  optional double predicted_isl = 2;
+  optional double predicted_osl = 3;
+  string source = 4;  // plugin_id or "builtin"
+
+  // Predicted KV cache hit rate.  ``optional`` follows the same
+  // first-writer-wins partial-merge semantic as the other predicted_*
+  // fields — ``unset`` means "no opinion, preserve previous chain
+  // plugin's value", ``set`` means "I assert this value (even 0.0)".
+  // PSM ``TickDiagnostics.predicted_kv_hit_rate`` mirrors this; external
+  // throughput-propose plugins replicating PSM behaviour need it on the
+  // wire schema for parity.
+  optional double predicted_kv_hit_rate = 5;
+}
+
+// Aligns wire format with existing ScaleRequest.target_replicas
+// (components/src/dynamo/planner/connectors/protocol.py).
+// Used as the output of RECONCILE/CONSTRAIN: each ComponentTarget's
+// `type` field is unused here (only `replicas` matters).
+message ScalingProposal
+{
+  repeated ComponentTarget targets = 1;
+  string reason = 2;
+  string source = 3;  // plugin_id or "builtin"
+}
+
+// One scaling target per component instance.
+// `sub_component_type` uses string (NOT proto enum) for parity with the
+// existing ScaleRequest wire format and to allow new engine kinds (e.g.
+// agg, AFD) without bumping the proto version.
+//
+// Allowed sub_component_type values evolve with Dynamo; current set:
+//   "prefill"  -- prefill engine
+//   "decode"   -- decode engine (also used in agg mode)
+//
+// Tag 2 was previously a per-pool ``component_name`` (forward-compat
+// surface for the hierarchical planner). Dropped because the
+// single-planner runtime in this PR has a single configured WorkerInfo
+// per sub_component_type and can never address an alternate pool —
+// shipping the field without a runtime consumer was the
+// "API advertises capability the runtime silently drops" mismatch
+// flagged in review. Re-add at the same or new tag when the
+// hierarchical planner PR lands.
+message ComponentTarget
+{
+  string sub_component_type = 1;
+  reserved 2;                   // was: optional string component_name
+  optional int32 replicas = 3;  // unset => "no opinion on this component"
+  OverrideType type = 4;        // only meaningful inside OverrideResult; ignored in ScalingProposal
+}
+
+message OverrideResult
+{
+  // Each target carries its own (component, type, replicas). One plugin
+  // can therefore say "prefill SET=10, decode AT_MOST=6" in a single RPC.
+  // Targets that the plugin has no opinion about are simply omitted.
+  repeated ComponentTarget targets = 1;
+  string reason = 2;
+}
+
+enum OverrideType {
+  SET = 0;       // "set replicas to exactly this" (recommendation; priority-resolved)
+  AT_LEAST = 1;  // "need at least this many" (floor; all values participate via max)
+  AT_MOST = 2;   // "allow at most this many" (ceiling; all values participate via min)
+}
+
+message AcceptResult {}
+message RejectResult
+{
+  string reason = 1;
+}
+
+// ============================================================================
+// Stage-specific request/response (each stage receives full PipelineContext)
+// ============================================================================
+
+service PredictPlugin
+{
+  rpc Predict(PredictStageRequest) returns (PredictStageResponse);
+}
+message PredictStageRequest
+{
+  PipelineContext context = 1;
+}
+message PredictStageResponse
+{
+  // PREDICT plugins return PredictionData (chain-augment partial merge).
+  // Omitted/unset prediction = ACCEPT (no opinion).
+  PredictionData predictions = 1;
+  string reason = 2;
+  // final=true: stop the PREDICT chain immediately; subsequent plugins
+  // in the chain are NOT called.
+  // **Chain-augment final usage convention**:
+  //   final=true is most commonly used as "my answer is enough; skip
+  //   all remaining plugins". With ascending priority sort the
+  //   authoritative plugin runs first, so the cleanest way to express
+  //   that intent is to set final=true on the smallest-priority plugin.
+  //   When final=true comes from a non-lowest-priority plugin, the
+  //   chain still breaks at that plugin: the smallest-priority plugin
+  //   has already weighed in (first-writer-wins protects its values),
+  //   but larger-priority-number plugins after the final-setter are
+  //   skipped. They lose the chance to populate fields earlier plugins
+  //   left as None. This may be intentional (cost / policy override)
+  //   or a config mistake; chain_augment cannot tell which. It logs a
+  //   WARNING and records the event on
+  //   ChainAugmentOutcome.chain_break_warnings (surfaced via
+  //   PipelineOutcome.audit_events). A Prometheus counter for this
+  //   signal is deferred to a follow-up observability PR.
+  bool final = 3;
+}
+
+service ProposePlugin
+{
+  rpc Propose(ProposeStageRequest) returns (ProposeStageResponse);
+}
+message ProposeStageRequest
+{
+  PipelineContext context = 1;
+}
+message ProposeStageResponse
+{
+  oneof result
+  {
+    AcceptResult accept = 1;
+    OverrideResult override = 2;
+    RejectResult reject = 3;
+  }
+  // final=true: this plugin's OverrideResult is the FINAL output of the
+  // PROPOSE stage—it COMPLETELY OVERRIDES all other plugins' outputs
+  // (including AT_LEAST / AT_MOST). All other plugins are STILL CALLED
+  // (preserving observability / metrics / audit), but their outputs are
+  // discarded for the merge. Multiple plugins with final=true: priority
+  // number smallest wins.
+  // Does NOT skip CONSTRAIN—the CONSTRAIN stage still runs as the safety
+  // net (with builtin-budget-constrain providing min_endpoint / max_gpu_budget).
+  // **REJECT is HIGHER priority than final** (v11 G-2): if any plugin returns
+  // RejectResult, the entire stage short-circuits regardless of final flags.
+  bool final = 4;
+}
+
+service ReconcilePlugin
+{
+  rpc Reconcile(ReconcileStageRequest) returns (ReconcileStageResponse);
+}
+message ReconcileStageRequest
+{
+  PipelineContext context = 1;
+  // All propose results from preceding stage. Reconcile plugins see the
+  // full propose set (with priority) and can reweight or filter.
+  repeated ProposeResult proposals = 2;
+}
+message ProposeResult
+{
+  string plugin_id = 1;
+  oneof result
+  {
+    AcceptResult accept = 2;
+    OverrideResult override = 3;
+    RejectResult reject = 4;
+  }
+  uint32 priority = 5;
+}
+// RECONCILE plugins return OverrideResult (same shape as ProposePlugin).
+// builtin-reconcile and user reconcile plugins all coexist; orchestrator
+// runs the type-aware merge across all RECONCILE outputs to produce the
+// final ScalingProposal.
+//
+// User reconcile plugins typically reweight or filter the propose results
+// (they see the full propose set), then output their own override-typed
+// recommendation. Priority resolves competing SETs across reconcile plugins.
+message ReconcileStageResponse
+{
+  oneof result
+  {
+    AcceptResult accept = 1;
+    OverrideResult override = 2;
+    RejectResult reject = 3;
+  }
+  // Same final semantics as ProposeStageResponse: this plugin's output
+  // completely overrides all other RECONCILE plugins' outputs in the merge,
+  // while still calling them for observability. Multiple final=true:
+  // priority number smallest wins. Does NOT skip CONSTRAIN.
+  bool final = 4;
+}
+
+service ConstrainPlugin
+{
+  rpc Constrain(ConstrainStageRequest) returns (ConstrainStageResponse);
+}
+message ConstrainStageRequest
+{
+  PipelineContext context = 1;
+}
+// CONSTRAIN plugins return OverrideResult (same shape as ProposePlugin /
+// ReconcilePlugin), but with a hard restriction on `type`:
+//   * AT_LEAST and AT_MOST are valid (they tighten the constraint).
+//   * SET is silently dropped at runtime (v11 决议: register-time static
+//     rejection is infeasible because proto3 has no plugin-self-declared
+//     output-type metadata; orchestrator cannot know in advance whether
+//     a plugin will emit SET):
+//     - At runtime, if a CONSTRAIN plugin produces SET (intentionally
+//       or via version drift), the orchestrator drops the SET entry and
+//       records the dropped component key on MergeOutcome.set_dropped
+//       (surfaced via PipelineOutcome.constrain_outcome.set_dropped);
+//       the rest of the OverrideResult is accepted. A Prometheus
+//       counter / audit event for this signal is deferred to a
+//       follow-up observability PR.
+//
+// Orchestrator merges all CONSTRAIN OverrideResults using the type-aware
+// merge algorithm (only AT_LEAST / AT_MOST participate); the resulting
+// floor / ceiling clamp the RECONCILE output per component_key.
+message ConstrainStageResponse
+{
+  oneof result
+  {
+    AcceptResult accept = 1;
+    OverrideResult override = 2;  // SET targets are silently dropped (see message comment above)
+    RejectResult reject = 3;
+  }
+  // final is SILENTLY IGNORED in CONSTRAIN stage. CONSTRAIN allows only
+  // AT_LEAST / AT_MOST, which are accumulated via max/min — there is no
+  // SET-priority competition for final to influence. Allowing final to
+  // "completely override" in CONSTRAIN would let a user plugin bypass
+  // builtin-budget-constrain, breaking the safety guarantee. To make
+  // your constrain win, simply tighten the bound (larger AT_LEAST or
+  // smaller AT_MOST) — max/min monotonicity will let you win automatically.
+  bool final = 4;
+}
+
+// ============================================================================
+// PluginLifecycle service (v10 YAGNI: only Bootstrap + Reset)
+// ============================================================================
+//
+// Snapshot/Restore are NOT part of this DEP — current code repo lacks the
+// mechanism, planner restart goes through Bootstrap to re-fit regression
+// (equivalent to cold start). proto3 add new RPC is backward-compatible;
+// future PR may add Snapshot/Restore without breaking clients.
+
+service PluginLifecycle
+{
+  // Plugin's first-call from orchestrator after Register; one-time priming
+  // (e.g. load benchmark FPM, warm regression model).
+  rpc Bootstrap(BootstrapRequest) returns (BootstrapResponse);
+
+  // Clear plugin internal state back to pre-Bootstrap; called on config
+  // reload or test setup/teardown. NOT idempotent in semantics (orchestrator
+  // guarantees single-call lifecycle).
+  rpc Reset(ResetRequest) returns (ResetResponse);
+}
+
+message BootstrapRequest
+{
+  // Generic blob; format defined by plugin itself (e.g. builtin-throughput-
+  // propose may serialize benchmark FPM into bytes).
+  bytes bootstrap_data = 1;
+
+  // Startup hints from orchestrator (e.g. "regression_kind: prefill").
+  // String-typed for flexibility; specific keys evolve with builtin plugins.
+  map<string, string> hints = 2;
+}
+message BootstrapResponse
+{
+  bool ok = 1;
+  string message = 2;  // optional; for audit / debugging
+}
+
+message ResetRequest
+{
+  string reason = 1;  // optional audit context (e.g. "config_reload" / "test_teardown")
+}
+message ResetResponse
+{
+  bool ok = 1;
+  string message = 2;
+}
diff --git a/components/src/dynamo/planner/plugins/proto/v1/plugin_pb2.py b/components/src/dynamo/planner/plugins/proto/v1/plugin_pb2.py
new file mode 100644
index 000000000000..9bd9bfc58a5d
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/proto/v1/plugin_pb2.py
@@ -0,0 +1,132 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: dynamo/planner/plugins/proto/v1/plugin.proto
+# Protobuf Python Version: 5.27.2
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    27,
+    2,
+    '',
+    'dynamo/planner/plugins/proto/v1/plugin.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n,dynamo/planner/plugins/proto/v1/plugin.proto\x12\x18\x64ynamo.planner.plugin.v1\"\xdc\x02\n\x0fRegisterRequest\x12\x11\n\tplugin_id\x18\x01 \x01(\t\x12\x13\n\x0bplugin_type\x18\x02 \x01(\t\x12\x10\n\x08priority\x18\x03 \x01(\r\x12\x10\n\x08\x65ndpoint\x18\x04 \x01(\t\x12\x0f\n\x07version\x18\x05 \x01(\t\x12\"\n\x1a\x65xecution_interval_seconds\x18\x06 \x01(\x02\x12\x39\n\x0bhold_policy\x18\x07 \x01(\x0e\x32$.dynamo.planner.plugin.v1.HoldPolicy\x12\r\n\x05needs\x18\x08 \x03(\t\x12\x18\n\x10protocol_version\x18\t \x01(\t\x12\x12\n\nauth_token\x18\n \x01(\t\x12 \n\x18requires_produced_fields\x18\r \x03(\t\x12\"\n\x1aobservation_window_seconds\x18\x0e \x01(\x02J\x04\x08\x0b\x10\x0cJ\x04\x08\x0c\x10\r\"`\n\x10RegisterResponse\x12\x10\n\x08\x61\x63\x63\x65pted\x18\x01 \x01(\x08\x12\x15\n\rreject_reason\x18\x02 \x01(\t\x12#\n\x1bnegotiated_protocol_version\x18\x03 \x01(\t\"9\n\x10HeartbeatRequest\x12\x11\n\tplugin_id\x18\x01 \x01(\t\x12\x12\n\nauth_token\x18\x02 \x01(\t\"\x1f\n\x11HeartbeatResponse\x12\n\n\x02ok\x18\x01 \x01(\x08\"J\n\x11UnregisterRequest\x12\x11\n\tplugin_id\x18\x01 \x01(\t\x12\x0e\n\x06reason\x18\x02 \x01(\t\x12\x12\n\nauth_token\x18\x03 \x01(\t\" \n\x12UnregisterResponse\x12\n\n\x02ok\x18\x01 \x01(\x08\"D\n\x12ListPluginsRequest\x12\x14\n\x0cstage_filter\x18\x01 \x01(\t\x12\x18\n\x10include_disabled\x18\x02 \x01(\x08\"L\n\x13ListPluginsResponse\x12\x35\n\x07plugins\x18\x01 \x03(\x0b\x32$.dynamo.planner.plugin.v1.PluginInfo\"\xc0\x02\n\nPluginInfo\x12\x11\n\tplugin_id\x18\x01 \x01(\t\x12\x13\n\x0bplugin_type\x18\x02 \x01(\t\x12\x10\n\x08priority\x18\x03 \x01(\r\x12\x0f\n\x07version\x18\x04 \x01(\t\x12\x18\n\x10protocol_version\x18\x05 \x01(\t\x12\x0f\n\x07\x65nabled\x18\x06 \x01(\x08\x12\x12\n\nis_builtin\x18\x07 \x01(\x08\x12\x11\n\ttransport\x18\x08 \x01(\t\x12=\n\rcircuit_state\x18\t \x01(\x0e\x32&.dynamo.planner.plugin.v1.CircuitState\x12\x19\n\x11\x65valuations_total\x18\n \x01(\x04\x12 \n\x18last_call_at_seconds_ago\x18\x0b \x01(\x01\x12\x19\n\x11\x63\x61\x63he_age_seconds\x18\x0c \x01(\x01\"\x89\x03\n\x0fPipelineContext\x12\x12\n\nrequest_id\x18\x01 \x01(\t\x12\x13\n\x0b\x64\x65\x63ision_id\x18\x02 \x01(\t\x12\x44\n\x0cobservations\x18\x03 \x01(\x0b\x32).dynamo.planner.plugin.v1.ObservationDataH\x00\x88\x01\x01\x12\x42\n\x0bpredictions\x18\x04 \x01(\x0b\x32(.dynamo.planner.plugin.v1.PredictionDataH\x01\x88\x01\x01\x12@\n\x08proposal\x18\x05 \x01(\x0b\x32).dynamo.planner.plugin.v1.ScalingProposalH\x02\x88\x01\x01\x12\x43\n\x0b\x63onstrained\x18\x06 \x01(\x0b\x32).dynamo.planner.plugin.v1.ScalingProposalH\x03\x88\x01\x01\x42\x0f\n\r_observationsB\x0e\n\x0c_predictionsB\x0b\n\t_proposalB\x0e\n\x0c_constrained\"\xe3\x01\n\x0fObservationData\x12>\n\x07traffic\x18\x01 \x01(\x0b\x32(.dynamo.planner.plugin.v1.TrafficMetricsH\x00\x88\x01\x01\x12\x33\n\x03\x66pm\x18\x02 \x01(\x0b\x32!.dynamo.planner.plugin.v1.FpmDataH\x01\x88\x01\x01\x12;\n\x07workers\x18\x03 \x01(\x0b\x32%.dynamo.planner.plugin.v1.WorkerStateH\x02\x88\x01\x01\x42\n\n\x08_trafficB\x06\n\x04_fpmB\n\n\x08_workers\"y\n\x0eTrafficMetrics\x12\x12\n\nduration_s\x18\x01 \x01(\x01\x12\x0f\n\x07num_req\x18\x02 \x01(\x01\x12\x0b\n\x03isl\x18\x03 \x01(\x01\x12\x0b\n\x03osl\x18\x04 \x01(\x01\x12\x18\n\x0bkv_hit_rate\x18\x05 \x01(\x01H\x00\x88\x01\x01\x42\x0e\n\x0c_kv_hit_rate\"\x94\x02\n\x07\x46pmData\x12N\n\x0fprefill_engines\x18\x01 \x03(\x0b\x32\x35.dynamo.planner.plugin.v1.FpmData.PrefillEnginesEntry\x12L\n\x0e\x64\x65\x63ode_engines\x18\x02 \x03(\x0b\x32\x34.dynamo.planner.plugin.v1.FpmData.DecodeEnginesEntry\x1a\x35\n\x13PrefillEnginesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\x1a\x34\n\x12\x44\x65\x63odeEnginesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\"\xdf\x02\n\x0bWorkerState\x12\x1a\n\rready_prefill\x18\x01 \x01(\x05H\x00\x88\x01\x01\x12\x19\n\x0cready_decode\x18\x02 \x01(\x05H\x01\x88\x01\x01\x12\x1d\n\x10\x65xpected_prefill\x18\x03 \x01(\x05H\x02\x88\x01\x01\x12\x1c\n\x0f\x65xpected_decode\x18\x04 \x01(\x05H\x03\x88\x01\x01\x12(\n\x1bprefill_scaling_in_progress\x18\x05 \x01(\x08H\x04\x88\x01\x01\x12\'\n\x1a\x64\x65\x63ode_scaling_in_progress\x18\x06 \x01(\x08H\x05\x88\x01\x01\x42\x10\n\x0e_ready_prefillB\x0f\n\r_ready_decodeB\x13\n\x11_expected_prefillB\x12\n\x10_expected_decodeB\x1e\n\x1c_prefill_scaling_in_progressB\x1d\n\x1b_decode_scaling_in_progress\"\xf0\x01\n\x0ePredictionData\x12\x1e\n\x11predicted_num_req\x18\x01 \x01(\x01H\x00\x88\x01\x01\x12\x1a\n\rpredicted_isl\x18\x02 \x01(\x01H\x01\x88\x01\x01\x12\x1a\n\rpredicted_osl\x18\x03 \x01(\x01H\x02\x88\x01\x01\x12\x0e\n\x06source\x18\x04 \x01(\t\x12\"\n\x15predicted_kv_hit_rate\x18\x05 \x01(\x01H\x03\x88\x01\x01\x42\x14\n\x12_predicted_num_reqB\x10\n\x0e_predicted_islB\x10\n\x0e_predicted_oslB\x18\n\x16_predicted_kv_hit_rate\"m\n\x0fScalingProposal\x12:\n\x07targets\x18\x01 \x03(\x0b\x32).dynamo.planner.plugin.v1.ComponentTarget\x12\x0e\n\x06reason\x18\x02 \x01(\t\x12\x0e\n\x06source\x18\x03 \x01(\t\"\x8d\x01\n\x0f\x43omponentTarget\x12\x1a\n\x12sub_component_type\x18\x01 \x01(\t\x12\x15\n\x08replicas\x18\x03 \x01(\x05H\x00\x88\x01\x01\x12\x34\n\x04type\x18\x04 \x01(\x0e\x32&.dynamo.planner.plugin.v1.OverrideTypeB\x0b\n\t_replicasJ\x04\x08\x02\x10\x03\"\\\n\x0eOverrideResult\x12:\n\x07targets\x18\x01 \x03(\x0b\x32).dynamo.planner.plugin.v1.ComponentTarget\x12\x0e\n\x06reason\x18\x02 \x01(\t\"\x0e\n\x0c\x41\x63\x63\x65ptResult\"\x1e\n\x0cRejectResult\x12\x0e\n\x06reason\x18\x01 \x01(\t\"Q\n\x13PredictStageRequest\x12:\n\x07\x63ontext\x18\x01 \x01(\x0b\x32).dynamo.planner.plugin.v1.PipelineContext\"t\n\x14PredictStageResponse\x12=\n\x0bpredictions\x18\x01 \x01(\x0b\x32(.dynamo.planner.plugin.v1.PredictionData\x12\x0e\n\x06reason\x18\x02 \x01(\t\x12\r\n\x05\x66inal\x18\x03 \x01(\x08\"Q\n\x13ProposeStageRequest\x12:\n\x07\x63ontext\x18\x01 \x01(\x0b\x32).dynamo.planner.plugin.v1.PipelineContext\"\xe1\x01\n\x14ProposeStageResponse\x12\x38\n\x06\x61\x63\x63\x65pt\x18\x01 \x01(\x0b\x32&.dynamo.planner.plugin.v1.AcceptResultH\x00\x12<\n\x08override\x18\x02 \x01(\x0b\x32(.dynamo.planner.plugin.v1.OverrideResultH\x00\x12\x38\n\x06reject\x18\x03 \x01(\x0b\x32&.dynamo.planner.plugin.v1.RejectResultH\x00\x12\r\n\x05\x66inal\x18\x04 \x01(\x08\x42\x08\n\x06result\"\x8f\x01\n\x15ReconcileStageRequest\x12:\n\x07\x63ontext\x18\x01 \x01(\x0b\x32).dynamo.planner.plugin.v1.PipelineContext\x12:\n\tproposals\x18\x02 \x03(\x0b\x32\'.dynamo.planner.plugin.v1.ProposeResult\"\xf0\x01\n\rProposeResult\x12\x11\n\tplugin_id\x18\x01 \x01(\t\x12\x38\n\x06\x61\x63\x63\x65pt\x18\x02 \x01(\x0b\x32&.dynamo.planner.plugin.v1.AcceptResultH\x00\x12<\n\x08override\x18\x03 \x01(\x0b\x32(.dynamo.planner.plugin.v1.OverrideResultH\x00\x12\x38\n\x06reject\x18\x04 \x01(\x0b\x32&.dynamo.planner.plugin.v1.RejectResultH\x00\x12\x10\n\x08priority\x18\x05 \x01(\rB\x08\n\x06result\"\xe3\x01\n\x16ReconcileStageResponse\x12\x38\n\x06\x61\x63\x63\x65pt\x18\x01 \x01(\x0b\x32&.dynamo.planner.plugin.v1.AcceptResultH\x00\x12<\n\x08override\x18\x02 \x01(\x0b\x32(.dynamo.planner.plugin.v1.OverrideResultH\x00\x12\x38\n\x06reject\x18\x03 \x01(\x0b\x32&.dynamo.planner.plugin.v1.RejectResultH\x00\x12\r\n\x05\x66inal\x18\x04 \x01(\x08\x42\x08\n\x06result\"S\n\x15\x43onstrainStageRequest\x12:\n\x07\x63ontext\x18\x01 \x01(\x0b\x32).dynamo.planner.plugin.v1.PipelineContext\"\xe3\x01\n\x16\x43onstrainStageResponse\x12\x38\n\x06\x61\x63\x63\x65pt\x18\x01 \x01(\x0b\x32&.dynamo.planner.plugin.v1.AcceptResultH\x00\x12<\n\x08override\x18\x02 \x01(\x0b\x32(.dynamo.planner.plugin.v1.OverrideResultH\x00\x12\x38\n\x06reject\x18\x03 \x01(\x0b\x32&.dynamo.planner.plugin.v1.RejectResultH\x00\x12\r\n\x05\x66inal\x18\x04 \x01(\x08\x42\x08\n\x06result\"\x9e\x01\n\x10\x42ootstrapRequest\x12\x16\n\x0e\x62ootstrap_data\x18\x01 \x01(\x0c\x12\x44\n\x05hints\x18\x02 \x03(\x0b\x32\x35.dynamo.planner.plugin.v1.BootstrapRequest.HintsEntry\x1a,\n\nHintsEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"0\n\x11\x42ootstrapResponse\x12\n\n\x02ok\x18\x01 \x01(\x08\x12\x0f\n\x07message\x18\x02 \x01(\t\"\x1e\n\x0cResetRequest\x12\x0e\n\x06reason\x18\x01 \x01(\t\",\n\rResetResponse\x12\n\n\x02ok\x18\x01 \x01(\x08\x12\x0f\n\x07message\x18\x02 \x01(\t*1\n\nHoldPolicy\x12\x14\n\x10\x41\x43\x43\x45PT_WHEN_IDLE\x10\x00\x12\r\n\tHOLD_LAST\x10\x01*3\n\x0c\x43ircuitState\x12\n\n\x06\x43LOSED\x10\x00\x12\x08\n\x04OPEN\x10\x01\x12\r\n\tHALF_OPEN\x10\x02*2\n\x0cOverrideType\x12\x07\n\x03SET\x10\x00\x12\x0c\n\x08\x41T_LEAST\x10\x01\x12\x0b\n\x07\x41T_MOST\x10\x02\x32\xae\x03\n\x0ePluginRegistry\x12\x61\n\x08Register\x12).dynamo.planner.plugin.v1.RegisterRequest\x1a*.dynamo.planner.plugin.v1.RegisterResponse\x12\x64\n\tHeartbeat\x12*.dynamo.planner.plugin.v1.HeartbeatRequest\x1a+.dynamo.planner.plugin.v1.HeartbeatResponse\x12g\n\nUnregister\x12+.dynamo.planner.plugin.v1.UnregisterRequest\x1a,.dynamo.planner.plugin.v1.UnregisterResponse\x12j\n\x0bListPlugins\x12,.dynamo.planner.plugin.v1.ListPluginsRequest\x1a-.dynamo.planner.plugin.v1.ListPluginsResponse2y\n\rPredictPlugin\x12h\n\x07Predict\x12-.dynamo.planner.plugin.v1.PredictStageRequest\x1a..dynamo.planner.plugin.v1.PredictStageResponse2y\n\rProposePlugin\x12h\n\x07Propose\x12-.dynamo.planner.plugin.v1.ProposeStageRequest\x1a..dynamo.planner.plugin.v1.ProposeStageResponse2\x81\x01\n\x0fReconcilePlugin\x12n\n\tReconcile\x12/.dynamo.planner.plugin.v1.ReconcileStageRequest\x1a\x30.dynamo.planner.plugin.v1.ReconcileStageResponse2\x81\x01\n\x0f\x43onstrainPlugin\x12n\n\tConstrain\x12/.dynamo.planner.plugin.v1.ConstrainStageRequest\x1a\x30.dynamo.planner.plugin.v1.ConstrainStageResponse2\xd1\x01\n\x0fPluginLifecycle\x12\x64\n\tBootstrap\x12*.dynamo.planner.plugin.v1.BootstrapRequest\x1a+.dynamo.planner.plugin.v1.BootstrapResponse\x12X\n\x05Reset\x12&.dynamo.planner.plugin.v1.ResetRequest\x1a\'.dynamo.planner.plugin.v1.ResetResponseb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'dynamo.planner.plugins.proto.v1.plugin_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_FPMDATA_PREFILLENGINESENTRY']._loaded_options = None
+  _globals['_FPMDATA_PREFILLENGINESENTRY']._serialized_options = b'8\001'
+  _globals['_FPMDATA_DECODEENGINESENTRY']._loaded_options = None
+  _globals['_FPMDATA_DECODEENGINESENTRY']._serialized_options = b'8\001'
+  _globals['_BOOTSTRAPREQUEST_HINTSENTRY']._loaded_options = None
+  _globals['_BOOTSTRAPREQUEST_HINTSENTRY']._serialized_options = b'8\001'
+  _globals['_HOLDPOLICY']._serialized_start=4953
+  _globals['_HOLDPOLICY']._serialized_end=5002
+  _globals['_CIRCUITSTATE']._serialized_start=5004
+  _globals['_CIRCUITSTATE']._serialized_end=5055
+  _globals['_OVERRIDETYPE']._serialized_start=5057
+  _globals['_OVERRIDETYPE']._serialized_end=5107
+  _globals['_REGISTERREQUEST']._serialized_start=75
+  _globals['_REGISTERREQUEST']._serialized_end=423
+  _globals['_REGISTERRESPONSE']._serialized_start=425
+  _globals['_REGISTERRESPONSE']._serialized_end=521
+  _globals['_HEARTBEATREQUEST']._serialized_start=523
+  _globals['_HEARTBEATREQUEST']._serialized_end=580
+  _globals['_HEARTBEATRESPONSE']._serialized_start=582
+  _globals['_HEARTBEATRESPONSE']._serialized_end=613
+  _globals['_UNREGISTERREQUEST']._serialized_start=615
+  _globals['_UNREGISTERREQUEST']._serialized_end=689
+  _globals['_UNREGISTERRESPONSE']._serialized_start=691
+  _globals['_UNREGISTERRESPONSE']._serialized_end=723
+  _globals['_LISTPLUGINSREQUEST']._serialized_start=725
+  _globals['_LISTPLUGINSREQUEST']._serialized_end=793
+  _globals['_LISTPLUGINSRESPONSE']._serialized_start=795
+  _globals['_LISTPLUGINSRESPONSE']._serialized_end=871
+  _globals['_PLUGININFO']._serialized_start=874
+  _globals['_PLUGININFO']._serialized_end=1194
+  _globals['_PIPELINECONTEXT']._serialized_start=1197
+  _globals['_PIPELINECONTEXT']._serialized_end=1590
+  _globals['_OBSERVATIONDATA']._serialized_start=1593
+  _globals['_OBSERVATIONDATA']._serialized_end=1820
+  _globals['_TRAFFICMETRICS']._serialized_start=1822
+  _globals['_TRAFFICMETRICS']._serialized_end=1943
+  _globals['_FPMDATA']._serialized_start=1946
+  _globals['_FPMDATA']._serialized_end=2222
+  _globals['_FPMDATA_PREFILLENGINESENTRY']._serialized_start=2115
+  _globals['_FPMDATA_PREFILLENGINESENTRY']._serialized_end=2168
+  _globals['_FPMDATA_DECODEENGINESENTRY']._serialized_start=2170
+  _globals['_FPMDATA_DECODEENGINESENTRY']._serialized_end=2222
+  _globals['_WORKERSTATE']._serialized_start=2225
+  _globals['_WORKERSTATE']._serialized_end=2576
+  _globals['_PREDICTIONDATA']._serialized_start=2579
+  _globals['_PREDICTIONDATA']._serialized_end=2819
+  _globals['_SCALINGPROPOSAL']._serialized_start=2821
+  _globals['_SCALINGPROPOSAL']._serialized_end=2930
+  _globals['_COMPONENTTARGET']._serialized_start=2933
+  _globals['_COMPONENTTARGET']._serialized_end=3074
+  _globals['_OVERRIDERESULT']._serialized_start=3076
+  _globals['_OVERRIDERESULT']._serialized_end=3168
+  _globals['_ACCEPTRESULT']._serialized_start=3170
+  _globals['_ACCEPTRESULT']._serialized_end=3184
+  _globals['_REJECTRESULT']._serialized_start=3186
+  _globals['_REJECTRESULT']._serialized_end=3216
+  _globals['_PREDICTSTAGEREQUEST']._serialized_start=3218
+  _globals['_PREDICTSTAGEREQUEST']._serialized_end=3299
+  _globals['_PREDICTSTAGERESPONSE']._serialized_start=3301
+  _globals['_PREDICTSTAGERESPONSE']._serialized_end=3417
+  _globals['_PROPOSESTAGEREQUEST']._serialized_start=3419
+  _globals['_PROPOSESTAGEREQUEST']._serialized_end=3500
+  _globals['_PROPOSESTAGERESPONSE']._serialized_start=3503
+  _globals['_PROPOSESTAGERESPONSE']._serialized_end=3728
+  _globals['_RECONCILESTAGEREQUEST']._serialized_start=3731
+  _globals['_RECONCILESTAGEREQUEST']._serialized_end=3874
+  _globals['_PROPOSERESULT']._serialized_start=3877
+  _globals['_PROPOSERESULT']._serialized_end=4117
+  _globals['_RECONCILESTAGERESPONSE']._serialized_start=4120
+  _globals['_RECONCILESTAGERESPONSE']._serialized_end=4347
+  _globals['_CONSTRAINSTAGEREQUEST']._serialized_start=4349
+  _globals['_CONSTRAINSTAGEREQUEST']._serialized_end=4432
+  _globals['_CONSTRAINSTAGERESPONSE']._serialized_start=4435
+  _globals['_CONSTRAINSTAGERESPONSE']._serialized_end=4662
+  _globals['_BOOTSTRAPREQUEST']._serialized_start=4665
+  _globals['_BOOTSTRAPREQUEST']._serialized_end=4823
+  _globals['_BOOTSTRAPREQUEST_HINTSENTRY']._serialized_start=4779
+  _globals['_BOOTSTRAPREQUEST_HINTSENTRY']._serialized_end=4823
+  _globals['_BOOTSTRAPRESPONSE']._serialized_start=4825
+  _globals['_BOOTSTRAPRESPONSE']._serialized_end=4873
+  _globals['_RESETREQUEST']._serialized_start=4875
+  _globals['_RESETREQUEST']._serialized_end=4905
+  _globals['_RESETRESPONSE']._serialized_start=4907
+  _globals['_RESETRESPONSE']._serialized_end=4951
+  _globals['_PLUGINREGISTRY']._serialized_start=5110
+  _globals['_PLUGINREGISTRY']._serialized_end=5540
+  _globals['_PREDICTPLUGIN']._serialized_start=5542
+  _globals['_PREDICTPLUGIN']._serialized_end=5663
+  _globals['_PROPOSEPLUGIN']._serialized_start=5665
+  _globals['_PROPOSEPLUGIN']._serialized_end=5786
+  _globals['_RECONCILEPLUGIN']._serialized_start=5789
+  _globals['_RECONCILEPLUGIN']._serialized_end=5918
+  _globals['_CONSTRAINPLUGIN']._serialized_start=5921
+  _globals['_CONSTRAINPLUGIN']._serialized_end=6050
+  _globals['_PLUGINLIFECYCLE']._serialized_start=6053
+  _globals['_PLUGINLIFECYCLE']._serialized_end=6262
+# @@protoc_insertion_point(module_scope)
\ No newline at end of file
diff --git a/components/src/dynamo/planner/plugins/proto/v1/plugin_pb2.pyi b/components/src/dynamo/planner/plugins/proto/v1/plugin_pb2.pyi
new file mode 100644
index 000000000000..efb9d0aeb670
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/proto/v1/plugin_pb2.pyi
@@ -0,0 +1,395 @@
+from google.protobuf.internal import containers as _containers
+from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Iterable as _Iterable, Mapping as _Mapping, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class HoldPolicy(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    ACCEPT_WHEN_IDLE: _ClassVar[HoldPolicy]
+    HOLD_LAST: _ClassVar[HoldPolicy]
+
+class CircuitState(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    CLOSED: _ClassVar[CircuitState]
+    OPEN: _ClassVar[CircuitState]
+    HALF_OPEN: _ClassVar[CircuitState]
+
+class OverrideType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = ()
+    SET: _ClassVar[OverrideType]
+    AT_LEAST: _ClassVar[OverrideType]
+    AT_MOST: _ClassVar[OverrideType]
+ACCEPT_WHEN_IDLE: HoldPolicy
+HOLD_LAST: HoldPolicy
+CLOSED: CircuitState
+OPEN: CircuitState
+HALF_OPEN: CircuitState
+SET: OverrideType
+AT_LEAST: OverrideType
+AT_MOST: OverrideType
+
+class RegisterRequest(_message.Message):
+    __slots__ = ("plugin_id", "plugin_type", "priority", "endpoint", "version", "execution_interval_seconds", "hold_policy", "needs", "protocol_version", "auth_token", "requires_produced_fields", "observation_window_seconds")
+    PLUGIN_ID_FIELD_NUMBER: _ClassVar[int]
+    PLUGIN_TYPE_FIELD_NUMBER: _ClassVar[int]
+    PRIORITY_FIELD_NUMBER: _ClassVar[int]
+    ENDPOINT_FIELD_NUMBER: _ClassVar[int]
+    VERSION_FIELD_NUMBER: _ClassVar[int]
+    EXECUTION_INTERVAL_SECONDS_FIELD_NUMBER: _ClassVar[int]
+    HOLD_POLICY_FIELD_NUMBER: _ClassVar[int]
+    NEEDS_FIELD_NUMBER: _ClassVar[int]
+    PROTOCOL_VERSION_FIELD_NUMBER: _ClassVar[int]
+    AUTH_TOKEN_FIELD_NUMBER: _ClassVar[int]
+    REQUIRES_PRODUCED_FIELDS_FIELD_NUMBER: _ClassVar[int]
+    OBSERVATION_WINDOW_SECONDS_FIELD_NUMBER: _ClassVar[int]
+    plugin_id: str
+    plugin_type: str
+    priority: int
+    endpoint: str
+    version: str
+    execution_interval_seconds: float
+    hold_policy: HoldPolicy
+    needs: _containers.RepeatedScalarFieldContainer[str]
+    protocol_version: str
+    auth_token: str
+    requires_produced_fields: _containers.RepeatedScalarFieldContainer[str]
+    observation_window_seconds: float
+    def __init__(self, plugin_id: _Optional[str] = ..., plugin_type: _Optional[str] = ..., priority: _Optional[int] = ..., endpoint: _Optional[str] = ..., version: _Optional[str] = ..., execution_interval_seconds: _Optional[float] = ..., hold_policy: _Optional[_Union[HoldPolicy, str]] = ..., needs: _Optional[_Iterable[str]] = ..., protocol_version: _Optional[str] = ..., auth_token: _Optional[str] = ..., requires_produced_fields: _Optional[_Iterable[str]] = ..., observation_window_seconds: _Optional[float] = ...) -> None: ...
+
+class RegisterResponse(_message.Message):
+    __slots__ = ("accepted", "reject_reason", "negotiated_protocol_version")
+    ACCEPTED_FIELD_NUMBER: _ClassVar[int]
+    REJECT_REASON_FIELD_NUMBER: _ClassVar[int]
+    NEGOTIATED_PROTOCOL_VERSION_FIELD_NUMBER: _ClassVar[int]
+    accepted: bool
+    reject_reason: str
+    negotiated_protocol_version: str
+    def __init__(self, accepted: bool = ..., reject_reason: _Optional[str] = ..., negotiated_protocol_version: _Optional[str] = ...) -> None: ...
+
+class HeartbeatRequest(_message.Message):
+    __slots__ = ("plugin_id", "auth_token")
+    PLUGIN_ID_FIELD_NUMBER: _ClassVar[int]
+    AUTH_TOKEN_FIELD_NUMBER: _ClassVar[int]
+    plugin_id: str
+    auth_token: str
+    def __init__(self, plugin_id: _Optional[str] = ..., auth_token: _Optional[str] = ...) -> None: ...
+
+class HeartbeatResponse(_message.Message):
+    __slots__ = ("ok",)
+    OK_FIELD_NUMBER: _ClassVar[int]
+    ok: bool
+    def __init__(self, ok: bool = ...) -> None: ...
+
+class UnregisterRequest(_message.Message):
+    __slots__ = ("plugin_id", "reason", "auth_token")
+    PLUGIN_ID_FIELD_NUMBER: _ClassVar[int]
+    REASON_FIELD_NUMBER: _ClassVar[int]
+    AUTH_TOKEN_FIELD_NUMBER: _ClassVar[int]
+    plugin_id: str
+    reason: str
+    auth_token: str
+    def __init__(self, plugin_id: _Optional[str] = ..., reason: _Optional[str] = ..., auth_token: _Optional[str] = ...) -> None: ...
+
+class UnregisterResponse(_message.Message):
+    __slots__ = ("ok",)
+    OK_FIELD_NUMBER: _ClassVar[int]
+    ok: bool
+    def __init__(self, ok: bool = ...) -> None: ...
+
+class ListPluginsRequest(_message.Message):
+    __slots__ = ("stage_filter", "include_disabled")
+    STAGE_FILTER_FIELD_NUMBER: _ClassVar[int]
+    INCLUDE_DISABLED_FIELD_NUMBER: _ClassVar[int]
+    stage_filter: str
+    include_disabled: bool
+    def __init__(self, stage_filter: _Optional[str] = ..., include_disabled: bool = ...) -> None: ...
+
+class ListPluginsResponse(_message.Message):
+    __slots__ = ("plugins",)
+    PLUGINS_FIELD_NUMBER: _ClassVar[int]
+    plugins: _containers.RepeatedCompositeFieldContainer[PluginInfo]
+    def __init__(self, plugins: _Optional[_Iterable[_Union[PluginInfo, _Mapping]]] = ...) -> None: ...
+
+class PluginInfo(_message.Message):
+    __slots__ = ("plugin_id", "plugin_type", "priority", "version", "protocol_version", "enabled", "is_builtin", "transport", "circuit_state", "evaluations_total", "last_call_at_seconds_ago", "cache_age_seconds")
+    PLUGIN_ID_FIELD_NUMBER: _ClassVar[int]
+    PLUGIN_TYPE_FIELD_NUMBER: _ClassVar[int]
+    PRIORITY_FIELD_NUMBER: _ClassVar[int]
+    VERSION_FIELD_NUMBER: _ClassVar[int]
+    PROTOCOL_VERSION_FIELD_NUMBER: _ClassVar[int]
+    ENABLED_FIELD_NUMBER: _ClassVar[int]
+    IS_BUILTIN_FIELD_NUMBER: _ClassVar[int]
+    TRANSPORT_FIELD_NUMBER: _ClassVar[int]
+    CIRCUIT_STATE_FIELD_NUMBER: _ClassVar[int]
+    EVALUATIONS_TOTAL_FIELD_NUMBER: _ClassVar[int]
+    LAST_CALL_AT_SECONDS_AGO_FIELD_NUMBER: _ClassVar[int]
+    CACHE_AGE_SECONDS_FIELD_NUMBER: _ClassVar[int]
+    plugin_id: str
+    plugin_type: str
+    priority: int
+    version: str
+    protocol_version: str
+    enabled: bool
+    is_builtin: bool
+    transport: str
+    circuit_state: CircuitState
+    evaluations_total: int
+    last_call_at_seconds_ago: float
+    cache_age_seconds: float
+    def __init__(self, plugin_id: _Optional[str] = ..., plugin_type: _Optional[str] = ..., priority: _Optional[int] = ..., version: _Optional[str] = ..., protocol_version: _Optional[str] = ..., enabled: bool = ..., is_builtin: bool = ..., transport: _Optional[str] = ..., circuit_state: _Optional[_Union[CircuitState, str]] = ..., evaluations_total: _Optional[int] = ..., last_call_at_seconds_ago: _Optional[float] = ..., cache_age_seconds: _Optional[float] = ...) -> None: ...
+
+class PipelineContext(_message.Message):
+    __slots__ = ("request_id", "decision_id", "observations", "predictions", "proposal", "constrained")
+    REQUEST_ID_FIELD_NUMBER: _ClassVar[int]
+    DECISION_ID_FIELD_NUMBER: _ClassVar[int]
+    OBSERVATIONS_FIELD_NUMBER: _ClassVar[int]
+    PREDICTIONS_FIELD_NUMBER: _ClassVar[int]
+    PROPOSAL_FIELD_NUMBER: _ClassVar[int]
+    CONSTRAINED_FIELD_NUMBER: _ClassVar[int]
+    request_id: str
+    decision_id: str
+    observations: ObservationData
+    predictions: PredictionData
+    proposal: ScalingProposal
+    constrained: ScalingProposal
+    def __init__(self, request_id: _Optional[str] = ..., decision_id: _Optional[str] = ..., observations: _Optional[_Union[ObservationData, _Mapping]] = ..., predictions: _Optional[_Union[PredictionData, _Mapping]] = ..., proposal: _Optional[_Union[ScalingProposal, _Mapping]] = ..., constrained: _Optional[_Union[ScalingProposal, _Mapping]] = ...) -> None: ...
+
+class ObservationData(_message.Message):
+    __slots__ = ("traffic", "fpm", "workers")
+    TRAFFIC_FIELD_NUMBER: _ClassVar[int]
+    FPM_FIELD_NUMBER: _ClassVar[int]
+    WORKERS_FIELD_NUMBER: _ClassVar[int]
+    traffic: TrafficMetrics
+    fpm: FpmData
+    workers: WorkerState
+    def __init__(self, traffic: _Optional[_Union[TrafficMetrics, _Mapping]] = ..., fpm: _Optional[_Union[FpmData, _Mapping]] = ..., workers: _Optional[_Union[WorkerState, _Mapping]] = ...) -> None: ...
+
+class TrafficMetrics(_message.Message):
+    __slots__ = ("duration_s", "num_req", "isl", "osl", "kv_hit_rate")
+    DURATION_S_FIELD_NUMBER: _ClassVar[int]
+    NUM_REQ_FIELD_NUMBER: _ClassVar[int]
+    ISL_FIELD_NUMBER: _ClassVar[int]
+    OSL_FIELD_NUMBER: _ClassVar[int]
+    KV_HIT_RATE_FIELD_NUMBER: _ClassVar[int]
+    duration_s: float
+    num_req: float
+    isl: float
+    osl: float
+    kv_hit_rate: float
+    def __init__(self, duration_s: _Optional[float] = ..., num_req: _Optional[float] = ..., isl: _Optional[float] = ..., osl: _Optional[float] = ..., kv_hit_rate: _Optional[float] = ...) -> None: ...
+
+class FpmData(_message.Message):
+    __slots__ = ("prefill_engines", "decode_engines")
+    class PrefillEnginesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: bytes
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[bytes] = ...) -> None: ...
+    class DecodeEnginesEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: bytes
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[bytes] = ...) -> None: ...
+    PREFILL_ENGINES_FIELD_NUMBER: _ClassVar[int]
+    DECODE_ENGINES_FIELD_NUMBER: _ClassVar[int]
+    prefill_engines: _containers.ScalarMap[str, bytes]
+    decode_engines: _containers.ScalarMap[str, bytes]
+    def __init__(self, prefill_engines: _Optional[_Mapping[str, bytes]] = ..., decode_engines: _Optional[_Mapping[str, bytes]] = ...) -> None: ...
+
+class WorkerState(_message.Message):
+    __slots__ = ("ready_prefill", "ready_decode", "expected_prefill", "expected_decode", "prefill_scaling_in_progress", "decode_scaling_in_progress")
+    READY_PREFILL_FIELD_NUMBER: _ClassVar[int]
+    READY_DECODE_FIELD_NUMBER: _ClassVar[int]
+    EXPECTED_PREFILL_FIELD_NUMBER: _ClassVar[int]
+    EXPECTED_DECODE_FIELD_NUMBER: _ClassVar[int]
+    PREFILL_SCALING_IN_PROGRESS_FIELD_NUMBER: _ClassVar[int]
+    DECODE_SCALING_IN_PROGRESS_FIELD_NUMBER: _ClassVar[int]
+    ready_prefill: int
+    ready_decode: int
+    expected_prefill: int
+    expected_decode: int
+    prefill_scaling_in_progress: bool
+    decode_scaling_in_progress: bool
+    def __init__(self, ready_prefill: _Optional[int] = ..., ready_decode: _Optional[int] = ..., expected_prefill: _Optional[int] = ..., expected_decode: _Optional[int] = ..., prefill_scaling_in_progress: bool = ..., decode_scaling_in_progress: bool = ...) -> None: ...
+
+class PredictionData(_message.Message):
+    __slots__ = ("predicted_num_req", "predicted_isl", "predicted_osl", "source", "predicted_kv_hit_rate")
+    PREDICTED_NUM_REQ_FIELD_NUMBER: _ClassVar[int]
+    PREDICTED_ISL_FIELD_NUMBER: _ClassVar[int]
+    PREDICTED_OSL_FIELD_NUMBER: _ClassVar[int]
+    SOURCE_FIELD_NUMBER: _ClassVar[int]
+    PREDICTED_KV_HIT_RATE_FIELD_NUMBER: _ClassVar[int]
+    predicted_num_req: float
+    predicted_isl: float
+    predicted_osl: float
+    source: str
+    predicted_kv_hit_rate: float
+    def __init__(self, predicted_num_req: _Optional[float] = ..., predicted_isl: _Optional[float] = ..., predicted_osl: _Optional[float] = ..., source: _Optional[str] = ..., predicted_kv_hit_rate: _Optional[float] = ...) -> None: ...
+
+class ScalingProposal(_message.Message):
+    __slots__ = ("targets", "reason", "source")
+    TARGETS_FIELD_NUMBER: _ClassVar[int]
+    REASON_FIELD_NUMBER: _ClassVar[int]
+    SOURCE_FIELD_NUMBER: _ClassVar[int]
+    targets: _containers.RepeatedCompositeFieldContainer[ComponentTarget]
+    reason: str
+    source: str
+    def __init__(self, targets: _Optional[_Iterable[_Union[ComponentTarget, _Mapping]]] = ..., reason: _Optional[str] = ..., source: _Optional[str] = ...) -> None: ...
+
+class ComponentTarget(_message.Message):
+    __slots__ = ("sub_component_type", "replicas", "type")
+    SUB_COMPONENT_TYPE_FIELD_NUMBER: _ClassVar[int]
+    REPLICAS_FIELD_NUMBER: _ClassVar[int]
+    TYPE_FIELD_NUMBER: _ClassVar[int]
+    sub_component_type: str
+    replicas: int
+    type: OverrideType
+    def __init__(self, sub_component_type: _Optional[str] = ..., replicas: _Optional[int] = ..., type: _Optional[_Union[OverrideType, str]] = ...) -> None: ...
+
+class OverrideResult(_message.Message):
+    __slots__ = ("targets", "reason")
+    TARGETS_FIELD_NUMBER: _ClassVar[int]
+    REASON_FIELD_NUMBER: _ClassVar[int]
+    targets: _containers.RepeatedCompositeFieldContainer[ComponentTarget]
+    reason: str
+    def __init__(self, targets: _Optional[_Iterable[_Union[ComponentTarget, _Mapping]]] = ..., reason: _Optional[str] = ...) -> None: ...
+
+class AcceptResult(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...
+
+class RejectResult(_message.Message):
+    __slots__ = ("reason",)
+    REASON_FIELD_NUMBER: _ClassVar[int]
+    reason: str
+    def __init__(self, reason: _Optional[str] = ...) -> None: ...
+
+class PredictStageRequest(_message.Message):
+    __slots__ = ("context",)
+    CONTEXT_FIELD_NUMBER: _ClassVar[int]
+    context: PipelineContext
+    def __init__(self, context: _Optional[_Union[PipelineContext, _Mapping]] = ...) -> None: ...
+
+class PredictStageResponse(_message.Message):
+    __slots__ = ("predictions", "reason", "final")
+    PREDICTIONS_FIELD_NUMBER: _ClassVar[int]
+    REASON_FIELD_NUMBER: _ClassVar[int]
+    FINAL_FIELD_NUMBER: _ClassVar[int]
+    predictions: PredictionData
+    reason: str
+    final: bool
+    def __init__(self, predictions: _Optional[_Union[PredictionData, _Mapping]] = ..., reason: _Optional[str] = ..., final: bool = ...) -> None: ...
+
+class ProposeStageRequest(_message.Message):
+    __slots__ = ("context",)
+    CONTEXT_FIELD_NUMBER: _ClassVar[int]
+    context: PipelineContext
+    def __init__(self, context: _Optional[_Union[PipelineContext, _Mapping]] = ...) -> None: ...
+
+class ProposeStageResponse(_message.Message):
+    __slots__ = ("accept", "override", "reject", "final")
+    ACCEPT_FIELD_NUMBER: _ClassVar[int]
+    OVERRIDE_FIELD_NUMBER: _ClassVar[int]
+    REJECT_FIELD_NUMBER: _ClassVar[int]
+    FINAL_FIELD_NUMBER: _ClassVar[int]
+    accept: AcceptResult
+    override: OverrideResult
+    reject: RejectResult
+    final: bool
+    def __init__(self, accept: _Optional[_Union[AcceptResult, _Mapping]] = ..., override: _Optional[_Union[OverrideResult, _Mapping]] = ..., reject: _Optional[_Union[RejectResult, _Mapping]] = ..., final: bool = ...) -> None: ...
+
+class ReconcileStageRequest(_message.Message):
+    __slots__ = ("context", "proposals")
+    CONTEXT_FIELD_NUMBER: _ClassVar[int]
+    PROPOSALS_FIELD_NUMBER: _ClassVar[int]
+    context: PipelineContext
+    proposals: _containers.RepeatedCompositeFieldContainer[ProposeResult]
+    def __init__(self, context: _Optional[_Union[PipelineContext, _Mapping]] = ..., proposals: _Optional[_Iterable[_Union[ProposeResult, _Mapping]]] = ...) -> None: ...
+
+class ProposeResult(_message.Message):
+    __slots__ = ("plugin_id", "accept", "override", "reject", "priority")
+    PLUGIN_ID_FIELD_NUMBER: _ClassVar[int]
+    ACCEPT_FIELD_NUMBER: _ClassVar[int]
+    OVERRIDE_FIELD_NUMBER: _ClassVar[int]
+    REJECT_FIELD_NUMBER: _ClassVar[int]
+    PRIORITY_FIELD_NUMBER: _ClassVar[int]
+    plugin_id: str
+    accept: AcceptResult
+    override: OverrideResult
+    reject: RejectResult
+    priority: int
+    def __init__(self, plugin_id: _Optional[str] = ..., accept: _Optional[_Union[AcceptResult, _Mapping]] = ..., override: _Optional[_Union[OverrideResult, _Mapping]] = ..., reject: _Optional[_Union[RejectResult, _Mapping]] = ..., priority: _Optional[int] = ...) -> None: ...
+
+class ReconcileStageResponse(_message.Message):
+    __slots__ = ("accept", "override", "reject", "final")
+    ACCEPT_FIELD_NUMBER: _ClassVar[int]
+    OVERRIDE_FIELD_NUMBER: _ClassVar[int]
+    REJECT_FIELD_NUMBER: _ClassVar[int]
+    FINAL_FIELD_NUMBER: _ClassVar[int]
+    accept: AcceptResult
+    override: OverrideResult
+    reject: RejectResult
+    final: bool
+    def __init__(self, accept: _Optional[_Union[AcceptResult, _Mapping]] = ..., override: _Optional[_Union[OverrideResult, _Mapping]] = ..., reject: _Optional[_Union[RejectResult, _Mapping]] = ..., final: bool = ...) -> None: ...
+
+class ConstrainStageRequest(_message.Message):
+    __slots__ = ("context",)
+    CONTEXT_FIELD_NUMBER: _ClassVar[int]
+    context: PipelineContext
+    def __init__(self, context: _Optional[_Union[PipelineContext, _Mapping]] = ...) -> None: ...
+
+class ConstrainStageResponse(_message.Message):
+    __slots__ = ("accept", "override", "reject", "final")
+    ACCEPT_FIELD_NUMBER: _ClassVar[int]
+    OVERRIDE_FIELD_NUMBER: _ClassVar[int]
+    REJECT_FIELD_NUMBER: _ClassVar[int]
+    FINAL_FIELD_NUMBER: _ClassVar[int]
+    accept: AcceptResult
+    override: OverrideResult
+    reject: RejectResult
+    final: bool
+    def __init__(self, accept: _Optional[_Union[AcceptResult, _Mapping]] = ..., override: _Optional[_Union[OverrideResult, _Mapping]] = ..., reject: _Optional[_Union[RejectResult, _Mapping]] = ..., final: bool = ...) -> None: ...
+
+class BootstrapRequest(_message.Message):
+    __slots__ = ("bootstrap_data", "hints")
+    class HintsEntry(_message.Message):
+        __slots__ = ("key", "value")
+        KEY_FIELD_NUMBER: _ClassVar[int]
+        VALUE_FIELD_NUMBER: _ClassVar[int]
+        key: str
+        value: str
+        def __init__(self, key: _Optional[str] = ..., value: _Optional[str] = ...) -> None: ...
+    BOOTSTRAP_DATA_FIELD_NUMBER: _ClassVar[int]
+    HINTS_FIELD_NUMBER: _ClassVar[int]
+    bootstrap_data: bytes
+    hints: _containers.ScalarMap[str, str]
+    def __init__(self, bootstrap_data: _Optional[bytes] = ..., hints: _Optional[_Mapping[str, str]] = ...) -> None: ...
+
+class BootstrapResponse(_message.Message):
+    __slots__ = ("ok", "message")
+    OK_FIELD_NUMBER: _ClassVar[int]
+    MESSAGE_FIELD_NUMBER: _ClassVar[int]
+    ok: bool
+    message: str
+    def __init__(self, ok: bool = ..., message: _Optional[str] = ...) -> None: ...
+
+class ResetRequest(_message.Message):
+    __slots__ = ("reason",)
+    REASON_FIELD_NUMBER: _ClassVar[int]
+    reason: str
+    def __init__(self, reason: _Optional[str] = ...) -> None: ...
+
+class ResetResponse(_message.Message):
+    __slots__ = ("ok", "message")
+    OK_FIELD_NUMBER: _ClassVar[int]
+    MESSAGE_FIELD_NUMBER: _ClassVar[int]
+    ok: bool
+    message: str
+    def __init__(self, ok: bool = ..., message: _Optional[str] = ...) -> None: ...
diff --git a/components/src/dynamo/planner/plugins/proto/v1/plugin_pb2_grpc.py b/components/src/dynamo/planner/plugins/proto/v1/plugin_pb2_grpc.py
new file mode 100644
index 000000000000..2240cd23785f
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/proto/v1/plugin_pb2_grpc.py
@@ -0,0 +1,694 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+from dynamo.planner.plugins.proto.v1 import plugin_pb2 as dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2
+
+GRPC_GENERATED_VERSION = '1.67.1'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + f' but the generated code in dynamo/planner/plugins/proto/v1/plugin_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class PluginRegistryStub(object):
+    """============================================================================
+    PluginRegistry service
+    ============================================================================
+
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.Register = channel.unary_unary(
+                '/dynamo.planner.plugin.v1.PluginRegistry/Register',
+                request_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.RegisterRequest.SerializeToString,
+                response_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.RegisterResponse.FromString,
+                _registered_method=True)
+        self.Heartbeat = channel.unary_unary(
+                '/dynamo.planner.plugin.v1.PluginRegistry/Heartbeat',
+                request_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.HeartbeatRequest.SerializeToString,
+                response_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.HeartbeatResponse.FromString,
+                _registered_method=True)
+        self.Unregister = channel.unary_unary(
+                '/dynamo.planner.plugin.v1.PluginRegistry/Unregister',
+                request_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.UnregisterRequest.SerializeToString,
+                response_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.UnregisterResponse.FromString,
+                _registered_method=True)
+        self.ListPlugins = channel.unary_unary(
+                '/dynamo.planner.plugin.v1.PluginRegistry/ListPlugins',
+                request_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ListPluginsRequest.SerializeToString,
+                response_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ListPluginsResponse.FromString,
+                _registered_method=True)
+
+
+class PluginRegistryServicer(object):
+    """============================================================================
+    PluginRegistry service
+    ============================================================================
+
+    """
+
+    def Register(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def Heartbeat(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def Unregister(self, request, context):
+        """Plugin gracefully announces shutdown; orchestrator immediately removes
+        it from active set and clears its HOLD_LAST cache (without waiting for
+        missed_heartbeat threshold).
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def ListPlugins(self, request, context):
+        """Admin / observability: returns metadata of all registered plugins
+        (builtin and user) plus runtime state (circuit breaker, cache age,
+        evaluation counts). Authorization typically gated by an admin RBAC
+        distinct from plugin Register auth.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_PluginRegistryServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'Register': grpc.unary_unary_rpc_method_handler(
+                    servicer.Register,
+                    request_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.RegisterRequest.FromString,
+                    response_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.RegisterResponse.SerializeToString,
+            ),
+            'Heartbeat': grpc.unary_unary_rpc_method_handler(
+                    servicer.Heartbeat,
+                    request_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.HeartbeatRequest.FromString,
+                    response_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.HeartbeatResponse.SerializeToString,
+            ),
+            'Unregister': grpc.unary_unary_rpc_method_handler(
+                    servicer.Unregister,
+                    request_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.UnregisterRequest.FromString,
+                    response_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.UnregisterResponse.SerializeToString,
+            ),
+            'ListPlugins': grpc.unary_unary_rpc_method_handler(
+                    servicer.ListPlugins,
+                    request_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ListPluginsRequest.FromString,
+                    response_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ListPluginsResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'dynamo.planner.plugin.v1.PluginRegistry', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('dynamo.planner.plugin.v1.PluginRegistry', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class PluginRegistry(object):
+    """============================================================================
+    PluginRegistry service
+    ============================================================================
+
+    """
+
+    @staticmethod
+    def Register(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/dynamo.planner.plugin.v1.PluginRegistry/Register',
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.RegisterRequest.SerializeToString,
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.RegisterResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def Heartbeat(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/dynamo.planner.plugin.v1.PluginRegistry/Heartbeat',
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.HeartbeatRequest.SerializeToString,
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.HeartbeatResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def Unregister(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/dynamo.planner.plugin.v1.PluginRegistry/Unregister',
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.UnregisterRequest.SerializeToString,
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.UnregisterResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def ListPlugins(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/dynamo.planner.plugin.v1.PluginRegistry/ListPlugins',
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ListPluginsRequest.SerializeToString,
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ListPluginsResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+
+class PredictPluginStub(object):
+    """============================================================================
+    Stage-specific request/response (each stage receives full PipelineContext)
+    ============================================================================
+
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.Predict = channel.unary_unary(
+                '/dynamo.planner.plugin.v1.PredictPlugin/Predict',
+                request_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.PredictStageRequest.SerializeToString,
+                response_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.PredictStageResponse.FromString,
+                _registered_method=True)
+
+
+class PredictPluginServicer(object):
+    """============================================================================
+    Stage-specific request/response (each stage receives full PipelineContext)
+    ============================================================================
+
+    """
+
+    def Predict(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_PredictPluginServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'Predict': grpc.unary_unary_rpc_method_handler(
+                    servicer.Predict,
+                    request_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.PredictStageRequest.FromString,
+                    response_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.PredictStageResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'dynamo.planner.plugin.v1.PredictPlugin', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('dynamo.planner.plugin.v1.PredictPlugin', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class PredictPlugin(object):
+    """============================================================================
+    Stage-specific request/response (each stage receives full PipelineContext)
+    ============================================================================
+
+    """
+
+    @staticmethod
+    def Predict(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/dynamo.planner.plugin.v1.PredictPlugin/Predict',
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.PredictStageRequest.SerializeToString,
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.PredictStageResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+
+class ProposePluginStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.Propose = channel.unary_unary(
+                '/dynamo.planner.plugin.v1.ProposePlugin/Propose',
+                request_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ProposeStageRequest.SerializeToString,
+                response_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ProposeStageResponse.FromString,
+                _registered_method=True)
+
+
+class ProposePluginServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def Propose(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_ProposePluginServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'Propose': grpc.unary_unary_rpc_method_handler(
+                    servicer.Propose,
+                    request_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ProposeStageRequest.FromString,
+                    response_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ProposeStageResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'dynamo.planner.plugin.v1.ProposePlugin', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('dynamo.planner.plugin.v1.ProposePlugin', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class ProposePlugin(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def Propose(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/dynamo.planner.plugin.v1.ProposePlugin/Propose',
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ProposeStageRequest.SerializeToString,
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ProposeStageResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+
+class ReconcilePluginStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.Reconcile = channel.unary_unary(
+                '/dynamo.planner.plugin.v1.ReconcilePlugin/Reconcile',
+                request_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ReconcileStageRequest.SerializeToString,
+                response_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ReconcileStageResponse.FromString,
+                _registered_method=True)
+
+
+class ReconcilePluginServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def Reconcile(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_ReconcilePluginServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'Reconcile': grpc.unary_unary_rpc_method_handler(
+                    servicer.Reconcile,
+                    request_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ReconcileStageRequest.FromString,
+                    response_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ReconcileStageResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'dynamo.planner.plugin.v1.ReconcilePlugin', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('dynamo.planner.plugin.v1.ReconcilePlugin', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class ReconcilePlugin(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def Reconcile(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/dynamo.planner.plugin.v1.ReconcilePlugin/Reconcile',
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ReconcileStageRequest.SerializeToString,
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ReconcileStageResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+
+class ConstrainPluginStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.Constrain = channel.unary_unary(
+                '/dynamo.planner.plugin.v1.ConstrainPlugin/Constrain',
+                request_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ConstrainStageRequest.SerializeToString,
+                response_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ConstrainStageResponse.FromString,
+                _registered_method=True)
+
+
+class ConstrainPluginServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def Constrain(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_ConstrainPluginServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'Constrain': grpc.unary_unary_rpc_method_handler(
+                    servicer.Constrain,
+                    request_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ConstrainStageRequest.FromString,
+                    response_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ConstrainStageResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'dynamo.planner.plugin.v1.ConstrainPlugin', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('dynamo.planner.plugin.v1.ConstrainPlugin', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class ConstrainPlugin(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def Constrain(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/dynamo.planner.plugin.v1.ConstrainPlugin/Constrain',
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ConstrainStageRequest.SerializeToString,
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ConstrainStageResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+
+class PluginLifecycleStub(object):
+    """============================================================================
+    PluginLifecycle service (v10 YAGNI: only Bootstrap + Reset)
+    ============================================================================
+
+    Snapshot/Restore are NOT part of this DEP — current code repo lacks the
+    mechanism, planner restart goes through Bootstrap to re-fit regression
+    (equivalent to cold start). proto3 add new RPC is backward-compatible;
+    future PR may add Snapshot/Restore without breaking clients.
+
+    """
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.Bootstrap = channel.unary_unary(
+                '/dynamo.planner.plugin.v1.PluginLifecycle/Bootstrap',
+                request_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.BootstrapRequest.SerializeToString,
+                response_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.BootstrapResponse.FromString,
+                _registered_method=True)
+        self.Reset = channel.unary_unary(
+                '/dynamo.planner.plugin.v1.PluginLifecycle/Reset',
+                request_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ResetRequest.SerializeToString,
+                response_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ResetResponse.FromString,
+                _registered_method=True)
+
+
+class PluginLifecycleServicer(object):
+    """============================================================================
+    PluginLifecycle service (v10 YAGNI: only Bootstrap + Reset)
+    ============================================================================
+
+    Snapshot/Restore are NOT part of this DEP — current code repo lacks the
+    mechanism, planner restart goes through Bootstrap to re-fit regression
+    (equivalent to cold start). proto3 add new RPC is backward-compatible;
+    future PR may add Snapshot/Restore without breaking clients.
+
+    """
+
+    def Bootstrap(self, request, context):
+        """Plugin's first-call from orchestrator after Register; one-time priming
+        (e.g. load benchmark FPM, warm regression model).
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def Reset(self, request, context):
+        """Clear plugin internal state back to pre-Bootstrap; called on config
+        reload or test setup/teardown. NOT idempotent in semantics (orchestrator
+        guarantees single-call lifecycle).
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_PluginLifecycleServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'Bootstrap': grpc.unary_unary_rpc_method_handler(
+                    servicer.Bootstrap,
+                    request_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.BootstrapRequest.FromString,
+                    response_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.BootstrapResponse.SerializeToString,
+            ),
+            'Reset': grpc.unary_unary_rpc_method_handler(
+                    servicer.Reset,
+                    request_deserializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ResetRequest.FromString,
+                    response_serializer=dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ResetResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'dynamo.planner.plugin.v1.PluginLifecycle', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('dynamo.planner.plugin.v1.PluginLifecycle', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class PluginLifecycle(object):
+    """============================================================================
+    PluginLifecycle service (v10 YAGNI: only Bootstrap + Reset)
+    ============================================================================
+
+    Snapshot/Restore are NOT part of this DEP — current code repo lacks the
+    mechanism, planner restart goes through Bootstrap to re-fit regression
+    (equivalent to cold start). proto3 add new RPC is backward-compatible;
+    future PR may add Snapshot/Restore without breaking clients.
+
+    """
+
+    @staticmethod
+    def Bootstrap(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/dynamo.planner.plugin.v1.PluginLifecycle/Bootstrap',
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.BootstrapRequest.SerializeToString,
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.BootstrapResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def Reset(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/dynamo.planner.plugin.v1.PluginLifecycle/Reset',
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ResetRequest.SerializeToString,
+            dynamo_dot_planner_dot_plugins_dot_proto_dot_v1_dot_plugin__pb2.ResetResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
\ No newline at end of file
diff --git a/components/src/dynamo/planner/plugins/registry/README.md b/components/src/dynamo/planner/plugins/registry/README.md
new file mode 100644
index 000000000000..a564e5c8822a
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/registry/README.md
@@ -0,0 +1,169 @@
+# PluginRegistry
+
+The registry tracks every plugin that can participate in a planner
+pipeline, gates every Register through auth + protocol checks, evicts
+stale plugins via heartbeat liveness, and coordinates with the circuit
+breaker and scheduler so HOLD_LAST caches stay consistent with registry
+state.
+
+## Architecture
+
+```
+            +-------------------+
+            |  register (RPC)   |<--- gateway.py (gRPC server)
+            |  heartbeat (RPC)  |
+            |  unregister (RPC) |
+            |  list_plugins     |
+            +---------+---------+
+                      | method calls (single-threaded asyncio)
+                      v
+            +-------------------+
+            | PluginRegistry    |  <-- register_internal (in-process)
+            |    Server         |
+            +---------+---------+
+                      |
+       +-- on_unregister events ---+
+       |                            |
+       v                            v
++---------------+          +------------------+
+| CircuitBreaker|<-- open->| PluginScheduler  |---> cache_age lookup
+|               |          |    - active set  |     (ListPlugins)
+|               |          |    - HOLD_LAST   |
++---------------+          +------------------+
+       ^
+       | can_call()
+       |
++---------------+
+| Orchestrator  |   <-- composes all of the above
++---------------+
+```
+
+## Cache invalidation: the 6-row table
+
+The PluginScheduler clears a plugin's HOLD_LAST cache when:
+
+| # | Trigger | Entry point |
+|---|---------|-------------|
+| 1 | Client Unregister | `registry.on_unregister` → `scheduler._on_registry_unregister` |
+| 2 | Heartbeat missed → auto-evict | Same as row 1 — registry-side `unregister(reason="heartbeat_missed")` is identical to client Unregister. The upstream monitor that calls it lands in a follow-up PR. |
+| 3 | Circuit breaker OPEN | `circuit_breaker.on_open` → `scheduler._on_circuit_open` |
+| 4 | Client-driven version upgrade (Unregister + Register) | Same as row 1 on the Unregister; fresh Register starts empty (Q6) |
+| 5 | `config.reload()` | Explicit `scheduler.invalidate_cache(reason="config_reload")` |
+| 6 | Planner process restart | Cache lives in memory; process exit discards it. No code required |
+
+Each row has a dedicated must-pass test in
+`tests/plugins/scheduler/test_cache_invalidation.py`.
+
+## Auth source decision tree
+
+```
+ dev environment / single-tenant lab / pre-shared key OK?
+    └── yes → static_secret  (PR #1 default)
+        │
+        └── share-a-secret-with-dynamo-planner K8s Secret; map the secret
+            value → subject label in AuthConfig.static_secrets
+
+ multi-cluster / mesh / zero-trust?
+    └── yes → k8s_sa  (FOLLOW-UP PR — not in PR #1) — TokenReview against kube API
+              or → spiffe_jwt (FOLLOW-UP PR — not in PR #1) — SPIRE JWT-SVID
+
+ quick dev loop without real secrets?
+    └── allow_unauthenticated  (emits WARNING on construction;
+                               NEVER use in production)
+```
+
+`AuthConfig.trusted_sources=[]` is fail-closed — the registry refuses
+every token at startup. You must opt in explicitly.
+
+## Protocol versioning
+
+`RegisterRequest.protocol_version` is checked against
+`[protocol_version_min, protocol_version_max]` inclusive. v1 supports
+`["1.0", "1.0"]` only; when introducing v1.1, set
+`protocol_version_max="1.1"` to give the registry a window during which
+both old and new plugins can register against the same server.
+
+## In-process plugin registration
+
+`register_internal(plugin_id, plugin_type, priority, instance, ...)`
+skips auth and protocol checks and wraps `instance` in an
+`InProcessTransport`. Two callers:
+
+- The orchestrator (`OrchestratorEngineAdapter`) at startup, for builtin
+  plugins (`is_builtin=True`).
+- `NativePlannerBase`, for user plugins listed under
+  `planner.plugin_registration.in_process_plugins` (`is_builtin=False`,
+  loaded via `load_in_process_plugins`).
+
+**Any future heartbeat monitor must skip every plugin whose
+`transport_type` is `in_process`** — not just builtins. In-process
+plugins live inside the planner process, so "heartbeat missed" is
+meaningless and evicting them would drop correctly-registered user
+plugins that don't emit heartbeats. (Monitor implementation deferred
+to follow-up PR.)
+
+## Single-threaded asyncio invariant
+
+Every public method on `PluginRegistryServer`, `CircuitBreaker`, and
+`PluginScheduler` MUST be called from the event loop's main task. In
+particular:
+
+- **Never** call `scheduler.record_result` or
+  `scheduler.invalidate_cache` from inside an `asyncio.gather` plugin
+  coroutine. Serialize after `await asyncio.gather(...)` completes.
+- CircuitBreaker state and Scheduler cache are unlocked dicts — two
+  concurrent mutations is undefined behaviour.
+
+No runtime assert is shipped in PR #1 — the single-writer constraint
+above is enforced only by code review. A defensive `current_task()`
+check could be added in a follow-up.
+
+## Deployment examples
+
+### K8s Secret for `static_secret`
+
+```yaml
+apiVersion: v1
+kind: Secret
+metadata:
+  name: dynamo-planner-plugin-tokens
+type: Opaque
+stringData:
+  # Each key is a shared secret; its value is the subject label surfaced
+  # in audit logs and AuthIdentity.subject.
+  "shared-with-team-a-SoMePHRaSe": "team-a"
+  "shared-with-team-b-SoMEphRAsE": "team-b"
+```
+
+Then in `planner.plugin_registration.auth`:
+
+```yaml
+trusted_sources: [static_secret]
+static_secrets:
+  "shared-with-team-a-SoMePHRaSe": "team-a"
+  "shared-with-team-b-SoMEphRAsE": "team-b"
+```
+
+(Real deployments should template-inject from the mounted Secret rather
+than hard-code in values.yaml.)
+
+### Dev-only `allow_unauthenticated`
+
+```yaml
+trusted_sources: [allow_unauthenticated]
+```
+
+Logs emit a WARNING on startup; production deployments SHOULD fail-fast
+on seeing that warning.
+
+## Pointers
+
+| Topic | File |
+|---|---|
+| Data types + error hierarchy | `types.py` / `errors.py` |
+| Auth validators | `auth/base.py` + `auth/static_secret.py` + `auth/multi.py` |
+| Registry server (4 RPCs + `register_internal`) | `server.py` |
+| Circuit breaker state machine | `circuit_breaker.py` |
+| Scheduler + cache 6-row table | `../scheduler.py` |
+| Config schema + factories | `config.py` |
+| Integration tests | `../../tests/plugins/registry/test_integration.py` |
diff --git a/components/src/dynamo/planner/plugins/registry/__init__.py b/components/src/dynamo/planner/plugins/registry/__init__.py
new file mode 100644
index 000000000000..99ffb54227c0
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/registry/__init__.py
@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Plugin registry + scheduler.
+
+- ``PluginRegistryServer`` hosts the Register / Heartbeat / Unregister /
+  ListPlugins RPCs. Invokable in-process (for builtin / in_process user
+  plugins via ``register_internal``) or behind a gRPC server.
+- ``CircuitBreaker`` tracks per-plugin failure counts and fans out OPEN
+  transitions to the scheduler for cache invalidation.
+- ``PluginScheduler`` computes per-tick active set (triggered vs inherited
+  via HOLD_LAST cache) and honours the cache invalidation 6-row table.
+- ``auth/`` hosts ``AuthValidator`` implementations (PR #1 ships
+  ``static_secret`` + ``allow_unauthenticated``; K8s SA / SPIFFE JWT
+  land in a follow-up PR).
+
+The orchestrator composes these with the merge algorithms and
+transport/clock primitives into the planner pipeline.
+"""
+
+from dynamo.planner.plugins.registry.errors import AuthError, RegistryError
+from dynamo.planner.plugins.registry.types import (
+    RegisteredPlugin,
+    derive_transport_type,
+)
+
+__all__ = [
+    "RegisteredPlugin",
+    "derive_transport_type",
+    "RegistryError",
+    "AuthError",
+]
diff --git a/components/src/dynamo/planner/plugins/registry/auth/__init__.py b/components/src/dynamo/planner/plugins/registry/auth/__init__.py
new file mode 100644
index 000000000000..91b92a2317ec
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/registry/auth/__init__.py
@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Pluggable auth validators for PluginRegistry.
+
+Validator hierarchy::
+
+    AuthValidator (ABC)
+    ├── StaticSecretAuth        # shared-secret map
+    ├── MultiSourceAuth         # fan-out across the above
+    └── AllowUnauthenticatedAuth  # DEV ONLY; emits WARNING on init
+
+Wired in ``registry/config.py``'s ``build_auth_validator``. Selection is
+per-deployment config; PR #1 ships ``static_secret`` + the dev bypass.
+K8s ServiceAccount tokens and SPIFFE JWT-SVIDs land in a follow-up PR.
+"""
+
+from dynamo.planner.plugins.registry.auth.base import (
+    AllowUnauthenticatedAuth,
+    AuthIdentity,
+    AuthValidator,
+)
+from dynamo.planner.plugins.registry.auth.multi import MultiSourceAuth
+from dynamo.planner.plugins.registry.auth.static_secret import StaticSecretAuth
+
+__all__ = [
+    "AuthValidator",
+    "AuthIdentity",
+    "StaticSecretAuth",
+    "MultiSourceAuth",
+    "AllowUnauthenticatedAuth",
+]
diff --git a/components/src/dynamo/planner/plugins/registry/auth/base.py b/components/src/dynamo/planner/plugins/registry/auth/base.py
new file mode 100644
index 000000000000..51c3d2733678
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/registry/auth/base.py
@@ -0,0 +1,78 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""``AuthValidator`` ABC + ``AuthIdentity`` record + dev-only open validator.
+
+On validation failure, validators MUST raise ``AuthError``; the RPC layer
+converts that to a generic ``RegisterResponse(accepted=False,
+reject_reason="auth_failed")`` — never propagate the specific failure to
+the client, to avoid giving a token oracle.
+"""
+
+from __future__ import annotations
+
+import abc
+import logging
+from dataclasses import dataclass, field
+from typing import Literal
+
+from dynamo.planner.plugins.registry.errors import AuthError
+
+log = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class AuthIdentity:
+    """Outcome of a successful ``AuthValidator.validate`` call.
+
+    ``source`` names the validator that accepted the token (useful for
+    audit logs + metrics). ``subject`` is the caller identity (static
+    label / K8s ``namespace/serviceaccount`` / SPIFFE ID).
+    ``metadata`` may carry validator-specific extras (e.g. ``audience``).
+    """
+
+    source: Literal["static_secret", "allow_unauthenticated"]
+    subject: str
+    metadata: dict[str, str] = field(default_factory=dict)
+
+
+class AuthValidator(abc.ABC):
+    """Validate a plugin-supplied auth token.
+
+    Implementations MUST be async to permit out-of-process validation
+    (e.g. K8s TokenReview API); pure in-memory validators (static_secret)
+    still satisfy this by returning from a coroutine without awaiting.
+    """
+
+    @abc.abstractmethod
+    async def validate(self, token: str) -> AuthIdentity:
+        """Return an ``AuthIdentity`` on success; raise ``AuthError`` on
+        any validation failure."""
+        raise NotImplementedError
+
+
+class AllowUnauthenticatedAuth(AuthValidator):
+    """Dev-only bypass validator: accepts any token.
+
+    Emits a WARNING on construction so operators see it in logs even if
+    the registry never receives a real Register call. Production startup
+    scripts are expected to grep for this log line and refuse to bring up
+    the planner Pod when the validator is enabled outside dev.
+    """
+
+    def __init__(self) -> None:
+        log.warning(
+            "AllowUnauthenticatedAuth enabled — ALL Register requests will "
+            "be accepted without auth. DEV ONLY; MUST NOT run in production."
+        )
+
+    async def validate(self, token: str) -> AuthIdentity:
+        return AuthIdentity(source="allow_unauthenticated", subject="anonymous")
+
+
+__all__ = [
+    "AuthValidator",
+    "AuthIdentity",
+    "AllowUnauthenticatedAuth",
+    "AuthError",
+]
diff --git a/components/src/dynamo/planner/plugins/registry/auth/multi.py b/components/src/dynamo/planner/plugins/registry/auth/multi.py
new file mode 100644
index 000000000000..a0da6f2b383d
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/registry/auth/multi.py
@@ -0,0 +1,49 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""``MultiSourceAuth`` — fan-out composition of AuthValidators.
+
+Tries each configured source in order; the first to return an
+``AuthIdentity`` wins. Short-circuit on first success — subsequent
+sources are not consulted, which is critical when a later source would
+incur network I/O (e.g. K8s TokenReview).
+
+On total failure, raises ``AuthError`` with the *last* underlying
+failure message. Callers (the RPC layer) log the chained message for
+server-side audit but only surface ``reject_reason="auth_failed"`` to
+the client.
+"""
+
+from __future__ import annotations
+
+from typing import Sequence
+
+from dynamo.planner.plugins.registry.auth.base import AuthIdentity, AuthValidator
+from dynamo.planner.plugins.registry.errors import AuthError
+
+
+class MultiSourceAuth(AuthValidator):
+    def __init__(self, sources: Sequence[AuthValidator]) -> None:
+        if not sources:
+            raise ValueError(
+                "MultiSourceAuth requires at least one source; "
+                "empty list would silently reject every token."
+            )
+        self._sources: list[AuthValidator] = list(sources)
+
+    async def validate(self, token: str) -> AuthIdentity:
+        last_err: Exception | None = None
+        for source in self._sources:
+            try:
+                return await source.validate(token)
+            except AuthError as exc:
+                last_err = exc
+                continue
+        # All sources rejected — raise with chained context (server log only).
+        raise AuthError(
+            f"all {len(self._sources)} auth source(s) rejected token; "
+            f"last error: {last_err}"
+        )
+
+
+__all__ = ["MultiSourceAuth"]
diff --git a/components/src/dynamo/planner/plugins/registry/auth/static_secret.py b/components/src/dynamo/planner/plugins/registry/auth/static_secret.py
new file mode 100644
index 000000000000..96897b1a4e07
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/registry/auth/static_secret.py
@@ -0,0 +1,65 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""``StaticSecretAuth`` — constant-time lookup against a configured secrets map.
+
+The v1 must-have validator: a shared-secret scheme backed by a K8s Secret
+mount (or equivalent). Keys are secret values; values are caller labels
+(e.g. ``"shared-team-a"``) returned via ``AuthIdentity.subject`` for
+audit. Uses ``hmac.compare_digest`` to avoid timing side channels when
+ruling out non-matches.
+"""
+
+from __future__ import annotations
+
+import hmac
+from typing import Mapping
+
+from dynamo.planner.plugins.registry.auth.base import AuthIdentity, AuthValidator
+from dynamo.planner.plugins.registry.errors import AuthError
+
+
+class StaticSecretAuth(AuthValidator):
+    """Validate tokens by exact-match against a pre-shared secrets map.
+
+    Args:
+        secrets: mapping of ``secret_value -> subject_label``. An empty
+            mapping is accepted at construction time (so an empty Secret
+            mount doesn't crash startup) but every ``validate`` call will
+            then raise ``AuthError`` — the registry effectively rejects
+            all tokens, which is the correct fail-closed behaviour.
+    """
+
+    def __init__(self, secrets: Mapping[str, str]) -> None:
+        # Reject empty-string subject at config-validation time. The
+        # gateway's authenticated_heartbeat / authenticated_unregister
+        # compares the validated identity.subject against the plugin's
+        # auth_subject; in-process / builtin plugins use the default
+        # auth_subject="" (no gateway-facing auth applies to them — they
+        # bypass the gateway entirely). An operator who configured a
+        # secret mapping to "" would let any gateway caller pass that
+        # subject check against in-process plugins.
+        for secret_index, (_secret, subject) in enumerate(secrets.items()):
+            if not subject:
+                raise ValueError(
+                    "StaticSecretAuth: empty subject is not allowed for "
+                    f"secret entry at index {secret_index}; configure a "
+                    "distinguishing subject label per secret. (Token "
+                    "bytes are intentionally omitted from this error to "
+                    "avoid leaking secret material into startup logs.)"
+                )
+        self._secrets: dict[str, str] = dict(secrets)
+
+    async def validate(self, token: str) -> AuthIdentity:
+        if not token:
+            raise AuthError("static_secret: empty token")
+        # Constant-time comparison avoids leaking "first N chars matched"
+        # via timing. Python dict lookup is fast-path but not constant;
+        # for N small secrets, iterating + compare_digest is fine.
+        for secret, subject in self._secrets.items():
+            if hmac.compare_digest(token, secret):
+                return AuthIdentity(source="static_secret", subject=subject)
+        raise AuthError("static_secret: token not in trusted set")
+
+
+__all__ = ["StaticSecretAuth"]
diff --git a/components/src/dynamo/planner/plugins/registry/circuit_breaker.py b/components/src/dynamo/planner/plugins/registry/circuit_breaker.py
new file mode 100644
index 000000000000..9a794fd97a1c
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/registry/circuit_breaker.py
@@ -0,0 +1,177 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Per-plugin circuit breaker.
+
+State machine::
+
+    CLOSED
+      │  ``record_failure`` N times in a row
+      ▼
+    OPEN ──────── cooldown elapsed ────────► HALF_OPEN
+      ▲                                           │
+      │ ``record_failure`` (reset cooldown)       │ ``record_success``
+      └───────────────────────────────────────────┘
+                                                  ▼
+                                                CLOSED
+
+Defaults (v1): ``failure_threshold=5``, ``cooldown_seconds=30.0``. Tune
+per-deployment via config; README recommends ``10 / 60s`` for production
+to avoid amplifying transient network blips.
+
+State is in-memory only — registry restart clears all circuits back to
+CLOSED (v11 cache persistence table row 3).
+
+Observers (the PluginScheduler) subscribe via ``on_open`` to receive
+``plugin_id`` fan-out when a CLOSED → OPEN transition happens, so the
+HOLD_LAST cache can be invalidated (v11 cache invalidation row 3).
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Callable
+
+from dynamo.planner.plugins.clock import Clock
+from dynamo.planner.plugins.types import CircuitState
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class _CircuitEntry:
+    state: CircuitState = CircuitState.CLOSED
+    consecutive_failures: int = 0
+    opened_at: float = 0.0  # monotonic; meaningful when state == OPEN / HALF_OPEN
+
+
+class CircuitBreaker:
+    """Per-``plugin_id`` circuit breaker driven by a deterministic Clock.
+
+    Instance methods are **sync** and must be called from the event loop
+    main task (single-threaded asyncio invariant; see ``PluginScheduler``
+    docstring). The internal map ``dict[plugin_id -> _CircuitEntry]`` has
+    no locks.
+    """
+
+    def __init__(
+        self,
+        clock: Clock,
+        failure_threshold: int = 5,
+        cooldown_seconds: float = 30.0,
+    ) -> None:
+        if failure_threshold < 1:
+            raise ValueError("failure_threshold must be >= 1")
+        if cooldown_seconds <= 0:
+            raise ValueError("cooldown_seconds must be > 0")
+        self._clock = clock
+        self._failure_threshold = failure_threshold
+        self._cooldown = cooldown_seconds
+        self._entries: dict[str, _CircuitEntry] = {}
+        self._open_callbacks: list[Callable[[str], None]] = []
+
+    # ------------------------------------------------------------------
+    # Observation
+    # ------------------------------------------------------------------
+
+    def state(self, plugin_id: str) -> CircuitState:
+        """Return the current state, auto-transitioning OPEN → HALF_OPEN
+        when the cooldown has elapsed. Unknown ``plugin_id`` returns
+        ``CLOSED`` (implicit new entries)."""
+        entry = self._entries.get(plugin_id)
+        if entry is None:
+            return CircuitState.CLOSED
+        if (
+            entry.state == CircuitState.OPEN
+            and self._clock.monotonic() - entry.opened_at >= self._cooldown
+        ):
+            entry.state = CircuitState.HALF_OPEN
+        return entry.state
+
+    def can_call(self, plugin_id: str) -> bool:
+        """``True`` if the orchestrator may attempt a plugin call now."""
+        return self.state(plugin_id) != CircuitState.OPEN
+
+    # ------------------------------------------------------------------
+    # Mutations
+    # ------------------------------------------------------------------
+
+    def record_success(self, plugin_id: str) -> None:
+        entry = self._entries.setdefault(plugin_id, _CircuitEntry())
+        # Unconditionally transition to CLOSED on success — any prior state
+        # (HALF_OPEN probe recovering / already-CLOSED stable / OPEN if a
+        # call somehow bypassed is_allowed) collapses to CLOSED. We do not
+        # need to call ``self.state(plugin_id)`` first because no branch
+        # below reads the refreshed state; ``record_failure`` does need it
+        # to detect the HALF_OPEN → re-open path.
+        entry.consecutive_failures = 0
+        entry.state = CircuitState.CLOSED
+
+    def record_failure(self, plugin_id: str) -> None:
+        entry = self._entries.setdefault(plugin_id, _CircuitEntry())
+        _ = self.state(plugin_id)
+        if entry.state == CircuitState.HALF_OPEN:
+            # HALF_OPEN probe failed → re-open + reset cooldown.
+            # ``consecutive_failures`` is only consulted in the
+            # state == CLOSED threshold check below, so we don't bother
+            # updating it here — record_success would zero it on
+            # recovery anyway.
+            entry.state = CircuitState.OPEN
+            entry.opened_at = self._clock.monotonic()
+            self._fan_out_open(plugin_id)
+            return
+        entry.consecutive_failures += 1
+        if (
+            entry.state == CircuitState.CLOSED
+            and entry.consecutive_failures >= self._failure_threshold
+        ):
+            entry.state = CircuitState.OPEN
+            entry.opened_at = self._clock.monotonic()
+            self._fan_out_open(plugin_id)
+
+    def reset(self, plugin_id: str) -> None:
+        """Clear any state for a plugin — used on (un)register to stop
+        state leaking across a plugin_id reuse (v11 Q6 clients are
+        expected to Unregister + Register for version upgrades)."""
+        self._entries.pop(plugin_id, None)
+
+    # ------------------------------------------------------------------
+    # Observers
+    # ------------------------------------------------------------------
+
+    def on_open(self, callback: Callable[[str], None]) -> None:
+        """Register a callback invoked with ``plugin_id`` whenever a
+        CLOSED / HALF_OPEN → OPEN transition occurs.
+
+        Scheduler subscribes here during construction to invalidate
+        HOLD_LAST cache entries for OPEN plugins (v11 cache invalidation
+        row 3). Callbacks run synchronously on the event loop main task;
+        they must not await.
+        """
+        self._open_callbacks.append(callback)
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    def _fan_out_open(self, plugin_id: str) -> None:
+        # Each observer is best-effort: a bad callback must not stop the
+        # remaining callbacks from firing. record_failure() runs on the
+        # circuit-breaker failure path; if one observer escaped the loop,
+        # a single buggy scheduler-side listener could turn a per-plugin
+        # blip into a registry-wide failure.
+        for cb in list(self._open_callbacks):
+            try:
+                cb(plugin_id)
+            except Exception as exc:  # noqa: BLE001 — defensive
+                log.warning(
+                    "on_open callback for plugin_id=%s raised %s: %s — "
+                    "remaining callbacks will still fire",
+                    plugin_id,
+                    type(exc).__name__,
+                    exc,
+                )
+
+
+__all__ = ["CircuitBreaker"]
diff --git a/components/src/dynamo/planner/plugins/registry/config.py b/components/src/dynamo/planner/plugins/registry/config.py
new file mode 100644
index 000000000000..73aa4cd5b34b
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/registry/config.py
@@ -0,0 +1,266 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Registry configuration schema + factories.
+
+Schema shape
+------------
+
+``planner.plugin_registration.*``
+  - ``auth`` (trusted_sources + per-source config)
+  - ``transport`` (TransportConfig; see ``transport/config.py``)
+  - ``protocol_version_min`` / ``_max``
+  - ``heartbeat_timeout_seconds`` / ``heartbeat_missed_threshold``
+  - ``in_process_plugins`` — lives next to other "how plugins register"
+    settings
+  - ``admin`` (simplified — ``AllowAllAdminAuth`` default)
+
+``planner.scheduling.*`` lives in ``config/planner_config.py``
+(``SchedulingConfig`` + ``GatewayConfig``); this module does not own
+that subtree. The clock + transport timeouts referenced by
+``SchedulingConfig`` come from ``plugins/transport/config.py``.
+
+Auth scope: PR #1 wires ``static_secret`` + ``allow_unauthenticated``.
+``k8s_sa`` and ``spiffe_jwt`` land in a follow-up PR alongside their
+cluster-side configuration and end-to-end smoke tests.
+"""
+
+from __future__ import annotations
+
+import functools
+import logging
+from typing import TYPE_CHECKING, Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from dynamo.planner.plugins.transport.config import TransportConfig
+
+# ``PluginRegistryServer`` (and through it ``plugin_pb2`` / ``plugin_pb2_grpc``)
+# is only needed at *runtime* by the build helpers below — not by the
+# Pydantic config schema this module exposes for import-time deserialisation.
+# Keeping the heavy import out of the module top-level lets
+# ``PlannerConfig.scheduling.plugin_registration`` resolve to its schema in
+# a default ``use_orchestrator=False`` deployment without requiring the
+# generated proto stubs to be present on disk (the stubs are generated at
+# install / dev-time only; PSM-only deployments must still parse the
+# config tree).
+if TYPE_CHECKING:
+    from dynamo.planner.plugins.clock import Clock
+    from dynamo.planner.plugins.registry.auth.base import AuthValidator
+    from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+    from dynamo.planner.plugins.registry.server import PluginRegistryServer
+    from dynamo.planner.plugins.transport.base import PluginTransport
+
+log = logging.getLogger(__name__)
+
+
+# ----------------------------------------------------------------------------
+# Auth
+# ----------------------------------------------------------------------------
+
+
+AuthSource = Literal["static_secret", "allow_unauthenticated"]
+
+
+class AuthConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    trusted_sources: list[AuthSource] = Field(default_factory=list)
+    """Empty default = fail-closed; ``build_auth_validator`` raises."""
+
+    static_secrets: dict[str, str] = Field(default_factory=dict)
+    """``secret_value -> subject_label`` map."""
+
+
+# ----------------------------------------------------------------------------
+# In-process plugin spec
+# ----------------------------------------------------------------------------
+
+
+class InProcessPluginSpec(BaseModel):
+    """Spec for an in-process plugin entry — lives under
+    PluginRegistrationConfig so all "how plugins come to exist"
+    settings live together.
+
+    ``extra="forbid"`` rejects unknown fields (including
+    ``protocol_version``, which is nonsensical for in-process plugins).
+    """
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    module: str
+    class_: str = Field(..., alias="class")
+    """Python class name in ``module``; aliased since ``class`` is a keyword."""
+
+    plugin_id: str
+    plugin_type: Literal["predict", "propose", "reconcile", "constrain"]
+    priority: int
+    execution_interval_seconds: float = 0.0
+    hold_policy: Literal["ACCEPT_WHEN_IDLE", "HOLD_LAST"] = "ACCEPT_WHEN_IDLE"
+    needs: list[str] = Field(default_factory=list)
+    """Capability list (consumed by type-aware merge / lazy-traffic-pull)."""
+
+    requires_produced_fields: list[str] = Field(default_factory=list)
+    """Hard dependency on earlier-stage produced fields. Each entry is a
+    dot-path into ``PipelineContext`` (e.g. ``"predictions"``,
+    ``"observations.traffic"``). Scheduler skips this plugin for the
+    tick if any listed field is unset; skipping does NOT advance the
+    plugin's anchor. Empty = no gating."""
+
+    observation_window_seconds: float = Field(default=0.0, ge=0)
+    """Aggregation window the plugin wants for windowed observation
+    types in ``needs``. ``0.0`` = ``scale_interval`` freshness;
+    ``N > 0`` = aggregate over the last ``N`` seconds."""
+
+    kwargs: dict[str, Any] = Field(default_factory=dict)
+
+
+# ----------------------------------------------------------------------------
+# Admin
+# ----------------------------------------------------------------------------
+
+
+class AdminAuthConfig(BaseModel):
+    """Admin (ListPlugins) RBAC config.
+
+    **PR #1 status — config is parsed but inert**: the gRPC
+    ``PluginRegistry.ListPlugins`` RPC currently default-denies with
+    ``PERMISSION_DENIED`` regardless of ``mode`` (see
+    ``plugins/registry/gateway.py:ListPlugins``). The admin RBAC path
+    that consumes this field — including ``k8s_rbac`` resolution — lands
+    together with the broader auth follow-up (PR 1.5). Setting ``mode``
+    in YAML today has no effect; in-process callers
+    (``PluginRegistryServer.list_plugins`` direct method) are
+    unaffected by the gateway default-deny.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    mode: Literal["allow_all", "k8s_rbac"] = "allow_all"
+
+
+# ----------------------------------------------------------------------------
+# Top-level aggregate
+# ----------------------------------------------------------------------------
+
+
+class PluginRegistrationConfig(BaseModel):
+    """``planner.plugin_registration.*`` root config tree (v11)."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    auth: AuthConfig = Field(default_factory=AuthConfig)
+    transport: TransportConfig = Field(default_factory=TransportConfig)
+    protocol_version_min: str = "1.0"
+    protocol_version_max: str = "1.0"
+    heartbeat_timeout_seconds: float = 15.0
+    heartbeat_missed_threshold: int = 2
+    in_process_plugins: list[InProcessPluginSpec] = Field(default_factory=list)
+    admin: AdminAuthConfig = Field(default_factory=AdminAuthConfig)
+
+
+# ----------------------------------------------------------------------------
+# Factories
+# ----------------------------------------------------------------------------
+
+
+def build_auth_validator(config: AuthConfig) -> "AuthValidator":
+    # Heavy auth/registry imports deferred to call time so this module
+    # stays importable in PSM-only deployments without the generated
+    # plugin_pb2 stubs (see TYPE_CHECKING block at module top).
+    from dynamo.planner.plugins.registry.auth import (
+        AllowUnauthenticatedAuth,
+        MultiSourceAuth,
+        StaticSecretAuth,
+    )
+
+    """Construct the composed auth validator from ``AuthConfig``.
+
+    Raises ``ValueError`` on empty ``trusted_sources`` (fail-closed) —
+    PR #1 supports ``static_secret`` and ``allow_unauthenticated``.
+    """
+    if not config.trusted_sources:
+        raise ValueError(
+            "AuthConfig.trusted_sources is empty; registry would reject "
+            "every token. Configure at least one source (e.g. "
+            "['static_secret']) or ['allow_unauthenticated'] for dev."
+        )
+    sources: list[AuthValidator] = []
+    for source_name in config.trusted_sources:
+        if source_name == "static_secret":
+            if not config.static_secrets:
+                log.warning(
+                    "AuthConfig.static_secrets is empty but 'static_secret' "
+                    "listed in trusted_sources — StaticSecretAuth will reject "
+                    "every token."
+                )
+            sources.append(StaticSecretAuth(config.static_secrets))
+        elif source_name == "allow_unauthenticated":
+            sources.append(AllowUnauthenticatedAuth())
+        else:  # pragma: no cover — schema Literal prevents reaching here
+            raise ValueError(f"unknown auth source: {source_name!r}")
+    return MultiSourceAuth(sources)
+
+
+def build_registry_from_config(
+    config: PluginRegistrationConfig,
+    clock: "Clock",
+) -> tuple["PluginRegistryServer", "CircuitBreaker"]:
+    """Construct and wire the registry + circuit breaker.
+
+    Returns the pair so the caller (orchestrator) can hand the circuit
+    breaker to other subsystems (scheduler, heartbeat monitor).
+    """
+    # Heavy registry imports deferred to call time so this module stays
+    # importable in PSM-only deployments without the generated
+    # plugin_pb2 stubs (see TYPE_CHECKING block at module top).
+    from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+    from dynamo.planner.plugins.registry.server import PluginRegistryServer
+
+    auth = build_auth_validator(config.auth)
+    cb = CircuitBreaker(clock)
+
+    transport_factory = functools.partial(
+        _transport_factory_shim, transport_config=config.transport
+    )
+
+    server = PluginRegistryServer(
+        clock=clock,
+        auth=auth,
+        circuit_breaker=cb,
+        transport_factory=transport_factory,
+        protocol_versions=(config.protocol_version_min, config.protocol_version_max),
+    )
+    return server, cb
+
+
+def _transport_factory_shim(
+    plugin_id: str,
+    endpoint: str,
+    *,
+    in_process_instance: Any = None,
+    transport_config: TransportConfig,
+) -> "PluginTransport":
+    """Adapter: ``make_transport_for_endpoint`` takes ``config`` as the
+    third positional argument; the registry's factory protocol is
+    ``(plugin_id, endpoint, *, in_process_instance=None)``."""
+    # Heavy transport import deferred (see TYPE_CHECKING block above).
+    from dynamo.planner.plugins.transport.config import make_transport_for_endpoint
+
+    return make_transport_for_endpoint(
+        plugin_id,
+        endpoint,
+        transport_config,
+        in_process_instance=in_process_instance,
+    )
+
+
+__all__ = [
+    "AuthSource",
+    "AuthConfig",
+    "InProcessPluginSpec",
+    "AdminAuthConfig",
+    "PluginRegistrationConfig",
+    "build_auth_validator",
+    "build_registry_from_config",
+]
diff --git a/components/src/dynamo/planner/plugins/registry/errors.py b/components/src/dynamo/planner/plugins/registry/errors.py
new file mode 100644
index 000000000000..2b3e23a0a7c0
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/registry/errors.py
@@ -0,0 +1,30 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Registry error hierarchy.
+
+All errors raised by ``PluginRegistryServer`` and its auth validators
+inherit ``RegistryError``. Orchestrator callers catch the base class for
+generic handling or a specific subclass when the reason matters for
+audit / metric labels.
+
+``AuthError`` deliberately uses a generic ``reject_reason="auth_failed"``
+at the RPC boundary — the *specific* failure mode is captured in the
+exception message for server-side audit only, to avoid giving token
+oracles to clients.
+"""
+
+from __future__ import annotations
+
+
+class RegistryError(Exception):
+    """Base class for all PluginRegistry errors."""
+
+
+class AuthError(RegistryError):
+    """Auth validation failed.
+
+    Raised by ``AuthValidator.validate``; the RPC layer converts this into
+    ``RegisterResponse(accepted=False, reject_reason="auth_failed")``
+    without leaking the specific reason to the client.
+    """
diff --git a/components/src/dynamo/planner/plugins/registry/gateway.py b/components/src/dynamo/planner/plugins/registry/gateway.py
new file mode 100644
index 000000000000..c35589292e91
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/registry/gateway.py
@@ -0,0 +1,255 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Public gRPC entry point for the plugin registry.
+
+Wraps a :class:`PluginRegistryServer` (single-process Python methods)
+and exposes its 4 RPCs over the network so external plugin processes
+can register / heartbeat / unregister / list themselves without
+needing to be inside the planner Python process.
+
+The class is deliberately thin: every RPC just converts proto →
+Pydantic via ``_proto_bridge``, calls the underlying
+``PluginRegistryServer`` method (which already enforces auth /
+protocol / dedup / endpoint-scheme), and converts the response back.
+That keeps the auth + reject-reason contract identical between the
+in-process call site and the gRPC call site — operators never have
+two diverging code paths to reason about.
+
+Lifecycle
+---------
+
+``start_gateway_server`` returns the bound ``grpc.aio.Server`` so the
+caller (``NativePlannerBase``-equivalent startup hook) controls
+``await server.stop(grace=...)`` on shutdown. Don't park the gRPC
+server's lifecycle inside this module — it has to coordinate with the
+planner's own shutdown sequence.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+import grpc
+
+from dynamo.planner.plugins._proto_bridge import proto_to_pydantic, pydantic_to_proto
+from dynamo.planner.plugins.proto.v1 import plugin_pb2 as pb
+from dynamo.planner.plugins.proto.v1 import plugin_pb2_grpc as pbg
+from dynamo.planner.plugins.registry.server import PluginRegistryServer
+from dynamo.planner.plugins.types import (
+    HeartbeatRequest,
+    HeartbeatResponse,
+    RegisterRequest,
+    RegisterResponse,
+    UnregisterRequest,
+    UnregisterResponse,
+)
+
+log = logging.getLogger(__name__)
+
+
+class PluginRegistryGatewayServicer(pbg.PluginRegistryServicer):
+    """Thin proto adapter over :class:`PluginRegistryServer`.
+
+    All 4 RPCs follow the same shape:
+
+    1. ``proto_to_pydantic`` the request (failure → INVALID_ARGUMENT)
+    2. ``await self._server.<method>(pyd_request)`` (the underlying
+       method is the same one in-process callers use, so auth / dedup
+       / circuit-breaker contracts are identical)
+    3. ``pydantic_to_proto`` the response
+
+    Authentication is performed *inside* ``server.register()`` (it
+    consults the configured ``AuthValidator``) — the gateway does NOT
+    duplicate that logic. Keeps a single source of truth for "what is
+    accepted".
+    """
+
+    def __init__(self, server: PluginRegistryServer) -> None:
+        self._server = server
+
+    async def Register(
+        self,
+        request: pb.RegisterRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> pb.RegisterResponse:
+        try:
+            pyd_req: RegisterRequest = proto_to_pydantic(request)
+        except Exception as exc:  # pragma: no cover (defensive)
+            await context.abort(
+                grpc.StatusCode.INVALID_ARGUMENT,
+                f"register: malformed request: {type(exc).__name__}: {exc}",
+            )
+        pyd_resp: RegisterResponse = await self._server.register(pyd_req)
+        return pydantic_to_proto(pyd_resp)
+
+    async def Heartbeat(
+        self,
+        request: pb.HeartbeatRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> pb.HeartbeatResponse:
+        try:
+            pyd_req: HeartbeatRequest = proto_to_pydantic(request)
+        except Exception as exc:  # pragma: no cover
+            await context.abort(
+                grpc.StatusCode.INVALID_ARGUMENT,
+                f"heartbeat: malformed request: {type(exc).__name__}: {exc}",
+            )
+        ok, reject = await self._server.authenticated_heartbeat(
+            pyd_req.plugin_id, pyd_req.auth_token
+        )
+        if reject == "auth_failed":
+            await context.abort(
+                grpc.StatusCode.UNAUTHENTICATED, "heartbeat: auth_failed"
+            )
+        if reject == "permission_denied":
+            await context.abort(
+                grpc.StatusCode.PERMISSION_DENIED,
+                "heartbeat: caller subject does not match registered plugin",
+            )
+        return pydantic_to_proto(HeartbeatResponse(ok=ok))
+
+    async def Unregister(
+        self,
+        request: pb.UnregisterRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> pb.UnregisterResponse:
+        try:
+            pyd_req: UnregisterRequest = proto_to_pydantic(request)
+        except Exception as exc:  # pragma: no cover
+            await context.abort(
+                grpc.StatusCode.INVALID_ARGUMENT,
+                f"unregister: malformed request: {type(exc).__name__}: {exc}",
+            )
+        ok, reject = await self._server.authenticated_unregister(
+            pyd_req.plugin_id, pyd_req.auth_token, reason=pyd_req.reason
+        )
+        if reject == "auth_failed":
+            await context.abort(
+                grpc.StatusCode.UNAUTHENTICATED, "unregister: auth_failed"
+            )
+        if reject == "permission_denied":
+            await context.abort(
+                grpc.StatusCode.PERMISSION_DENIED,
+                "unregister: caller subject does not match registered plugin",
+            )
+        return pydantic_to_proto(UnregisterResponse(ok=ok))
+
+    async def ListPlugins(  # type: ignore[return]
+        self,
+        request: pb.ListPluginsRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> pb.ListPluginsResponse:
+        # ListPlugins exposes the full plugin inventory (ids + endpoints +
+        # circuit state). The plugin-level ``auth_token`` model used for
+        # Register / Heartbeat / Unregister is not the right gate here —
+        # that's an admin-level RBAC concern. Until ``AdminAuthConfig`` is
+        # wired (PR 1.5, alongside k8s_sa / mTLS), the gateway default-denies
+        # this RPC. In-process callers (Prometheus exporter,
+        # ``PluginRegistryServer.list_plugins``) are unaffected.
+        await context.abort(
+            grpc.StatusCode.PERMISSION_DENIED,
+            "list_plugins: admin authentication is not yet wired over gRPC; "
+            "use the in-process registry method until admin RBAC lands.",
+        )
+
+
+# ---------------------------------------------------------------------------
+# Server lifecycle helper
+# ---------------------------------------------------------------------------
+
+
+async def start_gateway_server(
+    server: PluginRegistryServer,
+    *,
+    listen: str,
+    server_credentials: Optional[grpc.ServerCredentials] = None,
+    allow_insecure: bool = False,
+) -> tuple[grpc.aio.Server, str]:
+    """Build and start a gRPC server hosting :class:`PluginRegistryGatewayServicer`.
+
+    Args:
+        server: the in-process registry the gateway should delegate to.
+        listen: bind address, passed verbatim to
+            ``grpc.aio.server.add_insecure_port`` /
+            ``add_secure_port``. Both accept gRPC's URI scheme:
+            - ``unix:/abs/path`` (or ``unix:///abs/path``) for a Unix
+              domain socket — used when plugins register from the same
+              Pod and the Pod boundary is the trust boundary.
+            - ``host:port`` for TCP (use ``0.0.0.0:N`` to bind all
+              interfaces; ``:0`` for an ephemeral port).
+            - ``[::]:N`` for IPv6.
+            Note that this is the *gateway listen address*; the
+            plugins' own callback endpoints (``RegisterRequest.endpoint``)
+            are restricted to ``inproc://`` and ``grpc://`` by
+            ``make_transport_for_endpoint``.
+        server_credentials: optional ``ssl_server_credentials`` for
+            mTLS. mTLS itself lands in a follow-up PR — PR #1 callers
+            pass ``None`` (insecure port). Insecure is acceptable for
+            UDS bind (Pod-local trust) or tests; for cross-Pod TCP it
+            relies on K8s NetworkPolicy / Pod-to-Pod identity until
+            mTLS lands.
+
+    Returns:
+        ``(grpc_server, actual_listen)``. The caller is responsible
+        for ``await grpc_server.stop(grace=...)`` on planner shutdown.
+        ``actual_listen`` echoes ``listen`` unless an ephemeral port
+        was requested (``:0``), in which case it carries the bound port.
+    """
+    grpc_server = grpc.aio.server()
+    pbg.add_PluginRegistryServicer_to_server(
+        PluginRegistryGatewayServicer(server), grpc_server
+    )
+    if server_credentials is not None:
+        port = grpc_server.add_secure_port(listen, server_credentials)
+    else:
+        # Plaintext bind. The gateway receives plugins' shared-secret
+        # ``auth_token``, so an insecure TCP listen would leak it on the
+        # wire. Fail closed on TCP unless the operator explicitly opts in
+        # via ``allow_insecure`` — mirroring the outbound transport's
+        # ``allow_insecure_grpc`` gate. ``unix:`` (Pod-local) listens are
+        # always allowed: the Pod boundary is the trust boundary.
+        is_unix = listen.startswith("unix:")
+        if not is_unix and not allow_insecure:
+            raise RuntimeError(
+                f"refusing to bind plaintext (no-TLS) gRPC gateway on TCP "
+                f"listen {listen!r}: it would expose plugin auth tokens on "
+                f"the wire. Use a ``unix:`` listen, supply TLS credentials, "
+                f"or set ``gateway.allow_insecure=true`` to accept the risk."
+            )
+        if not is_unix:
+            log.warning(
+                "plugin registry gateway binding PLAINTEXT (no TLS) on TCP "
+                "%r — plugin auth tokens cross the wire unencrypted; "
+                "allow_insecure=true was set. Prefer a unix: socket or mTLS.",
+                listen,
+            )
+        port = grpc_server.add_insecure_port(listen)
+    # ``add_*_port`` returns 0 when the bind fails (port in use, bad
+    # address, permission denied on a unix socket path, etc). Catch this
+    # before starting so the operator sees a clear error instead of a
+    # silently-running gateway that never accepts connections.
+    if port == 0:
+        raise RuntimeError(
+            f"plugin registry gateway failed to bind {listen!r} — "
+            "address may be in use, the path may be unwritable, or the "
+            "scheme may be malformed"
+        )
+    await grpc_server.start()
+    actual_listen = listen
+    if listen.endswith(":0"):
+        host = listen.rsplit(":", 1)[0]
+        actual_listen = f"{host}:{port}"
+    log.info(
+        "plugin registry gateway listening at %s (secure=%s)",
+        actual_listen,
+        server_credentials is not None,
+    )
+    return grpc_server, actual_listen
+
+
+__all__ = [
+    "PluginRegistryGatewayServicer",
+    "start_gateway_server",
+]
diff --git a/components/src/dynamo/planner/plugins/registry/server.py b/components/src/dynamo/planner/plugins/registry/server.py
new file mode 100644
index 000000000000..e9e1017ede05
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/registry/server.py
@@ -0,0 +1,515 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""PluginRegistryServer.
+
+Hosts the four Register / Heartbeat / Unregister / ListPlugins operations.
+Invokable both via gRPC (a generated gRPC servicer wires to these methods)
+and in-process (orchestrator calls ``register_internal`` for builtin
+plugins + ``unregister`` during shutdown).
+
+Responsibilities
+----------------
+1. Gate every Register through the ``AuthValidator`` and a protocol
+   version check; reject duplicates (clients must Unregister + Register
+   for version upgrades, not upsert).
+2. Build the appropriate ``PluginTransport`` via an injected factory
+   (``functools.partial(make_transport_for_endpoint, config=...)`` or
+   equivalent) — the server stays decoupled from ``TransportConfig``.
+3. Maintain the in-memory ``dict[plugin_id -> RegisteredPlugin]`` and
+   update ``last_heartbeat_at`` / ``last_call_at`` / ``evaluations_total``
+   (the last two are written by the orchestrator via accessors).
+4. On Unregister, close the transport, reset the plugin's circuit-breaker
+   state, and fan out to any ``on_unregister`` subscriber
+   (PluginScheduler uses this to drop the plugin's HOLD_LAST cache).
+
+The class is **single-threaded asyncio** — all methods run on the event
+loop main task; the internal dict is unlocked.
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+from typing import Any, Callable, Optional
+
+from packaging.version import InvalidVersion, Version
+
+from dynamo.planner.plugins.clock import Clock
+from dynamo.planner.plugins.registry.auth.base import AuthValidator
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+from dynamo.planner.plugins.registry.errors import AuthError
+from dynamo.planner.plugins.registry.types import (
+    RegisteredPlugin,
+    derive_transport_type,
+)
+from dynamo.planner.plugins.transport.base import PluginTransport
+from dynamo.planner.plugins.types import (
+    HoldPolicy,
+    ListPluginsRequest,
+    PluginInfo,
+    RegisterRequest,
+    RegisterResponse,
+)
+
+log = logging.getLogger(__name__)
+
+
+# Callable[(plugin_id, endpoint, *, in_process_instance=None), PluginTransport]
+TransportFactory = Callable[..., PluginTransport]
+# Callback invoked on unregister with (plugin_id, reason).
+UnregisterCallback = Callable[[str, str], None]
+
+
+# Floating-point tolerance for "is this a clean multiple of scale_interval?"
+# Picked to absorb the float arithmetic noise that creeps in when a YAML
+# author writes ``observation_window_seconds: 7.5`` and Pydantic /
+# protobuf round-trip through float32: a 1e-6 tolerance is well below
+# any meaningful scale_interval (defaults to 5.0s) yet large enough to
+# accept ``2.0 * 5.0`` after a couple of float operations.
+_WINDOW_ALIGN_TOLERANCE_S = 1e-6
+
+
+def _check_observation_window(
+    window_s: float, scale_interval_s: float
+) -> Optional[str]:
+    """Return a ``reject_reason`` string if ``window_s`` violates the
+    proto contract, else ``None``.  Contract:
+
+      0.0                                       -> accept (use scale_interval)
+      N where (N > 0 and N is k * scale_interval) -> accept
+      anything else                             -> reject
+
+    ``scale_interval_s == 0.0`` disables the check (PSM path constructs
+    the server without a scale_interval; the proto contract there is
+    implicit and unverifiable).
+    """
+    if scale_interval_s <= 0.0:
+        return None
+    if window_s == 0.0:
+        return None
+    if window_s < 0.0:
+        return (
+            "observation_window_misaligned: "
+            f"observation_window_seconds={window_s} must be >= 0"
+        )
+    ratio = window_s / scale_interval_s
+    rounded = round(ratio)
+    if rounded < 1 or abs(ratio - rounded) > _WINDOW_ALIGN_TOLERANCE_S:
+        return (
+            "observation_window_misaligned: "
+            f"observation_window_seconds={window_s} must be 0 or a positive "
+            f"integer multiple of scale_interval_seconds="
+            f"{scale_interval_s}"
+        )
+    return None
+
+
+class PluginRegistryServer:
+    """In-memory plugin registry + transport lifecycle manager."""
+
+    def __init__(
+        self,
+        clock: Clock,
+        auth: AuthValidator,
+        circuit_breaker: CircuitBreaker,
+        transport_factory: TransportFactory,
+        protocol_versions: tuple[str, str] = ("1.0", "1.0"),
+        scale_interval_seconds: float = 0.0,
+    ) -> None:
+        self._clock = clock
+        self._auth = auth
+        self._circuit_breaker = circuit_breaker
+        self._transport_factory = transport_factory
+        self._protocol_min, self._protocol_max = protocol_versions
+        # ``scale_interval_seconds`` enables phase alignment of
+        # ``RegisteredPlugin.registered_at`` to the nearest tick boundary
+        # (``floor(now / scale_interval) * scale_interval``).  This makes
+        # plugins with the same ``execution_interval_seconds`` fire on
+        # the same pipeline tick irrespective of small registration-time
+        # skew between bootstrapped builtins (a few ms apart from
+        # ``register_internal`` ordering in the orchestrator startup
+        # sequence).  Without alignment, plugin A registered at T=0 and
+        # plugin B at T=0.003 would forever fire on different ticks if
+        # both declare the same interval, and any future
+        # ``requires_produced_fields`` dependency between them would
+        # silently deadlock.
+        #
+        # ``scale_interval_seconds == 0.0`` (the default) disables phase
+        # alignment — preserves the legacy behaviour for tests and the
+        # PSM path that constructs the server without a scale_interval.
+        self._scale_interval_seconds = scale_interval_seconds
+        self._plugins: dict[str, RegisteredPlugin] = {}
+        self._unregister_callbacks: list[UnregisterCallback] = []
+        # Scheduler reference lazy-attached so ``list_plugins`` can report
+        # ``cache_age_seconds`` without making server construction depend
+        # on the scheduler (which in turn already depends on the server).
+        self._cache_age_lookup: Optional[Callable[[str], float]] = None
+
+    def _aligned_anchor(self, raw_now: float) -> float:
+        """Compute the registered_at anchor for a plugin registering at
+        ``raw_now`` (monotonic clock).  When ``scale_interval_seconds``
+        > 0, snaps to the nearest tick boundary below ``raw_now``.
+        Otherwise returns ``raw_now`` unchanged (legacy / PSM path).
+        """
+        if self._scale_interval_seconds <= 0.0:
+            return raw_now
+        return (
+            math.floor(raw_now / self._scale_interval_seconds)
+            * self._scale_interval_seconds
+        )
+
+    # ------------------------------------------------------------------
+    # Public RPC-shaped API
+    # ------------------------------------------------------------------
+
+    async def register(self, req: RegisterRequest) -> RegisterResponse:
+        # 1. Auth — on failure, return generic reject_reason to avoid oracle.
+        try:
+            identity = await self._auth.validate(req.auth_token)
+        except AuthError as exc:
+            log.info(
+                "register rejected plugin_id=%s reason=auth_failed detail=%s",
+                req.plugin_id,
+                exc,
+            )
+            return RegisterResponse(accepted=False, reject_reason="auth_failed")
+
+        # 2. Protocol version (inclusive range check). Use semantic
+        # version compare via ``packaging.version.Version`` — a plain
+        # string compare mis-orders "1.10" vs "1.2" (lexicographic puts
+        # "1.10" < "1.2" because '1' < '2'), which could mistakenly
+        # reject valid plugins once a component reaches 10.
+        try:
+            req_v = Version(req.protocol_version)
+            min_v = Version(self._protocol_min)
+            max_v = Version(self._protocol_max)
+        except InvalidVersion as exc:
+            reason = (
+                f"protocol_version_malformed: requested={req.protocol_version!r} "
+                f"(detail={exc!s})"
+            )
+            log.info("register rejected plugin_id=%s reason=%s", req.plugin_id, reason)
+            return RegisterResponse(accepted=False, reject_reason=reason)
+        if not (min_v <= req_v <= max_v):
+            reason = (
+                f"protocol_version_unsupported: requested={req.protocol_version}, "
+                f"supported=[{self._protocol_min},{self._protocol_max}]"
+            )
+            log.info("register rejected plugin_id=%s reason=%s", req.plugin_id, reason)
+            return RegisterResponse(accepted=False, reject_reason=reason)
+
+        # 2.5. Observation window alignment.  Proto contract
+        # (plugin.proto:107) requires ``observation_window_seconds`` to
+        # be 0 OR a positive multiple of ``scale_interval_seconds`` so
+        # the resulting Prometheus window aligns to tick boundaries —
+        # otherwise the aggregated value crosses tick boundaries and the
+        # plugin sees a moving target.  Only enforce when the server has
+        # a known scale_interval (PSM path constructs without one, so
+        # the constraint there is implicit / unverifiable).
+        reject_window = _check_observation_window(
+            req.observation_window_seconds, self._scale_interval_seconds
+        )
+        if reject_window is not None:
+            log.info(
+                "register rejected plugin_id=%s reason=%s",
+                req.plugin_id,
+                reject_window,
+            )
+            return RegisterResponse(accepted=False, reject_reason=reject_window)
+
+        # 3. Duplicate plugin_id → reject.
+        if req.plugin_id in self._plugins:
+            reason = "duplicate_plugin_id: must Unregister before re-Register"
+            log.info("register rejected plugin_id=%s reason=%s", req.plugin_id, reason)
+            return RegisterResponse(accepted=False, reject_reason=reason)
+
+        # 4. Build transport. ValueError from the factory (e.g. unknown scheme,
+        # missing mTLS on grpc://) surfaces as a reject — don't crash the server.
+        try:
+            transport_type = derive_transport_type(req.endpoint)
+            if transport_type == "in_process":
+                # in_process endpoints arriving via the *network* RPC are a
+                # client-side bug: in-process plugins MUST use register_internal.
+                reason = (
+                    "endpoint_rejected: inproc:// endpoints are for in-process "
+                    "registration only; use register_internal() for builtin / "
+                    "in-process user plugins"
+                )
+                log.warning(
+                    "register rejected plugin_id=%s reason=%s", req.plugin_id, reason
+                )
+                return RegisterResponse(accepted=False, reject_reason=reason)
+            transport = self._transport_factory(req.plugin_id, req.endpoint)
+        except ValueError as exc:
+            log.warning(
+                "register rejected plugin_id=%s reason=transport_build_failed detail=%s",
+                req.plugin_id,
+                exc,
+            )
+            return RegisterResponse(
+                accepted=False, reject_reason=f"transport_build_failed: {exc}"
+            )
+
+        # 5. Build record + add to dict.
+        plugin = RegisteredPlugin(
+            plugin_id=req.plugin_id,
+            plugin_type=req.plugin_type,
+            priority=req.priority,
+            endpoint=req.endpoint,
+            version=req.version,
+            protocol_version=req.protocol_version,
+            execution_interval_seconds=req.execution_interval_seconds,
+            hold_policy=req.hold_policy,
+            needs=list(req.needs),
+            requires_produced_fields=list(req.requires_produced_fields),
+            observation_window_seconds=req.observation_window_seconds,
+            is_builtin=False,
+            transport=transport,
+            transport_type=transport_type,
+            registered_at=self._aligned_anchor(self._clock.monotonic()),
+            auth_subject=identity.subject,
+        )
+        self._plugins[req.plugin_id] = plugin
+        self._circuit_breaker.reset(req.plugin_id)
+
+        log.info(
+            "register accepted plugin_id=%s type=%s priority=%d endpoint=%s "
+            "subject=%s auth_source=%s",
+            plugin.plugin_id,
+            plugin.plugin_type,
+            plugin.priority,
+            plugin.endpoint,
+            identity.subject,
+            identity.source,
+        )
+        return RegisterResponse(
+            accepted=True,
+            negotiated_protocol_version=req.protocol_version,
+        )
+
+    async def heartbeat(self, plugin_id: str) -> bool:
+        plugin = self._plugins.get(plugin_id)
+        if plugin is None:
+            return False
+        plugin.last_heartbeat_at = self._clock.monotonic()
+        return True
+
+    async def authenticated_heartbeat(
+        self, plugin_id: str, auth_token: str
+    ) -> tuple[bool, Optional[str]]:
+        """Heartbeat for gateway-facing callers.
+
+        Returns ``(ok, reject)`` where ``reject`` is one of:
+          * ``None`` — auth succeeded AND plugin exists AND caller is its owner.
+            ``ok`` is the underlying heartbeat result.
+          * ``"auth_failed"`` — token did not validate.
+          * ``"permission_denied"`` — caller does not own this plugin OR the
+            plugin does not exist OR the plugin is in-process-only (registered
+            via ``register_internal``, ``auth_subject == ""``).  The three
+            cases collapse to a single gRPC status to avoid an existence-/
+            transport-leak oracle: a token-holder could otherwise enumerate
+            registered ``plugin_id``s by probing for differing status codes
+            (``OK ok=false`` vs ``PERMISSION_DENIED``).
+        """
+        try:
+            identity = await self._auth.validate(auth_token)
+        except AuthError:
+            return False, "auth_failed"
+        plugin = self._plugins.get(plugin_id)
+        # Collapse "unknown plugin" / "wrong subject" / "in-process plugin"
+        # into a single response.  See docstring for the rationale.
+        if (
+            plugin is None
+            or not plugin.auth_subject
+            or plugin.auth_subject != identity.subject
+        ):
+            return False, "permission_denied"
+        plugin.last_heartbeat_at = self._clock.monotonic()
+        return True, None
+
+    async def authenticated_unregister(
+        self, plugin_id: str, auth_token: str, reason: str = ""
+    ) -> tuple[bool, Optional[str]]:
+        """Unregister for gateway-facing callers; same return contract as
+        ``authenticated_heartbeat``.  Subject mismatch is rejected BEFORE the
+        plugin is removed from the dict, so a forged Unregister cannot evict
+        another caller's plugin even by accident.  Unknown plugin and
+        in-process-only plugin (``auth_subject == ""``) also collapse to
+        ``"permission_denied"`` to avoid an existence oracle — see
+        ``authenticated_heartbeat`` docstring."""
+        try:
+            identity = await self._auth.validate(auth_token)
+        except AuthError:
+            return False, "auth_failed"
+        plugin = self._plugins.get(plugin_id)
+        if (
+            plugin is None
+            or not plugin.auth_subject
+            or plugin.auth_subject != identity.subject
+        ):
+            return False, "permission_denied"
+        ok = await self.unregister(plugin_id, reason=reason)
+        return ok, None
+
+    async def unregister(self, plugin_id: str, reason: str = "") -> bool:
+        plugin = self._plugins.pop(plugin_id, None)
+        if plugin is None:
+            return False  # idempotent — caller can retry without surprise
+
+        try:
+            await plugin.transport.close()
+        except (
+            Exception
+        ) as exc:  # noqa: BLE001 — defensive; close should not block unregister
+            log.warning(
+                "unregister: transport.close failed plugin_id=%s detail=%s",
+                plugin_id,
+                exc,
+            )
+
+        self._circuit_breaker.reset(plugin_id)
+        for cb in list(self._unregister_callbacks):
+            try:
+                cb(plugin_id, reason)
+            except Exception as exc:  # noqa: BLE001
+                log.warning(
+                    "unregister: on_unregister callback failed plugin_id=%s detail=%s",
+                    plugin_id,
+                    exc,
+                )
+
+        log.info(
+            "unregister plugin_id=%s reason=%s", plugin_id, reason or "<unspecified>"
+        )
+        return True
+
+    def list_plugins(self, req: ListPluginsRequest) -> list[PluginInfo]:
+        """Return plugin metadata filtered by ``stage_filter`` and
+        ``include_disabled``. Full observability fields
+        (``last_call_at_seconds_ago`` / ``cache_age_seconds``) are stubbed
+        to ``0.0`` here and wired through the scheduler via
+        ``attach_cache_age_lookup``.
+        """
+        now = self._clock.monotonic()
+        out: list[PluginInfo] = []
+        for plugin in self._plugins.values():
+            if req.stage_filter and plugin.plugin_type != req.stage_filter:
+                continue
+            if not req.include_disabled and not plugin.enabled:
+                continue
+            out.append(
+                PluginInfo(
+                    plugin_id=plugin.plugin_id,
+                    plugin_type=plugin.plugin_type,
+                    priority=plugin.priority,
+                    version=plugin.version,
+                    protocol_version=plugin.protocol_version,
+                    enabled=plugin.enabled,
+                    is_builtin=plugin.is_builtin,
+                    transport=plugin.transport_type,
+                    circuit_state=self._circuit_breaker.state(plugin.plugin_id),
+                    evaluations_total=plugin.evaluations_total,
+                    last_call_at_seconds_ago=(
+                        0.0
+                        if plugin.last_call_at == float("-inf")
+                        else max(0.0, now - plugin.last_call_at)
+                    ),
+                    cache_age_seconds=(
+                        self._cache_age_lookup(plugin.plugin_id)
+                        if self._cache_age_lookup is not None
+                        else 0.0
+                    ),
+                )
+            )
+        return out
+
+    # ------------------------------------------------------------------
+    # Internal accessors (orchestrator / scheduler / heartbeat monitor use)
+    # ------------------------------------------------------------------
+
+    def get_plugin(self, plugin_id: str) -> Optional[RegisteredPlugin]:
+        return self._plugins.get(plugin_id)
+
+    def all_plugins(self) -> list[RegisteredPlugin]:
+        return list(self._plugins.values())
+
+    def on_unregister(self, callback: UnregisterCallback) -> None:
+        """Subscribe to unregister events; callback receives
+        ``(plugin_id, reason)``. Called synchronously on the event loop
+        main task — callbacks MUST NOT await."""
+        self._unregister_callbacks.append(callback)
+
+    def attach_cache_age_lookup(self, lookup: Callable[[str], float]) -> None:
+        """Wire a scheduler's ``cache_age(plugin_id)`` into
+        ``list_plugins``. Scheduler calls this from its own constructor so
+        the server-side view reports cache age without introducing a
+        server→scheduler import cycle."""
+        self._cache_age_lookup = lookup
+
+    # ------------------------------------------------------------------
+    # Internal register path (builtin + in_process user plugins)
+    # ------------------------------------------------------------------
+
+    def register_internal(
+        self,
+        plugin_id: str,
+        plugin_type: str,
+        priority: int,
+        instance: Any,
+        *,
+        execution_interval_seconds: float = 0.0,
+        hold_policy: HoldPolicy = HoldPolicy.ACCEPT_WHEN_IDLE,
+        is_builtin: bool = True,
+        version: str = "builtin",
+        needs: Optional[list[str]] = None,
+        requires_produced_fields: Optional[list[str]] = None,
+        observation_window_seconds: float = 0.0,
+    ) -> RegisteredPlugin:
+        """Register without auth / protocol checks; wrap ``instance`` in
+        ``InProcessTransport`` via the factory.
+
+        Used by the orchestrator at startup for builtin plugins and by
+        ``NativePlannerBase`` for ``in_process_plugins`` config entries.
+        ``is_builtin=False`` should be passed for user in-process plugins
+        so they show up as such in ListPlugins + metrics; they still
+        bypass auth (trust boundary is the Python process).
+        """
+        if plugin_id in self._plugins:
+            raise ValueError(
+                f"register_internal: plugin_id={plugin_id!r} already registered"
+            )
+        endpoint = f"inproc://{plugin_id}"
+        transport = self._transport_factory(
+            plugin_id, endpoint, in_process_instance=instance
+        )
+        plugin = RegisteredPlugin(
+            plugin_id=plugin_id,
+            plugin_type=plugin_type,  # type: ignore[arg-type]
+            priority=priority,
+            endpoint=endpoint,
+            version=version,
+            protocol_version=self._protocol_max,
+            execution_interval_seconds=execution_interval_seconds,
+            hold_policy=hold_policy,
+            needs=list(needs or []),
+            requires_produced_fields=list(requires_produced_fields or []),
+            observation_window_seconds=observation_window_seconds,
+            is_builtin=is_builtin,
+            transport=transport,
+            transport_type="in_process",
+            registered_at=self._aligned_anchor(self._clock.monotonic()),
+        )
+        self._plugins[plugin_id] = plugin
+        self._circuit_breaker.reset(plugin_id)
+        log.info(
+            "register_internal plugin_id=%s type=%s priority=%d is_builtin=%s",
+            plugin_id,
+            plugin_type,
+            priority,
+            is_builtin,
+        )
+        return plugin
+
+
+__all__ = ["PluginRegistryServer", "TransportFactory", "UnregisterCallback"]
diff --git a/components/src/dynamo/planner/plugins/registry/types.py b/components/src/dynamo/planner/plugins/registry/types.py
new file mode 100644
index 000000000000..ad75b30f14f7
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/registry/types.py
@@ -0,0 +1,103 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Registry-internal data types.
+
+``RegisteredPlugin`` is the in-memory record the ``PluginRegistryServer``
+owns for each active plugin. It holds the union of:
+
+- The ``RegisterRequest`` fields (identity, priority, scheduling, needs,
+  protocol negotiation, auth metadata).
+- Runtime fields (``registered_at``, ``last_heartbeat_at``,
+  ``last_call_at``, ``evaluations_total``, ``enabled``) that the
+  scheduler / heartbeat monitor read + update.
+- The constructed ``PluginTransport`` and a tag ``transport_type``
+  driving the heartbeat-skip rule.
+
+CircuitBreaker state is **not** stored on ``RegisteredPlugin`` — it lives
+in ``CircuitBreaker`` keyed by ``plugin_id`` (separable lifecycle:
+restart clears circuit, back to CLOSED).
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass, field
+from typing import Literal
+
+from dynamo.planner.plugins.transport.base import PluginTransport
+from dynamo.planner.plugins.types import HoldPolicy
+
+TransportType = Literal["in_process", "grpc"]
+
+
+def derive_transport_type(endpoint: str) -> TransportType:
+    """Classify an endpoint URL by scheme.
+
+    Raises ``ValueError`` for unknown schemes so configuration errors
+    fail at register time, not at the first ``call()``.
+    """
+    if endpoint.startswith("inproc://"):
+        return "in_process"
+    if endpoint.startswith("grpc://"):
+        return "grpc"
+    raise ValueError(
+        f"derive_transport_type: unknown endpoint scheme in {endpoint!r}; "
+        f"expected 'inproc://' or 'grpc://'"
+    )
+
+
+@dataclass
+class RegisteredPlugin:
+    """Internal record the registry owns for every registered plugin.
+
+    Mutable: ``last_heartbeat_at`` / ``last_call_at`` / ``evaluations_total``
+    / ``enabled`` are updated in place by the heartbeat monitor,
+    orchestrator pipeline driver, and admin endpoint respectively.
+    """
+
+    plugin_id: str
+    plugin_type: Literal["predict", "propose", "reconcile", "constrain"]
+    priority: int
+    endpoint: str
+    version: str
+    protocol_version: str
+    execution_interval_seconds: float
+    hold_policy: HoldPolicy
+    needs: list[str]
+    is_builtin: bool
+    transport: PluginTransport
+    transport_type: TransportType
+    registered_at: float
+    # ``AuthIdentity.subject`` captured at Register time. Used by the
+    # gateway to gate Heartbeat / Unregister: only a caller whose token
+    # validates to the same subject can manage this plugin. Empty string
+    # for ``register_internal`` (in-process plugins bypass auth — trust
+    # boundary is the Python process; the gateway never reaches these).
+    auth_subject: str = ""
+    last_heartbeat_at: float = field(default=-math.inf)
+    last_call_at: float = field(default=-math.inf)
+    evaluations_total: int = 0
+    enabled: bool = True
+    # ``requires_produced_fields``: scale_interval cadence model — plugin
+    # fires only if every listed dot-path resolves non-None in the current
+    # PipelineContext. Consumed by ``PluginScheduler.compute_active_set``
+    # in commit 16 (see design doc §4.6). Empty = no gating; the field is
+    # ignored by current orchestrator-path code in this commit (schema-
+    # only surface; behaviour change lands separately).
+    requires_produced_fields: list[str] = field(default_factory=list)
+    # ``observation_window_seconds``: scale_interval cadence model —
+    # plugin's declared Prometheus aggregation window for windowed
+    # observation types (currently ``observations.traffic``). Consumed by
+    # ``OrchestratorEngineAdapter._compute_next_scheduled_tick`` in commit
+    # 17 to drive lazy pull. 0.0 = scale_interval freshness; N > 0 = N-
+    # second aggregation. Field is ignored by current orchestrator-path
+    # code in this commit.
+    observation_window_seconds: float = 0.0
+
+
+__all__ = [
+    "TransportType",
+    "RegisteredPlugin",
+    "derive_transport_type",
+]
diff --git a/components/src/dynamo/planner/plugins/scheduler.py b/components/src/dynamo/planner/plugins/scheduler.py
new file mode 100644
index 000000000000..3377d4d063b0
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/scheduler.py
@@ -0,0 +1,415 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""PluginScheduler.
+
+Single-threaded asyncio invariant
+---------------------------------
+
+**All** public methods MUST be called from the event loop main task.
+``record_result`` / ``invalidate_cache`` / ``compute_active_set`` mutate
+the same in-memory dict; concurrent invocations from multiple asyncio
+tasks (e.g. inside ``asyncio.gather`` plugin coroutines) is undefined
+behaviour.
+
+The expected orchestrator pattern is::
+
+    active = scheduler.compute_active_set(now, stage)
+    results = await asyncio.gather(*[p.transport.call(...) for p in active.triggered])
+    # Back on the main task — serialise record_result:
+    for plugin, result in zip(active.triggered, results):
+        scheduler.record_result(plugin.plugin_id, stage, result, now)
+
+No locks needed by assumption.
+
+Cache invalidation 6-row table
+------------------------------
+
+Row-by-row, the scheduler clears a plugin's HOLD_LAST cache when:
+
+1. ``registry.unregister(plugin_id)`` is called → subscribed via
+   ``registry.on_unregister``.
+2. Heartbeat monitor evicts a plugin → same code path as row 1
+   (the monitor would call ``registry.unregister``). NOTE: the monitor
+   itself is not wired in this PR — ``last_heartbeat_at`` is recorded but
+   nothing reads it yet; the eviction monitor lands in a follow-up PR.
+   This row documents the code path the cache relies on once it exists.
+3. ``CircuitBreaker`` transitions any plugin to OPEN → subscribed via
+   ``circuit_breaker.on_open``.
+4. Client-driven version upgrade (Unregister old + Register new) →
+   row 1 for the unregister; the fresh Register starts a new cache.
+5. ``invalidate_cache(reason="config_reload")`` — explicit full clear.
+6. Orchestrator / planner process restart — cache lives in memory only,
+   so process exit drops everything. No code needed.
+"""
+
+from __future__ import annotations
+
+import logging
+import math
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Optional
+
+from dynamo.planner.plugins.clock import Clock
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+from dynamo.planner.plugins.registry.types import RegisteredPlugin
+from dynamo.planner.plugins.types import HoldPolicy, OverrideResult
+
+if TYPE_CHECKING:
+    from dynamo.planner.monitoring.planner_metrics import PluginFrameworkMetrics
+    from dynamo.planner.plugins.registry.server import PluginRegistryServer
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class InheritedResult:
+    """A cached OverrideResult injected into the active set when a plugin
+    is not due this tick but has HOLD_LAST hold_policy.
+
+    ``priority`` is read from the current ``RegisteredPlugin`` (not the
+    cache entry) so priority changes via re-registration take effect even
+    if cache carry-over is momentarily in play.
+    """
+
+    plugin_id: str
+    priority: int
+    result: OverrideResult
+    cached_at: float
+
+
+@dataclass
+class ActiveSet:
+    """Per-tick scheduling decision for one stage."""
+
+    triggered: list[RegisteredPlugin]
+    inherited: list[InheritedResult]
+
+
+@dataclass
+class _CacheEntry:
+    stage: str
+    result: OverrideResult
+    cached_at: float
+
+
+class PluginScheduler:
+    def __init__(
+        self,
+        registry: "PluginRegistryServer",
+        circuit_breaker: CircuitBreaker,
+        clock: Clock,
+        metrics: Optional["PluginFrameworkMetrics"] = None,
+    ) -> None:
+        self._registry = registry
+        self._circuit_breaker = circuit_breaker
+        self._clock = clock
+        # Cache keyed by (plugin_id, stage) — a plugin of plugin_type="predict"
+        # only ever caches "predict" stage results, but keying on both makes
+        # future per-stage caching explicit + avoids stage coupling bugs.
+        self._cache: dict[tuple[str, str], _CacheEntry] = {}
+        # Subscribe to the two event sources that drive cache invalidation.
+        registry.on_unregister(self._on_registry_unregister)
+        circuit_breaker.on_open(self._on_circuit_open)
+        # Expose cache_age to the server's list_plugins.
+        registry.attach_cache_age_lookup(self.cache_age)
+        # Per-plugin tick scheduling metrics.
+        # None = emission off; production path passes the orchestrator's
+        # shared PluginFrameworkMetrics instance.
+        self._metrics = metrics
+
+    # ------------------------------------------------------------------
+    # Per-tick scheduling
+    # ------------------------------------------------------------------
+
+    def compute_active_set(
+        self,
+        now: float,
+        stage: str,
+        ctx: Optional[Any] = None,
+    ) -> ActiveSet:
+        """Return triggered plugins (orchestrator must call) and inherited
+        results (use cached output in place of calling the plugin) for
+        this stage at ``now``.
+
+        Plugins skipped entirely:
+          - different ``plugin_type`` than the stage
+          - ``enabled=False``
+          - ``CircuitBreaker.can_call`` returns False (includes OPEN)
+          - ``requires_produced_fields`` non-empty AND any dot-path
+            resolves to None in ``ctx`` (scale_interval cadence model
+            declarative dependencies — bumps
+            ``tick_requires_unsatisfied_total`` per (plugin, missing
+            field) pair)
+
+        Among the remainder:
+          - "due" (``now - last_call_at >= execution_interval`` or
+            first-ever tick) → ``triggered``
+          - "not due" + ``HoldPolicy.HOLD_LAST`` + cache hit → ``inherited``
+          - otherwise → skipped (treat as ACCEPT)
+
+        ``ctx`` is optional for backward-compat with callers that don't
+        thread the PipelineContext through (e.g. test fixtures and the
+        PSM path). When ``ctx`` is None, plugins with
+        ``requires_produced_fields`` are treated as "requires
+        unsatisfied" and skipped — conservative default that prevents
+        firing a plugin without the data it declared dependence on.
+        """
+        triggered: list[RegisteredPlugin] = []
+        inherited: list[InheritedResult] = []
+
+        for plugin in self._registry.all_plugins():
+            if plugin.plugin_type != stage:
+                continue
+            if not plugin.enabled:
+                continue
+            if not self._circuit_breaker.can_call(plugin.plugin_id):
+                continue
+
+            is_due = self._is_due(plugin, now)
+            if is_due:
+                # Even if the throttle says due, declarative dependencies
+                # (``requires_produced_fields``) gate the fire.  If any
+                # required dot-path is None in ``ctx``, skip — upstream
+                # didn't produce; calling this plugin would feed it
+                # stale / missing input.
+                missing = self._requires_missing_field(plugin, ctx)
+                if missing is not None:
+                    if self._metrics is not None:
+                        self._metrics.tick_requires_unsatisfied_total.labels(
+                            plugin_id=plugin.plugin_id,
+                            missing_field=missing,
+                        ).inc()
+                    # Skip silently (no cache inherit for requires-gated
+                    # skip — the plugin chose to declare the dependency,
+                    # so a stale cached result would violate its own
+                    # contract).
+                    continue
+                triggered.append(plugin)
+                # tick_lag_seconds = how far behind the scheduled
+                # cadence this tick is.  For the first-ever
+                # call (last_call_at == -inf) lag is undefined; pin at
+                # 0.  For zero-interval plugins lag is also 0 ("every
+                # tick" means "always on time").
+                if self._metrics is not None:
+                    lag = self._compute_tick_lag(plugin, now)
+                    self._metrics.tick_lag_seconds.labels(
+                        plugin_id=plugin.plugin_id
+                    ).set(lag)
+                continue
+
+            # Not due — either inherit cache or skip entirely; in both
+            # cases the plugin was scheduled-but-deferred this tick, so
+            # the counter fires.
+            if self._metrics is not None:
+                self._metrics.tick_skipped_total.labels(
+                    plugin_id=plugin.plugin_id
+                ).inc()
+
+            if plugin.hold_policy == HoldPolicy.HOLD_LAST:
+                entry = self._cache.get((plugin.plugin_id, stage))
+                if entry is not None:
+                    inherited.append(
+                        InheritedResult(
+                            plugin_id=plugin.plugin_id,
+                            priority=plugin.priority,
+                            result=entry.result,
+                            cached_at=entry.cached_at,
+                        )
+                    )
+                    continue
+            # ACCEPT_WHEN_IDLE or HOLD_LAST with empty cache → treat as ACCEPT (skip).
+
+        return ActiveSet(triggered=triggered, inherited=inherited)
+
+    @staticmethod
+    def _requires_missing_field(
+        plugin: RegisteredPlugin, ctx: Optional[Any]
+    ) -> Optional[str]:
+        """Walk ``plugin.requires_produced_fields`` against ``ctx`` and
+        return the first dot-path that resolves to None, or None if all
+        required fields are satisfied (or the plugin declared no
+        requires).
+
+        Conservative default: if the caller didn't supply ``ctx`` and
+        the plugin has requires, return the first declared path as
+        "missing" — this prevents firing a plugin without the inputs
+        it asked for.
+        """
+        if not plugin.requires_produced_fields:
+            return None
+        if ctx is None:
+            return plugin.requires_produced_fields[0]
+        for path in plugin.requires_produced_fields:
+            if PluginScheduler._ctx_get(ctx, path) is None:
+                return path
+        return None
+
+    @staticmethod
+    def _ctx_get(ctx: Any, dot_path: str) -> Any:
+        """Resolve ``ctx.a.b.c`` for ``dot_path="a.b.c"``.  Returns None
+        if any intermediate attribute is None or missing (rather than
+        raising).  Used by ``_requires_missing_field`` for declarative
+        dependency checks against ``PipelineContext``.
+        """
+        cur: Any = ctx
+        for part in dot_path.split("."):
+            if cur is None:
+                return None
+            cur = getattr(cur, part, None)
+        return cur
+
+    @staticmethod
+    def _compute_tick_lag(plugin: RegisteredPlugin, now: float) -> float:
+        """Seconds elapsed past the plugin's next-scheduled moment.
+
+        Returns 0 for first-ever calls and for zero-interval plugins
+        (no "scheduled moment" to lag behind).
+        """
+        if plugin.last_call_at == -math.inf:
+            return 0.0
+        if plugin.execution_interval_seconds <= 0.0:
+            return 0.0
+        due_at = plugin.last_call_at + plugin.execution_interval_seconds
+        return max(0.0, now - due_at)
+
+    @staticmethod
+    def _is_due(plugin: RegisteredPlugin, now: float) -> bool:
+        # Zero interval means "every tick" — anchor doesn't matter.
+        if plugin.execution_interval_seconds <= 0.0:
+            return True
+        # Anchor: ``registered_at`` for the first-ever call,
+        # ``last_call_at`` for every call after.  Pre-fix the first-
+        # ever branch returned True unconditionally, which broke PSM
+        # cadence parity: PSM's ``initial_tick(start_s)`` schedules the
+        # first throughput-cadence fire at ``start_s + interval`` (not
+        # at ``start_s``).  A builtin throughput plugin (``interval=
+        # 180s``) firing on the first pipeline tick at T=5 would then
+        # bump ``last_call_at`` to 5, so the *next* due moment becomes
+        # T=185 — permanently 5s ahead of PSM's T=180/360/540 cadence.
+        # Anchoring on ``registered_at`` makes "fire every N seconds"
+        # mean "first fire N seconds after registration" — matching
+        # PSM and aligning with what most operators intuitively expect.
+        anchor = (
+            plugin.registered_at
+            if plugin.last_call_at == -math.inf
+            else plugin.last_call_at
+        )
+        return (now - anchor) >= plugin.execution_interval_seconds
+
+    # ------------------------------------------------------------------
+    # Per-tick bookkeeping + HOLD_LAST cache
+    # ------------------------------------------------------------------
+
+    def record_evaluation(self, plugin_id: str, tick_now: float) -> None:
+        """Bump per-plugin scheduling bookkeeping after a successful
+        plugin RPC, regardless of result kind.
+
+        Drives ``execution_interval_seconds`` throttling via
+        ``last_call_at`` and powers ``evaluations_total`` for
+        ``ListPlugins`` / metrics. Must be called by the orchestrator
+        after every successful plugin call — including AcceptResult /
+        RejectResult / empty-oneof silent-ACCEPT — because all of them
+        represent actual RPCs that consumed the plugin's interval slot.
+        Failed / timed-out calls do NOT call this; they feed the
+        circuit breaker instead.
+        """
+        plugin = self._registry.get_plugin(plugin_id)
+        if plugin is None:
+            # Plugin unregistered between dispatch and result — drop silently.
+            return
+        plugin.last_call_at = tick_now
+        plugin.evaluations_total += 1
+
+    def record_result(
+        self,
+        plugin_id: str,
+        stage: str,
+        result: OverrideResult,
+        tick_now: float,
+    ) -> None:
+        """Cache an OverrideResult for HOLD_LAST inheritance.
+
+        Caller must separately call ``record_evaluation`` to update
+        ``last_call_at`` / ``evaluations_total`` for **every** successful
+        plugin call regardless of result kind. This method is
+        OverrideResult-only because only overrides have inheritable
+        content (AcceptResult = no opinion, RejectResult = stage
+        short-circuited).
+        """
+        plugin = self._registry.get_plugin(plugin_id)
+        if plugin is None:
+            # Plugin unregistered between dispatch and result — drop silently.
+            return
+        if plugin.hold_policy == HoldPolicy.HOLD_LAST:
+            self._cache[(plugin_id, stage)] = _CacheEntry(
+                stage=stage, result=result, cached_at=tick_now
+            )
+
+    # ------------------------------------------------------------------
+    # Explicit cache invalidation (rows 5 + 6 of the v11 table)
+    # ------------------------------------------------------------------
+
+    def invalidate_cache(
+        self, plugin_id: Optional[str] = None, reason: str = ""
+    ) -> None:
+        """Clear cache for one plugin (``plugin_id`` set) or all plugins
+        (``plugin_id=None``). The ``reason`` is logged for audit.
+
+        Row 5 (config reload) passes ``plugin_id=None, reason="config_reload"``.
+        """
+        if plugin_id is None:
+            count = len(self._cache)
+            self._cache.clear()
+            log.info(
+                "scheduler.invalidate_cache: cleared ALL (%d entries) reason=%s",
+                count,
+                reason or "<unspecified>",
+            )
+            return
+        cleared = [k for k in self._cache if k[0] == plugin_id]
+        for key in cleared:
+            del self._cache[key]
+        if cleared:
+            log.info(
+                "scheduler.invalidate_cache: plugin_id=%s cleared %d entries reason=%s",
+                plugin_id,
+                len(cleared),
+                reason or "<unspecified>",
+            )
+
+    # ------------------------------------------------------------------
+    # Accessors
+    # ------------------------------------------------------------------
+
+    def cache_age(self, plugin_id: str) -> float:
+        """Oldest cached entry age in seconds for ``plugin_id``; ``0.0``
+        if no cache entry exists (matches the PluginInfo default for
+        never-called plugins)."""
+        ages = [
+            self._clock.monotonic() - entry.cached_at
+            for key, entry in self._cache.items()
+            if key[0] == plugin_id
+        ]
+        return max(ages) if ages else 0.0
+
+    def cache_entries_count(self) -> int:
+        """Total cache entries (all plugins × stages); admin/metric use."""
+        return len(self._cache)
+
+    # ------------------------------------------------------------------
+    # Event handlers (private)
+    # ------------------------------------------------------------------
+
+    def _on_registry_unregister(self, plugin_id: str, reason: str) -> None:
+        # Rows 1 + 2 + 4: unregister (explicit, heartbeat_missed, or
+        # version-upgrade) → drop this plugin's cache.
+        self.invalidate_cache(plugin_id, reason=f"unregister:{reason}")
+
+    def _on_circuit_open(self, plugin_id: str) -> None:
+        # Row 3: circuit OPEN → drop this plugin's cache so stale results
+        # don't leak as "inherited" while the plugin is failing.
+        self.invalidate_cache(plugin_id, reason="circuit_open")
+
+
+__all__ = ["PluginScheduler", "ActiveSet", "InheritedResult"]
diff --git a/components/src/dynamo/planner/plugins/transport/README.md b/components/src/dynamo/planner/plugins/transport/README.md
new file mode 100644
index 000000000000..03e2ed23dd94
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/transport/README.md
@@ -0,0 +1,223 @@
+# Plugin Transport
+
+Plugin RPC transport abstractions for the Dynamo Planner plugin framework.
+
+Two transports under one `PluginTransport` ABC; the orchestrator pipeline
+driver treats them uniformly via `await plugin.transport.call(method, request)`.
+
+A dedicated `UdsTransport` and mTLS for `GrpcTransport` are deferred to a
+follow-up PR — see "Deferred" section below.
+
+## Transports (shipped in PR #1)
+
+| Transport | Endpoint scheme | Use case |
+|---|---|---|
+| `InProcessTransport` | `inproc://<plugin_id>` | Built-in plugins, in-process user plugins, replay/test; **first-class production transport, NOT a test fallback** |
+| `GrpcTransport` | `grpc://host:port` | Out-of-process plugin (same Pod, cross-Pod, or cross-node). PR #1 supports plaintext only, gated behind `allow_insecure_grpc=true`; mTLS lands in a follow-up PR. |
+
+### Choosing a transport — decision tree
+
+```
+plugin and orchestrator in same process?
+  ├─ YES → InProcessTransport (zero RPC overhead, builtin plugins, in_process user plugins)
+  └─ NO  → GrpcTransport (set allow_insecure_grpc=true for plaintext in
+           PR #1; mTLS lands in a follow-up PR)
+```
+
+## `Clock` abstraction
+
+All time access in orchestrator (PR 5) and PluginRegistry (PR 3) MUST go
+through `Clock` — direct `time.time()` / `time.monotonic()` /
+`asyncio.sleep` is forbidden (lint check enabled in PR 5 5-9).
+
+| Implementation | Use |
+|---|---|
+| `WallClock` | Production |
+| `VirtualClock` | Replay / test; `advance(N)` warps time forward |
+
+**Production safety**: `make_clock()` rejects `clock.type=virtual` unless
+`DYNAMO_PLANNER_TEST=1` is set in environment. Replay code paths set
+this env var explicitly.
+
+Two time sources:
+
+- `now()`: epoch float — use for audit log timestamps, `decision_id`
+- `monotonic()`: monotonic float — use for duration / scheduling
+  (immune to NTP / clock skew)
+
+## Configuration
+
+```yaml
+planner:
+  plugin_registration:
+    transport:
+      allow_insecure_grpc: false      # default refuse plaintext grpc (PR #1
+                                      # has no mTLS path yet — setting this to
+                                      # true is the only way to use grpc:// in
+                                      # PR #1; logs WARNING on startup)
+      request_timeout_seconds: 5
+      keepalive_time_ms: 30000
+      max_message_size_bytes: 10000000
+  scheduling:
+    clock:
+      type: wall                       # virtual only allowed in test/replay
+```
+
+The mTLS config block (`grpc_mtls.enabled` / `secret_mount_path` etc.)
+documented in earlier drafts is **not** shipped in PR #1 and is not a
+field on `TransportConfig`. It lands together with the cert-manager /
+SPIFFE auth path in a follow-up PR.
+
+## Per-plugin timeout (no stage-level wait_for needed)
+
+Each transport implements a **per-plugin RPC timeout** at the call site:
+
+| Transport | Where | Code |
+|---|---|---|
+| `InProcessTransport` | `in_process.py` | `await asyncio.wait_for(coro, self.timeout_seconds)` |
+| `GrpcTransport` | `_grpc_base.py` | `await asyncio.wait_for(rpc(request), self.timeout_seconds)` |
+
+**Implication for the pipeline driver**:
+
+- The pipeline driver invokes plugins via `asyncio.gather(*[plugin.transport.call(...) for ...])`
+- The driver **MUST NOT** add an additional stage-level `asyncio.wait_for` —
+  per-plugin timeout already prevents any single plugin from dragging
+  down the whole stage
+- The whole-tick `tick_max_duration_seconds` is the outermost safety net
+  (catches systemic deadlock); per-stage budget is intentionally NOT
+  introduced in this version (left as a follow-up)
+
+Default `request_timeout_seconds = 5.0`, applied uniformly to every
+plugin in PR #1 (a per-plugin override field was prototyped on
+`RegisterRequest` but not plumbed into `make_transport_for_endpoint`,
+so it was removed before any client shipped — see `plugin.proto`
+"reserved 11, 12"). A future PR may re-introduce a per-plugin timeout
+at a new tag with the missing plumbing.
+
+## Sync plugin red line (`InProcessTransport`)
+
+`InProcessTransport` supports **both** `async def` and sync (`def`) plugin
+methods; sync methods dispatch via `asyncio.to_thread` to avoid blocking
+the orchestrator event loop.
+
+**Hard rule**: sync plugin methods MUST NOT do blocking IO (HTTP, file,
+`time.sleep > 100ms`). Default thread pool is small (~32 threads); a few
+slow sync plugins doing blocking IO will exhaust the pool and stall the
+orchestrator.
+
+If your plugin needs IO, write it as `async def`.
+
+## Wire-message conversion (Pydantic ↔ proto)
+
+The pipeline emits **Pydantic** stage requests (so it can keep using
+attribute-style access on the way back); gRPC stubs need **proto**
+messages. `_GrpcTransportBase.call()` handles the conversion at the
+wire boundary using `_proto_bridge.pydantic_to_proto` /
+`proto_to_pydantic`:
+
+- **Pydantic in → Pydantic out** — pipeline path. Request gets converted
+  to proto before send; response gets converted back to Pydantic before
+  return.
+- **Proto in → proto out** — passthrough. Used by the transport
+  contract test which asserts byte-equal proto round-trip across all
+  four transports.
+
+The conversion was **missing in PR 2 ship** and only surfaced when the
+external-plugin e2e test (`tests/integration/test_external_plugin_e2e.py`)
+first drove a real gRPC plugin via the pipeline. Before the fix, every
+external plugin call failed at `Message.SerializeToString` because the
+gRPC stub received a Pydantic instance. The in-process transport
+side-stepped this because Pydantic objects flow through unchanged.
+
+If you add a new wire transport (TCP, QUIC, etc.), inherit from
+`_GrpcTransportBase` so you get the bridge for free; if you must roll
+your own, replicate the same Pydantic-vs-proto branch.
+
+## Error contract
+
+ALL `call()` failures raise a `PluginCallError` subclass — orchestrator
+relies on this to never need a bare `except` clause.
+
+| Subclass | When | Orchestrator response (PR 5) |
+|---|---|---|
+| `PluginTimeoutError` | `asyncio.wait_for` exceeded `timeout_seconds` | Increment circuit breaker failure count |
+| `PluginConnectionError` | gRPC channel down / unreachable | Mark plugin unreachable; on next tick attempt reconnect |
+| `PluginUnknownMethodError` | Method name not registered on plugin | Log + treat as plugin contract violation |
+| `PluginSerializationError` | bytes-level (de)serialization failed (proto schema mismatch / FpmData decode); empty oneof is NOT this error — see `plugins/proto/v1/README.md` "result oneof empty" | Log + circuit breaker increment |
+| `PluginCallError` | Catch-all (plugin internal exception, etc.) | Log + circuit breaker increment |
+
+## Threat Model
+
+### `InProcessTransport`
+
+Trust assumption: **plugin code shares the orchestrator process**. Any
+Python module loaded as in_process plugin has full Python-level access
+to orchestrator state (limited only by Python's lack of memory protection).
+
+**Mitigation**:
+
+- `in_process_plugins` discovery is **config-only** (no setuptools
+  entrypoint auto-discovery) — operator must explicitly list each plugin
+  module/class in YAML, preventing "pip install rogue-plugin" silent injection
+- All in_process plugins go through the same `PluginRegistry` view
+  (`ListPlugins` shows them with `transport=in_process`, `is_builtin=false`)
+  for audit visibility
+- Sync plugin red line above protects against blocking-IO denial of service
+
+### `GrpcTransport` (PR #1 state)
+
+Trust assumption: **cross-Pod / cross-node** — anyone with network access
+to the gRPC port could try to call.
+
+**PR #1 ships plaintext gRPC only**, gated behind
+`allow_insecure_grpc=true` on `TransportConfig`. `make_transport_for_endpoint`
+refuses to build a `GrpcTransport` for a `grpc://` endpoint unless the
+flag is set, and a WARNING is logged when it is. **mTLS is not shipped
+in PR #1** — there is no certificate-loading code path, no `grpc_mtls`
+config block, and no in-process cert hot reload.
+
+Until the follow-up PR adds mTLS, the operational guidance is:
+
+- Use `InProcessTransport` for builtin and in-process plugins (no
+  network exposure, no flag needed).
+- For out-of-process plugins, set `allow_insecure_grpc=true` and pair
+  it with K8s NetworkPolicy / Pod-to-Pod identity to restrict who can
+  reach the gRPC port. Plaintext on the wire means the channel layer
+  contributes no authentication.
+- Plugin authentication via `RegisterRequest.auth_token` (validated by
+  `PluginRegistry` — see `plugins/registry/`) is the only auth in PR #1;
+  transport-level mTLS will layer on top of it later, not replace it.
+- gRPC `keepalive_time_ms=30000` detects dropped connections quickly.
+
+## Deferred
+
+The following are **not** shipped in PR #1 and will land in a follow-up:
+
+- **`UdsTransport`** as a separate transport class for plugin endpoints —
+  plugin endpoints are limited to `inproc://` and `grpc://`. (The gateway
+  registration server's *listen address* can already be a UDS path via
+  gRPC's URI scheme — see `gateway.start_gateway_server` — but that is a
+  separate mechanism from plugin transport endpoints.)
+- **mTLS for `GrpcTransport`** including cert-manager / certificateSecret
+  convention (`tls.crt` / `tls.key` / `ca.crt`), in-process cert hot reload,
+  and the matching `grpc_mtls.*` config block on `TransportConfig`.
+
+## Adding a new transport
+
+1. Subclass `PluginTransport` in `transport/<name>.py`
+2. Implement `call(method, request)` and `close()` per the contract
+3. All failures must raise `PluginCallError` subclasses (no naked exceptions)
+4. Add to `transport/__init__.py` exports
+5. Update `transport/config.py` `make_transport_for_endpoint` factory + add
+   endpoint scheme detection
+6. Add a parametrized variant to
+   `tests/plugins/transport/test_transport_contract.py` — your transport
+   MUST pass `test_round_trip_equivalence` and
+   `test_byte_equal_response_across_transports` (byte-equal with all other
+   transports for the same input)
+
+## References
+
+- `dynamo/planner/plugins/proto/v1/` — plugin proto schema
+- `tests/plugins/transport/test_transport_contract.py` — transport contract acceptance suite (round-trip equivalence + byte-equal cross-transport)
+- `tests/plugins/clock/test_clocks.py` — Clock unit tests
diff --git a/components/src/dynamo/planner/plugins/transport/__init__.py b/components/src/dynamo/planner/plugins/transport/__init__.py
new file mode 100644
index 000000000000..c2f949863186
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/transport/__init__.py
@@ -0,0 +1,56 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Transport abstractions for plugin invocation.
+
+Two transports under one ``PluginTransport`` ABC:
+- ``InProcessTransport``: direct Python call (``inproc://<plugin_id>``)
+- ``GrpcTransport``: plaintext grpc (``grpc://host:port``)
+
+All transports satisfy the same ``call(method, request)`` contract;
+the contract test enforces byte-equality across them.
+
+mTLS support lands in a follow-up PR; PR #1 ships plaintext gRPC only,
+gated behind ``allow_insecure_grpc=true`` (DEV ONLY).
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from dynamo.planner.plugins.transport.base import PluginTransport
+from dynamo.planner.plugins.transport.errors import (
+    PluginCallError,
+    PluginConnectionError,
+    PluginSerializationError,
+    PluginTimeoutError,
+    PluginUnknownMethodError,
+)
+from dynamo.planner.plugins.transport.in_process import InProcessTransport
+
+# ``GrpcTransport`` is eagerly *re-exported* via PEP 562 lazy
+# ``__getattr__`` so ``from ... transport import GrpcTransport`` still
+# works for consumers that want it.  Eager import would pull in
+# ``_grpc_base`` → ``_proto_bridge`` → ``plugin_pb2``, which is generated
+# at install time and not on disk in PSM-only source-tree deployments
+# (``scheduling.use_orchestrator=False``).  See ``planner_config.py``
+# lazy-import refactor for the matching change at the registry layer.
+if TYPE_CHECKING:
+    from dynamo.planner.plugins.transport.grpc_remote import GrpcTransport
+
+__all__ = [
+    "PluginTransport",
+    "InProcessTransport",
+    "GrpcTransport",
+    "PluginCallError",
+    "PluginConnectionError",
+    "PluginSerializationError",
+    "PluginTimeoutError",
+    "PluginUnknownMethodError",
+]
+
+
+def __getattr__(name: str) -> Any:
+    if name == "GrpcTransport":
+        from dynamo.planner.plugins.transport.grpc_remote import GrpcTransport
+
+        return GrpcTransport
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
diff --git a/components/src/dynamo/planner/plugins/transport/_grpc_base.py b/components/src/dynamo/planner/plugins/transport/_grpc_base.py
new file mode 100644
index 000000000000..c12d00cce676
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/transport/_grpc_base.py
@@ -0,0 +1,263 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Shared gRPC channel base for ``GrpcTransport``.
+
+Factored as a base class so that follow-up transports (e.g. a future
+``UdsTransport`` over the gRPC ``unix:`` URI scheme, or an mTLS variant)
+can reuse the call dispatch + error mapping path and only override
+channel construction. In PR #1 only ``GrpcTransport`` (plaintext, gated
+by ``allow_insecure_grpc``) subclasses this.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+import grpc
+from google.protobuf.message import Message as ProtoMessage
+from pydantic import BaseModel
+
+from dynamo.planner.plugins._proto_bridge import proto_to_pydantic, pydantic_to_proto
+from dynamo.planner.plugins.transport._method_dispatch import StubDispatcher
+from dynamo.planner.plugins.transport.base import PluginTransport
+from dynamo.planner.plugins.transport.errors import (
+    PluginCallError,
+    PluginConnectionError,
+    PluginSerializationError,
+    PluginTimeoutError,
+    PluginUnknownMethodError,
+)
+
+log = logging.getLogger(__name__)
+
+_DEFAULT_KEEPALIVE_TIME_MS = 30_000
+_DEFAULT_MAX_MESSAGE_SIZE_BYTES = 10 * 1024 * 1024  # 10 MB
+
+
+def grpc_channel_options(
+    *,
+    keepalive_time_ms: int = _DEFAULT_KEEPALIVE_TIME_MS,
+    max_message_size_bytes: int = _DEFAULT_MAX_MESSAGE_SIZE_BYTES,
+) -> list[tuple[str, int]]:
+    """Build the per-channel gRPC option list for a plugin transport.
+
+    Centralised so individual plugins can't quietly override the
+    common options (keepalive timing, max ping behaviour), but the
+    operator-tunable knobs (``keepalive_time_ms``,
+    ``max_message_size_bytes``) are honoured per the user's
+    ``TransportConfig``.
+    """
+    return [
+        ("grpc.keepalive_time_ms", keepalive_time_ms),
+        ("grpc.keepalive_timeout_ms", 10_000),
+        ("grpc.keepalive_permit_without_calls", 1),
+        ("grpc.http2.max_pings_without_data", 0),
+        ("grpc.max_send_message_length", max_message_size_bytes),
+        ("grpc.max_receive_message_length", max_message_size_bytes),
+    ]
+
+
+class _GrpcTransportBase(PluginTransport):
+    """Shared call/close logic for gRPC-based transports.
+
+    Subclasses must:
+    - set ``self.plugin_id`` / ``self.endpoint`` / ``self.timeout_seconds``
+      in ``__init__``
+    - implement ``_build_channel()`` to construct the appropriate
+      ``grpc.aio.Channel`` (insecure UDS / insecure TCP / secure mTLS TCP)
+    """
+
+    def __init__(
+        self,
+        plugin_id: str,
+        endpoint: str,
+        timeout_seconds: float,
+        *,
+        keepalive_time_ms: int = _DEFAULT_KEEPALIVE_TIME_MS,
+        max_message_size_bytes: int = _DEFAULT_MAX_MESSAGE_SIZE_BYTES,
+    ) -> None:
+        if timeout_seconds <= 0:
+            raise ValueError(
+                f"{type(self).__name__}(plugin_id={plugin_id!r}): "
+                f"timeout_seconds must be positive, got {timeout_seconds}"
+            )
+        self.plugin_id = plugin_id
+        self.endpoint = endpoint
+        self.timeout_seconds = timeout_seconds
+        self.keepalive_time_ms = keepalive_time_ms
+        self.max_message_size_bytes = max_message_size_bytes
+        self._channel: grpc.aio.Channel | None = None
+        self._dispatcher: StubDispatcher | None = None
+        self._closed = False
+        self._channel_lock = asyncio.Lock()
+
+    def _build_channel(self) -> grpc.aio.Channel:  # pragma: no cover (abstract)
+        raise NotImplementedError
+
+    async def _ensure_channel(self) -> StubDispatcher:
+        if self._dispatcher is not None:
+            return self._dispatcher
+        async with self._channel_lock:
+            if self._dispatcher is None:
+                if self._closed:
+                    raise PluginConnectionError(
+                        f"plugin {self.plugin_id!r}: transport already closed",
+                        plugin_id=self.plugin_id,
+                    )
+                try:
+                    self._channel = self._build_channel()
+                except Exception as e:
+                    raise PluginConnectionError(
+                        f"plugin {self.plugin_id!r}: failed to build gRPC channel "
+                        f"to {self.endpoint!r}: {type(e).__name__}: {e}",
+                        plugin_id=self.plugin_id,
+                        cause=e,
+                    ) from e
+                self._dispatcher = StubDispatcher(self._channel)
+        return self._dispatcher
+
+    async def call(self, method: str, request: Any) -> Any:
+        if self._closed:
+            raise PluginConnectionError(
+                f"plugin {self.plugin_id!r}: cannot call {method!r} — transport closed",
+                plugin_id=self.plugin_id,
+                method=method,
+            )
+        dispatcher = await self._ensure_channel()
+        rpc = dispatcher.get_method(method)
+        if rpc is None:
+            raise PluginUnknownMethodError(
+                f"method {method!r} not in dispatch table; "
+                f"plugin {self.plugin_id!r} cannot serve it",
+                plugin_id=self.plugin_id,
+                method=method,
+            )
+        # Pydantic ↔ proto bridging at the wire boundary.
+        # The pipeline emits Pydantic stage requests (so it can keep
+        # using attribute-style access on the way back). gRPC stubs
+        # need proto messages. Convert here, mirror back on the way
+        # out so callers always see whatever they sent — Pydantic in →
+        # Pydantic out; proto in (e.g. transport contract test) →
+        # proto out. Without this, every external gRPC plugin call fails
+        # at gRPC serialisation — found while writing the first real
+        # external-plugin e2e test.
+        request_was_pyd = isinstance(request, BaseModel)
+        try:
+            wire_request: Any = (
+                pydantic_to_proto(request) if request_was_pyd else request
+            )
+        except KeyError as e:
+            # Unmapped Pydantic request type — surface as a typed
+            # transport error so callers see the documented contract
+            # (PluginCallError hierarchy) rather than a raw KeyError.
+            raise PluginSerializationError(
+                f"plugin {self.plugin_id!r} method {method!r}: unmapped "
+                f"Pydantic request class {type(request).__name__} ({e})",
+                plugin_id=self.plugin_id,
+                method=method,
+                cause=e,
+            ) from e
+        try:
+            wire_response = await asyncio.wait_for(
+                rpc(wire_request), self.timeout_seconds
+            )
+        except asyncio.TimeoutError as e:
+            raise PluginTimeoutError(
+                f"plugin {self.plugin_id!r} method {method!r} exceeded "
+                f"timeout_seconds={self.timeout_seconds}",
+                plugin_id=self.plugin_id,
+                method=method,
+                cause=e,
+            ) from e
+        except grpc.aio.AioRpcError as e:
+            code = e.code()
+            details = e.details() or ""
+            # Map gRPC status codes to typed call errors
+            if code == grpc.StatusCode.UNAVAILABLE:
+                raise PluginConnectionError(
+                    f"plugin {self.plugin_id!r} method {method!r}: "
+                    f"endpoint unreachable ({details})",
+                    plugin_id=self.plugin_id,
+                    method=method,
+                    cause=e,
+                ) from e
+            if code == grpc.StatusCode.UNIMPLEMENTED:
+                raise PluginUnknownMethodError(
+                    f"plugin {self.plugin_id!r} did not implement method {method!r}",
+                    plugin_id=self.plugin_id,
+                    method=method,
+                    cause=e,
+                ) from e
+            if code in (grpc.StatusCode.INTERNAL, grpc.StatusCode.DATA_LOSS):
+                raise PluginSerializationError(
+                    f"plugin {self.plugin_id!r} method {method!r}: "
+                    f"serialization or internal error ({code.name}: {details})",
+                    plugin_id=self.plugin_id,
+                    method=method,
+                    cause=e,
+                ) from e
+            raise PluginCallError(
+                f"plugin {self.plugin_id!r} method {method!r}: "
+                f"gRPC error {code.name}: {details}",
+                plugin_id=self.plugin_id,
+                method=method,
+                cause=e,
+            ) from e
+        except PluginCallError:
+            raise
+        except Exception as e:
+            raise PluginCallError(
+                f"plugin {self.plugin_id!r} method {method!r} raised "
+                f"{type(e).__name__}: {e}",
+                plugin_id=self.plugin_id,
+                method=method,
+                cause=e,
+            ) from e
+
+        # Symmetric conversion on the response. Treat anything that
+        # isn't a proto Message as already-Pydantic / unknown and
+        # leave it alone (defensive — should never happen in practice
+        # because gRPC stubs always return proto). If the caller gave
+        # us proto in, give proto back: this preserves the transport
+        # contract test's roundtrip-equivalence assertions.
+        if request_was_pyd and isinstance(wire_response, ProtoMessage):
+            try:
+                return proto_to_pydantic(wire_response)
+            except KeyError as e:
+                raise PluginSerializationError(
+                    f"plugin {self.plugin_id!r} method {method!r}: "
+                    f"unmapped response proto class {type(wire_response).__name__} "
+                    f"({e})",
+                    plugin_id=self.plugin_id,
+                    method=method,
+                    cause=e,
+                ) from e
+        return wire_response
+
+    async def close(self) -> None:
+        # Idempotent
+        if self._closed:
+            return
+        self._closed = True
+        if self._channel is not None:
+            try:
+                await self._channel.close()
+            except Exception as exc:  # noqa: BLE001 — close must be idempotent
+                # ``close`` must not raise to caller (it's the planner
+                # shutdown path; one buggy plugin must not stall the
+                # remaining cleanup). Surface the failure via the
+                # logger so it isn't silently lost.
+                log.warning(
+                    "plugin %r transport close raised %s: %s",
+                    self.plugin_id,
+                    type(exc).__name__,
+                    exc,
+                )
+        self._channel = None
+        self._dispatcher = None
+
+
+__all__ = ["_GrpcTransportBase", "grpc_channel_options"]
diff --git a/components/src/dynamo/planner/plugins/transport/_method_dispatch.py b/components/src/dynamo/planner/plugins/transport/_method_dispatch.py
new file mode 100644
index 000000000000..4149ea2bdf5e
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/transport/_method_dispatch.py
@@ -0,0 +1,67 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Plugin RPC method → gRPC stub method dispatch table.
+
+Used by ``GrpcTransport``: maintains one gRPC channel per plugin, then
+dispatches ``call(method, ...)`` to the correct stub method. Lives in
+``_grpc_base`` rather than directly on ``GrpcTransport`` so future
+gRPC-based transports (e.g. a deferred ``UdsTransport`` over the gRPC
+``unix:`` URI scheme, or an mTLS variant) can reuse it.
+
+Dispatch table is built lazily per channel — each plugin only needs the
+stage-specific stub it serves (a propose plugin only needs ProposePlugin
+service; no need to instantiate all 6 service stubs).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable
+
+import grpc
+
+from dynamo.planner.plugins.proto.v1 import plugin_pb2_grpc as pbg
+
+# Method name → (stub class, method attribute on stub instance)
+_METHOD_STUB_MAP: dict[str, tuple[type[Any], str]] = {
+    # Stage RPCs
+    "Predict": (pbg.PredictPluginStub, "Predict"),
+    "Propose": (pbg.ProposePluginStub, "Propose"),
+    "Reconcile": (pbg.ReconcilePluginStub, "Reconcile"),
+    "Constrain": (pbg.ConstrainPluginStub, "Constrain"),
+    # PluginLifecycle RPCs
+    "Bootstrap": (pbg.PluginLifecycleStub, "Bootstrap"),
+    "Reset": (pbg.PluginLifecycleStub, "Reset"),
+}
+
+
+class StubDispatcher:
+    """Lazy stub-cache per gRPC channel.
+
+    Instantiates a service stub only on first use; caches the bound
+    method (``stub.Predict``) for direct invocation.
+    """
+
+    def __init__(self, channel: grpc.aio.Channel) -> None:
+        self._channel = channel
+        self._stub_cache: dict[type[Any], Any] = {}
+        self._method_cache: dict[str, Callable[..., Any]] = {}
+
+    def get_method(self, method_name: str) -> Callable[..., Any] | None:
+        """Resolve ``method_name`` → bound stub method, or None if unknown."""
+        if method_name in self._method_cache:
+            return self._method_cache[method_name]
+        entry = _METHOD_STUB_MAP.get(method_name)
+        if entry is None:
+            return None
+        stub_cls, attr = entry
+        stub = self._stub_cache.get(stub_cls)
+        if stub is None:
+            stub = stub_cls(self._channel)
+            self._stub_cache[stub_cls] = stub
+        bound = getattr(stub, attr)
+        self._method_cache[method_name] = bound
+        return bound
+
+
+__all__ = ["StubDispatcher", "_METHOD_STUB_MAP"]
diff --git a/components/src/dynamo/planner/plugins/transport/base.py b/components/src/dynamo/planner/plugins/transport/base.py
new file mode 100644
index 000000000000..8256592f0b3e
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/transport/base.py
@@ -0,0 +1,102 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""``PluginTransport`` ABC — unified contract for plugin RPC invocation.
+
+PR #1 ships two transports (in-process / grpc) under this interface; the
+orchestrator's pipeline driver treats them uniformly via
+``await plugin.transport.call(method, request)``. A dedicated
+``UdsTransport`` is deferred to a follow-up PR — see
+``plugins/transport/README.md`` "Deferred" section.
+"""
+
+from __future__ import annotations
+
+import abc
+from typing import Any
+
+
+class PluginTransport(abc.ABC):
+    """Abstract transport interface for plugin RPC invocation.
+
+    **Lifecycle**:
+    - Constructed once per plugin (during register / register_internal)
+    - ``call(method, request)`` invoked many times across ticks
+    - ``close()`` called once during plugin unregister or orchestrator shutdown
+        (must be idempotent — orchestrator may call multiple times defensively)
+
+    **Concurrency**:
+    - Single-threaded asyncio model
+    - ``call()`` is async; multiple concurrent calls to the SAME transport
+      from different ``asyncio.gather`` branches are safe (gRPC channel
+      multiplexing handles it)
+    - Concurrent calls from MULTIPLE event loops is UB
+
+    **Error contract**:
+    - ALL failures MUST raise a ``PluginCallError`` subclass
+    - Specifically: timeout → ``PluginTimeoutError``; connection failure →
+      ``PluginConnectionError``; method not found → ``PluginUnknownMethodError``;
+      (de)serialization → ``PluginSerializationError``
+    - Subclasses MUST NOT swallow exceptions or return error sentinels
+    """
+
+    plugin_id: str
+    """Plugin identifier (matches ``RegisterRequest.plugin_id``)."""
+
+    endpoint: str
+    """Endpoint URL — ``inproc://<plugin_id>`` for in-process plugins,
+    ``grpc://host:port`` for out-of-process. ``make_transport_for_endpoint``
+    rejects other schemes."""
+
+    timeout_seconds: float
+    """Per-RPC timeout. The **transport** enforces this internally — each
+    ``call()`` wraps its own dispatch in ``asyncio.wait_for(...,
+    timeout_seconds)`` (see ``in_process.py`` / ``_grpc_base.py``). The
+    pipeline driver deliberately does NOT wrap calls (it uses a bare
+    ``asyncio.gather``) so the per-plugin deadline isn't double-counted."""
+
+    @abc.abstractmethod
+    async def call(self, method: str, request: Any) -> Any:
+        """Invoke a plugin RPC by method name.
+
+        Args:
+            method: RPC method name. One of ``"Predict"`` / ``"Propose"`` /
+                ``"Reconcile"`` / ``"Constrain"`` / ``"Bootstrap"`` / ``"Reset"``.
+                For ``InProcessTransport``: must be a method name on the
+                Python plugin instance. For ``GrpcTransport``: must be a
+                registered stub method.
+            request: proto generated message instance (e.g.
+                ``ProposeStageRequest``) — or a Pydantic mirror; the gRPC
+                transport accepts both and converts at the wire boundary
+                (see ``_GrpcTransportBase`` for the bridge).
+
+        Returns:
+            proto generated response message (e.g. ``ProposeStageResponse``).
+
+        Raises:
+            PluginTimeoutError: ``asyncio.wait_for(timeout=self.timeout_seconds)`` expired
+            PluginUnknownMethodError: method not registered on this plugin
+            PluginConnectionError: transport-layer failure (gRPC channel
+                disconnected, unreachable endpoint, ...)
+            PluginSerializationError: request / response (de)serialization failure
+            PluginCallError: catch-all for plugin-internal exceptions
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def close(self) -> None:
+        """Release transport resources.
+
+        MUST be idempotent — orchestrator shutdown may invoke multiple times.
+
+        - ``InProcessTransport``: no-op (plugin instance lifecycle owned by orchestrator)
+        - ``GrpcTransport``: close the gRPC channel
+        """
+        raise NotImplementedError
+
+    def __repr__(self) -> str:
+        cls = type(self).__name__
+        return f"{cls}(plugin_id={self.plugin_id!r}, endpoint={self.endpoint!r})"
+
+
+__all__ = ["PluginTransport"]
diff --git a/components/src/dynamo/planner/plugins/transport/config.py b/components/src/dynamo/planner/plugins/transport/config.py
new file mode 100644
index 000000000000..7de333b8f564
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/transport/config.py
@@ -0,0 +1,178 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Transport / Clock configuration schema and factories.
+
+Configures both:
+- ``planner.plugin_registration.transport.*`` — TransportConfig (timeouts, etc.)
+- ``planner.scheduling.clock.*`` — ClockConfig (wall vs virtual)
+
+mTLS support lands in a follow-up PR; PR #1 ships plaintext gRPC only,
+gated behind ``allow_insecure_grpc=true`` (DEV ONLY).
+
+Factory functions:
+- ``make_transport_for_endpoint(plugin_id, endpoint, config, instance=None)``
+- ``make_clock(config)`` — production refuses ``virtual`` unless test override env set
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from dynamo.planner.plugins.clock import Clock, VirtualClock, WallClock
+from dynamo.planner.plugins.transport.base import PluginTransport
+
+# ``GrpcTransport`` import deferred to ``make_transport_for_endpoint``
+# where it's actually constructed.  Module-top import would pull in
+# ``_grpc_base`` → ``_proto_bridge`` → ``plugin_pb2``, which is generated
+# at install time and absent from the source tree — that would break
+# ``PlannerConfig`` parsing in PSM-only deployments (where
+# ``use_orchestrator=False`` never reaches the gRPC path).
+
+
+# ----------------------------------------------------------------------------
+# Schema
+# ----------------------------------------------------------------------------
+
+
+class TransportConfig(BaseModel):
+    """``planner.plugin_registration.transport.*`` config tree."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    allow_insecure_grpc: bool = False
+    """Default refuse plaintext grpc:// channels; set true + WARNING log for dev.
+
+    PR #1 only supports plaintext gRPC behind this flag. mTLS support
+    (cert-manager / Secret mount) lands in a follow-up PR."""
+
+    request_timeout_seconds: float = Field(default=5.0, gt=0)
+    """Per-RPC timeout — applies uniformly to every plugin's ``call()``.
+    Per-plugin override is not shipped in PR #1; a future PR may add it
+    by plumbing a new ``RegisterRequest`` field through
+    ``make_transport_for_endpoint``."""
+
+    keepalive_time_ms: int = 30_000
+    max_message_size_bytes: int = 10 * 1024 * 1024  # 10 MB
+
+
+class ClockConfig(BaseModel):
+    """``planner.scheduling.clock.*`` config tree."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    type: Literal["wall", "virtual"] = "wall"
+    """Production must be ``wall``; ``virtual`` only allowed when env
+    ``DYNAMO_PLANNER_TEST=1`` is set."""
+
+    virtual_start_now: float = 0.0
+    """Initial epoch time for VirtualClock (only used when type=virtual)."""
+
+    virtual_start_mono: float = 0.0
+    """Initial monotonic time for VirtualClock (only used when type=virtual)."""
+
+
+# ----------------------------------------------------------------------------
+# Factories
+# ----------------------------------------------------------------------------
+
+
+def make_transport_for_endpoint(
+    plugin_id: str,
+    endpoint: str,
+    config: TransportConfig,
+    *,
+    in_process_instance: Any | None = None,
+) -> PluginTransport:
+    """Construct a ``PluginTransport`` from endpoint scheme + config.
+
+    Args:
+        plugin_id: identifier passed through to the transport
+        endpoint: must start with ``inproc://`` or ``grpc://``
+        config: TransportConfig (timeouts + ``allow_insecure_grpc``)
+        in_process_instance: required when ``endpoint`` starts with ``inproc://``;
+            ignored otherwise. Bridges the ``register_internal`` path.
+
+    Raises:
+        ValueError: invalid endpoint scheme, missing instance for inproc,
+            or ``grpc://`` endpoint without ``allow_insecure_grpc=True``
+            (mTLS support lands in a follow-up PR).
+    """
+    timeout = config.request_timeout_seconds
+
+    if endpoint.startswith("inproc://"):
+        # Local import keeps the module top free of plugin_pb2-dependent
+        # transports — see comment at top of file.
+        from dynamo.planner.plugins.transport.in_process import InProcessTransport
+
+        if in_process_instance is None:
+            raise ValueError(
+                f"make_transport_for_endpoint(plugin_id={plugin_id!r}, "
+                f"endpoint={endpoint!r}): in_process_instance required for inproc://"
+            )
+        return InProcessTransport(
+            plugin_id, in_process_instance, timeout_seconds=timeout
+        )
+
+    if endpoint.startswith("grpc://"):
+        # Same deferred-import pattern as ``InProcessTransport`` above.
+        from dynamo.planner.plugins.transport.grpc_remote import GrpcTransport
+
+        if not config.allow_insecure_grpc:
+            raise ValueError(
+                f"make_transport_for_endpoint(plugin_id={plugin_id!r}, "
+                f"endpoint={endpoint!r}): plaintext grpc:// requires "
+                f"allow_insecure_grpc=True; mTLS support lands in a "
+                f"follow-up PR."
+            )
+        return GrpcTransport(
+            plugin_id,
+            endpoint,
+            timeout_seconds=timeout,
+            allow_insecure=config.allow_insecure_grpc,
+            keepalive_time_ms=config.keepalive_time_ms,
+            max_message_size_bytes=config.max_message_size_bytes,
+        )
+
+    raise ValueError(
+        f"make_transport_for_endpoint(plugin_id={plugin_id!r}): "
+        f"unknown endpoint scheme in {endpoint!r}; expected one of "
+        f"'inproc://', 'grpc://'"
+    )
+
+
+_TEST_OVERRIDE_ENV = "DYNAMO_PLANNER_TEST"
+
+
+def make_clock(config: ClockConfig) -> Clock:
+    """Construct a Clock from config.
+
+    Production safety: ``type="virtual"`` is rejected unless
+    ``DYNAMO_PLANNER_TEST=1`` is set in the environment. Replay /
+    test code paths set the env var explicitly.
+    """
+    if config.type == "wall":
+        return WallClock()
+    if config.type == "virtual":
+        if os.environ.get(_TEST_OVERRIDE_ENV) != "1":
+            raise ValueError(
+                f"make_clock: clock.type=virtual requires environment "
+                f"variable {_TEST_OVERRIDE_ENV}=1 (production safety check). "
+                f"VirtualClock must not be used in production."
+            )
+        return VirtualClock(
+            start_now=config.virtual_start_now,
+            start_mono=config.virtual_start_mono,
+        )
+    raise ValueError(f"make_clock: unknown clock.type={config.type!r}")
+
+
+__all__ = [
+    "TransportConfig",
+    "ClockConfig",
+    "make_transport_for_endpoint",
+    "make_clock",
+]
diff --git a/components/src/dynamo/planner/plugins/transport/errors.py b/components/src/dynamo/planner/plugins/transport/errors.py
new file mode 100644
index 000000000000..2e8f4c15762d
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/transport/errors.py
@@ -0,0 +1,87 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Plugin call error hierarchy.
+
+All transport ``call()`` failures MUST raise a ``PluginCallError``
+subclass — no naked exceptions, no silent return. The subtype hierarchy
+lets the orchestrator decide selectively: timeout → circuit breaker;
+connection → reconnect; unknown method → contract violation;
+serialization → plugin bug audit.
+"""
+
+from __future__ import annotations
+
+
+class PluginCallError(Exception):
+    """Base for all plugin transport / RPC errors.
+
+    Attributes:
+        plugin_id: which plugin raised
+        method: which RPC method was invoked
+        cause: original exception (if any), preserved via ``raise ... from cause``
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        plugin_id: str = "",
+        method: str = "",
+        cause: BaseException | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.plugin_id = plugin_id
+        self.method = method
+        self.cause = cause
+
+
+class PluginTimeoutError(PluginCallError):
+    """``asyncio.wait_for`` exceeded ``request_timeout_seconds`` for this RPC.
+
+    Orchestrator increments circuit breaker failure count.
+    """
+
+
+class PluginConnectionError(PluginCallError):
+    """Transport-layer connection failure: socket missing, channel down,
+    DNS error, mTLS handshake failed, etc.
+
+    Orchestrator may attempt reconnection on next tick (UDS / gRPC); for
+    in-process this should never occur.
+    """
+
+
+class PluginSerializationError(PluginCallError):
+    """Request / response (de)serialization failed.
+
+    Common causes:
+    - proto schema mismatch between orchestrator and plugin
+    - bytes encoding mismatch in ``FpmData`` (e.g. msgspec vs proto)
+
+    Note: a plugin returning a response with an empty ``oneof result`` is
+    NOT a serialization error — it is treated as silent ACCEPT for graceful
+    degradation (see ``plugins/proto/v1/README.md`` and the inline note in
+    ``pipeline.py:_response_to_plugin_result``). Only true bytes-level
+    decode failures land here.
+    """
+
+
+class PluginUnknownMethodError(PluginCallError):
+    """Requested method name not found on plugin.
+
+    For ``InProcessTransport``: ``getattr(instance, method)`` returned None.
+    For ``GrpcTransport``: stub map has no entry for method.
+
+    This indicates a programming bug in the orchestrator (calling wrong stage)
+    or a plugin missing required RPC handlers.
+    """
+
+
+__all__ = [
+    "PluginCallError",
+    "PluginTimeoutError",
+    "PluginConnectionError",
+    "PluginSerializationError",
+    "PluginUnknownMethodError",
+]
diff --git a/components/src/dynamo/planner/plugins/transport/grpc_remote.py b/components/src/dynamo/planner/plugins/transport/grpc_remote.py
new file mode 100644
index 000000000000..f8288fbb52c5
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/transport/grpc_remote.py
@@ -0,0 +1,76 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""gRPC over TCP transport — cross-Pod plugin.
+
+PR #1 ships plaintext gRPC only, gated behind ``allow_insecure=True``
+(DEV ONLY — startup logs WARNING). mTLS support (cert-manager / Secret
+mount) lands in a follow-up PR.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import grpc
+
+from dynamo.planner.plugins.transport._grpc_base import (
+    _GrpcTransportBase,
+    grpc_channel_options,
+)
+
+log = logging.getLogger(__name__)
+
+
+class GrpcTransport(_GrpcTransportBase):
+    """gRPC over TCP for cross-Pod plugins. Plaintext only in PR #1."""
+
+    def __init__(
+        self,
+        plugin_id: str,
+        endpoint: str,
+        timeout_seconds: float = 5.0,
+        *,
+        allow_insecure: bool = False,
+        keepalive_time_ms: int = 30_000,
+        max_message_size_bytes: int = 10 * 1024 * 1024,
+    ) -> None:
+        if not endpoint.startswith("grpc://"):
+            raise ValueError(
+                f"GrpcTransport endpoint must start with 'grpc://', got {endpoint!r}"
+            )
+        target = endpoint[len("grpc://") :]
+        if not target:
+            raise ValueError(f"GrpcTransport endpoint missing host:port: {endpoint!r}")
+        if not allow_insecure:
+            raise ValueError(
+                f"GrpcTransport(plugin_id={plugin_id!r}): plaintext gRPC requires "
+                f"allow_insecure=True (DEV ONLY — startup logs WARNING). mTLS "
+                f"support lands in a follow-up PR."
+            )
+        log.warning(
+            "GrpcTransport(plugin_id=%s, endpoint=%s): allow_insecure=True; "
+            "channel will be plaintext. DEV ONLY — never use in production.",
+            plugin_id,
+            endpoint,
+        )
+        self._target = target
+        super().__init__(
+            plugin_id,
+            endpoint,
+            timeout_seconds,
+            keepalive_time_ms=keepalive_time_ms,
+            max_message_size_bytes=max_message_size_bytes,
+        )
+
+    def _build_channel(self) -> grpc.aio.Channel:
+        return grpc.aio.insecure_channel(
+            self._target,
+            options=grpc_channel_options(
+                keepalive_time_ms=self.keepalive_time_ms,
+                max_message_size_bytes=self.max_message_size_bytes,
+            ),
+        )
+
+
+__all__ = ["GrpcTransport"]
diff --git a/components/src/dynamo/planner/plugins/transport/in_process.py b/components/src/dynamo/planner/plugins/transport/in_process.py
new file mode 100644
index 000000000000..02e20319a64f
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/transport/in_process.py
@@ -0,0 +1,117 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""In-process transport: direct Python call.
+
+Used by:
+- Builtin plugins — registered via ``register_internal``, zero RPC overhead
+- ``in_process`` user plugins — loaded by config
+- Replay / unit tests — first-class production transport, NOT a test fallback
+"""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+from typing import Any
+
+from dynamo.planner.plugins.transport.base import PluginTransport
+from dynamo.planner.plugins.transport.errors import (
+    PluginCallError,
+    PluginConnectionError,
+    PluginTimeoutError,
+    PluginUnknownMethodError,
+)
+
+
+class InProcessTransport(PluginTransport):
+    """Direct Python invocation; zero serialization cost.
+
+    Supports both ``async def`` and sync (``def``) plugin methods; sync
+    methods are dispatched via ``asyncio.to_thread`` to avoid blocking
+    the orchestrator event loop.
+
+    **⚠ Sync plugin red line** (see transport/README.md): sync plugin
+    methods MUST NOT do blocking IO (HTTP, file, ``time.sleep > 100ms``);
+    otherwise thread pool exhaustion will block the orchestrator. If
+    your plugin needs IO, write it as ``async def``.
+    """
+
+    def __init__(
+        self,
+        plugin_id: str,
+        instance: Any,
+        timeout_seconds: float = 5.0,
+    ) -> None:
+        if instance is None:
+            raise ValueError(
+                f"InProcessTransport(plugin_id={plugin_id!r}): instance must not be None"
+            )
+        if timeout_seconds <= 0:
+            raise ValueError(
+                f"InProcessTransport(plugin_id={plugin_id!r}): "
+                f"timeout_seconds must be positive, got {timeout_seconds}"
+            )
+        self.plugin_id = plugin_id
+        self.endpoint = f"inproc://{plugin_id}"
+        self.timeout_seconds = timeout_seconds
+        self._instance = instance
+        self._closed = False
+
+    async def call(self, method: str, request: Any) -> Any:
+        # Refuse calls after close() — mirrors _GrpcTransportBase contract
+        # so callers see the same PluginConnectionError regardless of
+        # transport type.
+        if self._closed:
+            raise PluginConnectionError(
+                f"InProcessTransport(plugin_id={self.plugin_id!r}): "
+                f"call() invoked after close()",
+                plugin_id=self.plugin_id,
+                method=method,
+            )
+
+        # Method lookup
+        fn = getattr(self._instance, method, None)
+        if fn is None or not callable(fn):
+            raise PluginUnknownMethodError(
+                f"method {method!r} not found on plugin {self.plugin_id!r} "
+                f"(type {type(self._instance).__name__})",
+                plugin_id=self.plugin_id,
+                method=method,
+            )
+
+        # Dispatch — async vs sync
+        try:
+            if inspect.iscoroutinefunction(fn):
+                coro = fn(request)
+            else:
+                # Sync plugin: run in default thread pool to avoid blocking event loop
+                coro = asyncio.to_thread(fn, request)
+            return await asyncio.wait_for(coro, self.timeout_seconds)
+        except asyncio.TimeoutError as e:
+            raise PluginTimeoutError(
+                f"plugin {self.plugin_id!r} method {method!r} exceeded "
+                f"timeout_seconds={self.timeout_seconds}",
+                plugin_id=self.plugin_id,
+                method=method,
+                cause=e,
+            ) from e
+        except PluginCallError:
+            # Plugin already raised a typed call error; propagate as-is
+            raise
+        except Exception as e:
+            raise PluginCallError(
+                f"plugin {self.plugin_id!r} method {method!r} raised "
+                f"{type(e).__name__}: {e}",
+                plugin_id=self.plugin_id,
+                method=method,
+                cause=e,
+            ) from e
+
+    async def close(self) -> None:
+        # In-process plugin instance lifecycle is owned by orchestrator;
+        # transport has nothing to release. Idempotent flag set for safety.
+        self._closed = True
+
+
+__all__ = ["InProcessTransport"]
diff --git a/components/src/dynamo/planner/plugins/types.py b/components/src/dynamo/planner/plugins/types.py
new file mode 100644
index 000000000000..3b85d2c7b4ff
--- /dev/null
+++ b/components/src/dynamo/planner/plugins/types.py
@@ -0,0 +1,472 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Pydantic v2 mirror of the v1 plugin proto messages.
+
+These classes are 1:1 with the proto messages in
+``dynamo.planner.plugins.proto.v1.plugin_pb2``; field names, types, and
+optional-ness must match exactly.
+
+**Why a Pydantic mirror?**
+1. **In-process plugin path** (`InProcessTransport`) directly invokes
+   plugin Python objects; Pydantic instances are far cleaner than proto
+   builder pattern + wrapped optionals.
+2. **Test construction**: ``OverrideResult(targets=[ComponentTarget(...)])``
+   reads naturally vs proto repeated-field setters.
+3. **JSON serialization** for audit logs / debug: Pydantic ``model_dump()``
+   gives JSON directly.
+
+**Lock-step contract** (the round-trip test enforces): any change to
+the proto MUST come with a matching change here, verified by
+``tests/plugins/proto/test_round_trip.py``.
+
+Plugin implementations are encouraged to use these classes internally;
+the ``call(method, request)`` transport boundary still uses proto
+generated messages (see ``_proto_bridge.py`` for converters).
+"""
+
+from __future__ import annotations
+
+from enum import IntEnum
+from typing import Any, Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+# ----------------------------------------------------------------------------
+# Enums (mirror proto enum integer values exactly)
+# ----------------------------------------------------------------------------
+
+
+class HoldPolicy(IntEnum):
+    """Mirrors plugin_pb2.HoldPolicy."""
+
+    ACCEPT_WHEN_IDLE = 0
+    HOLD_LAST = 1
+
+
+class CircuitState(IntEnum):
+    """Mirrors plugin_pb2.CircuitState."""
+
+    CLOSED = 0
+    OPEN = 1
+    HALF_OPEN = 2
+
+
+class OverrideType(IntEnum):
+    """Mirrors plugin_pb2.OverrideType."""
+
+    SET = 0
+    AT_LEAST = 1
+    AT_MOST = 2
+
+
+# ----------------------------------------------------------------------------
+# Shared base config — strict; reject extras
+# ----------------------------------------------------------------------------
+
+
+class _ProtoMirror(BaseModel):
+    """Shared base: strict, immutable hash for testing equality."""
+
+    model_config = ConfigDict(
+        extra="forbid",
+        validate_assignment=True,
+    )
+
+
+# ----------------------------------------------------------------------------
+# PluginRegistry messages
+# ----------------------------------------------------------------------------
+
+
+class RegisterRequest(_ProtoMirror):
+    plugin_id: str
+    plugin_type: Literal["predict", "propose", "reconcile", "constrain"]
+    priority: int = 0
+    endpoint: str = ""
+    version: str = ""
+    execution_interval_seconds: float = 0.0
+    hold_policy: HoldPolicy = HoldPolicy.ACCEPT_WHEN_IDLE
+    needs: list[str] = Field(default_factory=list)
+    protocol_version: str = ""
+    auth_token: str = ""
+    # ``requires_produced_fields``: scale_interval cadence model. Plugin only
+    # fires this tick when every listed dot-path resolves non-None in the
+    # current PipelineContext. Empty/unset = no gating.
+    requires_produced_fields: list[str] = Field(default_factory=list)
+    # ``observation_window_seconds``: scale_interval cadence model. For each
+    # windowed observation type in ``needs`` (currently
+    # ``observations.traffic``), declares the aggregation window the plugin
+    # wants. 0.0 = scale_interval freshness; N > 0 = Prometheus aggregates
+    # over N seconds. Must be 0 or a positive multiple of
+    # ``scale_interval_seconds`` (enforced at registration time).
+    observation_window_seconds: float = 0.0
+
+
+class RegisterResponse(_ProtoMirror):
+    accepted: bool = False
+    reject_reason: str = ""
+    negotiated_protocol_version: str = ""
+
+
+class HeartbeatRequest(_ProtoMirror):
+    plugin_id: str = ""
+    auth_token: str = ""
+
+
+class HeartbeatResponse(_ProtoMirror):
+    ok: bool = False
+
+
+class UnregisterRequest(_ProtoMirror):
+    plugin_id: str = ""
+    reason: str = ""
+    auth_token: str = ""
+
+
+class UnregisterResponse(_ProtoMirror):
+    ok: bool = False
+
+
+class ListPluginsRequest(_ProtoMirror):
+    stage_filter: str = ""
+    include_disabled: bool = False
+
+
+class PluginInfo(_ProtoMirror):
+    plugin_id: str = ""
+    plugin_type: str = ""
+    priority: int = 0
+    version: str = ""
+    protocol_version: str = ""
+    enabled: bool = False
+    is_builtin: bool = False
+    transport: Literal["", "in_process", "grpc"] = ""
+    circuit_state: CircuitState = CircuitState.CLOSED
+    evaluations_total: int = 0
+    last_call_at_seconds_ago: float = 0.0
+    cache_age_seconds: float = 0.0
+
+
+class ListPluginsResponse(_ProtoMirror):
+    plugins: list[PluginInfo] = Field(default_factory=list)
+
+
+# ----------------------------------------------------------------------------
+# Pipeline context + observation types
+# ----------------------------------------------------------------------------
+
+
+class TrafficMetrics(_ProtoMirror):
+    duration_s: float = 0.0
+    num_req: float = 0.0
+    isl: float = 0.0
+    osl: float = 0.0
+    # KV cache hit rate over the window.  ``Optional`` mirrors proto3
+    # field presence (``optional float kv_hit_rate = 5``) and matches the
+    # PSM-side ``TrafficObservation.kv_hit_rate`` semantic: ``None`` =
+    # Prometheus returned no datapoint; ``0.0`` = all-cold cache.  PSM
+    # throughput scaling consumes this; external throughput-propose
+    # plugins replicating PSM behaviour read it here.
+    kv_hit_rate: Optional[float] = None
+
+
+class FpmData(_ProtoMirror):
+    """Per-engine ForwardPassMetrics; wire format is msgspec/msgpack-encoded.
+
+    Populated by ``OrchestratorEngineAdapter`` when the adapter receives
+    ``FpmObservations`` from the FPM subscriber.  Map key format is
+    ``"<worker_id>/<dp_rank>"``; map value is the
+    ``msgspec.msgpack.encode``-ed ``ForwardPassMetrics`` payload.
+    Plugins declaring ``needs=["observations.fpm"]`` receive this; when
+    no engines reported FPM this tick the field is absent (not an empty
+    submap), so a plugin should treat ``ctx.observations.fpm is None``
+    as "no FPM data this tick"."""
+
+    prefill_engines: dict[str, bytes] = Field(default_factory=dict)
+    decode_engines: dict[str, bytes] = Field(default_factory=dict)
+
+
+class WorkerState(_ProtoMirror):
+    """Per-component worker inventory.
+
+    ``ready_*`` / ``expected_*`` are replica counts.
+    ``*_scaling_in_progress`` is true while a previously-issued scale
+    operation has not yet landed (ready != expected); external load-
+    scaling plugins replicating PSM behaviour gate further scale-up on
+    these flags (otherwise the planner can chase a moving target and
+    over-provision).  ``None`` means "not reported this tick"."""
+
+    ready_prefill: Optional[int] = None
+    ready_decode: Optional[int] = None
+    expected_prefill: Optional[int] = None
+    expected_decode: Optional[int] = None
+    prefill_scaling_in_progress: Optional[bool] = None
+    decode_scaling_in_progress: Optional[bool] = None
+
+
+class ObservationData(_ProtoMirror):
+    traffic: Optional[TrafficMetrics] = None
+    fpm: Optional[FpmData] = None
+    workers: Optional[WorkerState] = None
+
+
+class PredictionData(_ProtoMirror):
+    """All four prediction fields are ``Optional[float]``.
+
+    ``chain_augment`` partial-merge uses field set/unset to distinguish
+    "I assert this value (even 0.0)" vs "no opinion, preserve previous".
+    Proto3 ``optional`` modifier on the corresponding proto fields preserves
+    this; here in Pydantic, ``Optional[float] = None`` carries the same
+    semantics — ``None`` means unset, any concrete float (including 0.0)
+    means asserted.
+
+    ``predicted_kv_hit_rate`` mirrors the PSM-side
+    ``TickDiagnostics.predicted_kv_hit_rate``; external throughput-propose
+    plugins replicating PSM behaviour emit it here.
+    """
+
+    predicted_num_req: Optional[float] = None
+    predicted_isl: Optional[float] = None
+    predicted_osl: Optional[float] = None
+    predicted_kv_hit_rate: Optional[float] = None
+    source: str = ""
+
+
+class ComponentTarget(_ProtoMirror):
+    """One scaling target per component instance.
+
+    ``replicas=None`` means "no opinion on this component" (v9 semantics).
+    ``type`` is meaningful inside OverrideResult; ignored in ScalingProposal.
+
+    Single-pool by construction in this PR: one target per
+    ``sub_component_type``.  Per-pool addressing (the ``component_name``
+    surface previously here at proto tag 2) is hierarchical-planner
+    territory and is re-introduced when that PR lands.
+    """
+
+    sub_component_type: str
+    replicas: Optional[int] = None
+    type: OverrideType = OverrideType.SET
+
+
+class ScalingProposal(_ProtoMirror):
+    """Output of RECONCILE/CONSTRAIN. ComponentTarget.type is unused here."""
+
+    targets: list[ComponentTarget] = Field(default_factory=list)
+    reason: str = ""
+    source: str = ""
+
+
+class PipelineContext(_ProtoMirror):
+    """Full context flowing through PREDICT -> PROPOSE -> RECONCILE -> CONSTRAIN."""
+
+    request_id: str = ""
+    decision_id: str = ""
+    observations: Optional[ObservationData] = None
+    predictions: Optional[PredictionData] = None
+    proposal: Optional[ScalingProposal] = None
+    constrained: Optional[ScalingProposal] = None
+
+
+# ----------------------------------------------------------------------------
+# OverrideResult / Accept / Reject + stage-specific request/response
+# ----------------------------------------------------------------------------
+
+
+class AcceptResult(_ProtoMirror):
+    """Empty marker; proto AcceptResult is empty too."""
+
+
+class RejectResult(_ProtoMirror):
+    reason: str = ""
+
+
+class OverrideResult(_ProtoMirror):
+    targets: list[ComponentTarget] = Field(default_factory=list)
+    reason: str = ""
+
+
+# Stage request/response — `result` is a discriminated union; Pydantic
+# expresses it as a literal `Optional` of three kinds, only one set at a time.
+# We use a `result_kind` tag + payload field to mirror proto3 oneof semantics
+# explicitly. Round-trip test verifies equivalence.
+
+
+def _derive_result_kind(obj: Any) -> None:
+    """Auto-derive ``result_kind`` from the set oneof payload and validate
+    the oneof invariant. Shared by every message carrying the
+    ``result_kind`` + accept/override/reject oneof (stage responses AND
+    ``ProposeResult``) so they all get identical construction ergonomics
+    and the same oneof-violation guard — without which a message built the
+    natural way (e.g. ``ProposeResult(override=...)``) leaves
+    ``result_kind=''`` and fails proto round-trip equality."""
+    set_kinds = [
+        k for k in ("accept", "override", "reject") if getattr(obj, k) is not None
+    ]
+    if obj.result_kind == "" and len(set_kinds) == 1:
+        object.__setattr__(obj, "result_kind", set_kinds[0])
+    elif len(set_kinds) > 1:
+        raise ValueError(
+            f"oneof violation: at most one of accept/override/reject may be set; "
+            f"got {set_kinds}"
+        )
+    elif obj.result_kind != "" and obj.result_kind not in set_kinds:
+        raise ValueError(
+            f"result_kind={obj.result_kind!r} but corresponding payload not set"
+        )
+
+
+class _StageOneofResponse(_ProtoMirror):
+    """Common base for stage responses with proto3 ``oneof result``.
+
+    ``result_kind`` + payload mirror proto3's ``WhichOneof('result')``.
+    Exactly one of ``accept`` / ``override`` / ``reject`` should be set
+    (matching ``result_kind``); validators enforce it.
+    """
+
+    result_kind: Literal["", "accept", "override", "reject"] = ""
+    accept: Optional[AcceptResult] = None
+    override: Optional[OverrideResult] = None
+    reject: Optional[RejectResult] = None
+    final: bool = False
+
+    def model_post_init(self, __context: Any) -> None:
+        _derive_result_kind(self)
+
+
+class PredictStageRequest(_ProtoMirror):
+    context: Optional[PipelineContext] = None
+
+
+class PredictStageResponse(_ProtoMirror):
+    """PREDICT plugin output — chain-augment partial-merge.
+
+    ``predictions=None`` ≈ AcceptResult (no opinion);
+    ``final=True`` stops the chain (v11: should only be used by lowest-priority
+    plugin to avoid breaking chain before higher-priority plugins run).
+    """
+
+    predictions: Optional[PredictionData] = None
+    reason: str = ""
+    final: bool = False
+
+
+class ProposeStageRequest(_ProtoMirror):
+    context: Optional[PipelineContext] = None
+
+
+class ProposeStageResponse(_StageOneofResponse):
+    """PROPOSE plugin output. ``final=True`` completely overrides other plugins'
+    outputs in this stage (multiple final → priority number smallest wins).
+    REJECT > final priority (v11 G-2)."""
+
+
+class ProposeResult(_ProtoMirror):
+    """Per-plugin propose output passed to RECONCILE plugins.
+
+    Mirrors proto ProposeResult; ``priority`` is the originating plugin's
+    priority (RECONCILE plugins reweight / filter based on this).
+    """
+
+    plugin_id: str = ""
+    result_kind: Literal["", "accept", "override", "reject"] = ""
+    accept: Optional[AcceptResult] = None
+    override: Optional[OverrideResult] = None
+    reject: Optional[RejectResult] = None
+    priority: int = 0
+
+    def model_post_init(self, __context: Any) -> None:
+        # Same oneof auto-derive + validation as the stage responses, so
+        # ``ProposeResult(override=...)`` round-trips through proto without
+        # ``result_kind`` drifting from '' to the WhichOneof-injected value.
+        _derive_result_kind(self)
+
+
+class ReconcileStageRequest(_ProtoMirror):
+    context: Optional[PipelineContext] = None
+    proposals: list[ProposeResult] = Field(default_factory=list)
+
+
+class ReconcileStageResponse(_StageOneofResponse):
+    """RECONCILE plugin output. Same final semantics as ProposeStageResponse."""
+
+
+class ConstrainStageRequest(_ProtoMirror):
+    context: Optional[PipelineContext] = None
+
+
+class ConstrainStageResponse(_StageOneofResponse):
+    """CONSTRAIN plugin output. SET targets are silently dropped at runtime
+    (v11: register-time static rejection is infeasible). ``final`` is silently
+    ignored in CONSTRAIN."""
+
+
+# ----------------------------------------------------------------------------
+# PluginLifecycle messages (v10 YAGNI: only Bootstrap + Reset)
+# ----------------------------------------------------------------------------
+
+
+class BootstrapRequest(_ProtoMirror):
+    bootstrap_data: bytes = b""
+    hints: dict[str, str] = Field(default_factory=dict)
+
+
+class BootstrapResponse(_ProtoMirror):
+    ok: bool = False
+    message: str = ""
+
+
+class ResetRequest(_ProtoMirror):
+    reason: str = ""
+
+
+class ResetResponse(_ProtoMirror):
+    ok: bool = False
+    message: str = ""
+
+
+__all__ = [
+    # Enums
+    "HoldPolicy",
+    "CircuitState",
+    "OverrideType",
+    # PluginRegistry
+    "RegisterRequest",
+    "RegisterResponse",
+    "HeartbeatRequest",
+    "HeartbeatResponse",
+    "UnregisterRequest",
+    "UnregisterResponse",
+    "ListPluginsRequest",
+    "PluginInfo",
+    "ListPluginsResponse",
+    # Pipeline context + observation
+    "TrafficMetrics",
+    "FpmData",
+    "WorkerState",
+    "ObservationData",
+    "PredictionData",
+    "ComponentTarget",
+    "ScalingProposal",
+    "PipelineContext",
+    # Stage payloads
+    "AcceptResult",
+    "RejectResult",
+    "OverrideResult",
+    "ProposeResult",
+    # Stage request/response
+    "PredictStageRequest",
+    "PredictStageResponse",
+    "ProposeStageRequest",
+    "ProposeStageResponse",
+    "ReconcileStageRequest",
+    "ReconcileStageResponse",
+    "ConstrainStageRequest",
+    "ConstrainStageResponse",
+    # PluginLifecycle
+    "BootstrapRequest",
+    "BootstrapResponse",
+    "ResetRequest",
+    "ResetResponse",
+]
diff --git a/components/src/dynamo/planner/tests/config/__init__.py b/components/src/dynamo/planner/tests/config/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/tests/config/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/tests/config/test_scheduling_config.py b/components/src/dynamo/planner/tests/config/test_scheduling_config.py
new file mode 100644
index 000000000000..6f2b20a51595
--- /dev/null
+++ b/components/src/dynamo/planner/tests/config/test_scheduling_config.py
@@ -0,0 +1,146 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for SchedulingConfig + PlannerConfig.scheduling."""
+
+from __future__ import annotations
+
+import pytest
+import yaml
+from pydantic import ValidationError
+
+from dynamo.planner.config.planner_config import PlannerConfig, SchedulingConfig
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+# ---------------------------------------------------------------------------
+# SchedulingConfig defaults
+# ---------------------------------------------------------------------------
+
+
+def test_scheduling_defaults_opt_out_of_orchestrator():
+    """Feature flag default MUST be False — upgrading existing
+    deployments shouldn't flip behavior until operators opt in."""
+    s = SchedulingConfig()
+    assert s.use_orchestrator is False
+
+
+def test_scheduling_default_timeouts_match_spec():
+    s = SchedulingConfig()
+    assert s.tick_max_duration_seconds == 30.0
+
+
+def test_scheduling_rejects_non_positive_tick_deadline():
+    with pytest.raises(ValidationError):
+        SchedulingConfig(tick_max_duration_seconds=0)
+
+
+# ---------------------------------------------------------------------------
+# scale_interval_seconds (scale_interval cadence model surface)
+# ---------------------------------------------------------------------------
+
+
+def test_scale_interval_default_matches_load_cadence():
+    """Default 5.0s matches the default load_adjustment_interval_seconds
+    so an orchestrator-path deployment with default config sees
+    pipeline ticks at the same cadence the load cadence used to drive
+    (under the legacy PSM-mirror model). Behaviour-equivalent default."""
+    s = SchedulingConfig()
+    assert s.scale_interval_seconds == 5.0
+
+
+def test_scale_interval_rejects_zero_or_negative():
+    """Pipeline cannot fire at zero or negative cadence. Pydantic gt=0
+    catches at config-validation time."""
+    with pytest.raises(ValidationError):
+        SchedulingConfig(scale_interval_seconds=0)
+    with pytest.raises(ValidationError):
+        SchedulingConfig(scale_interval_seconds=-1.0)
+
+
+def test_scale_interval_accepts_explicit_value():
+    """Operators can override the default — e.g., set a 1s cadence for
+    high-frequency scenarios. Lock that the field accepts positive
+    floats."""
+    s = SchedulingConfig(scale_interval_seconds=1.0)
+    assert s.scale_interval_seconds == 1.0
+
+
+# ---------------------------------------------------------------------------
+# PlannerConfig integration — backwards compat
+# ---------------------------------------------------------------------------
+
+
+def test_planner_config_default_has_scheduling_subtree():
+    pc = PlannerConfig()
+    assert isinstance(pc.scheduling, SchedulingConfig)
+    assert pc.scheduling.use_orchestrator is False
+
+
+def test_planner_config_without_scheduling_section_loads_unchanged():
+    """Existing yaml configs (pre-PR-7) don't have a scheduling section.
+    They must continue to load with default SchedulingConfig."""
+    # A minimal config — no scheduling key.
+    raw = yaml.safe_dump(
+        {
+            "mode": "disagg",
+            "environment": "kubernetes",
+            "enable_throughput_scaling": True,
+        }
+    )
+    loaded = yaml.safe_load(raw)
+    pc = PlannerConfig.model_validate(loaded)
+    assert pc.scheduling.use_orchestrator is False
+    assert pc.scheduling.tick_max_duration_seconds == 30.0
+
+
+def test_planner_config_with_scheduling_override_parses():
+    pc = PlannerConfig.model_validate(
+        {
+            "mode": "disagg",
+            "environment": "kubernetes",
+            "enable_throughput_scaling": True,
+            "scheduling": {
+                "use_orchestrator": True,
+                "tick_max_duration_seconds": 60.0,
+            },
+        }
+    )
+    assert pc.scheduling.use_orchestrator is True
+    assert pc.scheduling.tick_max_duration_seconds == 60.0
+
+
+def test_planner_config_yaml_round_trip_preserves_scheduling():
+    pc = PlannerConfig.model_validate(
+        {
+            "mode": "disagg",
+            "environment": "kubernetes",
+            "enable_throughput_scaling": True,
+            "scheduling": {"use_orchestrator": True},
+        }
+    )
+    # mode="json" projects enums → strings so yaml.safe_dump is happy.
+    dumped = yaml.safe_dump(pc.model_dump(mode="json"))
+    reloaded = yaml.safe_load(dumped)
+    pc2 = PlannerConfig.model_validate(reloaded)
+    assert pc2.scheduling.use_orchestrator is True
+
+
+def test_planner_config_partial_scheduling_override_keeps_other_defaults():
+    pc = PlannerConfig.model_validate(
+        {
+            "mode": "disagg",
+            "environment": "kubernetes",
+            "enable_throughput_scaling": True,
+            "scheduling": {"use_orchestrator": True},  # only flip the flag
+        }
+    )
+    assert pc.scheduling.use_orchestrator is True
+    # Other fields take defaults.
+    assert pc.scheduling.tick_max_duration_seconds == 30.0
diff --git a/components/src/dynamo/planner/tests/core/__init__.py b/components/src/dynamo/planner/tests/core/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/tests/core/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/tests/core/test_engine_protocol.py b/components/src/dynamo/planner/tests/core/test_engine_protocol.py
new file mode 100644
index 000000000000..691c18c80f07
--- /dev/null
+++ b/components/src/dynamo/planner/tests/core/test_engine_protocol.py
@@ -0,0 +1,160 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for EngineProtocol + _PSMEngineAdapter.
+
+Scope of this test file:
+- Protocol conformance (runtime_checkable): both adapters pass
+  ``isinstance(x, EngineProtocol)``.
+- ``_PSMEngineAdapter`` forwards ``initial_tick`` and async-wraps
+  ``on_tick`` to match the protocol's async ``tick``.
+- ``_PSMEngineAdapter.shutdown`` is idempotent + a no-op.
+
+Orchestrator-side adapter parity is out-of-scope for this file —
+``test_engine_adapter.py`` exercises the full TickInput↔PipelineContext
+bridge + ``OrchestratorEngineAdapter``.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.config.planner_config import PlannerConfig
+from dynamo.planner.core.engine_protocol import EngineProtocol, _PSMEngineAdapter
+from dynamo.planner.core.state_machine import PlannerStateMachine
+from dynamo.planner.core.types import (
+    EngineCapabilities,
+    FpmObservations,
+    ScheduledTick,
+    TickInput,
+    WorkerCapabilities,
+    WorkerCounts,
+)
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+def _simple_caps() -> WorkerCapabilities:
+    return WorkerCapabilities(
+        decode=EngineCapabilities(
+            num_gpu=1, max_num_batched_tokens=2048, max_kv_tokens=16384
+        )
+    )
+
+
+def _easy_agg_config() -> PlannerConfig:
+    # Easy mode avoids needing to seed regressions / predictors.
+    return PlannerConfig(
+        mode="agg",
+        enable_load_scaling=True,
+        enable_throughput_scaling=False,
+        optimization_target="throughput",
+    )
+
+
+# ---------------------------------------------------------------------------
+# Protocol conformance
+# ---------------------------------------------------------------------------
+
+
+def test_psm_adapter_satisfies_engine_protocol():
+    psm = PlannerStateMachine(_easy_agg_config(), _simple_caps())
+    adapter = _PSMEngineAdapter(psm)
+    assert isinstance(adapter, EngineProtocol)
+
+
+def test_plain_psm_is_not_engine_protocol():
+    """PSM's ``on_tick`` is synchronous + named differently; it should
+    NOT satisfy EngineProtocol directly. The adapter is required."""
+    psm = PlannerStateMachine(_easy_agg_config(), _simple_caps())
+    assert not isinstance(psm, EngineProtocol)
+
+
+# ---------------------------------------------------------------------------
+# _PSMEngineAdapter behaviour
+# ---------------------------------------------------------------------------
+
+
+def test_initial_tick_forwards_to_psm():
+    psm = PlannerStateMachine(_easy_agg_config(), _simple_caps())
+    adapter = _PSMEngineAdapter(psm)
+    # PSM.initial_tick schedules first load/throughput tick.
+    st = adapter.initial_tick(0.0)
+    assert isinstance(st, ScheduledTick)
+    # Either load or throughput scaling should be scheduled (easy agg + load on).
+    assert st.run_load_scaling or st.run_throughput_scaling
+
+
+@pytest.mark.asyncio
+async def test_tick_async_wraps_psm_on_tick_identically():
+    psm = PlannerStateMachine(_easy_agg_config(), _simple_caps())
+    # ``adapter`` not used directly here — we construct it to assert the
+    # constructor accepts a PSM without raising. The second-half of the
+    # test below builds ``adapter2`` for the actual tick comparison.
+    _PSMEngineAdapter(psm)
+
+    # Baseline: call PSM directly.
+    tick_input_a = TickInput(
+        now_s=5.0,
+        fpm_observations=FpmObservations(
+            decode={("w1", 0): _make_fpm()},
+        ),
+        worker_counts=WorkerCounts(ready_num_decode=1),
+    )
+    scheduled = ScheduledTick(
+        at_s=5.0, run_load_scaling=True, run_throughput_scaling=False
+    )
+
+    direct_effects = psm.on_tick(scheduled, tick_input_a)
+
+    # Rebuild PSM for parity (on_tick mutates state).
+    psm2 = PlannerStateMachine(_easy_agg_config(), _simple_caps())
+    adapter2 = _PSMEngineAdapter(psm2)
+    adapter_effects = await adapter2.tick(scheduled, tick_input_a)
+
+    # Both produce PlannerEffects (same shape / equal fields here since
+    # easy mode is deterministic given identical inputs).
+    assert direct_effects.scale_to == adapter_effects.scale_to
+    assert direct_effects.next_tick == adapter_effects.next_tick
+
+
+@pytest.mark.asyncio
+async def test_shutdown_is_noop_and_idempotent():
+    psm = PlannerStateMachine(_easy_agg_config(), _simple_caps())
+    adapter = _PSMEngineAdapter(psm)
+    assert await adapter.shutdown() is None
+    assert await adapter.shutdown() is None  # idempotent
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _make_fpm():
+    from dynamo.common.forward_pass_metrics import (
+        ForwardPassMetrics,
+        QueuedRequestMetrics,
+        ScheduledRequestMetrics,
+    )
+
+    return ForwardPassMetrics(
+        worker_id="w1",
+        dp_rank=0,
+        wall_time=0.01,
+        scheduled_requests=ScheduledRequestMetrics(
+            sum_prefill_tokens=0,
+            num_prefill_requests=0,
+            sum_decode_kv_tokens=100,
+            num_decode_requests=1,
+        ),
+        queued_requests=QueuedRequestMetrics(
+            sum_prefill_tokens=0,
+            sum_decode_kv_tokens=0,
+        ),
+    )
diff --git a/components/src/dynamo/planner/tests/core/test_tick_diagnostics_extended.py b/components/src/dynamo/planner/tests/core/test_tick_diagnostics_extended.py
new file mode 100644
index 000000000000..b769af290305
--- /dev/null
+++ b/components/src/dynamo/planner/tests/core/test_tick_diagnostics_extended.py
@@ -0,0 +1,182 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tests for the plugin-era ``TickDiagnostics`` fields.
+
+The extension adds three plugin-aware fields:
+- plugin_overrides: list[tuple[str, str, str, str, int]]
+- reconcile_reasons: dict[str, str]
+- held_over_plugins: list[str]
+
+All three default to empty collections so PSM-path callers that never
+touch them still produce a byte-identical ``TickDiagnostics()`` value.
+
+SCOPE NOTE: no production code path populates these three fields in this
+PR — the orchestrator's diagnostics projection
+(``engine_adapter._outcome_to_effects``) fills ``predicted_*`` /
+``execute_action`` / ``short_circuit_reason`` / ``audit_events`` and the
+load/throughput reason strings, but not these. The fields + their
+default-factory contract are shipped here so the wiring that fills them
+(diagnostics recorder consumption in a follow-up PR) doesn't have to
+re-touch ``core/types.py``. These tests therefore lock the dataclass
+contract (defaults, no shared-mutable aliasing, deep-copy independence),
+NOT live production behavior."""
+
+from __future__ import annotations
+
+import copy
+import dataclasses
+
+import pytest
+
+from dynamo.planner.core.types import TickDiagnostics
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+# ---------------------------------------------------------------------------
+# Defaults
+# ---------------------------------------------------------------------------
+
+
+def test_defaults_are_empty_collections():
+    d = TickDiagnostics()
+    assert d.plugin_overrides == []
+    assert d.reconcile_reasons == {}
+    assert d.held_over_plugins == []
+
+
+def test_default_collections_are_not_shared_across_instances():
+    """Regression guard: ``field(default_factory=list)`` prevents the
+    classic mutable-default aliasing bug. This test makes the invariant
+    explicit so a future refactor that swaps to a bare default doesn't
+    slip through."""
+    a = TickDiagnostics()
+    b = TickDiagnostics()
+    a.plugin_overrides.append(("p1", "propose", "SET", "prefill/w1", 3))
+    a.reconcile_reasons["prefill/w1"] = "set_by_p1"
+    a.held_over_plugins.append("p2")
+    assert b.plugin_overrides == []
+    assert b.reconcile_reasons == {}
+    assert b.held_over_plugins == []
+
+
+# ---------------------------------------------------------------------------
+# Field population + shape checks
+# ---------------------------------------------------------------------------
+
+
+def test_plugin_overrides_accepts_tuple_shape():
+    d = TickDiagnostics()
+    d.plugin_overrides.append(("my_plugin", "propose", "SET", "decode/w1", 5))
+    d.plugin_overrides.append(("other_plugin", "constrain", "AT_MOST", "", 8))
+    # REJECT uses -1 placeholder per the contract documented on the field.
+    d.plugin_overrides.append(("safe", "reconcile", "REJECT", "", -1))
+
+    assert len(d.plugin_overrides) == 3
+    plugin_ids = [o[0] for o in d.plugin_overrides]
+    stages = [o[1] for o in d.plugin_overrides]
+    types_ = [o[2] for o in d.plugin_overrides]
+    assert plugin_ids == ["my_plugin", "other_plugin", "safe"]
+    assert stages == ["propose", "constrain", "reconcile"]
+    assert types_ == ["SET", "AT_MOST", "REJECT"]
+
+
+def test_reconcile_reasons_accepts_component_key_mapping():
+    d = TickDiagnostics()
+    d.reconcile_reasons["prefill/worker_a"] = "set_by_budget_constrain"
+    d.reconcile_reasons["decode/worker_a"] = "clamped_to_floor"
+    d.reconcile_reasons["decode/worker_b"] = "passthrough"
+
+    assert d.reconcile_reasons["prefill/worker_a"] == "set_by_budget_constrain"
+    assert d.reconcile_reasons["decode/worker_a"] == "clamped_to_floor"
+    assert d.reconcile_reasons["decode/worker_b"] == "passthrough"
+
+
+def test_held_over_plugins_accepts_plugin_id_list():
+    d = TickDiagnostics()
+    d.held_over_plugins.extend(["slow_predictor", "bursty_propose"])
+    assert d.held_over_plugins == ["slow_predictor", "bursty_propose"]
+
+
+# ---------------------------------------------------------------------------
+# asdict round-trip (for replay + dashboard serialisation)
+# ---------------------------------------------------------------------------
+
+
+def test_asdict_round_trip_preserves_new_fields():
+    d = TickDiagnostics(
+        load_decision_reason="no_change",
+        plugin_overrides=[("p1", "propose", "SET", "decode/w", 3)],
+        reconcile_reasons={"decode/w": "set_by_p1"},
+        held_over_plugins=["p2"],
+    )
+    encoded = dataclasses.asdict(d)
+    decoded = TickDiagnostics(**encoded)
+    assert decoded == d
+
+
+def test_asdict_empty_new_fields_round_trip():
+    """PSM path never writes the new fields; round-trip must preserve
+    the empty defaults without drifting to None or leaking."""
+    d = TickDiagnostics(load_decision_reason="scale_up", estimated_itl_ms=12.3)
+    encoded = dataclasses.asdict(d)
+    decoded = TickDiagnostics(**encoded)
+    assert decoded == d
+    assert decoded.plugin_overrides == []
+    assert decoded.reconcile_reasons == {}
+    assert decoded.held_over_plugins == []
+
+
+# ---------------------------------------------------------------------------
+# Backward compatibility with PSM path
+# ---------------------------------------------------------------------------
+
+
+def test_psm_style_construction_still_works():
+    """PSM call sites only pass existing numeric + reason fields; adding
+    new fields with default_factory MUST NOT break those call sites."""
+    d = TickDiagnostics(
+        estimated_ttft_ms=12.3,
+        estimated_itl_ms=4.5,
+        predicted_num_req=100.0,
+        predicted_isl=1500.0,
+        predicted_osl=200.0,
+        engine_rps_prefill=2.0,
+        engine_rps_decode=0.4,
+        throughput_lower_bound_prefill=2,
+        throughput_lower_bound_decode=3,
+        load_decision_reason="no_change",
+        throughput_decision_reason="scale",
+    )
+    # Original fields preserved.
+    assert d.estimated_ttft_ms == 12.3
+    assert d.throughput_lower_bound_prefill == 2
+    # New fields defaulted.
+    assert d.plugin_overrides == []
+    assert d.reconcile_reasons == {}
+    assert d.held_over_plugins == []
+
+
+def test_deepcopy_of_populated_diagnostics():
+    """Some consumers (diagnostics_recorder, replay) deepcopy the
+    TickDiagnostics to snapshot state. Verify the new fields survive."""
+    d = TickDiagnostics(
+        plugin_overrides=[("p", "propose", "SET", "k", 1)],
+        reconcile_reasons={"k": "r"},
+        held_over_plugins=["q"],
+    )
+    d2 = copy.deepcopy(d)
+    assert d2 == d
+    # Deep copy: mutating one must not affect the other.
+    d2.plugin_overrides.clear()
+    d2.reconcile_reasons.clear()
+    d2.held_over_plugins.clear()
+    assert d.plugin_overrides == [("p", "propose", "SET", "k", 1)]
+    assert d.reconcile_reasons == {"k": "r"}
+    assert d.held_over_plugins == ["q"]
diff --git a/components/src/dynamo/planner/tests/integration/test_external_plugin_e2e.py b/components/src/dynamo/planner/tests/integration/test_external_plugin_e2e.py
new file mode 100644
index 000000000000..76c0b6afec1c
--- /dev/null
+++ b/components/src/dynamo/planner/tests/integration/test_external_plugin_e2e.py
@@ -0,0 +1,751 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""End-to-end test for the **external plugin** path.
+
+A third-party plugin running in its own gRPC server, registering with
+the planner through the public ``register()`` RPC over a real socket,
+and being invoked by the orchestrator during a tick.
+
+Coverage gap before this file:
+- transport contract test exercises every transport shipped in PR #1
+  (in_process / grpc) but only against an **echo** servicer — the plugin
+  contract (ProposeStageRequest → ProposeStageResponse oneof) is never
+  driven over a real network socket
+- registry integration test covers the full lifecycle but with a
+  **stub** transport — no real gRPC channel ever opens
+- orchestrator e2e tests register builtins via ``register_internal``
+  (in-process) — no transport hop
+
+What this file proves:
+1. A user-authored ``ProposePluginServicer`` running in a real
+   ``grpc.aio.Server`` accepts ``Propose`` calls over the wire.
+2. ``PluginRegistryServer.register(RegisterRequest(endpoint='grpc://...'))``
+   builds a real ``GrpcTransport`` and stores the plugin record.
+3. ``LocalPlannerOrchestrator.tick(...)`` invokes the external plugin
+   over the gRPC channel and threads its ``OverrideResult`` through
+   merge → reconcile → constrain into the final ``ScalingProposal``.
+4. Same path works for ``unix://`` (UDS) — exercising both production
+   transport schemes.
+
+The test deliberately **does not** stand up a gRPC gateway in front of
+``PluginRegistryServer``. This file calls ``server.register()`` from
+Python directly; a real external plugin would need either (a) a gateway
+or (b) ``register_internal`` for in-process Python plugins. The
+transport hop being exercised is the **plugin invocation** hop
+(orchestrator → plugin), which is the path that matters for dual-path
+correctness.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, AsyncIterator
+
+import grpc
+import pytest
+
+from dynamo.planner.plugins.clock import WallClock
+from dynamo.planner.plugins.merge.types import ComponentKey
+from dynamo.planner.plugins.orchestrator.orchestrator import LocalPlannerOrchestrator
+from dynamo.planner.plugins.proto.v1 import plugin_pb2 as pb
+from dynamo.planner.plugins.proto.v1 import plugin_pb2_grpc as pbg
+from dynamo.planner.plugins.registry.auth.base import AllowUnauthenticatedAuth
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+from dynamo.planner.plugins.registry.server import PluginRegistryServer
+from dynamo.planner.plugins.scheduler import PluginScheduler
+from dynamo.planner.plugins.transport.config import (
+    TransportConfig,
+    make_transport_for_endpoint,
+)
+from dynamo.planner.plugins.types import (
+    HoldPolicy,
+    ListPluginsRequest,
+    PipelineContext,
+    RegisterRequest,
+)
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+# ---------------------------------------------------------------------------
+# External plugin under test: a deterministic ProposePluginServicer
+# ---------------------------------------------------------------------------
+
+
+class _RecordingProposePlugin(pbg.ProposePluginServicer):
+    """A deliberately simple external plugin that returns a fixed
+    OverrideResult on every call. The orchestrator hits this over the
+    network; the test asserts that:
+
+    1. ``Propose`` was actually invoked (vs. the orchestrator silently
+       skipping the plugin) — tracked via ``self.calls``.
+    2. The response we returned is what lands in the tick's final
+       proposal.
+    """
+
+    def __init__(self, *, prefill: int = 7, decode: int = 11) -> None:
+        self.prefill = prefill
+        self.decode = decode
+        self.calls: list[pb.ProposeStageRequest] = []
+
+    async def Propose(
+        self,
+        request: pb.ProposeStageRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> pb.ProposeStageResponse:
+        self.calls.append(request)
+        resp = pb.ProposeStageResponse()
+        ovr = resp.override
+        ovr.reason = "external_plugin_e2e"
+        t1 = ovr.targets.add()
+        t1.sub_component_type = "prefill"
+        t1.replicas = self.prefill
+        t1.type = pb.OverrideType.SET
+        t2 = ovr.targets.add()
+        t2.sub_component_type = "decode"
+        t2.replicas = self.decode
+        t2.type = pb.OverrideType.SET
+        # final=False so the merge layer is exercised normally.
+        return resp
+
+
+# ---------------------------------------------------------------------------
+# Test infrastructure: spin up a plugin gRPC server and tear it down
+# ---------------------------------------------------------------------------
+
+
+async def _start_plugin_grpc_server(
+    plugin: _RecordingProposePlugin, listen: str
+) -> tuple[grpc.aio.Server, str]:
+    """Start a real gRPC server hosting ``plugin`` at ``listen``.
+
+    Returns (server, actual_listen). For ``:0`` ports, the actual bound
+    port replaces the placeholder so the caller can plug it back into
+    a ``grpc://`` endpoint.
+    """
+    server = grpc.aio.server()
+    pbg.add_ProposePluginServicer_to_server(plugin, server)
+    if listen.startswith("unix:"):
+        port = server.add_insecure_port(listen)
+    else:
+        port = server.add_insecure_port(listen)
+    await server.start()
+    if listen.endswith(":0"):
+        host = listen.rsplit(":", 1)[0]
+        return server, f"{host}:{port}"
+    return server, listen
+
+
+def _build_orchestrator() -> (
+    tuple[LocalPlannerOrchestrator, PluginRegistryServer, list[Any]]
+):
+    """Compose the registry + scheduler + circuit breaker + orchestrator
+    with the **real** transport factory (so ``register()`` over
+    ``grpc://`` / ``unix://`` actually opens a channel).
+
+    Returns the orchestrator, the registry (so the test can call
+    ``register()`` directly), and a list of cleanup callables.
+    """
+    clock = WallClock()
+    cb = CircuitBreaker(clock)
+    transport_config = TransportConfig(
+        request_timeout_seconds=2.0,
+        # External plugin uses plain grpc:// (no mTLS) — opt in
+        # explicitly so the factory accepts the endpoint instead of
+        # rejecting it as insecure.
+        allow_insecure_grpc=True,
+    )
+
+    def factory(plugin_id: str, endpoint: str, *, in_process_instance=None):
+        return make_transport_for_endpoint(
+            plugin_id,
+            endpoint,
+            transport_config,
+            in_process_instance=in_process_instance,
+        )
+
+    server = PluginRegistryServer(
+        clock=clock,
+        auth=AllowUnauthenticatedAuth(),
+        circuit_breaker=cb,
+        transport_factory=factory,
+    )
+    scheduler = PluginScheduler(server, cb, clock)
+    orch = LocalPlannerOrchestrator(
+        registry=server,
+        scheduler=scheduler,
+        circuit_breaker=cb,
+        clock=clock,
+        capabilities=None,  # this test doesn't depend on capabilities
+    )
+    return orch, server, []
+
+
+async def _register_external_plugin(
+    server: PluginRegistryServer, *, plugin_id: str, endpoint: str
+) -> None:
+    """Hit the public ``register()`` RPC the way an external client
+    would — same code path as a future gRPC gateway would invoke."""
+    resp = await server.register(
+        RegisterRequest(
+            plugin_id=plugin_id,
+            plugin_type="propose",
+            priority=5,
+            endpoint=endpoint,
+            auth_token="anything",  # AllowUnauthenticatedAuth ignores it
+            protocol_version="1.0",
+            execution_interval_seconds=0.0,  # always due
+            hold_policy=HoldPolicy.HOLD_LAST,
+            version="v1",
+        )
+    )
+    assert resp.accepted, f"register() rejected: {resp.reject_reason!r}"
+
+
+def _make_baseline(prefill: int, decode: int) -> dict[ComponentKey, int]:
+    return {
+        ComponentKey(sub_component_type="prefill"): prefill,
+        ComponentKey(sub_component_type="decode"): decode,
+    }
+
+
+def _ctx() -> PipelineContext:
+    return PipelineContext(request_id="external-e2e-tick", decision_id="d-1")
+
+
+def _final_targets(outcome) -> dict[str, int]:
+    """Project ``ScalingProposal.targets`` into a dict keyed by sub
+    component for easy assertion."""
+    assert outcome.final_proposal is not None, (
+        f"expected final_proposal on outcome, got "
+        f"execute_action={outcome.execute_action!r} "
+        f"short_circuit_reason={outcome.short_circuit_reason!r}"
+    )
+    out: dict[str, int] = {}
+    for t in outcome.final_proposal.targets:
+        if t.replicas is not None:
+            out[t.sub_component_type] = t.replicas
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+async def grpc_external_plugin(
+    request,
+) -> AsyncIterator[tuple[_RecordingProposePlugin, str]]:
+    """Plugin reachable via ``grpc://127.0.0.1:<bound>``."""
+    plugin = _RecordingProposePlugin(prefill=7, decode=11)
+    server, listen = await _start_plugin_grpc_server(plugin, "127.0.0.1:0")
+    try:
+        yield plugin, f"grpc://{listen}"
+    finally:
+        await server.stop(grace=0.1)
+
+
+# ---------------------------------------------------------------------------
+# Tests — both transports drive the same flow end-to-end
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_external_plugin_register_and_invoked_over_grpc(
+    grpc_external_plugin,
+):
+    """grpc:// path: plugin server in its own coroutine, planner
+    registers it, one tick → plugin's Propose fires over the wire,
+    its decision lands in the final proposal."""
+    plugin, endpoint = grpc_external_plugin
+    orch, registry, _ = _build_orchestrator()
+
+    await _register_external_plugin(
+        registry, plugin_id="external-propose-grpc", endpoint=endpoint
+    )
+
+    # Sanity: registry list shows the plugin with the right transport.
+    plugins = registry.list_plugins(ListPluginsRequest())
+    info = next(p for p in plugins if p.plugin_id == "external-propose-grpc")
+    assert info.transport == "grpc"
+    assert info.plugin_type == "propose"
+
+    # Drive a tick. baseline=(2,2) means the budget/reconcile passthrough
+    # leaves the plugin's SET unchanged → final proposal == plugin's
+    # OverrideResult after merge.
+    outcome = await orch.tick(_ctx(), _make_baseline(prefill=2, decode=2))
+
+    # 1. The plugin actually got called over the network.
+    assert (
+        len(plugin.calls) == 1
+    ), f"expected exactly one Propose() call, got {len(plugin.calls)}"
+    # 2. The decision propagated end-to-end into the final proposal.
+    assert outcome.execute_action == "apply"
+    assert _final_targets(outcome) == {"prefill": 7, "decode": 11}
+
+    await orch.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_external_plugin_unregister_stops_invocations(
+    grpc_external_plugin,
+):
+    """After Unregister, subsequent ticks must NOT invoke the plugin —
+    the registry contract: removing a plugin closes its transport and
+    drops it from the active set."""
+    plugin, endpoint = grpc_external_plugin
+    orch, registry, _ = _build_orchestrator()
+
+    await _register_external_plugin(
+        registry, plugin_id="external-propose-bye", endpoint=endpoint
+    )
+
+    # First tick invokes the plugin.
+    await orch.tick(_ctx(), _make_baseline(prefill=2, decode=2))
+    assert len(plugin.calls) == 1
+
+    # Unregister; second tick must not call the plugin.
+    ok = await registry.unregister("external-propose-bye", reason="test")
+    assert ok
+    await orch.tick(_ctx(), _make_baseline(prefill=2, decode=2))
+    assert len(plugin.calls) == 1, (
+        "plugin received a call after Unregister — registry isn't honouring "
+        "the unregister contract"
+    )
+
+    await orch.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_external_plugin_register_rejects_inproc_endpoint():
+    """``inproc://`` over the network RPC is a client-side bug; the
+    server must reject it. Locks the contract that drives the
+    distinction between ``register()`` and ``register_internal()``."""
+    orch, registry, _ = _build_orchestrator()
+
+    resp = await registry.register(
+        RegisterRequest(
+            plugin_id="should-not-register",
+            plugin_type="propose",
+            priority=5,
+            endpoint="inproc://x",
+            auth_token="anything",
+            protocol_version="1.0",
+            hold_policy=HoldPolicy.HOLD_LAST,
+            version="v1",
+        )
+    )
+    assert resp.accepted is False
+    assert "inproc://" in resp.reject_reason
+
+    await orch.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_external_plugin_two_external_plugins_compose(
+    tmp_path: Path,
+):
+    """Two external plugins on two separate grpc:// loopback ports,
+    both registered; one tick → both invoked → merge picks the
+    higher-priority winner. Sanity-checks the multi-plugin path
+    under real transport hops."""
+    plugin_a = _RecordingProposePlugin(prefill=10, decode=10)
+    plugin_b = _RecordingProposePlugin(prefill=99, decode=99)
+
+    server_a, listen_a = await _start_plugin_grpc_server(plugin_a, "127.0.0.1:0")
+    server_b, listen_b = await _start_plugin_grpc_server(plugin_b, "127.0.0.1:0")
+    try:
+        orch, registry, _ = _build_orchestrator()
+
+        # plugin_a priority=5 (wins); plugin_b priority=10 (loses).
+        # type-aware merge: smallest priority number wins on
+        # PROPOSE conflict.
+        await registry.register(
+            RegisterRequest(
+                plugin_id="ext-a",
+                plugin_type="propose",
+                priority=5,
+                endpoint=f"grpc://{listen_a}",
+                auth_token="x",
+                protocol_version="1.0",
+                hold_policy=HoldPolicy.HOLD_LAST,
+                version="v1",
+            )
+        )
+        await registry.register(
+            RegisterRequest(
+                plugin_id="ext-b",
+                plugin_type="propose",
+                priority=10,
+                endpoint=f"grpc://{listen_b}",
+                auth_token="x",
+                protocol_version="1.0",
+                hold_policy=HoldPolicy.HOLD_LAST,
+                version="v1",
+            )
+        )
+
+        outcome = await orch.tick(_ctx(), _make_baseline(prefill=2, decode=2))
+
+        # Both plugins were called over their respective transports
+        # (all PROPOSE plugins evaluated in parallel via asyncio.gather).
+        assert len(plugin_a.calls) == 1
+        assert len(plugin_b.calls) == 1
+        # plugin_a's lower priority wins the merge.
+        assert outcome.execute_action == "apply"
+        assert _final_targets(outcome) == {"prefill": 10, "decode": 10}
+
+        await orch.shutdown()
+    finally:
+        await server_a.stop(grace=0.1)
+        await server_b.stop(grace=0.1)
+
+
+# ---------------------------------------------------------------------------
+# 4-stage coverage: PREDICT / RECONCILE / CONSTRAIN external plugins
+#
+# The PROPOSE tests above prove the wire path works for the most-used stage,
+# but each stage has its own request/response shape and its own pipeline-
+# adapter logic (``_PredictAdapter`` for PREDICT chain-augment, the
+# ``ReconcileStageRequest.proposals`` carrier for RECONCILE, the silent
+# SET-drop in CONSTRAIN). These tests drive each over a real grpc.aio
+# socket so stage-specific bugs surface.
+# ---------------------------------------------------------------------------
+
+
+class _RecordingPredictPlugin(pbg.PredictPluginServicer):
+    """External PREDICT plugin: returns a deterministic
+    ``PredictionData`` so the test can confirm chain-augment threaded
+    it through and the orchestrator surfaced it on the
+    ``PipelineOutcome.predict_outcome.prediction``.
+    """
+
+    def __init__(
+        self,
+        *,
+        predicted_num_req: float = 1234.0,
+        predicted_isl: float = 567.0,
+        predicted_osl: float = 89.0,
+        source: str = "external_predict_e2e",
+    ) -> None:
+        self._num_req = predicted_num_req
+        self._isl = predicted_isl
+        self._osl = predicted_osl
+        self._source = source
+        self.calls: list[pb.PredictStageRequest] = []
+
+    async def Predict(
+        self,
+        request: pb.PredictStageRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> pb.PredictStageResponse:
+        self.calls.append(request)
+        resp = pb.PredictStageResponse()
+        resp.predictions.predicted_num_req = self._num_req
+        resp.predictions.predicted_isl = self._isl
+        resp.predictions.predicted_osl = self._osl
+        resp.predictions.source = self._source
+        # final=True: lowest-priority terminator. We only register one
+        # external PREDICT plugin in this test so it's the only one.
+        resp.final = True
+        return resp
+
+
+class _RecordingReconcilePlugin(pbg.ReconcilePluginServicer):
+    """External RECONCILE plugin: emits a SET that re-shapes whatever
+    the PROPOSE merge produced. RECONCILE-stage merge runs after
+    PROPOSE so any RECONCILE OverrideResult takes precedence in the
+    final scaling proposal."""
+
+    def __init__(self, *, prefill: int, decode: int) -> None:
+        self._prefill = prefill
+        self._decode = decode
+        self.calls: list[pb.ReconcileStageRequest] = []
+
+    async def Reconcile(
+        self,
+        request: pb.ReconcileStageRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> pb.ReconcileStageResponse:
+        self.calls.append(request)
+        resp = pb.ReconcileStageResponse()
+        ovr = resp.override
+        ovr.reason = "external_reconcile_e2e"
+        for sub, n in (("prefill", self._prefill), ("decode", self._decode)):
+            t = ovr.targets.add()
+            t.sub_component_type = sub
+            t.replicas = n
+            t.type = pb.OverrideType.SET
+        return resp
+
+
+class _RecordingConstrainPlugin(pbg.ConstrainPluginServicer):
+    """External CONSTRAIN plugin: emits an AT_MOST ceiling that should
+    clamp whatever PROPOSE+RECONCILE produced. ``SET`` from a
+    CONSTRAIN plugin is silently dropped at runtime (per the merge
+    contract — CONSTRAIN can only narrow, not assert specific values);
+    we use AT_MOST so the test can assert clamping actually happens."""
+
+    def __init__(self, *, ceiling_prefill: int, ceiling_decode: int) -> None:
+        self._cp = ceiling_prefill
+        self._cd = ceiling_decode
+        self.calls: list[pb.ConstrainStageRequest] = []
+
+    async def Constrain(
+        self,
+        request: pb.ConstrainStageRequest,
+        context: grpc.aio.ServicerContext,
+    ) -> pb.ConstrainStageResponse:
+        self.calls.append(request)
+        resp = pb.ConstrainStageResponse()
+        ovr = resp.override
+        ovr.reason = "external_constrain_e2e"
+        for sub, n in (("prefill", self._cp), ("decode", self._cd)):
+            t = ovr.targets.add()
+            t.sub_component_type = sub
+            t.replicas = n
+            t.type = pb.OverrideType.AT_MOST
+        return resp
+
+
+async def _start_predict_grpc_server(
+    plugin: _RecordingPredictPlugin,
+) -> tuple[grpc.aio.Server, str]:
+    server = grpc.aio.server()
+    pbg.add_PredictPluginServicer_to_server(plugin, server)
+    port = server.add_insecure_port("127.0.0.1:0")
+    await server.start()
+    return server, f"127.0.0.1:{port}"
+
+
+async def _start_reconcile_grpc_server(
+    plugin: _RecordingReconcilePlugin,
+) -> tuple[grpc.aio.Server, str]:
+    server = grpc.aio.server()
+    pbg.add_ReconcilePluginServicer_to_server(plugin, server)
+    port = server.add_insecure_port("127.0.0.1:0")
+    await server.start()
+    return server, f"127.0.0.1:{port}"
+
+
+async def _start_constrain_grpc_server(
+    plugin: _RecordingConstrainPlugin,
+) -> tuple[grpc.aio.Server, str]:
+    server = grpc.aio.server()
+    pbg.add_ConstrainPluginServicer_to_server(plugin, server)
+    port = server.add_insecure_port("127.0.0.1:0")
+    await server.start()
+    return server, f"127.0.0.1:{port}"
+
+
+async def _register_with_type(server, *, plugin_id, plugin_type, priority, endpoint):
+    resp = await server.register(
+        RegisterRequest(
+            plugin_id=plugin_id,
+            plugin_type=plugin_type,
+            priority=priority,
+            endpoint=endpoint,
+            auth_token="anything",
+            protocol_version="1.0",
+            execution_interval_seconds=0.0,
+            hold_policy=HoldPolicy.HOLD_LAST,
+            version="v1",
+        )
+    )
+    assert resp.accepted, f"register({plugin_type}) rejected: {resp.reject_reason!r}"
+
+
+@pytest.mark.asyncio
+async def test_external_predict_plugin_threaded_through_chain_augment():
+    """A real PREDICT plugin in its own gRPC server: its
+    ``PredictionData`` must surface as the chain-augment final
+    prediction (visible on ``PipelineOutcome.predict_outcome``).
+
+    Stage-specific check beyond PROPOSE: the wire boundary correctly
+    handles the ``optional float`` semantics (``HasField()``-driven
+    partial-merge in ``chain_augment``) — pre-bridge-fix, every
+    PREDICT plugin call would have failed at gRPC serialisation just
+    like PROPOSE did, but only the PROPOSE tests would have caught it.
+    """
+    plugin = _RecordingPredictPlugin(
+        predicted_num_req=1234.0, predicted_isl=567.0, predicted_osl=89.0
+    )
+    server, listen = await _start_predict_grpc_server(plugin)
+    try:
+        orch, registry, _ = _build_orchestrator()
+        await _register_with_type(
+            registry,
+            plugin_id="ext-predict",
+            plugin_type="predict",
+            priority=1,  # lowest priority = chain terminator
+            endpoint=f"grpc://{listen}",
+        )
+
+        outcome = await orch.tick(_ctx(), _make_baseline(prefill=2, decode=2))
+
+        # 1. Plugin actually got called over the wire.
+        assert len(plugin.calls) == 1
+        # 2. Its PredictionData propagated to the chain outcome.
+        assert outcome.predict_outcome is not None
+        pred = outcome.predict_outcome.prediction
+        assert pred is not None
+        assert pred.predicted_num_req == 1234.0
+        assert pred.predicted_isl == 567.0
+        assert pred.predicted_osl == 89.0
+        # 3. ``final=True`` correctly set the chain terminator.
+        assert outcome.predict_outcome.final_from == "ext-predict"
+
+        await orch.shutdown()
+    finally:
+        await server.stop(grace=0.1)
+
+
+@pytest.mark.asyncio
+async def test_external_reconcile_plugin_overrides_propose_decision():
+    """A real RECONCILE plugin: even with no PROPOSE plugins
+    registered (so PROPOSE merge is empty), the RECONCILE override
+    must drive the final proposal — proves RECONCILE plugins can
+    inject decisions, not just transform existing ones.
+
+    Pre-bridge-fix, ``ReconcileStageRequest.proposals`` (a repeated
+    nested message) would have failed conversion separately from
+    PROPOSE's flatter shape, so this is a distinct serialisation
+    path worth locking."""
+    plugin = _RecordingReconcilePlugin(prefill=12, decode=15)
+    server, listen = await _start_reconcile_grpc_server(plugin)
+    try:
+        orch, registry, _ = _build_orchestrator()
+        await _register_with_type(
+            registry,
+            plugin_id="ext-reconcile",
+            plugin_type="reconcile",
+            priority=2,
+            endpoint=f"grpc://{listen}",
+        )
+
+        outcome = await orch.tick(_ctx(), _make_baseline(prefill=1, decode=1))
+
+        assert len(plugin.calls) == 1
+        assert outcome.execute_action == "apply"
+        assert _final_targets(outcome) == {"prefill": 12, "decode": 15}
+
+        await orch.shutdown()
+    finally:
+        await server.stop(grace=0.1)
+
+
+@pytest.mark.asyncio
+async def test_external_constrain_plugin_clamps_with_at_most():
+    """A real CONSTRAIN plugin emits AT_MOST ceilings; combined with
+    a PROPOSE plugin's SET targets above the ceiling, the final
+    proposal must reflect the clamp.
+
+    CONSTRAIN's runtime SET-drop is locked elsewhere; this test
+    verifies the *over-the-wire* AT_MOST path actually clamps. Tests
+    the OverrideType enum encoding survives proto round-trip — a
+    common breakage mode in proto schema evolution."""
+    propose_plugin = _RecordingProposePlugin(prefill=20, decode=25)
+    constrain_plugin = _RecordingConstrainPlugin(ceiling_prefill=8, ceiling_decode=10)
+    s_propose, listen_p = await _start_plugin_grpc_server(propose_plugin, "127.0.0.1:0")
+    s_constrain, listen_c = await _start_constrain_grpc_server(constrain_plugin)
+    try:
+        orch, registry, _ = _build_orchestrator()
+        await _register_with_type(
+            registry,
+            plugin_id="ext-propose-overshoot",
+            plugin_type="propose",
+            priority=5,
+            endpoint=f"grpc://{listen_p}",
+        )
+        await _register_with_type(
+            registry,
+            plugin_id="ext-constrain-cap",
+            plugin_type="constrain",
+            priority=3,
+            endpoint=f"grpc://{listen_c}",
+        )
+
+        outcome = await orch.tick(_ctx(), _make_baseline(prefill=2, decode=2))
+
+        assert len(propose_plugin.calls) == 1
+        assert len(constrain_plugin.calls) == 1
+        # PROPOSE asked for (20,25); CONSTRAIN ceiling clamps to (8,10).
+        assert outcome.execute_action == "apply"
+        assert _final_targets(outcome) == {"prefill": 8, "decode": 10}
+
+        await orch.shutdown()
+    finally:
+        await s_propose.stop(grace=0.1)
+        await s_constrain.stop(grace=0.1)
+
+
+@pytest.mark.asyncio
+async def test_external_constrain_plugin_set_silently_dropped():
+    """Contract: SET-type targets from a CONSTRAIN plugin are
+    **silently dropped at runtime** (register-time rejection is
+    infeasible since proto3 has no way for a plugin to self-declare
+    its output types). The plugin is still called; its output just
+    has no effect on scale_to.
+
+    This is the regression guard against a constraint plugin
+    accidentally taking over the scaling decision via SET — which it
+    must NOT be allowed to do (that's PROPOSE/RECONCILE territory)."""
+
+    class _SetEmittingConstrain(pbg.ConstrainPluginServicer):
+        def __init__(self):
+            self.calls = 0
+
+        async def Constrain(self, request, context):
+            self.calls += 1
+            resp = pb.ConstrainStageResponse()
+            ovr = resp.override
+            t = ovr.targets.add()
+            t.sub_component_type = "prefill"
+            t.replicas = 999  # absurd value to make the SET-drop visible
+            t.type = pb.OverrideType.SET
+            return resp
+
+    propose_plugin = _RecordingProposePlugin(prefill=4, decode=5)
+    constrain_plugin = _SetEmittingConstrain()
+    s_propose, listen_p = await _start_plugin_grpc_server(propose_plugin, "127.0.0.1:0")
+    s_constrain = grpc.aio.server()
+    pbg.add_ConstrainPluginServicer_to_server(constrain_plugin, s_constrain)
+    port_c = s_constrain.add_insecure_port("127.0.0.1:0")
+    await s_constrain.start()
+    try:
+        orch, registry, _ = _build_orchestrator()
+        await _register_with_type(
+            registry,
+            plugin_id="ext-propose-good",
+            plugin_type="propose",
+            priority=5,
+            endpoint=f"grpc://{listen_p}",
+        )
+        await _register_with_type(
+            registry,
+            plugin_id="ext-constrain-misuse",
+            plugin_type="constrain",
+            priority=3,
+            endpoint=f"grpc://127.0.0.1:{port_c}",
+        )
+
+        outcome = await orch.tick(_ctx(), _make_baseline(prefill=2, decode=2))
+
+        # Constrain WAS called over the wire (its SET wasn't silently
+        # short-circuited at the transport layer).
+        assert constrain_plugin.calls == 1
+        # And the SET=999 was dropped — final proposal still reflects
+        # PROPOSE's prefill=4.
+        assert _final_targets(outcome)["prefill"] == 4
+
+        await orch.shutdown()
+    finally:
+        await s_propose.stop(grace=0.1)
+        await s_constrain.stop(grace=0.1)
diff --git a/components/src/dynamo/planner/tests/manual/README.md b/components/src/dynamo/planner/tests/manual/README.md
index dd90a527168a..d3b2a1f50fbb 100644
--- a/components/src/dynamo/planner/tests/manual/README.md
+++ b/components/src/dynamo/planner/tests/manual/README.md
@@ -52,7 +52,7 @@ This directory contains comprehensive tests for validating the SLA planner's sca
 
 ### Test Types
 
-1. **Unit Tests** (`components/src/dynamo/planner/tests/unit/test_replica_calculation.py`) - Test the mathematical formulas for calculating prefill and decode replicas in isolation
+1. **Unit Tests** (`components/src/dynamo/planner/tests/unit/test_load_based_scaling.py` + `test_state_machine.py`) - Test the mathematical formulas for calculating prefill and decode replicas in isolation
 2. **End-to-End Tests** (`scaling/run_scaling_test.sh`) - Test complete workflow including Kubernetes deployment, load generation, and pod scaling validation
 3. **End-to-End Perf Tests** (see instructions below) - Compare performance (goodput and goodput/GPU) on deployments with and without sla planner
 
@@ -63,7 +63,7 @@ This directory contains comprehensive tests for validating the SLA planner's sca
 Test the replica calculation logic without requiring Kubernetes:
 
 ```bash
-PYTHONPATH=components/src python -m pytest components/src/dynamo/planner/tests/unit/test_replica_calculation.py -v
+PYTHONPATH=components/src python -m pytest components/src/dynamo/planner/tests/unit/test_load_based_scaling.py components/src/dynamo/planner/tests/unit/test_state_machine.py -v
 ```
 
 **Note**: The unit tests automatically mock external dependencies (prometheus_client, runtime modules) to ensure they can run in isolation without requiring the full Dynamo environment.
@@ -111,6 +111,7 @@ In this test, we compare performance (goodput and goodput/GPU) on deployments on
 - Config 3 with inefficient parallelization mapping: 1xTP2P_1xTP2D_4GPU
  `./perf_test_configs/disagg_8b_tp2.yaml`
 - Config 4 with sla planner: `./perf_test_configs/disagg_8b_planner.yaml`
+- Config 4b same as Config 4 but using the **plugin-based orchestrator** tick engine (PR 7+ cutover): `./perf_test_configs/disagg_8b_planner_orchestrator.yaml`. Decisions track PSM at the decision level (cadence + tick-merge parity is locked by `tests/plugins/orchestrator/test_engine_adapter.py`); the difference is observability — extra `dynamo_planner_*` Prometheus series and structured `AUDIT` log events.
 
 To run the test on each configuration, first deploy the corresponding DynamoGraphDeployment by
 
diff --git a/components/src/dynamo/planner/tests/manual/perf_test_configs/disagg_8b_planner_orchestrator.yaml b/components/src/dynamo/planner/tests/manual/perf_test_configs/disagg_8b_planner_orchestrator.yaml
new file mode 100644
index 000000000000..b5e1a9a846b0
--- /dev/null
+++ b/components/src/dynamo/planner/tests/manual/perf_test_configs/disagg_8b_planner_orchestrator.yaml
@@ -0,0 +1,216 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Variant of disagg_8b_planner.yaml that opts into the plugin-based
+# orchestrator tick engine (use_orchestrator cutover). The only diff vs
+# the sibling is the planner --config JSON adding
+# "scheduling": {"use_orchestrator": true}.
+#
+# Decision outputs (scale_to / next_tick) track the legacy PSM path at
+# the decision level — cadence + tick-merge parity is locked by
+# tests/plugins/orchestrator/test_engine_adapter.py. The differences
+# operators see are observability:
+#
+# - Extra dynamo_planner_* Prometheus series (plugin / reconcile / tick)
+# - Structured AUDIT log events on the dynamo.planner.audit logger
+# - load_decision_reason emitted into TickDiagnostics from the orchestrator path
+
+apiVersion: nvidia.com/v1alpha1
+kind: DynamoGraphDeployment
+metadata:
+  name: vllm-disagg-planner-orchestrator
+spec:
+  envs:
+    - name: DYNAMO_SERVICE_CONFIG
+      value: '{"Prometheus":{"global":{"scrape_interval":"5s"},"scrape_configs":[{"job_name":"prometheus","static_configs":[{"targets":["localhost:8000"]}]},{"job_name":"frontend","static_configs":[{"targets":["vllm-disagg-planner-orchestrator-frontend:8000"]}]}]}}'
+  services:
+    Frontend:
+      componentType: main
+      replicas: 1
+      livenessProbe:
+        httpGet:
+          path: /health
+          port: 8000
+        initialDelaySeconds: 20
+        periodSeconds: 5
+        timeoutSeconds: 5
+        failureThreshold: 3
+      readinessProbe:
+        exec:
+          command:
+            - /bin/sh
+            - -c
+            - 'curl -s http://localhost:8000/health | jq -e ".status == \"healthy\""'
+        initialDelaySeconds: 60
+        periodSeconds: 60
+        timeoutSeconds: 30
+        failureThreshold: 10
+      resources:
+        requests:
+          cpu: "16"
+          memory: "10Gi"
+        limits:
+          cpu: "128"
+          memory: "100Gi"
+      extraPodSpec:
+        mainContainer:
+          image: my-registry/dynamo-frontend:my-tag
+          workingDir: /workspace/examples/backends/vllm
+          command:
+            - /bin/sh
+            - -c
+          args:
+            - "python3 -m dynamo.frontend --http-port 8000 --kv-cache-block-size 128 --router-mode kv --router-kv-overlap-score-weight 0.0 --router-temperature 0.0 --no-router-kv-events"
+    Planner:
+      envFromSecret: hf-token-secret
+      componentType: planner
+      replicas: 1
+      livenessProbe:
+        exec:
+          command:
+            - /bin/sh
+            - -c
+            - "exit 0"
+        periodSeconds: 60
+        timeoutSeconds: 30
+        failureThreshold: 10
+      readinessProbe:
+        exec:
+          command:
+            - /bin/sh
+            - -c
+            - "exit 0"
+        initialDelaySeconds: 60
+        periodSeconds: 60
+        timeoutSeconds: 30
+        failureThreshold: 10
+      extraPodSpec:
+        mainContainer:
+          image: my-registry/dynamo-planner:my-tag
+          ports:
+            - name: metrics
+              containerPort: 9085
+          command:
+            - python3
+            - -m
+            - dynamo.planner
+          args:
+            - --config
+            # Same config as the sibling sample, plus
+            #   "scheduling": {"use_orchestrator": true}
+            # which routes the tick loop through LocalPlannerOrchestrator
+            # + 5 builtin plugins instead of the legacy PSM. See the
+            # rollout runbook before flipping in production.
+            - '{"environment": "kubernetes", "backend": "vllm", "ttft": 200, "itl": 10, "profile_results_dir": "/workspace/components/src/dynamo/planner/tests/data/profiling_results/H200_TP1P_TP1D/", "throughput_adjustment_interval": 60, "metric_reporting_prometheus_port": 9085, "scheduling": {"use_orchestrator": true}}'
+    VllmDecodeWorker:
+      envFromSecret: hf-token-secret
+      componentType: worker
+      subComponentType: decode
+      replicas: 1
+      livenessProbe:
+        httpGet:
+          path: /live
+          port: 9090
+        periodSeconds: 5
+        timeoutSeconds: 30
+        failureThreshold: 1
+      readinessProbe:
+        httpGet:
+          path: /health
+          port: 9090
+        periodSeconds: 10
+        timeoutSeconds: 30
+        failureThreshold: 60
+      resources:
+        requests:
+          cpu: "16"
+          memory: "20Gi"
+          gpu: "1"
+        limits:
+          cpu: "128"
+          memory: "100Gi"
+          gpu: "1"
+      envs:
+        - name: DYN_SYSTEM_USE_ENDPOINT_HEALTH_STATUS
+          value: "[\"generate\"]"
+        - name: DYN_SYSTEM_PORT
+          value: "9090"
+      extraPodSpec:
+        terminationGracePeriodSeconds: 600
+        mainContainer:
+          startupProbe:
+            httpGet:
+              path: /health
+              port: 9090
+            periodSeconds: 10
+            failureThreshold: 60
+          image: my-registry/vllm-runtime:my-tag
+          workingDir: /workspace/examples/backends/vllm
+          command:
+            - python3
+          args:
+            - -m
+            - dynamo.vllm
+            - --model
+            - nvidia/Llama-3.1-8B-Instruct-FP8
+            - --no-enable-prefix-caching
+            - --block-size
+            - "128"
+    VllmPrefillWorker:
+      envFromSecret: hf-token-secret
+      componentType: worker
+      subComponentType: prefill
+      replicas: 1
+      livenessProbe:
+        httpGet:
+          path: /live
+          port: 9090
+        periodSeconds: 5
+        timeoutSeconds: 30
+        failureThreshold: 1
+      readinessProbe:
+        httpGet:
+          path: /health
+          port: 9090
+        periodSeconds: 10
+        timeoutSeconds: 30
+        failureThreshold: 60
+      resources:
+        requests:
+          cpu: "16"
+          memory: "20Gi"
+          gpu: "1"
+        limits:
+          cpu: "128"
+          memory: "100Gi"
+          gpu: "1"
+      envs:
+        - name: DYN_SYSTEM_USE_ENDPOINT_HEALTH_STATUS
+          value: "[\"generate\"]"
+        - name: DYN_SYSTEM_PORT
+          value: "9090"
+      extraPodSpec:
+        terminationGracePeriodSeconds: 600
+        mainContainer:
+          startupProbe:
+            httpGet:
+              path: /health
+              port: 9090
+            periodSeconds: 10
+            failureThreshold: 60
+          image: my-registry/vllm-runtime:my-tag
+          workingDir: /workspace/examples/backends/vllm
+          command:
+            - python3
+          args:
+            - -m
+            - dynamo.vllm
+            - --model
+            - nvidia/Llama-3.1-8B-Instruct-FP8
+            - --disaggregation-mode
+            - prefill
+            - --kv-transfer-config
+            - '{"kv_connector":"NixlConnector","kv_role":"kv_both"}'
+            - --no-enable-prefix-caching
+            - --block-size
+            - "128"
diff --git a/components/src/dynamo/planner/tests/monitoring/__init__.py b/components/src/dynamo/planner/tests/monitoring/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/tests/monitoring/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/tests/monitoring/test_decision_state_enums.py b/components/src/dynamo/planner/tests/monitoring/test_decision_state_enums.py
new file mode 100644
index 000000000000..ee6f09a48c9c
--- /dev/null
+++ b/components/src/dynamo/planner/tests/monitoring/test_decision_state_enums.py
@@ -0,0 +1,161 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tests for LOAD/THROUGHPUT decision state enum extensions.
+
+Enum.states is fixed at construction time; these tests guard against
+accidental removal or reordering that would break scrapers.
+"""
+
+from __future__ import annotations
+
+import pytest
+from prometheus_client import CollectorRegistry, Enum
+
+from dynamo.planner.monitoring.planner_metrics import (
+    LOAD_DECISION_STATES,
+    THROUGHPUT_DECISION_STATES,
+)
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+# The original v1 states MUST remain in the list and MUST remain at the
+# same positions so scrapers reading older label sets keep working.
+_V1_LOAD_STATES = [
+    "unset",
+    "disabled",
+    "no_fpm_data",
+    "scaling_in_progress",
+    "worker_count_mismatch",
+    "insufficient_data",
+    "no_change",
+    "scale_up",
+    "scale_down",
+    "scale_down_capped_by_throughput",
+    # Upstream main added this after the original v1 list but before the
+    # plugin-era additions. Append-only contract still honoured.
+    "scale_down_refused_consolidation",
+]
+
+_V1_THROUGHPUT_STATES = [
+    "unset",
+    "disabled",
+    "no_traffic_data",
+    "predict_failed",
+    "model_not_ready",
+    "set_lower_bound",
+    "scale",
+]
+
+# Plugin-era additions — appended in this order.
+_PLUGIN_LOAD_ADDITIONS = [
+    "override_by_user_plugin",
+    "reconcile_clamped_to_floor",
+    "reconcile_clamped_to_ceiling",
+    "held_over",
+    "rejected_by_plugin",
+]
+
+_PLUGIN_THROUGHPUT_ADDITIONS = [
+    "override_by_user_plugin",
+    "held_over",
+    "circuit_open",
+    "rejected_by_plugin",
+]
+
+
+def test_v1_load_states_preserved_in_original_order():
+    assert LOAD_DECISION_STATES[: len(_V1_LOAD_STATES)] == _V1_LOAD_STATES
+
+
+def test_v1_throughput_states_preserved_in_original_order():
+    assert (
+        THROUGHPUT_DECISION_STATES[: len(_V1_THROUGHPUT_STATES)]
+        == _V1_THROUGHPUT_STATES
+    )
+
+
+def test_load_additions_appended_in_order():
+    assert LOAD_DECISION_STATES[len(_V1_LOAD_STATES) :] == _PLUGIN_LOAD_ADDITIONS
+
+
+def test_throughput_additions_appended_in_order():
+    assert (
+        THROUGHPUT_DECISION_STATES[len(_V1_THROUGHPUT_STATES) :]
+        == _PLUGIN_THROUGHPUT_ADDITIONS
+    )
+
+
+@pytest.mark.parametrize("state", _PLUGIN_LOAD_ADDITIONS)
+def test_new_load_state_is_settable_on_enum(state):
+    """Construct an Enum with our extended states list and verify the
+    new state can be set without raising. Uses an isolated registry so
+    this test doesn't interfere with the module-level Prometheus
+    registry."""
+    registry = CollectorRegistry()
+    gauge = Enum(
+        "test_load_state",
+        "test",
+        states=LOAD_DECISION_STATES,
+        registry=registry,
+    )
+    gauge.state(state)  # must not raise
+    # Readback via collect() — the active state should be ours.
+    samples = list(gauge.collect())[0].samples
+    active = [s for s in samples if s.value == 1.0]
+    assert len(active) == 1
+    assert active[0].labels["test_load_state"] == state
+
+
+@pytest.mark.parametrize("state", _PLUGIN_THROUGHPUT_ADDITIONS)
+def test_new_throughput_state_is_settable_on_enum(state):
+    registry = CollectorRegistry()
+    gauge = Enum(
+        "test_throughput_state",
+        "test",
+        states=THROUGHPUT_DECISION_STATES,
+        registry=registry,
+    )
+    gauge.state(state)
+    samples = list(gauge.collect())[0].samples
+    active = [s for s in samples if s.value == 1.0]
+    assert len(active) == 1
+    assert active[0].labels["test_throughput_state"] == state
+
+
+def test_load_state_list_has_no_duplicates():
+    assert len(LOAD_DECISION_STATES) == len(set(LOAD_DECISION_STATES))
+
+
+def test_throughput_state_list_has_no_duplicates():
+    assert len(THROUGHPUT_DECISION_STATES) == len(set(THROUGHPUT_DECISION_STATES))
+
+
+def test_all_current_states_settable_end_to_end():
+    """Defence-in-depth: each state in both lists must be settable on
+    a freshly-constructed Enum gauge. Catches cases where a state name
+    contains characters that Prometheus would silently accept at list
+    construction but reject at state() call time (none today, but guards
+    against future additions)."""
+    for state in LOAD_DECISION_STATES:
+        registry = CollectorRegistry()
+        gauge = Enum(
+            "test_all_load", "test", states=LOAD_DECISION_STATES, registry=registry
+        )
+        gauge.state(state)
+
+    for state in THROUGHPUT_DECISION_STATES:
+        registry = CollectorRegistry()
+        gauge = Enum(
+            "test_all_throughput",
+            "test",
+            states=THROUGHPUT_DECISION_STATES,
+            registry=registry,
+        )
+        gauge.state(state)
diff --git a/components/src/dynamo/planner/tests/monitoring/test_plugin_framework_metrics.py b/components/src/dynamo/planner/tests/monitoring/test_plugin_framework_metrics.py
new file mode 100644
index 000000000000..34b35d0dd33c
--- /dev/null
+++ b/components/src/dynamo/planner/tests/monitoring/test_plugin_framework_metrics.py
@@ -0,0 +1,477 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tests for PluginFrameworkMetrics."""
+
+from __future__ import annotations
+
+import pytest
+from prometheus_client import CollectorRegistry
+
+from dynamo.planner.monitoring.planner_metrics import (
+    CIRCUIT_STATE_CLOSED,
+    CIRCUIT_STATE_HALF_OPEN,
+    CIRCUIT_STATE_OPEN,
+    PluginFrameworkMetrics,
+)
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def metrics():
+    """Fresh isolated registry per test so we can instantiate the
+    metrics container repeatedly without ``Duplicated timeseries``."""
+    return PluginFrameworkMetrics(registry=CollectorRegistry())
+
+
+def _sample_value(metric, **labels):
+    """Read a single sample value from a labelled metric — the
+    `_sum`/`_count`/actual-value depending on metric type. Tests use
+    ``.labels(...)._value.get()`` on counters/gauges; for histograms
+    we read `_count` via iteration."""
+    # For Counter / Gauge, read the labelled child's internal value
+    # directly. (A previous version iterated ``metric.collect()`` samples
+    # but its match branch was a no-op ``pass`` — dead code — so it was
+    # removed.)
+    labelled = metric.labels(**labels)
+    return labelled._value.get()
+
+
+# ---------------------------------------------------------------------------
+# plugin_evaluations_total
+# ---------------------------------------------------------------------------
+
+
+def test_plugin_evaluations_total_increments_per_call(metrics):
+    metrics.plugin_evaluations_total.labels(
+        plugin_id="p1", stage="propose", result="accept"
+    ).inc()
+    metrics.plugin_evaluations_total.labels(
+        plugin_id="p1", stage="propose", result="accept"
+    ).inc()
+    metrics.plugin_evaluations_total.labels(
+        plugin_id="p1", stage="propose", result="set"
+    ).inc()
+    metrics.plugin_evaluations_total.labels(
+        plugin_id="p2", stage="constrain", result="at_most"
+    ).inc()
+
+    assert (
+        _sample_value(
+            metrics.plugin_evaluations_total,
+            plugin_id="p1",
+            stage="propose",
+            result="accept",
+        )
+        == 2
+    )
+    assert (
+        _sample_value(
+            metrics.plugin_evaluations_total,
+            plugin_id="p1",
+            stage="propose",
+            result="set",
+        )
+        == 1
+    )
+    assert (
+        _sample_value(
+            metrics.plugin_evaluations_total,
+            plugin_id="p2",
+            stage="constrain",
+            result="at_most",
+        )
+        == 1
+    )
+
+
+# ---------------------------------------------------------------------------
+# plugin_latency_seconds
+# ---------------------------------------------------------------------------
+
+
+def test_plugin_latency_seconds_observes_values(metrics):
+    h = metrics.plugin_latency_seconds.labels(plugin_id="p1", stage="propose")
+    h.observe(0.003)
+    h.observe(0.045)
+    h.observe(0.8)
+
+    # Histogram buckets are (0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 1.0, 5.0)
+    # 3 observations total.
+    samples = {
+        s.name: s.value
+        for s in list(metrics.plugin_latency_seconds.collect())[0].samples
+        if s.labels.get("plugin_id") == "p1" and s.labels.get("stage") == "propose"
+    }
+    # Total count across buckets = 3
+    count_samples = [v for k, v in samples.items() if k.endswith("_count")]
+    assert any(v == 3.0 for v in count_samples)
+
+
+def test_plugin_latency_buckets_span_in_process_to_timeout(metrics):
+    """Verify the bucket boundaries: the family should be useful both
+    for in-process plugins (~1ms) and up to the default request_timeout
+    (5s)."""
+    # Reading buckets out of the collected samples is the cleanest way.
+    h = metrics.plugin_latency_seconds.labels(plugin_id="any", stage="propose")
+    h.observe(0.0)
+    bucket_bounds = []
+    for s in list(metrics.plugin_latency_seconds.collect())[0].samples:
+        if s.name.endswith("_bucket") and s.labels.get("plugin_id") == "any":
+            bucket_bounds.append(s.labels["le"])
+    assert "0.001" in bucket_bounds
+    assert "5.0" in bucket_bounds or "5" in bucket_bounds
+    assert "+Inf" in bucket_bounds
+
+
+# ---------------------------------------------------------------------------
+# plugin_circuit_state
+# ---------------------------------------------------------------------------
+
+
+def test_plugin_circuit_state_encoding(metrics):
+    metrics.plugin_circuit_state.labels(plugin_id="p1").set(CIRCUIT_STATE_CLOSED)
+    metrics.plugin_circuit_state.labels(plugin_id="p2").set(CIRCUIT_STATE_HALF_OPEN)
+    metrics.plugin_circuit_state.labels(plugin_id="p3").set(CIRCUIT_STATE_OPEN)
+
+    assert _sample_value(metrics.plugin_circuit_state, plugin_id="p1") == 0.0
+    assert _sample_value(metrics.plugin_circuit_state, plugin_id="p2") == 0.5
+    assert _sample_value(metrics.plugin_circuit_state, plugin_id="p3") == 1.0
+
+
+def test_circuit_state_constants_are_monotonic():
+    """Encoding must be monotonic closed→half_open→open so dashboards
+    can compute ``max_over_time()`` without inversions."""
+    assert CIRCUIT_STATE_CLOSED < CIRCUIT_STATE_HALF_OPEN < CIRCUIT_STATE_OPEN
+
+
+# ---------------------------------------------------------------------------
+# plugin_held_over_total
+# ---------------------------------------------------------------------------
+
+
+def test_plugin_held_over_total_increments(metrics):
+    metrics.plugin_held_over_total.labels(plugin_id="p1", stage="propose").inc()
+    metrics.plugin_held_over_total.labels(plugin_id="p1", stage="propose").inc()
+    metrics.plugin_held_over_total.labels(plugin_id="p2", stage="predict").inc()
+
+    assert (
+        _sample_value(metrics.plugin_held_over_total, plugin_id="p1", stage="propose")
+        == 2
+    )
+    assert (
+        _sample_value(metrics.plugin_held_over_total, plugin_id="p2", stage="predict")
+        == 1
+    )
+
+
+# ---------------------------------------------------------------------------
+# plugin_cache_age_seconds
+# ---------------------------------------------------------------------------
+
+
+def test_plugin_cache_age_seconds_set_per_plugin(metrics):
+    metrics.plugin_cache_age_seconds.labels(plugin_id="p1").set(4.2)
+    metrics.plugin_cache_age_seconds.labels(plugin_id="p2").set(60.0)
+    assert _sample_value(metrics.plugin_cache_age_seconds, plugin_id="p1") == 4.2
+    assert _sample_value(metrics.plugin_cache_age_seconds, plugin_id="p2") == 60.0
+
+
+# ---------------------------------------------------------------------------
+# plugin_override_active + reset_overrides
+# ---------------------------------------------------------------------------
+
+
+def test_plugin_override_active_per_label(metrics):
+    metrics.plugin_override_active.labels(
+        plugin_id="p1", stage="propose", override_type="SET"
+    ).set(1)
+    metrics.plugin_override_active.labels(
+        plugin_id="p1", stage="propose", override_type="AT_LEAST"
+    ).set(0)
+
+    assert (
+        _sample_value(
+            metrics.plugin_override_active,
+            plugin_id="p1",
+            stage="propose",
+            override_type="SET",
+        )
+        == 1
+    )
+    assert (
+        _sample_value(
+            metrics.plugin_override_active,
+            plugin_id="p1",
+            stage="propose",
+            override_type="AT_LEAST",
+        )
+        == 0
+    )
+
+
+def test_reset_overrides_zeroes_all_types(metrics):
+    # Set all four override types active for the same plugin/stage.
+    for t in ("SET", "AT_LEAST", "AT_MOST", "REJECT"):
+        metrics.plugin_override_active.labels(
+            plugin_id="p1", stage="propose", override_type=t
+        ).set(1)
+
+    metrics.reset_overrides("p1", "propose")
+
+    for t in ("SET", "AT_LEAST", "AT_MOST", "REJECT"):
+        assert (
+            _sample_value(
+                metrics.plugin_override_active,
+                plugin_id="p1",
+                stage="propose",
+                override_type=t,
+            )
+            == 0
+        )
+
+
+def test_reset_overrides_isolates_per_plugin_stage(metrics):
+    """``reset_overrides`` zeros only the (plugin_id, stage) pair, not
+    other plugins' overrides."""
+    metrics.plugin_override_active.labels(
+        plugin_id="p1", stage="propose", override_type="SET"
+    ).set(1)
+    metrics.plugin_override_active.labels(
+        plugin_id="p2", stage="propose", override_type="SET"
+    ).set(1)
+
+    metrics.reset_overrides("p1", "propose")
+
+    assert (
+        _sample_value(
+            metrics.plugin_override_active,
+            plugin_id="p1",
+            stage="propose",
+            override_type="SET",
+        )
+        == 0
+    )
+    assert (
+        _sample_value(
+            metrics.plugin_override_active,
+            plugin_id="p2",
+            stage="propose",
+            override_type="SET",
+        )
+        == 1
+    )
+
+
+# ---------------------------------------------------------------------------
+# Registry isolation
+# ---------------------------------------------------------------------------
+
+
+def test_default_registry_construction_succeeds():
+    """Without an explicit registry, metrics land on the global REGISTRY.
+    The production path must be usable without changing anything.
+
+    Note: ``OrchestratorEngineAdapter.__init__`` claims these metric
+    names on the global REGISTRY at first construction. Other tests
+    that construct the adapter therefore race with this one. We skip
+    when names are already registered — the production path is the
+    same either way.
+    """
+    from prometheus_client import REGISTRY
+
+    try:
+        m = PluginFrameworkMetrics()
+    except ValueError:
+        pytest.skip(
+            "PluginFrameworkMetrics already registered on REGISTRY by "
+            "another test in this session; test-only collision, not a bug."
+        )
+        return  # unreachable: pytest.skip() raises Skipped
+    try:
+        m.plugin_evaluations_total.labels(
+            plugin_id="x", stage="propose", result="accept"
+        ).inc()
+        value = _sample_value(
+            m.plugin_evaluations_total,
+            plugin_id="x",
+            stage="propose",
+            result="accept",
+        )
+        assert value == 1
+    finally:
+        for metric in (
+            m.plugin_evaluations_total,
+            m.plugin_latency_seconds,
+            m.plugin_circuit_state,
+            m.plugin_held_over_total,
+            m.plugin_cache_age_seconds,
+            m.plugin_override_active,
+        ):
+            try:
+                REGISTRY.unregister(metric)
+            except KeyError:
+                # Metric wasn't registered yet — fixture is idempotent
+                # so a missing entry just means the previous test didn't
+                # register it; nothing to clean up.
+                pass
+
+
+# ---------------------------------------------------------------------------
+# Family-3 metrics (unit-level)
+# ---------------------------------------------------------------------------
+
+
+def test_reconcile_clamped_total_increments(metrics):
+    metrics.reconcile_clamped_total.labels(
+        sub_component_type="prefill",
+        source="budget_constrain",
+    ).inc()
+    metrics.reconcile_clamped_total.labels(
+        sub_component_type="prefill",
+        source="budget_constrain",
+    ).inc()
+    metrics.reconcile_clamped_total.labels(
+        sub_component_type="decode",
+        source="user_plugin",
+    ).inc()
+    assert (
+        _sample_value(
+            metrics.reconcile_clamped_total,
+            sub_component_type="prefill",
+            source="budget_constrain",
+        )
+        == 2
+    )
+    assert (
+        _sample_value(
+            metrics.reconcile_clamped_total,
+            sub_component_type="decode",
+            source="user_plugin",
+        )
+        == 1
+    )
+
+
+def test_constrain_capped_total_increments(metrics):
+    metrics.constrain_capped_total.labels(
+        sub_component_type="prefill",
+        source="budget_constrain",
+    ).inc()
+    assert (
+        _sample_value(
+            metrics.constrain_capped_total,
+            sub_component_type="prefill",
+            source="budget_constrain",
+        )
+        == 1
+    )
+
+
+# ---------------------------------------------------------------------------
+# Family-6 tick metrics (unit-level)
+# ---------------------------------------------------------------------------
+
+
+def test_tick_skipped_total_increments_per_plugin(metrics):
+    metrics.tick_skipped_total.labels(plugin_id="p1").inc()
+    metrics.tick_skipped_total.labels(plugin_id="p1").inc()
+    metrics.tick_skipped_total.labels(plugin_id="p2").inc()
+    assert _sample_value(metrics.tick_skipped_total, plugin_id="p1") == 2
+    assert _sample_value(metrics.tick_skipped_total, plugin_id="p2") == 1
+
+
+def test_tick_lag_seconds_is_last_set_value(metrics):
+    metrics.tick_lag_seconds.labels(plugin_id="p1").set(0.0)
+    metrics.tick_lag_seconds.labels(plugin_id="p1").set(3.2)
+    metrics.tick_lag_seconds.labels(plugin_id="p2").set(0.5)
+    assert _sample_value(metrics.tick_lag_seconds, plugin_id="p1") == 3.2
+    assert _sample_value(metrics.tick_lag_seconds, plugin_id="p2") == 0.5
+
+
+def test_tick_duration_seconds_observes_and_counts(metrics):
+    metrics.tick_duration_seconds.observe(0.5)
+    metrics.tick_duration_seconds.observe(2.0)
+    metrics.tick_duration_seconds.observe(0.1)
+    # Histogram: no labels on this one → one set of samples
+    samples = list(metrics.tick_duration_seconds.collect())[0].samples
+    counts = [s.value for s in samples if s.name.endswith("_count")]
+    assert counts and counts[0] == 3.0
+
+
+def test_tick_timeout_total_increments(metrics):
+    metrics.tick_timeout_total.inc()
+    metrics.tick_timeout_total.inc()
+    # Unlabelled counter: value is on the Counter itself
+    samples = list(metrics.tick_timeout_total.collect())[0].samples
+    values = [s.value for s in samples if s.name.endswith("_total")]
+    assert values and values[0] == 2.0
+
+
+def test_tick_duration_buckets_span_healthy_to_deadline(metrics):
+    """Buckets must cover the full range from healthy tick (~50ms) to
+    the default ``tick_max_duration_seconds=30`` — operators scale
+    ``tick_max_duration_seconds`` higher by default when their pipeline
+    has slow user plugins, so 30s is the upper interesting bucket."""
+    metrics.tick_duration_seconds.observe(0.0)
+    samples = list(metrics.tick_duration_seconds.collect())[0].samples
+    buckets = {s.labels["le"] for s in samples if s.name.endswith("_bucket")}
+    assert "0.01" in buckets
+    assert "30.0" in buckets or "30" in buckets
+    assert "+Inf" in buckets
+
+
+def test_reject_short_circuited_total_increments(metrics):
+    metrics.reject_short_circuited_total.labels(plugin_id="safety_plugin").inc()
+    metrics.reject_short_circuited_total.labels(plugin_id="safety_plugin").inc()
+    metrics.reject_short_circuited_total.labels(plugin_id="other_plugin").inc()
+    assert (
+        _sample_value(metrics.reject_short_circuited_total, plugin_id="safety_plugin")
+        == 2
+    )
+    assert (
+        _sample_value(metrics.reject_short_circuited_total, plugin_id="other_plugin")
+        == 1
+    )
+
+
+def test_two_instances_with_fresh_registries_coexist():
+    r1 = CollectorRegistry()
+    r2 = CollectorRegistry()
+    m1 = PluginFrameworkMetrics(registry=r1)
+    m2 = PluginFrameworkMetrics(registry=r2)
+    m1.plugin_evaluations_total.labels(
+        plugin_id="a", stage="propose", result="accept"
+    ).inc()
+    m2.plugin_evaluations_total.labels(
+        plugin_id="a", stage="propose", result="accept"
+    ).inc(5)
+    assert (
+        _sample_value(
+            m1.plugin_evaluations_total,
+            plugin_id="a",
+            stage="propose",
+            result="accept",
+        )
+        == 1
+    )
+    assert (
+        _sample_value(
+            m2.plugin_evaluations_total,
+            plugin_id="a",
+            stage="propose",
+            result="accept",
+        )
+        == 5
+    )
diff --git a/components/src/dynamo/planner/tests/offline/__init__.py b/components/src/dynamo/planner/tests/offline/__init__.py
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/components/src/dynamo/planner/tests/offline/test_replay_adapter_fpm.py b/components/src/dynamo/planner/tests/offline/test_replay_adapter_fpm.py
new file mode 100644
index 000000000000..beb9c4a1fe56
--- /dev/null
+++ b/components/src/dynamo/planner/tests/offline/test_replay_adapter_fpm.py
@@ -0,0 +1,138 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Regression test for the replay-path FPM feed.
+
+``ReplayPlannerAdapter._feed_extra_fpm_to_regression`` feeds accumulated
+intra-tick FPM snapshots into the regression model. The regression slots
+hold ``PlannerEnginePerfModel`` (built by the PSM in SLA mode), which
+exposes only ``add_observations(dict)`` — the pre-fix singular
+``add_observation(fpm)`` raised ``AttributeError`` and crashed the
+*default* (``use_orchestrator=False``) SLA-mode replay on any tick that
+carried more than one FPM snapshot per worker. No test covered this
+method, so the crash shipped silently.
+
+This test drives the method against a real PSM-built regression and
+asserts it does not raise.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.config.planner_config import PlannerConfig
+from dynamo.planner.core.state_machine import PlannerStateMachine
+from dynamo.planner.core.types import EngineCapabilities, WorkerCapabilities
+from dynamo.planner.offline.replay_adapter import (
+    ReplayPlannerAdapter,
+    _build_fpm_from_dict,
+)
+from dynamo.planner.plugins.orchestrator.engine_adapter import OrchestratorEngineAdapter
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+def _agg_caps() -> WorkerCapabilities:
+    return WorkerCapabilities(
+        decode=EngineCapabilities(
+            num_gpu=1, max_num_batched_tokens=2048, max_kv_tokens=16384
+        )
+    )
+
+
+def _agg_config_sla() -> PlannerConfig:
+    return PlannerConfig(
+        mode="agg",
+        enable_load_scaling=True,
+        enable_throughput_scaling=True,
+        optimization_target="sla",
+        served_model_name="test",
+    )
+
+
+def _snap(worker_id: str, wall_time: float) -> dict:
+    """A bridge FPM snapshot dict with every key ``_build_fpm_from_dict`` reads."""
+    return {
+        "worker_id": worker_id,
+        "wall_time": wall_time,
+        "num_prefill_requests": 0,
+        "sum_prefill_tokens": 0,
+        "var_prefill_length": 0.0,
+        "sum_prefill_kv_tokens": 0,
+        "num_decode_requests": 1,
+        "sum_decode_kv_tokens": 100,
+        "var_decode_kv_tokens": 0.0,
+        "num_queued_prefill": 0,
+        "sum_queued_prefill_tokens": 0,
+        "var_queued_prefill_length": 0.0,
+        "num_queued_decode": 0,
+        "sum_queued_decode_kv_tokens": 0,
+        "var_queued_decode_kv_tokens": 0.0,
+    }
+
+
+def _adapter_for_psm(
+    cfg: PlannerConfig, caps: WorkerCapabilities
+) -> ReplayPlannerAdapter:
+    """Build just enough of a ReplayPlannerAdapter to exercise
+    ``_feed_extra_fpm_to_regression`` without a full replay harness.
+
+    The method only touches ``_config`` (mode / optimization_target via
+    ``_is_easy_mode``) and ``_get_regression`` (which on the PSM path reads
+    ``_use_orchestrator`` + ``_sm``)."""
+    adapter = ReplayPlannerAdapter.__new__(ReplayPlannerAdapter)
+    adapter._config = cfg
+    adapter._use_orchestrator = False
+    adapter._sm = PlannerStateMachine(cfg, caps)
+    return adapter
+
+
+def test_feed_extra_fpm_to_regression_does_not_crash_psm_sla():
+    """Two decode snapshots for the same worker → one is non-excluded and
+    flows into the regression. Pre-fix this raised AttributeError on the
+    PlannerEnginePerfModel slot."""
+    cfg = _agg_config_sla()
+    adapter = _adapter_for_psm(cfg, _agg_caps())
+
+    decode_snaps = [
+        _snap("w1", wall_time=1.0),
+        _snap("w1", wall_time=2.0),  # last-per-worker → excluded; the first feeds
+    ]
+    # Pre-fix:
+    #   AttributeError: 'PlannerEnginePerfModel' object has no attribute
+    #   'add_observation'
+    adapter._feed_extra_fpm_to_regression(decode_snaps=decode_snaps, prefill_snaps=[])
+
+
+def _orch_agg_config_sla() -> PlannerConfig:
+    cfg = _agg_config_sla()
+    cfg.scheduling.use_orchestrator = True
+    return cfg
+
+
+def test_install_benchmark_fpms_installs_regression_on_orchestrator_path():
+    """Review #3: the orchestrator replay path must actually install
+    regressions. ``ReplayPlannerAdapter.install_benchmark_fpms`` routes to
+    ``OrchestratorEngineAdapter.install_regressions_from_fpms`` so
+    ``get_regression`` is non-None afterwards. Pre-fix, replay/main.py only
+    fed ``adapter._sm`` (None under use_orchestrator), so the orchestrator
+    regression stayed empty and replay diverged from PSM."""
+    cfg = _orch_agg_config_sla()
+    adapter = ReplayPlannerAdapter.__new__(ReplayPlannerAdapter)
+    adapter._config = cfg
+    adapter._use_orchestrator = True
+    adapter._sm = None
+    adapter._engine = OrchestratorEngineAdapter(cfg, _agg_caps())
+
+    # Before: no regression installed on the orchestrator path.
+    assert adapter._engine._orchestrator.get_regression("agg") is None
+
+    adapter.install_benchmark_fpms(agg_fpms=[_build_fpm_from_dict(_snap("w1", 1.0))])
+
+    # After: the agg regression is installed (non-None).
+    assert adapter._engine._orchestrator.get_regression("agg") is not None
diff --git a/components/src/dynamo/planner/tests/plugins/__init__.py b/components/src/dynamo/planner/tests/plugins/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/tests/plugins/clock/__init__.py b/components/src/dynamo/planner/tests/plugins/clock/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/clock/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/tests/plugins/clock/test_clocks.py b/components/src/dynamo/planner/tests/plugins/clock/test_clocks.py
new file mode 100644
index 000000000000..91015fae5289
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/clock/test_clocks.py
@@ -0,0 +1,156 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for Clock implementations."""
+
+from __future__ import annotations
+
+import asyncio
+import time
+
+import pytest
+
+from dynamo.planner.plugins.clock import VirtualClock, WallClock
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+# ----- WallClock -----
+
+
+def test_wall_clock_now_close_to_time_time():
+    c = WallClock()
+    delta = abs(c.now() - time.time())
+    assert delta < 0.5  # generous; just sanity
+
+
+def test_wall_clock_monotonic_strictly_increasing():
+    c = WallClock()
+    a = c.monotonic()
+    time.sleep(0.001)
+    b = c.monotonic()
+    assert b > a
+
+
+@pytest.mark.asyncio
+async def test_wall_clock_sleep_actually_sleeps():
+    c = WallClock()
+    t_start = c.monotonic()
+    await c.sleep(0.05)
+    elapsed = c.monotonic() - t_start
+    assert 0.04 < elapsed < 0.5  # generous upper for slow CI
+
+
+# ----- VirtualClock -----
+
+
+def test_virtual_clock_initial_state():
+    c = VirtualClock(start_now=1000.0, start_mono=0.0)
+    assert c.now() == 1000.0
+    assert c.monotonic() == 0.0
+
+
+def test_virtual_clock_advance_updates_both():
+    c = VirtualClock(start_now=1000.0, start_mono=5.0)
+    c.advance(7.5)
+    assert c.now() == 1007.5
+    assert c.monotonic() == 12.5
+
+
+def test_virtual_clock_advance_negative_rejected():
+    c = VirtualClock()
+    with pytest.raises(ValueError, match="seconds must be >= 0"):
+        c.advance(-1.0)
+
+
+@pytest.mark.asyncio
+async def test_virtual_clock_sleeper_resumes_on_advance():
+    c = VirtualClock()
+    woke = []
+
+    async def sleeper(name: str, secs: float):
+        await c.sleep(secs)
+        woke.append((name, c.monotonic()))
+
+    task1 = asyncio.create_task(sleeper("a", 5.0))
+    task2 = asyncio.create_task(sleeper("b", 10.0))
+    task3 = asyncio.create_task(sleeper("c", 3.0))
+
+    # Let coroutines schedule and queue their futures
+    await asyncio.sleep(0)
+
+    c.advance(7.0)
+    # Let resumed coroutines run
+    for _ in range(3):
+        await asyncio.sleep(0)
+
+    # a (5s) and c (3s) should have woken at mono=7.0
+    assert ("c", 7.0) in woke
+    assert ("a", 7.0) in woke
+    # b (10s) still pending
+    assert not any(name == "b" for name, _ in woke)
+    assert not task2.done()
+
+    c.advance(5.0)
+    for _ in range(3):
+        await asyncio.sleep(0)
+    assert ("b", 12.0) in woke
+    await asyncio.gather(task1, task2, task3)
+
+
+@pytest.mark.asyncio
+async def test_virtual_clock_immediate_yield_for_zero_sleep():
+    c = VirtualClock()
+    initial = c.monotonic()
+    await c.sleep(0)
+    assert c.monotonic() == initial  # zero sleep does not advance virtual time
+
+
+@pytest.mark.asyncio
+async def test_virtual_clock_advance_skips_past_deadline():
+    """Sleeper with deadline T resolves even when advance(N) where N > T."""
+    c = VirtualClock()
+
+    async def sleeper():
+        await c.sleep(2.0)
+        return c.monotonic()
+
+    task = asyncio.create_task(sleeper())
+    await asyncio.sleep(0)
+    c.advance(100.0)  # way past 2s
+    for _ in range(3):
+        await asyncio.sleep(0)
+    result = await task
+    assert result == 100.0
+
+
+@pytest.mark.asyncio
+async def test_virtual_clock_cancellation_does_not_leak_heap():
+    """Cancelled sleeper futures must not keep the sleeper heap growing
+    (memory leak in long-running replays / tests)."""
+    c = VirtualClock()
+
+    async def cancelled_sleeper():
+        await c.sleep(1000)
+
+    task = asyncio.create_task(cancelled_sleeper())
+    await asyncio.sleep(0)
+
+    task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        # Awaiting a cancelled task re-raises ``CancelledError`` — the
+        # whole point of this block. Assign the await expression so
+        # CodeQL doesn't read it as "statement has no effect".
+        _result = await task
+        del _result  # silence "unused local" warnings symmetrically
+
+    # After advance past deadline, the cancelled future is dropped from heap
+    assert len(c._sleepers) == 1  # before advance, still in heap
+    c.advance(2000)
+    # Heap should now be empty (cancelled future popped + silently discarded)
+    assert len(c._sleepers) == 0
diff --git a/components/src/dynamo/planner/tests/plugins/merge/__init__.py b/components/src/dynamo/planner/tests/plugins/merge/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/merge/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/tests/plugins/merge/test_chain_augment.py b/components/src/dynamo/planner/tests/plugins/merge/test_chain_augment.py
new file mode 100644
index 000000000000..14b849b64e51
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/merge/test_chain_augment.py
@@ -0,0 +1,385 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for chain_augment.
+
+Covered patterns:
+- Replace: single plugin emits complete PredictionData
+- Patch: higher-priority plugin overrides one field only
+- Augment: plugins fill disjoint fields
+- Passthrough: all plugins emit predictions=None (ACCEPT)
+- final break: chain stops at final=true, subsequent plugin never called
+- final misuse: non-lowest-priority final => warning + downstream skipped
+- final correct: lowest-priority final => no warning
+- Multiple finals in chain: first-encountered (non-lowest) wins + warning
+- partial-merge preserves earlier fields when later plugin has None
+- Empty chain / mixed priority order from caller
+
+Note: the as-built ``PredictStageResponse`` does not expose a REJECT
+mechanism (the proto message has only ``predictions`` / ``reason`` /
+``final``). So the ``degraded`` field on ``ChainAugmentOutcome`` is
+always empty. A future proto revision can introduce explicit reject;
+tests here assert ``degraded == []``.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.merge import chain_augment
+from dynamo.planner.plugins.types import (
+    PipelineContext,
+    PredictionData,
+    PredictStageResponse,
+)
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+class _StubPlugin:
+    """Minimal PredictPluginCallable for tests — returns a queued
+    ``PredictStageResponse`` on each ``call``; counts invocations."""
+
+    def __init__(self, plugin_id: str, priority: int, responses):
+        self.plugin_id = plugin_id
+        self.priority = priority
+        self._responses = list(responses)
+        self.call_count = 0
+        self.seen_contexts: list[PipelineContext] = []
+
+    async def call(self, method: str, context: PipelineContext) -> PredictStageResponse:
+        assert method == "Predict"
+        self.call_count += 1
+        self.seen_contexts.append(context)
+        return self._responses.pop(0)
+
+
+def _pd(num_req=None, isl=None, osl=None, kv=None, source=""):
+    return PredictionData(
+        predicted_num_req=num_req,
+        predicted_isl=isl,
+        predicted_osl=osl,
+        predicted_kv_hit_rate=kv,
+        source=source,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Replace / Patch / Augment / Passthrough
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_replace_single_plugin_complete_prediction():
+    p = _StubPlugin(
+        "p1",
+        10,
+        [PredictStageResponse(predictions=_pd(num_req=1000, isl=3000, osl=150))],
+    )
+    out = await chain_augment([p], PipelineContext())
+    assert out.prediction is not None
+    assert out.prediction.predicted_num_req == 1000
+    assert out.prediction.predicted_isl == 3000
+    assert out.prediction.predicted_osl == 150
+    assert out.final_from == ""
+    assert out.degraded == []
+    assert out.chain_break_warnings == []
+
+
+@pytest.mark.asyncio
+async def test_predicted_kv_hit_rate_merges_across_chain():
+    # predicted_kv_hit_rate must participate in first-writer-wins partial
+    # merge like the other three predicted_* fields. Regression guard: it
+    # was missing from _PREDICTION_FIELDS, so any 2+ plugin chain dropped it.
+    high = _StubPlugin(
+        "high",
+        10,
+        [PredictStageResponse(predictions=_pd(num_req=1200, kv=0.42))],
+    )
+    low = _StubPlugin(
+        "low",
+        100,
+        [PredictStageResponse(predictions=_pd(isl=3000, osl=150, kv=0.99))],
+    )
+    out = await chain_augment([high, low], PipelineContext())
+    assert out.prediction is not None
+    # high (smaller priority) wrote kv=0.42 first → first-writer-wins
+    assert out.prediction.predicted_kv_hit_rate == 0.42
+    # and the disjoint fields from low still fill in
+    assert out.prediction.predicted_isl == 3000
+    assert out.prediction.predicted_osl == 150
+
+
+@pytest.mark.asyncio
+async def test_predicted_kv_hit_rate_fills_from_later_plugin_when_unset():
+    # high leaves kv unset (None) → low's kv fills the gap.
+    high = _StubPlugin(
+        "high", 10, [PredictStageResponse(predictions=_pd(num_req=1200))]
+    )
+    low = _StubPlugin("low", 100, [PredictStageResponse(predictions=_pd(kv=0.7))])
+    out = await chain_augment([high, low], PipelineContext())
+    assert out.prediction is not None
+    assert out.prediction.predicted_kv_hit_rate == 0.7
+
+
+@pytest.mark.asyncio
+async def test_patch_high_priority_overrides_single_field():
+    # Caller passes arbitrary order; chain_augment sorts priority-ascending.
+    # priority=10 (high precedence) runs first and writes num_req=1200;
+    # priority=100 (low precedence) runs last — first-writer-wins keeps
+    # num_req=1200, and low's isl/osl fill the gaps high left as None.
+    low = _StubPlugin(
+        "low",
+        100,
+        [PredictStageResponse(predictions=_pd(num_req=1000, isl=3000, osl=150))],
+    )
+    high = _StubPlugin(
+        "high",
+        10,
+        [PredictStageResponse(predictions=_pd(num_req=1200))],
+    )
+    out = await chain_augment([high, low], PipelineContext())
+    assert out.prediction is not None
+    assert out.prediction.predicted_num_req == 1200
+    assert out.prediction.predicted_isl == 3000
+    assert out.prediction.predicted_osl == 150
+
+
+@pytest.mark.asyncio
+async def test_augment_disjoint_fields_merge():
+    a = _StubPlugin("A", 100, [PredictStageResponse(predictions=_pd(num_req=1000))])
+    b = _StubPlugin("B", 10, [PredictStageResponse(predictions=_pd(isl=3000, osl=150))])
+    out = await chain_augment([a, b], PipelineContext())
+    assert out.prediction is not None
+    assert out.prediction.predicted_num_req == 1000
+    assert out.prediction.predicted_isl == 3000
+    assert out.prediction.predicted_osl == 150
+
+
+@pytest.mark.asyncio
+async def test_passthrough_all_plugins_accept():
+    a = _StubPlugin("A", 100, [PredictStageResponse()])
+    b = _StubPlugin("B", 10, [PredictStageResponse()])
+    out = await chain_augment([a, b], PipelineContext())
+    assert out.prediction is None
+    assert out.final_from == ""
+
+
+@pytest.mark.asyncio
+async def test_predictions_none_preserves_prior():
+    # Sort asc: B (10) runs first, returns predictions=None (no opinion) so
+    # the running prediction stays None. A (100) runs second and emits a full
+    # PredictionData. The chain returns A's prediction verbatim — a None
+    # response from a higher-precedence plugin doesn't poison later writers.
+    a = _StubPlugin(
+        "A",
+        100,
+        [PredictStageResponse(predictions=_pd(num_req=1000, isl=3000, osl=150))],
+    )
+    b = _StubPlugin("B", 10, [PredictStageResponse()])
+    out = await chain_augment([a, b], PipelineContext())
+    assert out.prediction is not None
+    assert out.prediction.predicted_num_req == 1000
+    assert out.prediction.predicted_isl == 3000
+    assert out.prediction.predicted_osl == 150
+
+
+@pytest.mark.asyncio
+async def test_source_higher_precedence_wins_when_non_empty():
+    # Sort asc: B (10) runs first with source="patch"; A (100) runs second
+    # with source="base". First-writer-wins for source: B's non-empty value
+    # is preserved.
+    a = _StubPlugin(
+        "A", 100, [PredictStageResponse(predictions=_pd(num_req=1.0, source="base"))]
+    )
+    b = _StubPlugin(
+        "B", 10, [PredictStageResponse(predictions=_pd(isl=2.0, source="patch"))]
+    )
+    out = await chain_augment([a, b], PipelineContext())
+    assert out.prediction is not None
+    assert out.prediction.source == "patch"
+
+
+@pytest.mark.asyncio
+async def test_source_falls_back_to_lower_precedence_when_higher_empty():
+    # Sort asc: B (10) runs first with source=""; A (100) runs second with
+    # source="base". Empty string is treated as "no opinion" for source,
+    # so A's value fills in.
+    a = _StubPlugin(
+        "A", 100, [PredictStageResponse(predictions=_pd(num_req=1.0, source="base"))]
+    )
+    b = _StubPlugin(
+        "B", 10, [PredictStageResponse(predictions=_pd(isl=2.0))]
+    )  # source=""
+    out = await chain_augment([a, b], PipelineContext())
+    assert out.prediction is not None
+    assert out.prediction.source == "base"
+
+
+# ---------------------------------------------------------------------------
+# final break semantics
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_final_breaks_chain_and_subsequent_plugins_never_called():
+    # Sort asc: [p10 (10), p50 (50), p100 (100)]; p50 returns final → break.
+    # p10 ran first (set osl=100), p50 ran second (set isl=2000 + final),
+    # p100 never gets to fill predicted_num_req. Misuse warning fires
+    # because p50 isn't the lowest-priority plugin in the chain (p10 is).
+    p100 = _StubPlugin(
+        "p100", 100, [PredictStageResponse(predictions=_pd(num_req=500))]
+    )
+    p50 = _StubPlugin(
+        "p50", 50, [PredictStageResponse(predictions=_pd(isl=2000), final=True)]
+    )
+    p10 = _StubPlugin("p10", 10, [PredictStageResponse(predictions=_pd(osl=100))])
+    out = await chain_augment([p100, p50, p10], PipelineContext())
+    assert out.final_from == "p50"
+    assert p10.call_count == 1
+    assert p50.call_count == 1
+    assert p100.call_count == 0
+    assert out.prediction is not None
+    assert out.prediction.predicted_num_req is None  # p100 never ran
+    assert out.prediction.predicted_isl == 2000  # p50 filled this
+    assert out.prediction.predicted_osl == 100  # p10 filled this
+    # p50 is not lowest priority (p10 is) → misuse warning.
+    assert len(out.chain_break_warnings) == 1
+    assert "p50" in out.chain_break_warnings[0]
+
+
+@pytest.mark.asyncio
+async def test_final_at_lowest_priority_no_warning():
+    # Sort asc: [emergency (5), low (100)]. emergency runs first, sets final →
+    # break. emergency.priority equals lowest_priority → no misuse warning.
+    # low never runs (chain short-circuited by the authoritative plugin).
+    low = _StubPlugin("low", 100, [PredictStageResponse(predictions=_pd(num_req=500))])
+    emergency = _StubPlugin(
+        "emergency",
+        5,
+        [PredictStageResponse(predictions=_pd(num_req=1000), final=True)],
+    )
+    out = await chain_augment([low, emergency], PipelineContext())
+    assert out.final_from == "emergency"
+    assert emergency.call_count == 1
+    assert low.call_count == 0
+    assert out.chain_break_warnings == []
+    assert out.prediction is not None
+    assert out.prediction.predicted_num_req == 1000
+
+
+@pytest.mark.asyncio
+async def test_final_at_non_lowest_priority_warns_and_skips_lower_precedence():
+    # Sort asc: [emergency (5), mid (50), low (100)]. mid returns final → break.
+    # emergency ran first (no final), mid ran second and short-circuited the
+    # chain. low (lower precedence) is correctly skipped. The misuse warning
+    # fires because mid is NOT the lowest-priority plugin in the chain — the
+    # authoritative emergency had already weighed in, but using final=true from
+    # a mid-priority plugin is still a configuration smell.
+    emergency = _StubPlugin(
+        "emergency",
+        5,
+        [PredictStageResponse(predictions=_pd(num_req=9000))],
+    )
+    mid = _StubPlugin(
+        "mid",
+        50,
+        [PredictStageResponse(predictions=_pd(isl=500), final=True)],
+    )
+    low = _StubPlugin(
+        "low",
+        100,
+        [PredictStageResponse(predictions=_pd(osl=100))],
+    )
+    out = await chain_augment([mid, emergency, low], PipelineContext())
+    assert out.final_from == "mid"
+    assert emergency.call_count == 1
+    assert mid.call_count == 1
+    assert low.call_count == 0
+    assert len(out.chain_break_warnings) == 1
+    warning = out.chain_break_warnings[0]
+    assert "mid" in warning
+    assert "priority=50" in warning
+    assert "lowest_priority=5" in warning
+
+
+@pytest.mark.asyncio
+async def test_multiple_finals_first_in_sorted_order_wins():
+    # Both A (100) and B (5) are final=True.
+    # Sort asc: [B (5), A (100)] → B runs first, triggers break, A never runs.
+    # B.priority (5) == lowest_priority → no misuse warning.
+    a = _StubPlugin(
+        "A", 100, [PredictStageResponse(predictions=_pd(num_req=100), final=True)]
+    )
+    b = _StubPlugin(
+        "B", 5, [PredictStageResponse(predictions=_pd(num_req=200), final=True)]
+    )
+    out = await chain_augment([a, b], PipelineContext())
+    assert out.final_from == "B"
+    assert b.call_count == 1
+    assert a.call_count == 0
+    assert out.chain_break_warnings == []
+    assert out.prediction is not None
+    assert out.prediction.predicted_num_req == 200
+
+
+# ---------------------------------------------------------------------------
+# Edge cases
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_empty_chain_returns_empty_outcome():
+    out = await chain_augment([], PipelineContext())
+    assert out.prediction is None
+    assert out.final_from == ""
+    assert out.degraded == []
+    assert out.chain_break_warnings == []
+
+
+@pytest.mark.asyncio
+async def test_running_prediction_threaded_via_context_predictions():
+    # Each plugin should see, via its context, the merged prediction from
+    # the plugins that ran before it in the sort order. Asc-order: smaller
+    # priority runs first, so `first` (priority=10) precedes `second` (100).
+    first = _StubPlugin(
+        "first", 10, [PredictStageResponse(predictions=_pd(num_req=42.0))]
+    )
+    second = _StubPlugin("second", 100, [PredictStageResponse()])  # just observes
+    await chain_augment([first, second], PipelineContext())
+    # first sees predictions=None (chain starts fresh); second sees first's output
+    assert first.seen_contexts[0].predictions is None
+    assert second.seen_contexts[0].predictions is not None
+    assert second.seen_contexts[0].predictions.predicted_num_req == 42.0
+
+
+@pytest.mark.asyncio
+async def test_zero_float_value_preserved_not_treated_as_unset():
+    # PredictionData fields are Optional[float]: 0.0 means "I assert 0",
+    # None means "no opinion". Partial-merge must distinguish them.
+    a = _StubPlugin(
+        "A",
+        100,
+        [PredictStageResponse(predictions=_pd(num_req=1000.0, isl=3000.0, osl=150.0))],
+    )
+    b = _StubPlugin("B", 10, [PredictStageResponse(predictions=_pd(num_req=0.0))])
+    out = await chain_augment([a, b], PipelineContext())
+    assert out.prediction is not None
+    assert out.prediction.predicted_num_req == 0.0  # B's assertion survives
+    assert out.prediction.predicted_isl == 3000.0
+    assert out.prediction.predicted_osl == 150.0
+
+
+@pytest.mark.asyncio
+async def test_chain_preserves_initial_context_non_prediction_fields():
+    initial = PipelineContext(request_id="req-42", decision_id="dec-7")
+    spy = _StubPlugin("spy", 10, [PredictStageResponse()])
+    await chain_augment([spy], initial)
+    # The plugin's received context should carry the id fields through.
+    assert spy.seen_contexts[0].request_id == "req-42"
+    assert spy.seen_contexts[0].decision_id == "dec-7"
diff --git a/components/src/dynamo/planner/tests/plugins/merge/test_type_aware_basic.py b/components/src/dynamo/planner/tests/plugins/merge/test_type_aware_basic.py
new file mode 100644
index 000000000000..e75bd90da5b5
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/merge/test_type_aware_basic.py
@@ -0,0 +1,249 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for type_aware_merge basic paths.
+
+Covers the non-short-circuit, non-CONSTRAIN cases:
+- baseline passthrough / AcceptResult passthrough
+- SET recommendation (single + priority tiebreak)
+- AT_LEAST floor (single + max of multi)
+- AT_MOST ceiling (single + min of multi)
+- clamp ordering when floor > ceiling
+- SET clamped by floor / ceiling
+- multi-component independent buckets (prefill vs decode)
+- replicas=None ComponentTarget skipped
+
+Multi-pool bucketing (per-pool ``component_name`` axis) is removed in
+this PR — the single-planner runtime has no consumer.  Cases that
+previously exercised ``(type, name)`` independence are dropped or
+reframed as same-type conflict resolution (e.g. multi-SET in the same
+bucket).  See proto ``ComponentTarget`` reserved-tag 2 note.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.merge import (
+    ComponentKey,
+    MergeOutcome,
+    PluginResult,
+    type_aware_merge,
+)
+from dynamo.planner.plugins.types import (
+    AcceptResult,
+    ComponentTarget,
+    OverrideResult,
+    OverrideType,
+)
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+PREFILL = ComponentKey(sub_component_type="prefill")
+DECODE = ComponentKey(sub_component_type="decode")
+
+
+def _pr(plugin_id, priority, targets, final=False):
+    return PluginResult(
+        plugin_id=plugin_id,
+        priority=priority,
+        result=OverrideResult(targets=list(targets)),
+        final=final,
+    )
+
+
+def _ct(sub_component_type, type_, replicas):
+    return ComponentTarget(
+        sub_component_type=sub_component_type,
+        type=type_,
+        replicas=replicas,
+    )
+
+
+def _replicas_by_key(outcome: MergeOutcome) -> dict[ComponentKey, int]:
+    assert outcome.proposal is not None
+    out: dict[ComponentKey, int] = {}
+    for t in outcome.proposal.targets:
+        key = ComponentKey(sub_component_type=t.sub_component_type)
+        assert t.replicas is not None
+        out[key] = t.replicas
+    return out
+
+
+def test_empty_plugins_passes_through_baseline():
+    out = type_aware_merge([], {PREFILL: 5})
+    assert out.short_circuited is False
+    assert _replicas_by_key(out) == {PREFILL: 5}
+    assert out.used_final_from == ""
+    assert out.set_dropped == []
+
+
+def test_accept_only_passes_through_baseline():
+    out = type_aware_merge(
+        [PluginResult(plugin_id="p1", priority=100, result=AcceptResult())],
+        {PREFILL: 5},
+    )
+    assert _replicas_by_key(out) == {PREFILL: 5}
+
+
+def test_single_set_wins_over_baseline():
+    out = type_aware_merge(
+        [_pr("p1", 100, [_ct("prefill", OverrideType.SET, 8)])],
+        {PREFILL: 5},
+    )
+    assert _replicas_by_key(out) == {PREFILL: 8}
+
+
+def test_multi_set_priority_smallest_wins():
+    # p2 has priority=50 (smaller number = higher priority) -> 10 wins
+    out = type_aware_merge(
+        [
+            _pr("p1", 100, [_ct("prefill", OverrideType.SET, 8)]),
+            _pr("p2", 50, [_ct("prefill", OverrideType.SET, 10)]),
+        ],
+        {PREFILL: 5},
+    )
+    assert _replicas_by_key(out) == {PREFILL: 10}
+
+
+def test_single_at_least_raises_floor_above_baseline():
+    out = type_aware_merge(
+        [_pr("p1", 100, [_ct("prefill", OverrideType.AT_LEAST, 6)])],
+        {PREFILL: 5},
+    )
+    assert _replicas_by_key(out) == {PREFILL: 6}
+
+
+def test_multi_at_least_takes_max():
+    out = type_aware_merge(
+        [
+            _pr("p1", 100, [_ct("prefill", OverrideType.AT_LEAST, 4)]),
+            _pr("p2", 50, [_ct("prefill", OverrideType.AT_LEAST, 7)]),
+        ],
+        {PREFILL: 3},
+    )
+    assert _replicas_by_key(out) == {PREFILL: 7}
+
+
+def test_single_at_most_lowers_ceiling_below_baseline():
+    out = type_aware_merge(
+        [_pr("p1", 100, [_ct("prefill", OverrideType.AT_MOST, 4)])],
+        {PREFILL: 10},
+    )
+    assert _replicas_by_key(out) == {PREFILL: 4}
+
+
+def test_multi_at_most_takes_min():
+    out = type_aware_merge(
+        [
+            _pr("p1", 100, [_ct("prefill", OverrideType.AT_MOST, 8)]),
+            _pr("p2", 50, [_ct("prefill", OverrideType.AT_MOST, 5)]),
+        ],
+        {PREFILL: 10},
+    )
+    assert _replicas_by_key(out) == {PREFILL: 5}
+
+
+def test_floor_wins_when_floor_above_ceiling():
+    # max(floor, min(ceiling, rec)) => floor wins because clamp is outer max.
+    out = type_aware_merge(
+        [
+            _pr("p1", 100, [_ct("prefill", OverrideType.AT_LEAST, 6)]),
+            _pr("p2", 50, [_ct("prefill", OverrideType.AT_MOST, 4)]),
+        ],
+        {PREFILL: 5},
+    )
+    assert _replicas_by_key(out) == {PREFILL: 6}
+
+
+def test_set_raised_by_at_least_floor():
+    # SET=4 below AT_LEAST=6 -> floor pulls it up to 6.
+    out = type_aware_merge(
+        [
+            _pr("p1", 100, [_ct("prefill", OverrideType.SET, 4)]),
+            _pr("p2", 50, [_ct("prefill", OverrideType.AT_LEAST, 6)]),
+        ],
+        {PREFILL: 5},
+    )
+    assert _replicas_by_key(out) == {PREFILL: 6}
+
+
+def test_set_capped_by_at_most_ceiling():
+    # SET=12 above AT_MOST=8 -> ceiling pulls it down to 8.
+    out = type_aware_merge(
+        [
+            _pr("p1", 100, [_ct("prefill", OverrideType.SET, 12)]),
+            _pr("p2", 50, [_ct("prefill", OverrideType.AT_MOST, 8)]),
+        ],
+        {PREFILL: 5},
+    )
+    assert _replicas_by_key(out) == {PREFILL: 8}
+
+
+def test_multi_component_independent_buckets():
+    out = type_aware_merge(
+        [
+            _pr(
+                "p1",
+                100,
+                [
+                    _ct("prefill", OverrideType.SET, 8),
+                    _ct("decode", OverrideType.SET, 4),
+                ],
+            )
+        ],
+        {PREFILL: 5, DECODE: 3},
+    )
+    assert _replicas_by_key(out) == {PREFILL: 8, DECODE: 4}
+
+
+def test_unset_replicas_skipped_falls_back_to_baseline():
+    out = type_aware_merge(
+        [_pr("p1", 100, [_ct("prefill", OverrideType.SET, None)])],
+        {PREFILL: 5},
+    )
+    assert _replicas_by_key(out) == {PREFILL: 5}
+
+
+def test_proposal_source_is_merged_and_no_final_used():
+    out = type_aware_merge(
+        [_pr("p1", 100, [_ct("prefill", OverrideType.SET, 8)])],
+        {PREFILL: 5},
+    )
+    assert out.proposal is not None
+    assert out.proposal.source == "merged"
+    assert out.used_final_from == ""
+    assert out.set_dropped == []
+
+
+def test_baseline_only_key_appears_in_output():
+    # plugin touches prefill; decode only in baseline -> both present.
+    out = type_aware_merge(
+        [_pr("p1", 100, [_ct("prefill", OverrideType.SET, 8)])],
+        {PREFILL: 5, DECODE: 3},
+    )
+    assert _replicas_by_key(out) == {PREFILL: 8, DECODE: 3}
+
+
+def test_final_path_passes_baseline_only_keys_through():
+    # A final plugin that mentions only prefill must NOT drop decode from
+    # the proposal: baseline-only keys pass through (same contract as the
+    # non-final bucket path) so downstream stages see a complete proposal.
+    out = type_aware_merge(
+        [_pr("p1", 100, [_ct("prefill", OverrideType.SET, 8)], final=True)],
+        {PREFILL: 5, DECODE: 3},
+    )
+    assert out.used_final_from == "p1"
+    assert _replicas_by_key(out) == {PREFILL: 8, DECODE: 3}
+
+
+def test_empty_plugins_and_empty_baseline_emits_empty_proposal():
+    out = type_aware_merge([], {})
+    assert out.short_circuited is False
+    assert out.proposal is not None
+    assert out.proposal.targets == []
diff --git a/components/src/dynamo/planner/tests/plugins/merge/test_type_aware_clamp_tracking.py b/components/src/dynamo/planner/tests/plugins/merge/test_type_aware_clamp_tracking.py
new file mode 100644
index 000000000000..7507fe8c1329
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/merge/test_type_aware_clamp_tracking.py
@@ -0,0 +1,248 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tests for ``MergeOutcome.clamped`` population.
+
+Extends existing ``type_aware_merge`` tests to verify the new
+``clamped`` field accurately records which (key, direction, source)
+events should drive RECONCILE/CONSTRAIN clamp counters.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.merge import ComponentKey, PluginResult, type_aware_merge
+from dynamo.planner.plugins.types import ComponentTarget, OverrideResult, OverrideType
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+PREFILL = ComponentKey(sub_component_type="prefill")
+
+
+def _override(plugin_id, priority, override_type, replicas):
+    return PluginResult(
+        plugin_id=plugin_id,
+        priority=priority,
+        result=OverrideResult(
+            targets=[
+                ComponentTarget(
+                    sub_component_type="prefill",
+                    replicas=replicas,
+                    type=override_type,
+                )
+            ]
+        ),
+        final=False,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Empty clamp list when no clamping happens
+# ---------------------------------------------------------------------------
+
+
+def test_clamped_empty_when_no_override_present():
+    outcome = type_aware_merge([], {PREFILL: 2}, set_allowed=True)
+    assert outcome.clamped == []
+
+
+def test_clamped_empty_when_set_matches_bounds():
+    """SET=4 between AT_LEAST=2 and AT_MOST=6 — no clamp fires."""
+    outcome = type_aware_merge(
+        [
+            _override("setter", 1, OverrideType.SET, 4),
+            _override("floor", 2, OverrideType.AT_LEAST, 2),
+            _override("ceiling", 3, OverrideType.AT_MOST, 6),
+        ],
+        {PREFILL: 0},
+        set_allowed=True,
+    )
+    assert outcome.proposal.targets[0].replicas == 4
+    assert outcome.clamped == []
+
+
+# ---------------------------------------------------------------------------
+# Floor clamp (AT_LEAST raised recommendation)
+# ---------------------------------------------------------------------------
+
+
+def test_clamped_records_floor_when_at_least_raises_recommendation():
+    """SET=1, AT_LEAST=5 → result=5, clamped=[(key, 'floor', 'floor_plugin')]."""
+    outcome = type_aware_merge(
+        [
+            _override("set_plugin", 1, OverrideType.SET, 1),
+            _override("floor_plugin", 2, OverrideType.AT_LEAST, 5),
+        ],
+        {PREFILL: 0},
+        set_allowed=True,
+    )
+    assert outcome.proposal.targets[0].replicas == 5
+    assert len(outcome.clamped) == 1
+    key, direction, source = outcome.clamped[0]
+    assert key == PREFILL
+    assert direction == "floor"
+    assert source == "floor_plugin"
+
+
+def test_clamped_floor_uses_winning_at_least_source():
+    """Multiple AT_LEAST — the highest value wins; source labels that plugin."""
+    outcome = type_aware_merge(
+        [
+            _override("set_plugin", 1, OverrideType.SET, 1),
+            _override("weak_floor", 2, OverrideType.AT_LEAST, 2),
+            _override("strong_floor", 3, OverrideType.AT_LEAST, 7),
+            _override("mid_floor", 4, OverrideType.AT_LEAST, 4),
+        ],
+        {PREFILL: 0},
+        set_allowed=True,
+    )
+    assert outcome.proposal.targets[0].replicas == 7
+    assert len(outcome.clamped) == 1
+    assert outcome.clamped[0][2] == "strong_floor"
+
+
+def test_clamped_floor_fires_even_when_baseline_recommendation():
+    """No SET; baseline=1; AT_LEAST=4 → floor clamp still recorded."""
+    outcome = type_aware_merge(
+        [_override("floor", 1, OverrideType.AT_LEAST, 4)],
+        {PREFILL: 1},
+        set_allowed=True,
+    )
+    assert outcome.proposal.targets[0].replicas == 4
+    assert outcome.clamped == [(PREFILL, "floor", "floor")]
+
+
+# ---------------------------------------------------------------------------
+# Ceiling clamp (AT_MOST lowered recommendation)
+# ---------------------------------------------------------------------------
+
+
+def test_clamped_records_ceiling_when_at_most_lowers_recommendation():
+    """SET=10, AT_MOST=3 → result=3, clamped=[(key, 'ceiling', ...)]."""
+    outcome = type_aware_merge(
+        [
+            _override("set_plugin", 1, OverrideType.SET, 10),
+            _override("budget", 2, OverrideType.AT_MOST, 3),
+        ],
+        {PREFILL: 0},
+        set_allowed=True,
+    )
+    assert outcome.proposal.targets[0].replicas == 3
+    assert len(outcome.clamped) == 1
+    key, direction, source = outcome.clamped[0]
+    assert direction == "ceiling"
+    assert source == "budget"
+
+
+def test_clamped_ceiling_uses_tightest_at_most_source():
+    """Multiple AT_MOST — the lowest value wins; source labels that plugin."""
+    outcome = type_aware_merge(
+        [
+            _override("set_plugin", 1, OverrideType.SET, 10),
+            _override("loose_budget", 2, OverrideType.AT_MOST, 8),
+            _override("tight_budget", 3, OverrideType.AT_MOST, 4),
+        ],
+        {PREFILL: 0},
+        set_allowed=True,
+    )
+    assert outcome.proposal.targets[0].replicas == 4
+    assert len(outcome.clamped) == 1
+    assert outcome.clamped[0][2] == "tight_budget"
+
+
+# ---------------------------------------------------------------------------
+# Both floor + ceiling fire when they clamp simultaneously
+# ---------------------------------------------------------------------------
+
+
+def test_clamped_records_only_winning_direction_when_floor_exceeds_ceiling():
+    """Degenerate case: AT_LEAST=7 > AT_MOST=3. Spec: floor wins
+    (result=7). The ceiling ``tried`` to lower the recommendation but
+    the floor overrode it, so the net effect is only a floor clamp.
+    Only the direction that actually changed the output vs
+    recommendation is recorded — dashboards should show "floor clamped
+    this component" but not a ceiling that was itself overridden.
+    """
+    outcome = type_aware_merge(
+        [
+            _override("set_plugin", 1, OverrideType.SET, 1),
+            _override("high_floor", 2, OverrideType.AT_LEAST, 7),
+            _override("tight_budget", 3, OverrideType.AT_MOST, 3),
+        ],
+        {PREFILL: 0},
+        set_allowed=True,
+    )
+    assert outcome.proposal.targets[0].replicas == 7
+    assert len(outcome.clamped) == 1
+    assert outcome.clamped[0][1] == "floor"
+    assert outcome.clamped[0][2] == "high_floor"
+
+
+# ---------------------------------------------------------------------------
+# Multi-key clamps are reported per-key
+# ---------------------------------------------------------------------------
+
+
+DECODE = ComponentKey(sub_component_type="decode")
+
+
+def test_clamped_reports_per_component_independently():
+    def override_for(key, plugin_id, priority, ot, replicas):
+        return PluginResult(
+            plugin_id=plugin_id,
+            priority=priority,
+            result=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type=key.sub_component_type,
+                        replicas=replicas,
+                        type=ot,
+                    )
+                ]
+            ),
+            final=False,
+        )
+
+    outcome = type_aware_merge(
+        [
+            override_for(PREFILL, "set_p", 1, OverrideType.SET, 1),
+            override_for(PREFILL, "floor_p", 2, OverrideType.AT_LEAST, 5),
+            override_for(DECODE, "set_d", 1, OverrideType.SET, 10),
+            override_for(DECODE, "cap_d", 2, OverrideType.AT_MOST, 4),
+        ],
+        {PREFILL: 0, DECODE: 0},
+        set_allowed=True,
+    )
+    keys_clamped = {(k.sub_component_type, d) for k, d, _ in outcome.clamped}
+    assert keys_clamped == {("prefill", "floor"), ("decode", "ceiling")}
+
+
+# ---------------------------------------------------------------------------
+# Short-circuit (REJECT) keeps clamped empty (no merge happened)
+# ---------------------------------------------------------------------------
+
+
+def test_short_circuit_leaves_clamped_empty():
+    from dynamo.planner.plugins.types import RejectResult
+
+    outcome = type_aware_merge(
+        [
+            PluginResult(
+                plugin_id="nope",
+                priority=1,
+                result=RejectResult(reason="no"),
+                final=False,
+            ),
+        ],
+        {PREFILL: 0},
+        set_allowed=True,
+    )
+    assert outcome.short_circuited is True
+    assert outcome.clamped == []
diff --git a/components/src/dynamo/planner/tests/plugins/merge/test_type_aware_constrain.py b/components/src/dynamo/planner/tests/plugins/merge/test_type_aware_constrain.py
new file mode 100644
index 000000000000..e9ec114aaab6
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/merge/test_type_aware_constrain.py
@@ -0,0 +1,133 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for type_aware_merge CONSTRAIN mode.
+
+With ``set_allowed=False`` (CONSTRAIN stage):
+- SET targets are silently dropped from the merge
+- dropped keys are recorded in ``MergeOutcome.set_dropped`` for audit
+- AT_LEAST / AT_MOST bounds merge normally
+
+Register-time static rejection of CONSTRAIN-SET plugins is infeasible
+(proto3 has no plugin-declared output-type metadata); drop + audit is
+the only workable approach.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.merge import (
+    ComponentKey,
+    MergeOutcome,
+    PluginResult,
+    type_aware_merge,
+)
+from dynamo.planner.plugins.types import ComponentTarget, OverrideResult, OverrideType
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+PREFILL = ComponentKey(sub_component_type="prefill")
+DECODE = ComponentKey(sub_component_type="decode")
+
+
+def _pr(plugin_id, priority, targets, final=False):
+    return PluginResult(
+        plugin_id=plugin_id,
+        priority=priority,
+        result=OverrideResult(targets=list(targets)),
+        final=final,
+    )
+
+
+def _ct(sub_component_type, type_, replicas):
+    return ComponentTarget(
+        sub_component_type=sub_component_type,
+        type=type_,
+        replicas=replicas,
+    )
+
+
+def _replicas_by_key(outcome: MergeOutcome) -> dict[ComponentKey, int]:
+    assert outcome.proposal is not None
+    out: dict[ComponentKey, int] = {}
+    for t in outcome.proposal.targets:
+        key = ComponentKey(sub_component_type=t.sub_component_type)
+        assert t.replicas is not None
+        out[key] = t.replicas
+    return out
+
+
+def test_single_set_dropped_and_baseline_passthrough():
+    out = type_aware_merge(
+        [_pr("p1", 100, [_ct("prefill", OverrideType.SET, 8)])],
+        {PREFILL: 5},
+        set_allowed=False,
+    )
+    assert _replicas_by_key(out) == {PREFILL: 5}
+    assert out.set_dropped == [PREFILL]
+
+
+def test_at_least_merges_normally_when_set_disallowed():
+    out = type_aware_merge(
+        [_pr("p1", 100, [_ct("prefill", OverrideType.AT_LEAST, 6)])],
+        {PREFILL: 5},
+        set_allowed=False,
+    )
+    # baseline=5 raised by floor=6
+    assert _replicas_by_key(out) == {PREFILL: 6}
+    assert out.set_dropped == []
+
+
+def test_at_most_merges_normally_when_set_disallowed():
+    out = type_aware_merge(
+        [_pr("p1", 100, [_ct("prefill", OverrideType.AT_MOST, 4)])],
+        {PREFILL: 10},
+        set_allowed=False,
+    )
+    assert _replicas_by_key(out) == {PREFILL: 4}
+    assert out.set_dropped == []
+
+
+def test_mixed_set_and_bounds_drops_only_sets():
+    # p1: prefill SET (dropped) + decode AT_MOST (kept)
+    # p2: decode SET (dropped)
+    # Expected: prefill = baseline 3; decode = baseline 2 clamped by AT_MOST=6 => 2
+    out = type_aware_merge(
+        [
+            _pr(
+                "p1",
+                100,
+                [
+                    _ct("prefill", OverrideType.SET, 12),
+                    _ct("decode", OverrideType.AT_MOST, 6),
+                ],
+            ),
+            _pr("p2", 50, [_ct("decode", OverrideType.SET, 10)]),
+        ],
+        {PREFILL: 3, DECODE: 2},
+        set_allowed=False,
+    )
+    assert _replicas_by_key(out) == {PREFILL: 3, DECODE: 2}
+    # Drop order follows iteration: p1.prefill first, then p2.decode.
+    assert out.set_dropped == [PREFILL, DECODE]
+
+
+def test_duplicate_set_keys_recorded_per_plugin():
+    # Same key SET from two plugins: both recorded in set_dropped so
+    # orchestrator can bump the per-plugin Prometheus counter correctly.
+    out = type_aware_merge(
+        [
+            _pr("p1", 100, [_ct("prefill", OverrideType.SET, 8)]),
+            _pr("p2", 50, [_ct("prefill", OverrideType.SET, 10)]),
+        ],
+        {PREFILL: 5},
+        set_allowed=False,
+    )
+    assert _replicas_by_key(out) == {PREFILL: 5}
+    assert out.set_dropped == [PREFILL, PREFILL]
diff --git a/components/src/dynamo/planner/tests/plugins/merge/test_type_aware_short_circuit.py b/components/src/dynamo/planner/tests/plugins/merge/test_type_aware_short_circuit.py
new file mode 100644
index 000000000000..86c139bda4ed
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/merge/test_type_aware_short_circuit.py
@@ -0,0 +1,237 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for type_aware_merge REJECT short-circuit + final paths.
+
+REJECT matrix (REJECT > final priority):
+- single REJECT → short_circuited, proposal=None, reason includes plugin_id
+- REJECT + other SET → still short-circuits
+- REJECT + final OverrideResult → still short-circuits
+- multiple REJECTs → short_circuit_reason reflects the first one
+
+final matrix (priority rule for PROPOSE/RECONCILE):
+- single final SET → that plugin's targets become the proposal verbatim
+- multiple finals → priority-smallest wins
+- final + non-final bounds → non-final entries discarded
+- final with AT_LEAST only → proposal carries that AT_LEAST target verbatim
+- final in CONSTRAIN (set_allowed=False) → SET dropped, set_dropped recorded,
+  used_final_from still set (final remains authoritative for non-SET targets)
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.merge import ComponentKey, PluginResult, type_aware_merge
+from dynamo.planner.plugins.types import (
+    ComponentTarget,
+    OverrideResult,
+    OverrideType,
+    RejectResult,
+)
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+PREFILL = ComponentKey(sub_component_type="prefill")
+DECODE = ComponentKey(sub_component_type="decode")
+
+
+def _reject(plugin_id, priority, reason):
+    return PluginResult(
+        plugin_id=plugin_id,
+        priority=priority,
+        result=RejectResult(reason=reason),
+    )
+
+
+def _override(plugin_id, priority, targets, final=False):
+    return PluginResult(
+        plugin_id=plugin_id,
+        priority=priority,
+        result=OverrideResult(targets=list(targets)),
+        final=final,
+    )
+
+
+def _ct(sub_component_type, type_, replicas):
+    return ComponentTarget(
+        sub_component_type=sub_component_type,
+        type=type_,
+        replicas=replicas,
+    )
+
+
+# ---------------------------------------------------------------------------
+# REJECT short-circuit matrix
+# ---------------------------------------------------------------------------
+
+
+def test_single_reject_short_circuits():
+    out = type_aware_merge(
+        [_reject("p1", 100, "over-capacity")],
+        {PREFILL: 5},
+    )
+    assert out.short_circuited is True
+    assert out.proposal is None
+    assert "p1" in out.short_circuit_reason
+    assert "over-capacity" in out.short_circuit_reason
+
+
+def test_reject_with_other_set_still_short_circuits():
+    out = type_aware_merge(
+        [
+            _override("p1", 100, [_ct("prefill", OverrideType.SET, 8)]),
+            _reject("p2", 50, "nope"),
+        ],
+        {PREFILL: 5},
+    )
+    assert out.short_circuited is True
+    assert out.proposal is None
+
+
+def test_reject_outranks_final():
+    # REJECT > final priority even when final is priority-small.
+    out = type_aware_merge(
+        [
+            _override("p1", 10, [_ct("prefill", OverrideType.SET, 8)], final=True),
+            _reject("p2", 100, "safety veto"),
+        ],
+        {PREFILL: 5},
+    )
+    assert out.short_circuited is True
+    assert out.proposal is None
+    assert out.used_final_from == ""
+
+
+def test_multiple_rejects_reports_first_encountered():
+    out = type_aware_merge(
+        [
+            _reject("p1", 100, "first"),
+            _reject("p2", 50, "second"),
+        ],
+        {PREFILL: 5},
+    )
+    assert out.short_circuited is True
+    assert "p1" in out.short_circuit_reason
+    assert "first" in out.short_circuit_reason
+    assert "p2" not in out.short_circuit_reason
+
+
+# ---------------------------------------------------------------------------
+# final priority matrix
+# ---------------------------------------------------------------------------
+
+
+def test_single_final_overrides_all():
+    # p1 final SET=8; p2 non-final SET=10 (priority-smaller) discarded.
+    out = type_aware_merge(
+        [
+            _override("p1", 100, [_ct("prefill", OverrideType.SET, 8)], final=True),
+            _override("p2", 50, [_ct("prefill", OverrideType.SET, 10)]),
+        ],
+        {PREFILL: 5},
+    )
+    assert out.proposal is not None
+    assert out.used_final_from == "p1"
+    assert out.proposal.source == "p1"
+    assert len(out.proposal.targets) == 1
+    assert out.proposal.targets[0].replicas == 8
+
+
+def test_multiple_finals_priority_smallest_wins():
+    # Both final; p2 has smaller priority (higher precedence) -> its SET wins.
+    out = type_aware_merge(
+        [
+            _override("p1", 100, [_ct("prefill", OverrideType.SET, 8)], final=True),
+            _override("p2", 50, [_ct("prefill", OverrideType.SET, 10)], final=True),
+        ],
+        {PREFILL: 5},
+    )
+    assert out.proposal is not None
+    assert out.used_final_from == "p2"
+    assert out.proposal.targets[0].replicas == 10
+
+
+def test_final_discards_non_final_bounds():
+    # final's OverrideResult is taken verbatim; non-final AT_LEAST/AT_MOST
+    # from other plugins are fully ignored (no clamp).
+    out = type_aware_merge(
+        [
+            _override("p1", 100, [_ct("prefill", OverrideType.SET, 8)], final=True),
+            _override("p2", 50, [_ct("prefill", OverrideType.AT_LEAST, 20)]),
+            _override("p3", 30, [_ct("prefill", OverrideType.AT_MOST, 4)]),
+        ],
+        {PREFILL: 5},
+    )
+    assert out.proposal is not None
+    assert out.used_final_from == "p1"
+    assert len(out.proposal.targets) == 1
+    assert out.proposal.targets[0].replicas == 8
+    assert out.proposal.targets[0].type == OverrideType.SET
+
+
+def test_final_with_at_least_only_preserves_type():
+    # ScalingProposal.ComponentTarget.type is unused downstream but the
+    # verbatim-passthrough contract should preserve whatever the final
+    # plugin emitted.
+    out = type_aware_merge(
+        [
+            _override(
+                "p1",
+                100,
+                [_ct("prefill", OverrideType.AT_LEAST, 7)],
+                final=True,
+            ),
+        ],
+        {PREFILL: 5},
+    )
+    assert out.proposal is not None
+    assert out.used_final_from == "p1"
+    assert len(out.proposal.targets) == 1
+    assert out.proposal.targets[0].type == OverrideType.AT_LEAST
+    assert out.proposal.targets[0].replicas == 7
+
+
+def test_final_in_constrain_drops_set_but_final_still_applied():
+    # CONSTRAIN + final containing SET + AT_MOST:
+    # - SET prefill dropped and recorded in set_dropped
+    # - AT_MOST decode preserved
+    # - prefill is NOT lost: it passes through at the baseline value (3),
+    #   matching the non-final bucket path's baseline-passthrough contract so
+    #   the constrained proposal stays complete
+    # - used_final_from set (final still authoritative for non-SET entries)
+    out = type_aware_merge(
+        [
+            _override(
+                "p1",
+                100,
+                [
+                    _ct("prefill", OverrideType.SET, 8),
+                    _ct("decode", OverrideType.AT_MOST, 4),
+                ],
+                final=True,
+            ),
+        ],
+        {PREFILL: 3, DECODE: 2},
+        set_allowed=False,
+    )
+    assert out.proposal is not None
+    assert out.used_final_from == "p1"
+    assert out.set_dropped == [PREFILL]
+
+    remaining = [
+        (t.sub_component_type, t.type, t.replicas) for t in out.proposal.targets
+    ]
+    assert ("decode", OverrideType.AT_MOST, 4) in remaining
+    # The dropped SET prefill does not erase prefill from the proposal: it
+    # reappears via baseline passthrough at the current value (3).
+    prefill_targets = [
+        t for t in out.proposal.targets if t.sub_component_type == "prefill"
+    ]
+    assert len(prefill_targets) == 1
+    assert prefill_targets[0].replicas == 3
diff --git a/components/src/dynamo/planner/tests/plugins/merge/test_type_aware_worked_examples.py b/components/src/dynamo/planner/tests/plugins/merge/test_type_aware_worked_examples.py
new file mode 100644
index 000000000000..1c2291d0ca16
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/merge/test_type_aware_worked_examples.py
@@ -0,0 +1,170 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Worked example verbatim assertions.
+
+This file is the **source of truth** for type_aware_merge behaviour. The 9
+cases below mirror the worked example table in the design doc PROPOSE
+section verbatim — any edit to that table MUST come with a matching
+edit here (and vice versa). Test IDs match the ``case_name`` so CI output
+points directly at the offending case.
+
+Helpers ``PR`` / ``OR`` / ``CT`` / ``key`` are named to make each row read
+like the source table:
+
+    PR("p1", 100, OR([CT("prefill", SET, 8)]))
+    key("prefill", "pool-A")
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.merge import ComponentKey, PluginResult, type_aware_merge
+from dynamo.planner.plugins.types import ComponentTarget, OverrideResult, OverrideType
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+SET = OverrideType.SET
+AT_LEAST = OverrideType.AT_LEAST
+AT_MOST = OverrideType.AT_MOST
+
+
+def PR(plugin_id, priority, result, final=False):
+    return PluginResult(
+        plugin_id=plugin_id, priority=priority, result=result, final=final
+    )
+
+
+def OR(targets):
+    return OverrideResult(targets=list(targets))
+
+
+def CT(sub_component_type, type_, replicas):
+    return ComponentTarget(
+        sub_component_type=sub_component_type,
+        type=type_,
+        replicas=replicas,
+    )
+
+
+def key(sub_component_type):
+    return ComponentKey(sub_component_type=sub_component_type)
+
+
+WORKED_EXAMPLES = [
+    # (case_name, plugin_results, baseline, expected_replicas_by_key)
+    # -- Single-component rows --
+    (
+        "only_baseline",
+        [],
+        {key("prefill"): 5},
+        {key("prefill"): 5},
+    ),
+    (
+        "only_set",
+        [PR("p1", 100, OR([CT("prefill", SET, 8)]))],
+        {key("prefill"): 5},
+        {key("prefill"): 8},
+    ),
+    (
+        "set_priority_wins",
+        [
+            PR("p1", 100, OR([CT("prefill", SET, 8)])),
+            PR("p2", 50, OR([CT("prefill", SET, 10)])),
+        ],
+        {key("prefill"): 5},
+        # p2 priority=50 (smaller number = higher precedence) -> 10 wins.
+        {key("prefill"): 10},
+    ),
+    (
+        "set_with_at_least_floor",
+        [
+            PR("p1", 100, OR([CT("prefill", SET, 4)])),
+            PR("p2", 50, OR([CT("prefill", AT_LEAST, 6)])),
+        ],
+        {key("prefill"): 5},
+        # SET=4 pulled up to floor=6.
+        {key("prefill"): 6},
+    ),
+    (
+        "set_with_at_most_ceiling",
+        [
+            PR("p1", 100, OR([CT("prefill", SET, 12)])),
+            PR("p2", 50, OR([CT("prefill", AT_MOST, 8)])),
+        ],
+        {key("prefill"): 5},
+        # SET=12 clamped down to ceiling=8.
+        {key("prefill"): 8},
+    ),
+    # -- Multi-component rows --
+    (
+        "multi_component_independent",
+        [
+            PR(
+                "p1",
+                100,
+                OR([CT("prefill", SET, 8), CT("decode", SET, 4)]),
+            )
+        ],
+        {key("prefill"): 5, key("decode"): 3},
+        {key("prefill"): 8, key("decode"): 4},
+    ),
+    (
+        "multi_component_mixed_types",
+        [
+            PR(
+                "p1",
+                100,
+                OR([CT("prefill", SET, 8), CT("decode", AT_MOST, 6)]),
+            ),
+            PR("p2", 50, OR([CT("decode", SET, 10)])),
+        ],
+        {key("prefill"): 5, key("decode"): 3},
+        # decode SET=10 clamped down to AT_MOST=6.
+        {key("prefill"): 8, key("decode"): 6},
+    ),
+    # -- final verbatim override --
+    (
+        "final_override_completely",
+        [
+            PR("p1", 100, OR([CT("prefill", SET, 8)]), final=True),
+            PR("p2", 50, OR([CT("prefill", SET, 10)])),
+            PR("p3", 30, OR([CT("prefill", AT_MOST, 4)])),
+        ],
+        {key("prefill"): 5},
+        # p1 final=True: its target wins verbatim; p2/p3 fully discarded.
+        {key("prefill"): 8},
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "case_name,plugin_results,baseline,expected",
+    WORKED_EXAMPLES,
+    ids=[c[0] for c in WORKED_EXAMPLES],
+)
+def test_worked_example(case_name, plugin_results, baseline, expected):
+    out = type_aware_merge(plugin_results, baseline, set_allowed=True)
+    assert (
+        out.proposal is not None
+    ), f"case={case_name}: proposal unexpectedly None (short_circuited={out.short_circuited})"
+    actual = {
+        ComponentKey(sub_component_type=t.sub_component_type): t.replicas
+        for t in out.proposal.targets
+    }
+    assert actual == expected, f"case={case_name}: expected={expected}, got={actual}"
+
+
+def test_worked_examples_count_matches_main_doc():
+    # Tripwire: PROPOSE worked-example table currently covers 8 cases.
+    # The hierarchical-pools case is removed in this PR alongside the
+    # ``component_name`` strip — re-add when the hierarchical planner
+    # PR lands.  Bump the assertion intentionally on each table change
+    # so a doc/test drift is impossible to slip by.
+    assert len(WORKED_EXAMPLES) == 8
diff --git a/components/src/dynamo/planner/tests/plugins/orchestrator/__init__.py b/components/src/dynamo/planner/tests/plugins/orchestrator/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/orchestrator/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/tests/plugins/orchestrator/_fake_in_process_plugin.py b/components/src/dynamo/planner/tests/plugins/orchestrator/_fake_in_process_plugin.py
new file mode 100644
index 000000000000..2779a0a40fca
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/orchestrator/_fake_in_process_plugin.py
@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Fake in-process plugin module consumed by test_in_process_loader.
+
+The loader imports this module by path and constructs ``FakePlugin``
+with the configured ``kwargs``.
+"""
+
+from __future__ import annotations
+
+from dynamo.planner.plugins.types import AcceptResult, ProposeStageResponse
+
+
+class FakePlugin:
+    def __init__(self, tag: str = "default"):
+        self.tag = tag
+
+    async def Propose(self, request):
+        return ProposeStageResponse(result_kind="accept", accept=AcceptResult())
diff --git a/components/src/dynamo/planner/tests/plugins/orchestrator/conftest.py b/components/src/dynamo/planner/tests/plugins/orchestrator/conftest.py
new file mode 100644
index 000000000000..891a50d0a806
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/orchestrator/conftest.py
@@ -0,0 +1,120 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Shared fixtures and stub plugins for orchestrator tests."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Callable, Optional
+
+import pytest
+
+from dynamo.planner.plugins.clock import VirtualClock
+from dynamo.planner.plugins.orchestrator.orchestrator import LocalPlannerOrchestrator
+from dynamo.planner.plugins.registry.auth import AllowUnauthenticatedAuth
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+from dynamo.planner.plugins.registry.server import PluginRegistryServer
+from dynamo.planner.plugins.scheduler import PluginScheduler
+from dynamo.planner.plugins.transport.config import (
+    TransportConfig,
+    make_transport_for_endpoint,
+)
+
+
+@pytest.fixture
+def clock():
+    return VirtualClock()
+
+
+@pytest.fixture
+def ctx_factory():
+    """Build a fresh registry / scheduler / orchestrator triplet.
+
+    Returned callable yields a dict with ``orchestrator`` / ``registry``
+    / ``scheduler`` / ``circuit_breaker`` / ``clock`` so individual
+    tests can interact with whichever layer is relevant.
+    """
+
+    def _make(
+        *,
+        failure_threshold: int = 3,
+        cooldown_seconds: float = 30.0,
+        tick_max_duration_seconds: float = 30.0,
+    ):
+        clk = VirtualClock()
+        cb = CircuitBreaker(
+            clk, failure_threshold=failure_threshold, cooldown_seconds=cooldown_seconds
+        )
+        transport_config = TransportConfig(request_timeout_seconds=1.0)
+
+        def factory(plugin_id, endpoint, *, in_process_instance=None):
+            return make_transport_for_endpoint(
+                plugin_id,
+                endpoint,
+                transport_config,
+                in_process_instance=in_process_instance,
+            )
+
+        server = PluginRegistryServer(
+            clock=clk,
+            auth=AllowUnauthenticatedAuth(),
+            circuit_breaker=cb,
+            transport_factory=factory,
+        )
+        scheduler = PluginScheduler(server, cb, clk)
+        orchestrator = LocalPlannerOrchestrator(
+            registry=server,
+            scheduler=scheduler,
+            circuit_breaker=cb,
+            clock=clk,
+            tick_max_duration_seconds=tick_max_duration_seconds,
+        )
+        return {
+            "orchestrator": orchestrator,
+            "registry": server,
+            "scheduler": scheduler,
+            "circuit_breaker": cb,
+            "clock": clk,
+        }
+
+    return _make
+
+
+class StubPlugin:
+    """A plugin object with per-method response handlers.
+
+    Pass one handler per stage as ``async def fn(request) -> Response``.
+    Missing methods cause ``PluginUnknownMethodError`` from the
+    InProcessTransport, which the pipeline treats as a plugin failure.
+    """
+
+    def __init__(
+        self,
+        *,
+        predict: Optional[Callable[[Any], Any]] = None,
+        propose: Optional[Callable[[Any], Any]] = None,
+        reconcile: Optional[Callable[[Any], Any]] = None,
+        constrain: Optional[Callable[[Any], Any]] = None,
+    ) -> None:
+        self._handlers = {
+            "Predict": predict,
+            "Propose": propose,
+            "Reconcile": reconcile,
+            "Constrain": constrain,
+        }
+        self.call_counts: dict[str, int] = {method: 0 for method in self._handlers}
+
+    def __getattr__(self, name: str):
+        handler = self._handlers.get(name)
+        if handler is None:
+            raise AttributeError(name)
+
+        async def call(request):
+            self.call_counts[name] += 1
+            result = handler(request)
+            if asyncio.iscoroutine(result):
+                return await result
+            return result
+
+        return call
diff --git a/components/src/dynamo/planner/tests/plugins/orchestrator/test_concurrency.py b/components/src/dynamo/planner/tests/plugins/orchestrator/test_concurrency.py
new file mode 100644
index 000000000000..a1b02b0c2342
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/orchestrator/test_concurrency.py
@@ -0,0 +1,299 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Concurrency / failure / timeout tests.
+
+These exercise the pipeline's `asyncio.gather` semantics:
+
+- Multiple PROPOSE plugins run concurrently (elapsed ≈ max, not sum).
+- A per-plugin timeout (PluginTimeoutError from the transport) records
+  a failure on the circuit breaker without failing other plugins.
+- A per-plugin exception path likewise records a failure.
+- Enough consecutive failures OPEN the circuit → plugin drops from
+  subsequent active sets.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+
+import pytest
+
+from dynamo.planner.plugins.merge.types import ComponentKey
+from dynamo.planner.plugins.types import (
+    AcceptResult,
+    CircuitState,
+    ComponentTarget,
+    OverrideResult,
+    OverrideType,
+    PipelineContext,
+    ProposeStageResponse,
+)
+
+from .conftest import StubPlugin
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+PREFILL = ComponentKey(sub_component_type="prefill")
+
+
+def _override(replicas):
+    def handler(req):
+        return ProposeStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type="prefill",
+                        replicas=replicas,
+                        type=OverrideType.SET,
+                    )
+                ]
+            ),
+        )
+
+    return handler
+
+
+# ---------------------------------------------------------------------------
+# asyncio.gather parallelism
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_multiple_propose_plugins_run_concurrently(ctx_factory):
+    ctx = ctx_factory(tick_max_duration_seconds=10.0)
+    orchestrator = ctx["orchestrator"]
+
+    DELAY = 0.05
+
+    async def slow_handler(req):
+        await asyncio.sleep(DELAY)
+        return ProposeStageResponse(result_kind="accept", accept=AcceptResult())
+
+    for i in range(5):
+        orchestrator.register_internal(
+            plugin_id=f"p{i}",
+            plugin_type="propose",
+            priority=10 + i,
+            instance=StubPlugin(propose=slow_handler),
+        )
+
+    started = time.perf_counter()
+    await orchestrator.tick(PipelineContext(), {PREFILL: 3})
+    elapsed = time.perf_counter() - started
+    # 5 plugins × 50ms serial would be 250ms; concurrent should be closer
+    # to 50ms. Assert well under the serial lower bound with generous CI margin.
+    assert (
+        elapsed < DELAY * 3
+    ), f"expected concurrent execution (~{DELAY}s), got {elapsed:.3f}s"
+
+
+# ---------------------------------------------------------------------------
+# Per-plugin failure paths
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_one_plugin_raises_others_continue(ctx_factory):
+    ctx = ctx_factory()
+    orchestrator = ctx["orchestrator"]
+    cb = ctx["circuit_breaker"]
+
+    def raising_handler(req):
+        raise RuntimeError("boom")
+
+    orchestrator.register_internal(
+        plugin_id="bad",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=raising_handler),
+    )
+    orchestrator.register_internal(
+        plugin_id="good",
+        plugin_type="propose",
+        priority=5,
+        instance=StubPlugin(propose=_override(8)),
+    )
+
+    outcome = await orchestrator.tick(PipelineContext(), {PREFILL: 3})
+    # good plugin's SET won; bad plugin's failure recorded but didn't short-circuit.
+    assert outcome.execute_action == "apply"
+    assert outcome.final_proposal.targets[0].replicas == 8
+    # Circuit breaker noticed the failure on "bad".
+    assert cb.state("good") == CircuitState.CLOSED
+    # After one failure on "bad", state still CLOSED (default threshold > 1).
+    assert cb.state("bad") == CircuitState.CLOSED
+
+
+@pytest.mark.asyncio
+async def test_plugin_timeout_records_failure_without_tripping_tick(ctx_factory):
+    # per-plugin timeout: InProcessTransport timeout=1.0s (from conftest);
+    # slow handler exceeds it, transport raises PluginTimeoutError.
+    ctx = ctx_factory(tick_max_duration_seconds=5.0)
+    orchestrator = ctx["orchestrator"]
+
+    async def slow_handler(req):
+        await asyncio.sleep(2.0)  # > transport timeout 1.0s
+        return ProposeStageResponse(result_kind="accept", accept=AcceptResult())
+
+    orchestrator.register_internal(
+        plugin_id="slow",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=slow_handler),
+    )
+    orchestrator.register_internal(
+        plugin_id="fast",
+        plugin_type="propose",
+        priority=5,
+        instance=StubPlugin(propose=_override(12)),
+    )
+
+    outcome = await orchestrator.tick(PipelineContext(), {PREFILL: 3})
+    # fast plugin's SET won; slow timed out, didn't drag the whole tick.
+    assert outcome.execute_action == "apply"
+    assert outcome.final_proposal.targets[0].replicas == 12
+
+
+@pytest.mark.asyncio
+async def test_repeated_failures_open_circuit_drops_plugin_from_active_set(
+    ctx_factory,
+):
+    ctx = ctx_factory(failure_threshold=2)
+    orchestrator = ctx["orchestrator"]
+    cb = ctx["circuit_breaker"]
+
+    def raising_handler(req):
+        raise RuntimeError("boom")
+
+    orchestrator.register_internal(
+        plugin_id="flaky",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=raising_handler),
+    )
+    orchestrator.register_internal(
+        plugin_id="steady",
+        plugin_type="propose",
+        priority=5,
+        instance=StubPlugin(propose=_override(4)),
+    )
+
+    # Two ticks → "flaky" accumulates failures → circuit OPEN.
+    await orchestrator.tick(PipelineContext(), {PREFILL: 3})
+    await orchestrator.tick(PipelineContext(), {PREFILL: 3})
+    assert cb.state("flaky") == CircuitState.OPEN
+
+    # Third tick: "flaky" not in active set; no new failure recorded.
+    outcome = await orchestrator.tick(PipelineContext(), {PREFILL: 3})
+    assert outcome.execute_action == "apply"
+    assert outcome.final_proposal.targets[0].replicas == 4
+    # "flaky" still OPEN (it wasn't even called this tick).
+    assert cb.state("flaky") == CircuitState.OPEN
+
+
+# ---------------------------------------------------------------------------
+# Pairing regression: plugins + results matched by position via zip
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_M1_priority_paired_by_position_not_result_backref(ctx_factory):
+    # If the pipeline were assuming a backreference from result to plugin,
+    # it would fail to use the priority correctly when raw responses don't
+    # carry plugin identity. Verify: two SET responses with different
+    # priorities → priority-smaller wins; result objects themselves have
+    # no priority field so this confirms the zip(plugins, results) pattern.
+    ctx = ctx_factory()
+    ctx["orchestrator"].register_internal(
+        plugin_id="low_prio",
+        plugin_type="propose",
+        priority=100,
+        instance=StubPlugin(propose=_override(5)),
+    )
+    ctx["orchestrator"].register_internal(
+        plugin_id="high_prio",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=_override(50)),
+    )
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 1})
+    # high_prio (priority-smaller number) wins.
+    assert outcome.final_proposal.targets[0].replicas == 50
+
+
+@pytest.mark.asyncio
+async def test_registry_mutation_during_in_flight_tick_uses_pretick_snapshot(
+    ctx_factory,
+):
+    """No-locks invariant guard: a stage snapshots its active set up front
+    (``compute_active_set`` → ``all_plugins()``) with no ``await`` between
+    snapshot and mutation, so registering a plugin while a tick is suspended
+    mid-``gather`` must NOT inject it into the in-flight stage or corrupt the
+    tick. ``test_concurrency`` previously only covered gather parallelism +
+    circuit-breaker accumulation; nothing exercised a registry mutation
+    racing a suspended tick despite the prominent invariant in
+    scheduler.py / server.py."""
+    ctx = ctx_factory()
+    orch = ctx["orchestrator"]
+
+    release = asyncio.Event()
+    slow_seen = {"count": 0}
+
+    async def slow_propose(req):
+        slow_seen["count"] += 1
+        await release.wait()  # suspend the PROPOSE gather here
+        return ProposeStageResponse(result_kind="accept", accept=AcceptResult())
+
+    orch.register_internal(
+        plugin_id="slow",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=slow_propose),
+    )
+
+    late = StubPlugin(propose=_override(99))
+
+    tick_task = asyncio.create_task(orch.tick(PipelineContext(), {PREFILL: 3}))
+
+    # Let the tick start and suspend inside the slow plugin's await.
+    for _ in range(50):
+        await asyncio.sleep(0)
+        if slow_seen["count"]:
+            break
+    assert slow_seen["count"] == 1, "tick did not reach the slow plugin"
+
+    # Mutate the registry while the PROPOSE gather is suspended.
+    orch.register_internal(
+        plugin_id="late",
+        plugin_type="propose",
+        priority=5,
+        instance=late,
+    )
+
+    release.set()
+    outcome = await tick_task  # must not raise
+
+    # The late plugin registered after PROPOSE snapshotted its active set,
+    # so it must not have been called in this tick.
+    assert late.call_counts["Propose"] == 0
+    assert outcome.execute_action in (
+        "apply",
+        "skip_no_targets",
+        "skip_short_circuit",
+        "skip_tick_timeout",
+    )
+
+    # Sanity: a fresh tick now sees the late plugin (priority 5 wins its SET).
+    outcome2 = await orch.tick(PipelineContext(), {PREFILL: 3})
+    assert late.call_counts["Propose"] == 1
+    assert outcome2.final_proposal is not None
+    assert outcome2.final_proposal.targets[0].replicas == 99
diff --git a/components/src/dynamo/planner/tests/plugins/orchestrator/test_engine_adapter.py b/components/src/dynamo/planner/tests/plugins/orchestrator/test_engine_adapter.py
new file mode 100644
index 000000000000..ae4fdb410511
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/orchestrator/test_engine_adapter.py
@@ -0,0 +1,695 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Regression tests for ``OrchestratorEngineAdapter`` cadence parity.
+
+Covers PSM-parity bugs caught after K8s smoke / dual-path review:
+
+- ``initial_tick`` previously read ``self._config.throughput_adjustment_interval``
+  (missing ``_seconds`` suffix). The Pydantic ``validation_alias`` only affects
+  input parsing — attribute access requires the canonical name. Triggered an
+  ``AttributeError`` whenever ``enable_throughput_scaling=True``.
+
+- ``_MERGE_TOLERANCE_S`` was set to ``1e-9`` (float epsilon framing) instead
+  of PSM's ``0.5`` (wall-clock-drift padding). With the tight tolerance a
+  load tick and a throughput tick scheduled within ~ms of each other failed
+  to merge — splitting into 2 ticks where PSM produces 1.
+
+- Hard-coded ``WallClock`` broke replay: plugin scheduler / CircuitBreaker
+  / HOLD_LAST cache all read ``self._clock.monotonic()``, but replay
+  fast-forwards trace time without advancing real wall-clock. Adapter now
+  accepts an injectable ``Clock`` and bumps it to ``tick_input.now_s`` on
+  every tick when the clock is manually-advanced (``VirtualClock``).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.config.planner_config import PlannerConfig
+from dynamo.planner.core.types import (
+    EngineCapabilities,
+    FpmObservations,
+    ScheduledTick,
+    TickInput,
+    TrafficObservation,
+    WorkerCapabilities,
+    WorkerCounts,
+)
+from dynamo.planner.plugins.clock import VirtualClock
+from dynamo.planner.plugins.orchestrator.engine_adapter import OrchestratorEngineAdapter
+from dynamo.planner.plugins.orchestrator.pipeline import PipelineOutcome
+from dynamo.planner.plugins.types import ComponentTarget, ScalingProposal
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+def _caps() -> WorkerCapabilities:
+    return WorkerCapabilities(
+        decode=EngineCapabilities(
+            num_gpu=1, max_num_batched_tokens=2048, max_kv_tokens=16384
+        )
+    )
+
+
+def _agg_config_throughput_on() -> PlannerConfig:
+    # SLA mode keeps ``enable_throughput_scaling=True`` honored;
+    # easy modes (``optimization_target="throughput"`` / ``"load"``)
+    # silently force it back to False during config validation.
+    return PlannerConfig(
+        mode="agg",
+        enable_load_scaling=True,
+        enable_throughput_scaling=True,
+        optimization_target="sla",
+        served_model_name="test",
+    )
+
+
+def _disagg_caps() -> WorkerCapabilities:
+    return WorkerCapabilities(
+        prefill=EngineCapabilities(
+            num_gpu=1, max_num_batched_tokens=2048, max_kv_tokens=16384
+        ),
+        decode=EngineCapabilities(
+            num_gpu=1, max_num_batched_tokens=2048, max_kv_tokens=16384
+        ),
+    )
+
+
+def _disagg_config_sla() -> PlannerConfig:
+    return PlannerConfig(
+        mode="disagg",
+        enable_load_scaling=True,
+        enable_throughput_scaling=True,
+        optimization_target="sla",
+        served_model_name="test",
+    )
+
+
+def _make_fpm(worker_id: str = "w1", dp_rank: int = 0):
+    from dynamo.common.forward_pass_metrics import (
+        ForwardPassMetrics,
+        QueuedRequestMetrics,
+        ScheduledRequestMetrics,
+    )
+
+    return ForwardPassMetrics(
+        worker_id=worker_id,
+        dp_rank=dp_rank,
+        wall_time=0.01,
+        scheduled_requests=ScheduledRequestMetrics(
+            sum_prefill_tokens=0,
+            num_prefill_requests=0,
+            sum_decode_kv_tokens=100,
+            num_decode_requests=1,
+        ),
+        queued_requests=QueuedRequestMetrics(
+            sum_prefill_tokens=0,
+            sum_decode_kv_tokens=0,
+        ),
+    )
+
+
+def _build_real_regression(cfg: PlannerConfig, caps: WorkerCapabilities, kind: str):
+    """Build a regression the exact way production does.
+
+    A ``PlannerStateMachine`` in SLA mode constructs ``PlannerEnginePerfModel``
+    instances in its ``_{agg,prefill,decode}_regression`` slots — the same
+    objects the orchestrator path installs via ``install_regressions``. We
+    reuse that construction so the test exercises the real type (which only
+    exposes ``add_observations``, never the singular ``add_observation``).
+    """
+    from dynamo.planner.core.state_machine import PlannerStateMachine
+
+    psm = PlannerStateMachine(cfg, caps)
+    return getattr(psm, f"_{kind}_regression")
+
+
+def test_observe_fpm_feeds_installed_regression_without_crashing_agg():
+    """Regression guard for the add_observation→add_observations P1.
+
+    The orchestrator FPM-observation feed (``_observe_fpm``) is reached on
+    every SLA-mode load tick when ``fpm_observations`` is non-empty and a
+    regression is installed. The regression slots hold
+    ``PlannerEnginePerfModel``, which exposes only ``add_observations(dict)``
+    — the pre-fix singular ``add_observation(fpm)`` raised AttributeError
+    and crashed the tick. No unit test or K8s smoke exercised this exact
+    combination (SLA + live FPM + installed regression), so the crash
+    shipped silently. Feed a *real* ``PlannerEnginePerfModel`` (built the
+    same way PSM builds it) and assert ``_observe_fpm`` does not raise.
+    """
+    cfg = _agg_config_throughput_on()  # agg, SLA
+    caps = _caps()
+    adapter = OrchestratorEngineAdapter(cfg, caps)
+    adapter.install_regressions(agg=_build_real_regression(cfg, caps, "agg"))
+    assert adapter._orchestrator.get_regression("agg") is not None
+
+    # Pre-fix this raised:
+    #   AttributeError: 'PlannerEnginePerfModel' object has no attribute
+    #   'add_observation'
+    adapter._observe_fpm(FpmObservations(decode={("w1", 0): _make_fpm()}))
+
+
+def test_observe_fpm_feeds_installed_regression_without_crashing_disagg():
+    """Same guard for the disagg prefill+decode branches of ``_observe_fpm``."""
+    cfg = _disagg_config_sla()
+    caps = _disagg_caps()
+    adapter = OrchestratorEngineAdapter(cfg, caps)
+    adapter.install_regressions(
+        prefill=_build_real_regression(cfg, caps, "prefill"),
+        decode=_build_real_regression(cfg, caps, "decode"),
+    )
+    assert adapter._orchestrator.get_regression("prefill") is not None
+    assert adapter._orchestrator.get_regression("decode") is not None
+
+    adapter._observe_fpm(
+        FpmObservations(
+            prefill={("p1", 0): _make_fpm("p1")},
+            decode={("d1", 0): _make_fpm("d1")},
+        )
+    )
+
+
+def _apply_outcome(targets):
+    return PipelineOutcome(
+        execute_action="apply",
+        final_proposal=ScalingProposal(targets=targets),
+    )
+
+
+def test_project_scale_to_both_components_changed():
+    # apply + prefill & decode both differ from current → full decision.
+    wc = WorkerCounts(ready_num_prefill=2, ready_num_decode=4)
+    outcome = _apply_outcome(
+        [
+            ComponentTarget(sub_component_type="prefill", replicas=6),
+            ComponentTarget(sub_component_type="decode", replicas=8),
+        ]
+    )
+    dec = OrchestratorEngineAdapter._project_scale_to(outcome, wc)
+    assert dec is not None
+    assert dec.num_prefill == 6
+    assert dec.num_decode == 8
+
+
+def test_project_scale_to_no_change_returns_none():
+    # apply but both equal current → PSM-equivalent "no change → None".
+    wc = WorkerCounts(ready_num_prefill=6, ready_num_decode=8)
+    outcome = _apply_outcome(
+        [
+            ComponentTarget(sub_component_type="prefill", replicas=6),
+            ComponentTarget(sub_component_type="decode", replicas=8),
+        ]
+    )
+    assert OrchestratorEngineAdapter._project_scale_to(outcome, wc) is None
+
+
+def test_project_scale_to_single_component_proposal():
+    # Proposal mentions only prefill → num_decode stays None (no opinion),
+    # prefill changed → decision emitted.
+    wc = WorkerCounts(ready_num_prefill=2, ready_num_decode=4)
+    outcome = _apply_outcome(
+        [ComponentTarget(sub_component_type="prefill", replicas=6)]
+    )
+    dec = OrchestratorEngineAdapter._project_scale_to(outcome, wc)
+    assert dec is not None
+    assert dec.num_prefill == 6
+    assert dec.num_decode is None
+
+
+def test_project_scale_to_non_apply_action_returns_none():
+    wc = WorkerCounts(ready_num_prefill=2, ready_num_decode=4)
+    for action in ("skip_short_circuit", "skip_no_targets", "skip_tick_timeout"):
+        outcome = PipelineOutcome(execute_action=action, final_proposal=None)
+        assert OrchestratorEngineAdapter._project_scale_to(outcome, wc) is None
+
+
+def test_tick_input_to_context_maps_observations_and_fpm():
+    # The ingress glue: TickInput → PipelineContext.observations, including
+    # the FPM msgpack encoding external plugins decode. Asserts field mapping
+    # (traffic + worker scaling flags) and that the FPM bytes round-trip.
+    from dynamo.common.forward_pass_metrics import decode as _fpm_decode
+
+    adapter = OrchestratorEngineAdapter(_agg_config_throughput_on(), _caps())
+    ti = TickInput(
+        now_s=10.0,
+        traffic=TrafficObservation(
+            duration_s=60.0, num_req=100.0, isl=1000.0, osl=150.0, kv_hit_rate=0.4
+        ),
+        worker_counts=WorkerCounts(
+            ready_num_prefill=2,
+            ready_num_decode=4,
+            prefill_scaling_in_progress=True,
+            decode_scaling_in_progress=False,
+        ),
+        fpm_observations=FpmObservations(decode={("w1", 0): _make_fpm("w1")}),
+    )
+    ctx = adapter._tick_input_to_context(ti)
+
+    assert ctx.observations.traffic.num_req == 100.0
+    assert ctx.observations.traffic.kv_hit_rate == 0.4
+    assert ctx.observations.workers.ready_decode == 4
+    assert ctx.observations.workers.prefill_scaling_in_progress is True
+    assert ctx.observations.workers.decode_scaling_in_progress is False
+
+    # FPM key format is "<worker_id>/<dp_rank>" and the value is a
+    # canonical-encoded ForwardPassMetrics the external plugin decodes.
+    raw = ctx.observations.fpm.decode_engines["w1/0"]
+    back = _fpm_decode(raw)
+    assert back is not None
+    assert back.worker_id == "w1"
+
+
+def test_initial_tick_with_throughput_scaling_enabled_does_not_attribute_error():
+    """``initial_tick`` used to read the non-existent
+    ``throughput_adjustment_interval`` attribute (canonical name has a
+    ``_seconds`` suffix; the short form is only a validation alias, not
+    an attribute accessor in Pydantic v2). Pre-fix this branch raised
+    ``AttributeError`` and crashed planner startup whenever
+    ``enable_throughput_scaling`` was True.
+    """
+    config = _agg_config_throughput_on()
+    # Sanity guard: if the validator ever changes and silently flips
+    # this off, the test would pass for the wrong reason (the buggy
+    # branch is short-circuited at line 340 ``if enable_throughput_scaling``).
+    assert config.enable_throughput_scaling is True
+
+    adapter = OrchestratorEngineAdapter(config, _caps())
+    tick = adapter.initial_tick(start_s=0.0)
+    assert isinstance(tick, ScheduledTick)
+    # First tick is whichever cadence is shorter. We don't pin the exact
+    # value here — defaults move between SLA presets — only that we
+    # got past the buggy attribute read.
+    assert tick.at_s > 0.0
+    assert tick.run_load_scaling or tick.run_throughput_scaling
+
+
+def test_orchestrator_path_honours_configured_protocol_version_range():
+    """``planner.plugin_registration.protocol_version_min/max`` must
+    flow into the orchestrator-path registry server (previously dropped
+    on the floor — server defaulted to ``("1.0", "1.0")`` regardless of
+    config, making any non-default range silently ineffective on the
+    gateway).
+    """
+    from dynamo.planner.config.planner_config import PluginRegistrationConfig
+
+    config = PlannerConfig(
+        mode="agg",
+        enable_load_scaling=True,
+        enable_throughput_scaling=True,
+        optimization_target="sla",
+        served_model_name="test",
+        plugin_registration=PluginRegistrationConfig(
+            protocol_version_min="1.0",
+            protocol_version_max="1.5",
+        ),
+    )
+    adapter = OrchestratorEngineAdapter(config, _caps())
+    server = adapter._orchestrator._registry  # type: ignore[attr-defined]
+    assert server._protocol_min == "1.0"
+    assert server._protocol_max == "1.5"
+
+
+@pytest.mark.asyncio
+async def test_tick_propagates_pipeline_execute_action_to_diagnostics():
+    """``PipelineOutcome.execute_action`` / ``short_circuit_reason`` /
+    ``audit_events`` must surface on ``PlannerEffects.diagnostics`` so
+    in-process consumers (replay adapter, diagnostics recorder) can
+    tell ``apply`` from ``skip_short_circuit`` / ``skip_no_targets`` /
+    ``skip_tick_timeout`` without scraping Prometheus.
+
+    Pre-fix the adapter created a fresh ``TickDiagnostics()`` and only
+    populated prediction / load / throughput fields — the three
+    execute-action fields were silently dropped.
+    """
+    from dynamo.planner.plugins.orchestrator.pipeline import PipelineOutcome
+
+    adapter = OrchestratorEngineAdapter(_agg_config_throughput_on(), _caps())
+
+    canned_outcome = PipelineOutcome(
+        execute_action="skip_short_circuit",
+        final_proposal=None,
+        short_circuit_reason="propose: my-plugin: over-capacity",
+        audit_events=[
+            "chain_break_warning: predict-A set final=true at non-lowest priority"
+        ],
+    )
+
+    async def fake_tick(ctx, baseline):
+        return canned_outcome
+
+    adapter._orchestrator.tick = fake_tick  # type: ignore[method-assign]
+
+    initial_tick = adapter.initial_tick(start_s=0.0)
+    effects = await adapter.tick(initial_tick, TickInput(now_s=initial_tick.at_s))
+
+    assert effects.diagnostics.execute_action == "skip_short_circuit"
+    assert (
+        effects.diagnostics.short_circuit_reason == "propose: my-plugin: over-capacity"
+    )
+    assert effects.diagnostics.audit_events == [
+        "chain_break_warning: predict-A set final=true at non-lowest priority"
+    ]
+
+
+@pytest.mark.asyncio
+async def test_bootstrap_registers_static_externals_before_bootstrap_fanout():
+    """Static external plugins (``scheduling.external_plugins``) must be
+    registered **before** the orchestrator-side Bootstrap fan-out so
+    they receive the same ``historical_traffic`` warm + Bootstrap RPC
+    pass as in-process / builtin plugins.
+
+    Pre-fix order was bootstrap → register → gateway, which meant
+    config-listed externals registered into an already-bootstrapped
+    registry and silently missed the warm step.  This test pins the
+    correct ordering via monkey-patched call records.
+    """
+    adapter = OrchestratorEngineAdapter(_agg_config_throughput_on(), _caps())
+
+    call_order: list[str] = []
+
+    orig_orchestrator_bootstrap = adapter._orchestrator.bootstrap_plugins
+
+    async def record_orchestrator_bootstrap(*args, **kwargs):
+        call_order.append("bootstrap")
+        await orig_orchestrator_bootstrap(*args, **kwargs)
+
+    orig_wire = adapter._wire_external_plugins_from_config
+
+    async def record_wire():
+        call_order.append("wire_externals")
+        await orig_wire()
+
+    orig_gateway = adapter._maybe_start_gateway
+
+    async def record_gateway():
+        call_order.append("gateway")
+        await orig_gateway()
+
+    adapter._orchestrator.bootstrap_plugins = (  # type: ignore[method-assign]
+        record_orchestrator_bootstrap
+    )
+    adapter._wire_external_plugins_from_config = (  # type: ignore[method-assign]
+        record_wire
+    )
+    adapter._maybe_start_gateway = record_gateway  # type: ignore[method-assign]
+
+    await adapter.bootstrap_plugins()
+
+    assert call_order == ["wire_externals", "bootstrap", "gateway"], call_order
+
+
+def test_pipeline_fires_at_scale_interval_cadence():
+    """Replaces the previous ``test_merge_tolerance_matches_psm_500ms_window``.
+
+    Under the scale_interval cadence model, the engine_adapter no longer
+    runs the PSM ``_MERGE_TOLERANCE_S = 0.5`` merge logic — there is no
+    dual ``_next_load_s`` / ``_next_throughput_s`` to reconcile.
+    Pipeline fires once per ``scale_interval_seconds`` from the last
+    tick moment.  Per-plugin throttling (in ``PluginScheduler._is_due``)
+    decides which plugins actually fire each tick — the merge-tolerance
+    concept that used to live here is now naturally absorbed by the
+    plugin scheduler, which evaluates each plugin's throttle
+    independently using the same ``now`` value.
+
+    Cadence-merge parity with PSM is preserved at the *decision* level
+    rather than the *tick-shape* level (see Decision 1 in
+    /tmp/scale_interval_design.md §11).  This test locks the new shape:
+    next_tick.at_s = last_tick + scale_interval, exactly.
+    """
+    adapter = OrchestratorEngineAdapter(_agg_config_throughput_on(), _caps())
+    tick = adapter.initial_tick(start_s=0.0)
+    # Default scale_interval_seconds = 5.0 (see SchedulingConfig).
+    assert tick.at_s == pytest.approx(5.0, abs=1e-9)
+    assert tick.run_load_scaling, "scale_interval ticks fire both flags"
+    assert tick.run_throughput_scaling, "scale_interval ticks fire both flags"
+
+
+def test_scale_interval_advances_from_actual_tick_now():
+    """Sequential ticks anchor on ``tick_input.now_s``, not on a
+    pre-computed schedule — so a 700ms-late tick at T=5.7 produces the
+    next tick at T=10.7, accumulating drift symmetrically with PSM
+    (PSM also advances from ``tick_input.now_s``).  This is the basic
+    contract for scale_interval cadence advancement.
+    """
+
+    adapter = OrchestratorEngineAdapter(_agg_config_throughput_on(), _caps())
+    initial = adapter.initial_tick(start_s=0.0)
+    assert initial.at_s == pytest.approx(5.0)
+
+
+@pytest.mark.asyncio
+async def test_lazy_traffic_pull_skips_prometheus_when_no_plugin_needs_traffic():
+    """Under scale_interval, ``need_traffic_metrics`` is True only
+    when some registered plugin both lists ``observations.traffic``
+    in its ``needs`` AND is due at the next tick.  With no traffic
+    consumer registered, every pipeline tick should signal
+    ``need_traffic_metrics=False`` to the gather layer — saving
+    36 Prometheus queries per 180s window compared to the eager
+    "always pull" alternative.
+    """
+    adapter = OrchestratorEngineAdapter(_agg_config_throughput_on(), _caps())
+    tick = adapter.initial_tick(start_s=0.0)
+    # No plugin is registered, so no plugin needs ``observations.traffic``.
+    assert tick.need_traffic_metrics is False
+    assert tick.traffic_metrics_duration_s == 0.0
+
+
+# ---------------------------------------------------------------------------
+# Clock injection for replay
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_tick_advances_injected_virtual_clock_to_trace_time():
+    """When a ``VirtualClock`` is injected (replay path), every
+    ``engine_adapter.tick()`` must bump the clock to
+    ``tick_input.now_s`` so the plugin scheduler / CircuitBreaker /
+    HOLD_LAST cache see *trace time*, not real wall-clock.
+
+    Without this bump, a fast-forward replay (e.g. 1hr trace in 10s
+    real time) would leave every plugin with
+    ``execution_interval_seconds`` greater than the real elapsed time
+    never re-firing after its first call — breaking PSM-parity on the
+    replay path and blocking PR #10's ``use_orchestrator=True`` default.
+    """
+    vc = VirtualClock()
+    adapter = OrchestratorEngineAdapter(_agg_config_throughput_on(), _caps(), clock=vc)
+    # ``initial_tick`` is pure cadence math — no plugin scheduler call,
+    # so the clock must not advance from this alone.
+    initial = adapter.initial_tick(start_s=0.0)
+    assert vc.monotonic() == 0.0
+
+    # Drive a tick at trace time 180.0 — real wall-clock has barely
+    # moved, but ``tick_input.now_s`` says we're 180s into the trace.
+    await adapter.tick(initial, TickInput(now_s=180.0))
+    assert vc.monotonic() == pytest.approx(180.0)
+
+    # Subsequent tick at trace time 360.0 advances further.
+    next_tick = ScheduledTick(
+        at_s=360.0,
+        run_load_scaling=True,
+        run_throughput_scaling=True,
+        need_worker_states=True,
+        need_worker_fpm=True,
+        need_traffic_metrics=True,
+        traffic_metrics_duration_s=180.0,
+    )
+    await adapter.tick(next_tick, TickInput(now_s=360.0))
+    assert vc.monotonic() == pytest.approx(360.0)
+
+
+@pytest.mark.asyncio
+async def test_tick_does_not_advance_clock_backwards():
+    """Defensive: if ``tick_input.now_s`` is *before* the clock's
+    current monotonic, ``advance(negative)`` would raise
+    ``ValueError`` from VirtualClock. The bump must be gated on
+    ``delta > 0`` so this case is a silent no-op.
+
+    Trace time should never go backwards in practice, but a paranoid
+    replay driver that pre-advances the clock manually should not
+    crash the adapter.
+    """
+    vc = VirtualClock()
+    vc.advance(500.0)  # clock already at 500s
+    adapter = OrchestratorEngineAdapter(_agg_config_throughput_on(), _caps(), clock=vc)
+    initial = adapter.initial_tick(start_s=0.0)
+    # tick_input.now_s = 300.0 is *before* the clock — must not raise.
+    await adapter.tick(initial, TickInput(now_s=300.0))
+    # Clock stays put (no backwards advance).
+    assert vc.monotonic() == pytest.approx(500.0)
+
+
+def test_default_clock_is_wallclock():
+    """Production path: when no ``clock`` kwarg is supplied, the
+    adapter falls back to ``WallClock`` so existing K8s deployments
+    keep their real-time semantics. Lock the default so a future
+    refactor that flips it doesn't silently break production cadence
+    tracking.
+    """
+    from dynamo.planner.plugins.clock import WallClock
+
+    adapter = OrchestratorEngineAdapter(_agg_config_throughput_on(), _caps())
+    assert isinstance(adapter._clock, WallClock)
+
+
+def test_lazy_traffic_due_check_uses_monotonic_not_wall_epoch():
+    """Regression: ``_compute_next_scheduled_tick`` must call
+    ``PluginScheduler._is_due`` with the **monotonic-domain** projection
+    of the next tick, not the wall-epoch projection.
+
+    In production ``WallClock`` deployments, ``tick_input.now_s`` is
+    wall-epoch (~1.7e9) while ``RegisteredPlugin.last_call_at`` is set
+    by the pipeline via ``self._clock.monotonic()`` (boot-relative,
+    ~1e3). A naive ``_is_due(plugin, _last_tick_s + scale_interval)``
+    therefore compares ~1.7e9 against ~1e3 — every plugin reads as due
+    forever, and the lazy traffic pull degenerates to "always pull".
+
+    This test wires a custom ``Clock`` that fixes monotonic() at 100s
+    while ``_last_tick_s`` is set to a wall-epoch-like 1.7e9, then
+    pins ``plugin.last_call_at`` such that the plugin is **not yet due**
+    in the monotonic domain.  With the bug, the plugin would be in
+    ``traffic_consumers_due`` and ``need_traffic_metrics`` would be
+    ``True``.  Fixed: monotonic projection correctly skips the plugin.
+    """
+    from dynamo.planner.plugins.clock import Clock
+    from dynamo.planner.plugins.registry.types import RegisteredPlugin
+    from dynamo.planner.plugins.types import HoldPolicy
+
+    class _FixedMonoClock(Clock):
+        """Wall-vs-monotonic drift simulator — not a VirtualClock so the
+        ``tick()`` sync path stays out of the picture."""
+
+        def __init__(self, mono: float) -> None:
+            self._mono = mono
+
+        def now(self) -> float:
+            return 1.7e9  # arbitrary wall epoch
+
+        def monotonic(self) -> float:
+            return self._mono
+
+        async def sleep(self, seconds: float) -> None:  # pragma: no cover
+            return None
+
+    clock = _FixedMonoClock(mono=100.0)
+    adapter = OrchestratorEngineAdapter(
+        _agg_config_throughput_on(), _caps(), clock=clock
+    )
+    # adapter._scale_interval defaults to 5.0s — the monotonic projection
+    # below uses it implicitly inside ``_compute_next_scheduled_tick``.
+
+    # Simulate "one tick has just been recorded" — _last_tick_s is wall epoch,
+    # _last_tick_monotonic is the matching monotonic snapshot.
+    adapter._last_tick_s = 1.7e9
+    adapter._last_tick_monotonic = 100.0
+
+    # Inject a registered traffic-consuming plugin whose last_call_at is in
+    # monotonic domain and whose execution_interval keeps it NOT due at the
+    # next tick.
+    registry = adapter._orchestrator._registry
+    plugin = RegisteredPlugin(
+        plugin_id="traffic_consumer",
+        plugin_type="propose",
+        priority=10,
+        endpoint="inproc://traffic_consumer",
+        version="test",
+        protocol_version="1.0",
+        execution_interval_seconds=60.0,
+        hold_policy=HoldPolicy.ACCEPT_WHEN_IDLE,
+        needs=["observations.traffic"],
+        is_builtin=False,
+        transport=None,  # type: ignore[arg-type]
+        transport_type="grpc",
+        registered_at=95.0,  # monotonic — 5s ago, well before tick
+    )
+    plugin.last_call_at = 95.0  # plugin called 5s ago in monotonic time
+    registry._plugins[plugin.plugin_id] = plugin
+
+    # Next tick monotonic projection = 100 + 5 = 105; plugin last_call_at = 95,
+    # execution_interval = 60 → next-due monotonic = 95 + 60 = 155.  Not due.
+    # If the buggy code path were active, at_s = 1.7e9 + 5 ≫ 155 → due.
+    sched = adapter._compute_next_scheduled_tick()
+    assert sched.need_traffic_metrics is False, (
+        "lazy traffic pull broke: plugin with last_call_at in monotonic domain "
+        "was read as due against a wall-epoch projection of the next tick"
+    )
+
+
+def test_lazy_traffic_pull_matches_dot_path_sub_paths_of_observations_traffic():
+    """``needs`` are dot-paths into ``PipelineContext`` per the proto
+    contract.  A plugin declaring a sub-path like
+    ``"observations.traffic.num_req"`` (signalling "I only consume
+    num_req — you may trim the rest from ctx") must still trigger the
+    lazy Prometheus pull, because the sub-path can only resolve if
+    its parent ``ctx.observations.traffic`` is populated.
+
+    Sibling fields like ``"observations.traffic_legacy"`` must NOT
+    trigger the pull — the trailing ``.`` in the prefix-match is
+    load-bearing.  Locks both branches.
+    """
+    from dynamo.planner.plugins.registry.types import RegisteredPlugin
+    from dynamo.planner.plugins.types import HoldPolicy
+
+    def _make_traffic_plugin(plugin_id: str, needs: list[str]) -> RegisteredPlugin:
+        plugin = RegisteredPlugin(
+            plugin_id=plugin_id,
+            plugin_type="propose",
+            priority=10,
+            endpoint=f"inproc://{plugin_id}",
+            version="test",
+            protocol_version="1.0",
+            execution_interval_seconds=0.0,  # every tick, always due
+            hold_policy=HoldPolicy.ACCEPT_WHEN_IDLE,
+            needs=needs,
+            is_builtin=False,
+            transport=None,  # type: ignore[arg-type]
+            transport_type="grpc",
+            registered_at=0.0,
+        )
+        plugin.last_call_at = float("-inf")
+        return plugin
+
+    # --- Case 1: exact parent path matches (existing behavior, keep working) ---
+    adapter = OrchestratorEngineAdapter(_agg_config_throughput_on(), _caps())
+    adapter._orchestrator._registry._plugins["p_parent"] = _make_traffic_plugin(
+        "p_parent", ["observations.traffic"]
+    )
+    sched = adapter._compute_next_scheduled_tick()
+    assert sched.need_traffic_metrics is True, "parent path must trigger pull"
+    del adapter._orchestrator._registry._plugins["p_parent"]
+
+    # --- Case 2: sub-path matches (regression — was broken before fix) ---
+    adapter._orchestrator._registry._plugins["p_child"] = _make_traffic_plugin(
+        "p_child", ["observations.traffic.num_req"]
+    )
+    sched = adapter._compute_next_scheduled_tick()
+    assert sched.need_traffic_metrics is True, (
+        "sub-path of observations.traffic must trigger pull — without this "
+        "the plugin would receive ctx.observations.traffic == None despite "
+        "declaring a dot-path into it"
+    )
+    del adapter._orchestrator._registry._plugins["p_child"]
+
+    # --- Case 3: sibling field must NOT match (prefix guard) ---
+    adapter._orchestrator._registry._plugins["p_sibling"] = _make_traffic_plugin(
+        "p_sibling", ["observations.traffic_legacy"]
+    )
+    sched = adapter._compute_next_scheduled_tick()
+    assert (
+        sched.need_traffic_metrics is False
+    ), "prefix match must not over-fire on sibling field 'observations.traffic_legacy'"
+
+    # --- Case 4: completely unrelated needs must NOT match ---
+    adapter._orchestrator._registry._plugins["p_other"] = _make_traffic_plugin(
+        "p_other", ["observations.fpm", "predictions"]
+    )
+    sched = adapter._compute_next_scheduled_tick()
+    assert (
+        sched.need_traffic_metrics is False
+    ), "unrelated needs must not trigger the traffic pull"
diff --git a/components/src/dynamo/planner/tests/plugins/orchestrator/test_in_process_loader.py b/components/src/dynamo/planner/tests/plugins/orchestrator/test_in_process_loader.py
new file mode 100644
index 000000000000..d0df0b051a6a
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/orchestrator/test_in_process_loader.py
@@ -0,0 +1,176 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for load_in_process_plugins."""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.orchestrator.in_process_loader import (
+    load_in_process_plugins,
+)
+from dynamo.planner.plugins.registry.config import InProcessPluginSpec
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+FAKE_PLUGIN_MODULE = "dynamo.planner.tests.plugins.orchestrator._fake_in_process_plugin"
+
+
+def test_loader_registers_plugin_from_module_path(ctx_factory):
+    ctx = ctx_factory()
+    spec = InProcessPluginSpec.model_validate(
+        {
+            "module": FAKE_PLUGIN_MODULE,
+            "class": "FakePlugin",
+            "plugin_id": "fake1",
+            "plugin_type": "propose",
+            "priority": 10,
+            "execution_interval_seconds": 5.0,
+            "hold_policy": "HOLD_LAST",
+            "kwargs": {"tag": "alpha"},
+        }
+    )
+    load_in_process_plugins(ctx["orchestrator"], [spec])
+    (info,) = ctx["orchestrator"].list_plugins()
+    assert info.plugin_id == "fake1"
+    assert info.transport == "in_process"
+    # is_builtin=False since loader sets it that way for user plugins.
+    assert info.is_builtin is False
+
+
+def test_loader_propagates_kwargs_to_instance(ctx_factory):
+    ctx = ctx_factory()
+    spec = InProcessPluginSpec.model_validate(
+        {
+            "module": FAKE_PLUGIN_MODULE,
+            "class": "FakePlugin",
+            "plugin_id": "fake_kw",
+            "plugin_type": "propose",
+            "priority": 10,
+            "kwargs": {"tag": "configured-tag"},
+        }
+    )
+    load_in_process_plugins(ctx["orchestrator"], [spec])
+    plugin = ctx["registry"].get_plugin("fake_kw")
+    assert plugin is not None
+    # The instance is wrapped inside InProcessTransport; retrieve the
+    # underlying object to verify kwargs landed.
+    instance = plugin.transport._instance  # noqa: SLF001 — test-only
+    assert instance.tag == "configured-tag"
+
+
+def test_loader_raises_on_unknown_module(ctx_factory):
+    ctx = ctx_factory()
+    spec = InProcessPluginSpec.model_validate(
+        {
+            "module": "dynamo.planner.tests.plugins.orchestrator.does_not_exist",
+            "class": "Missing",
+            "plugin_id": "x",
+            "plugin_type": "propose",
+            "priority": 1,
+        }
+    )
+    with pytest.raises(ImportError, match="failed to import module"):
+        load_in_process_plugins(ctx["orchestrator"], [spec])
+
+
+def test_loader_raises_on_unknown_class(ctx_factory):
+    ctx = ctx_factory()
+    spec = InProcessPluginSpec.model_validate(
+        {
+            "module": FAKE_PLUGIN_MODULE,
+            "class": "NoSuchClass",
+            "plugin_id": "y",
+            "plugin_type": "propose",
+            "priority": 1,
+        }
+    )
+    with pytest.raises(AttributeError, match="no attribute"):
+        load_in_process_plugins(ctx["orchestrator"], [spec])
+
+
+def test_loader_wraps_construction_failure_with_context(ctx_factory):
+    """``cls(**kwargs)`` failure (e.g. typo in kwarg name) must surface a
+    RuntimeError naming the plugin_id + class + kwargs, so operators can
+    identify the offending YAML entry without parsing a raw TypeError
+    traceback."""
+    ctx = ctx_factory()
+    spec = InProcessPluginSpec.model_validate(
+        {
+            "module": FAKE_PLUGIN_MODULE,
+            "class": "FakePlugin",
+            "plugin_id": "bad-kwargs",
+            "plugin_type": "propose",
+            "priority": 1,
+            # FakePlugin.__init__(self, tag: str = "default") — `unknown_kw`
+            # is not a valid parameter.
+            "kwargs": {"unknown_kw": "value"},
+        }
+    )
+    with pytest.raises(RuntimeError) as exc_info:
+        load_in_process_plugins(ctx["orchestrator"], [spec])
+    # Error message must include enough breadcrumbs to identify the entry.
+    msg = str(exc_info.value)
+    assert "bad-kwargs" in msg
+    assert "FakePlugin" in msg
+    assert "unknown_kw" in msg
+    # Underlying cause must be preserved.
+    assert isinstance(exc_info.value.__cause__, TypeError)
+
+
+def test_loader_loads_multiple_specs(ctx_factory):
+    ctx = ctx_factory()
+    specs = [
+        InProcessPluginSpec.model_validate(
+            {
+                "module": FAKE_PLUGIN_MODULE,
+                "class": "FakePlugin",
+                "plugin_id": f"fake{i}",
+                "plugin_type": "propose",
+                "priority": i,
+            }
+        )
+        for i in range(3)
+    ]
+    load_in_process_plugins(ctx["orchestrator"], specs)
+    ids = sorted(i.plugin_id for i in ctx["orchestrator"].list_plugins())
+    assert ids == ["fake0", "fake1", "fake2"]
+
+
+def test_loader_passes_scale_interval_fields_to_registered_plugin(ctx_factory):
+    """``InProcessPluginSpec`` now exposes ``needs`` /
+    ``requires_produced_fields`` / ``observation_window_seconds`` so
+    ConfigMap-driven in-process plugins can declare the scale_interval
+    cadence contract.  Without the loader-side passthrough a
+    ``throughput_propose`` asking for ``requires_produced_fields=
+    ["predictions"]`` would have fired every tick regardless of
+    upstream predict output.
+    """
+    ctx = ctx_factory()
+    spec = InProcessPluginSpec.model_validate(
+        {
+            "module": FAKE_PLUGIN_MODULE,
+            "class": "FakePlugin",
+            "plugin_id": "throughput_propose",
+            "plugin_type": "propose",
+            "priority": 100,
+            "execution_interval_seconds": 60.0,
+            "needs": ["observations.traffic"],
+            "requires_produced_fields": ["predictions"],
+            "observation_window_seconds": 180.0,
+        }
+    )
+    load_in_process_plugins(ctx["orchestrator"], [spec])
+    plugin = ctx["orchestrator"].registry.get_plugin("throughput_propose")
+    assert plugin is not None
+    assert plugin.needs == ["observations.traffic"]
+    assert plugin.requires_produced_fields == ["predictions"]
+    assert plugin.observation_window_seconds == 180.0
+    assert plugin.execution_interval_seconds == 60.0
diff --git a/components/src/dynamo/planner/tests/plugins/orchestrator/test_orchestrator_lifecycle.py b/components/src/dynamo/planner/tests/plugins/orchestrator/test_orchestrator_lifecycle.py
new file mode 100644
index 000000000000..ff62ae2ff011
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/orchestrator/test_orchestrator_lifecycle.py
@@ -0,0 +1,183 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Lifecycle + regression-model accessor tests for LocalPlannerOrchestrator."""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.merge.types import ComponentKey
+from dynamo.planner.plugins.types import (
+    ComponentTarget,
+    OverrideResult,
+    OverrideType,
+    PipelineContext,
+    ProposeStageResponse,
+)
+
+from .conftest import StubPlugin
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+def _make_propose_stub(replicas):
+    def handler(req):
+        return ProposeStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type="prefill",
+                        replicas=replicas,
+                        type=OverrideType.SET,
+                    )
+                ]
+            ),
+        )
+
+    return handler
+
+
+# ---------------------------------------------------------------------------
+# Construction + invalid config
+# ---------------------------------------------------------------------------
+
+
+def test_zero_tick_max_duration_rejected(ctx_factory):
+    with pytest.raises(ValueError):
+        ctx_factory(tick_max_duration_seconds=0)
+
+
+def test_orchestrator_starts_with_empty_plugin_set(ctx_factory):
+    ctx = ctx_factory()
+    assert ctx["orchestrator"].list_plugins() == []
+
+
+# ---------------------------------------------------------------------------
+# register_internal
+# ---------------------------------------------------------------------------
+
+
+def test_register_internal_via_orchestrator_appears_in_list(ctx_factory):
+    ctx = ctx_factory()
+    orchestrator = ctx["orchestrator"]
+    orchestrator.register_internal(
+        plugin_id="stub",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=_make_propose_stub(5)),
+    )
+    infos = orchestrator.list_plugins()
+    assert [i.plugin_id for i in infos] == ["stub"]
+    assert infos[0].is_builtin is True
+    assert infos[0].transport == "in_process"
+
+
+# ---------------------------------------------------------------------------
+# Regression-model accessors
+# ---------------------------------------------------------------------------
+
+
+def test_get_regression_returns_none_for_unknown_kind(ctx_factory):
+    ctx = ctx_factory()
+    assert ctx["orchestrator"].get_regression("prefill") is None
+
+
+def test_update_then_get_regression_returns_same_reference(ctx_factory):
+    ctx = ctx_factory()
+    model = object()
+    ctx["orchestrator"].update_regression("prefill", model)
+    assert ctx["orchestrator"].get_regression("prefill") is model
+
+
+def test_update_regression_replaces_existing(ctx_factory):
+    ctx = ctx_factory()
+    ctx["orchestrator"].update_regression("prefill", "v1")
+    ctx["orchestrator"].update_regression("prefill", "v2")
+    assert ctx["orchestrator"].get_regression("prefill") == "v2"
+
+
+# ---------------------------------------------------------------------------
+# tick happy path
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_tick_happy_path_single_propose_plugin(ctx_factory):
+    ctx = ctx_factory()
+    orchestrator = ctx["orchestrator"]
+    orchestrator.register_internal(
+        plugin_id="propose_one",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=_make_propose_stub(7)),
+    )
+    baseline = {ComponentKey(sub_component_type="prefill"): 3}
+    outcome = await orchestrator.tick(PipelineContext(), baseline)
+    assert outcome.execute_action == "apply"
+    assert outcome.final_proposal is not None
+    assert outcome.final_proposal.targets[0].replicas == 7
+
+
+@pytest.mark.asyncio
+async def test_tick_with_no_plugins_applies_baseline(ctx_factory):
+    # No plugins registered in any stage → type_aware_merge emits a
+    # pass-through proposal from the baseline, so EXECUTE applies it.
+    ctx = ctx_factory()
+    baseline = {ComponentKey(sub_component_type="prefill"): 5}
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), baseline)
+    assert outcome.execute_action == "apply"
+    assert outcome.final_proposal is not None
+    assert outcome.final_proposal.targets[0].replicas == 5
+
+
+@pytest.mark.asyncio
+async def test_tick_empty_baseline_and_no_plugins_is_skip_no_targets(
+    ctx_factory,
+):
+    # Empty baseline + no plugins → CONSTRAIN proposal.targets == [] →
+    # Empty-targets path: skip_no_targets + audit event.
+    ctx = ctx_factory()
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), baseline={})
+    assert outcome.execute_action == "skip_no_targets"
+    assert "execute_skipped_no_targets" in outcome.audit_events
+
+
+# ---------------------------------------------------------------------------
+# shutdown
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_shutdown_unregisters_all(ctx_factory):
+    ctx = ctx_factory()
+    orchestrator = ctx["orchestrator"]
+    orchestrator.register_internal(
+        plugin_id="a",
+        plugin_type="propose",
+        priority=1,
+        instance=StubPlugin(propose=_make_propose_stub(1)),
+    )
+    orchestrator.register_internal(
+        plugin_id="b",
+        plugin_type="propose",
+        priority=2,
+        instance=StubPlugin(propose=_make_propose_stub(2)),
+    )
+    assert len(orchestrator.list_plugins()) == 2
+    await orchestrator.shutdown()
+    assert orchestrator.list_plugins() == []
+
+
+@pytest.mark.asyncio
+async def test_shutdown_is_idempotent(ctx_factory):
+    ctx = ctx_factory()
+    await ctx["orchestrator"].shutdown()
+    await ctx["orchestrator"].shutdown()
+    assert ctx["orchestrator"].list_plugins() == []
diff --git a/components/src/dynamo/planner/tests/plugins/orchestrator/test_pipeline.py b/components/src/dynamo/planner/tests/plugins/orchestrator/test_pipeline.py
new file mode 100644
index 000000000000..dedd6a4945aa
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/orchestrator/test_pipeline.py
@@ -0,0 +1,742 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""4-stage pipeline tests.
+
+Covers:
+- PREDICT chain_augment threads predictions into PROPOSE ctx
+- PROPOSE / RECONCILE / CONSTRAIN merge happy path + baseline threading
+- REJECT short-circuits the stage + rest of pipeline
+- CONSTRAIN empty targets → skip_no_targets + audit event
+- final priority in PROPOSE
+- HOLD_LAST cache inherits to next tick
+- chain-augment chain-break warnings surface in audit events
+- **Grep-based regression test**: ``pipeline.py`` must NOT wrap
+  ``asyncio.gather`` in ``asyncio.wait_for`` (stage-level timeouts are
+  forbidden; per-plugin timeouts live in the transport).
+"""
+
+from __future__ import annotations
+
+import ast
+import pathlib
+
+import pytest
+
+from dynamo.planner.plugins.merge.types import ComponentKey
+from dynamo.planner.plugins.types import (
+    AcceptResult,
+    ComponentTarget,
+    ConstrainStageResponse,
+    HoldPolicy,
+    OverrideResult,
+    OverrideType,
+    PipelineContext,
+    PredictionData,
+    PredictStageResponse,
+    ProposeStageResponse,
+    ReconcileStageResponse,
+    RejectResult,
+)
+
+from .conftest import StubPlugin
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _propose_override(
+    replicas, sub_component_type="prefill", type_=OverrideType.SET, final=False
+):
+    def handler(req):
+        return ProposeStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type=sub_component_type,
+                        replicas=replicas,
+                        type=type_,
+                    )
+                ]
+            ),
+            final=final,
+        )
+
+    return handler
+
+
+def _reconcile_override(replicas, sub_component_type="prefill", type_=OverrideType.SET):
+    def handler(req):
+        return ReconcileStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type=sub_component_type,
+                        replicas=replicas,
+                        type=type_,
+                    )
+                ]
+            ),
+        )
+
+    return handler
+
+
+def _constrain_at_most(replicas, sub_component_type="prefill"):
+    def handler(req):
+        return ConstrainStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type=sub_component_type,
+                        replicas=replicas,
+                        type=OverrideType.AT_MOST,
+                    )
+                ]
+            ),
+        )
+
+    return handler
+
+
+def _predict_response(num_req=None, final=False):
+    def handler(req):
+        preds = None if num_req is None else PredictionData(predicted_num_req=num_req)
+        return PredictStageResponse(predictions=preds, final=final)
+
+    return handler
+
+
+def _accept_propose(req):
+    return ProposeStageResponse(result_kind="accept", accept=AcceptResult())
+
+
+def _reject_propose(reason="safety"):
+    def handler(req):
+        return ProposeStageResponse(
+            result_kind="reject", reject=RejectResult(reason=reason)
+        )
+
+    return handler
+
+
+PREFILL = ComponentKey(sub_component_type="prefill")
+
+
+# ---------------------------------------------------------------------------
+# Happy-path multi-stage
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_propose_output_flows_as_reconcile_baseline(ctx_factory):
+    ctx = ctx_factory()
+    orchestrator = ctx["orchestrator"]
+    # PROPOSE sets prefill to 7 via SET.
+    orchestrator.register_internal(
+        plugin_id="propose",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=_propose_override(7)),
+    )
+    # RECONCILE has no plugins → passes PROPOSE output through unchanged.
+    outcome = await orchestrator.tick(PipelineContext(), {PREFILL: 3})
+    assert outcome.execute_action == "apply"
+    assert outcome.final_proposal.targets[0].replicas == 7
+
+
+@pytest.mark.asyncio
+async def test_constrain_at_most_clamps_propose_output(ctx_factory):
+    ctx = ctx_factory()
+    ctx["orchestrator"].register_internal(
+        plugin_id="propose",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=_propose_override(12)),
+    )
+    ctx["orchestrator"].register_internal(
+        plugin_id="budget",
+        plugin_type="constrain",
+        priority=1,
+        instance=StubPlugin(constrain=_constrain_at_most(8)),
+    )
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    assert outcome.execute_action == "apply"
+    assert outcome.final_proposal.targets[0].replicas == 8
+
+
+@pytest.mark.asyncio
+async def test_broken_predict_plugin_isolated_does_not_fail_whole_tick(ctx_factory):
+    """A PREDICT plugin whose ``Predict`` call raises must NOT propagate
+    the exception out of the pipeline — that would kill the whole
+    planner tick (regression for tedzhouhk review comment).  Instead
+    ``_PredictAdapter`` records a circuit-breaker failure, emits the
+    error metric, and returns a no-op response so ``chain_augment``
+    moves on to the next plugin in the chain.
+
+    Mirror of the same isolation behaviour
+    ``_run_fanout_stage`` already provides for PROPOSE / RECONCILE /
+    CONSTRAIN.
+    """
+    ctx = ctx_factory()
+
+    def boom(_req):
+        raise RuntimeError("simulated predict failure")
+
+    # Lower priority (numerically smaller) — runs first.
+    ctx["orchestrator"].register_internal(
+        plugin_id="predict_broken",
+        plugin_type="predict",
+        priority=1,
+        instance=StubPlugin(predict=boom),
+    )
+    # Healthy predict plugin runs after the broken one and produces
+    # predictions; if isolation works the chain reaches this plugin.
+    ctx["orchestrator"].register_internal(
+        plugin_id="predict_healthy",
+        plugin_type="predict",
+        priority=2,
+        instance=StubPlugin(predict=_predict_response(num_req=42.0)),
+    )
+
+    def propose_echo(req):
+        # Only fires when predictions made it through the chain.
+        if req.context.predictions is None:
+            return ProposeStageResponse(result_kind="accept", accept=AcceptResult())
+        predicted = req.context.predictions.predicted_num_req
+        return ProposeStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type="prefill",
+                        replicas=int(predicted),
+                        type=OverrideType.SET,
+                    )
+                ]
+            ),
+        )
+
+    ctx["orchestrator"].register_internal(
+        plugin_id="propose_echo",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=propose_echo),
+    )
+
+    # Tick must complete without raising; healthy plugin produces the
+    # expected prediction; CB recorded a failure for the broken plugin.
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    assert outcome.execute_action == "apply"
+    assert outcome.final_proposal.targets[0].replicas == 42
+    cb = ctx["circuit_breaker"]
+    # The CB recorded a failure on the broken plugin's per-plugin
+    # entry; healthy plugin's CB entry remains at zero failures.
+    broken_entry = cb._entries.get("predict_broken")
+    healthy_entry = cb._entries.get("predict_healthy")
+    assert broken_entry is not None and broken_entry.consecutive_failures >= 1
+    assert healthy_entry is not None and healthy_entry.consecutive_failures == 0
+
+
+@pytest.mark.asyncio
+async def test_predict_chain_threads_predictions_into_propose_context(ctx_factory):
+    # PREDICT plugin sets predictions; a PROPOSE plugin that echoes the
+    # running prediction into an OverrideResult demonstrates the thread.
+    ctx = ctx_factory()
+
+    def propose_from_predictions(req):
+        predicted = req.context.predictions.predicted_num_req
+        return ProposeStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type="prefill",
+                        replicas=int(predicted),
+                        type=OverrideType.SET,
+                    )
+                ]
+            ),
+        )
+
+    ctx["orchestrator"].register_internal(
+        plugin_id="predict_one",
+        plugin_type="predict",
+        priority=10,
+        instance=StubPlugin(predict=_predict_response(num_req=42.0)),
+    )
+    ctx["orchestrator"].register_internal(
+        plugin_id="propose_echo",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=propose_from_predictions),
+    )
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    assert outcome.final_proposal.targets[0].replicas == 42
+
+
+# ---------------------------------------------------------------------------
+# REJECT short-circuits
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_propose_reject_short_circuits(ctx_factory):
+    ctx = ctx_factory()
+    ctx["orchestrator"].register_internal(
+        plugin_id="rej",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=_reject_propose("over-capacity")),
+    )
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    assert outcome.execute_action == "skip_short_circuit"
+    assert outcome.final_proposal is None
+    assert "over-capacity" in outcome.short_circuit_reason
+
+
+# ---------------------------------------------------------------------------
+# Empty-targets path
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_all_accept_on_empty_baseline_is_skip_no_targets(ctx_factory):
+    # All PROPOSE plugins ACCEPT + empty baseline → CONSTRAIN produces
+    # a proposal with no targets → skip_no_targets.
+    ctx = ctx_factory()
+    ctx["orchestrator"].register_internal(
+        plugin_id="p1",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=_accept_propose),
+    )
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), {})
+    assert outcome.execute_action == "skip_no_targets"
+    assert "execute_skipped_no_targets" in outcome.audit_events
+
+
+# ---------------------------------------------------------------------------
+# final priority
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_final_priority_wins_in_propose(ctx_factory):
+    ctx = ctx_factory()
+    # p_final (priority=5, final=True) vs p_other (priority=10, SET 99)
+    ctx["orchestrator"].register_internal(
+        plugin_id="p_final",
+        plugin_type="propose",
+        priority=5,
+        instance=StubPlugin(propose=_propose_override(7, final=True)),
+    )
+    ctx["orchestrator"].register_internal(
+        plugin_id="p_other",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=_propose_override(99)),
+    )
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    assert outcome.execute_action == "apply"
+    assert outcome.final_proposal.targets[0].replicas == 7
+    assert outcome.propose_outcome.used_final_from == "p_final"
+
+
+# ---------------------------------------------------------------------------
+# HOLD_LAST cache inherits to next tick
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_hold_last_cache_inherits_on_idle_tick(ctx_factory):
+    ctx = ctx_factory()
+    orchestrator = ctx["orchestrator"]
+    clock = ctx["clock"]
+    # execution_interval=10s, HOLD_LAST → first tick fires after interval
+    # elapses (PSM-parity anchor), mid-interval tick inherits cache.
+    orchestrator.register_internal(
+        plugin_id="propose",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=_propose_override(7)),
+        execution_interval_seconds=10.0,
+        hold_policy=HoldPolicy.HOLD_LAST,
+    )
+    # Advance to the first-fire moment (interval seconds since
+    # registration — see test_first_fire_anchored_on_registration_time).
+    clock.advance(10.0)
+    first = await orchestrator.tick(PipelineContext(), {PREFILL: 3})
+    assert first.final_proposal.targets[0].replicas == 7
+    # Advance 5s: not due; HOLD_LAST inherits cached (7).
+    clock.advance(5.0)
+    second = await orchestrator.tick(PipelineContext(), {PREFILL: 3})
+    assert second.execute_action == "apply"
+    assert second.final_proposal.targets[0].replicas == 7
+
+
+# ---------------------------------------------------------------------------
+# CONSTRAIN SET dropped
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_constrain_set_dropped_and_audited(ctx_factory):
+    ctx = ctx_factory()
+
+    def constrain_set(req):
+        return ConstrainStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type="prefill",
+                        replicas=5,
+                        type=OverrideType.SET,
+                    )
+                ]
+            ),
+        )
+
+    ctx["orchestrator"].register_internal(
+        plugin_id="propose",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=_propose_override(7)),
+    )
+    ctx["orchestrator"].register_internal(
+        plugin_id="bad_constrain",
+        plugin_type="constrain",
+        priority=10,
+        instance=StubPlugin(constrain=constrain_set),
+    )
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    assert outcome.constrain_outcome.set_dropped == [PREFILL]
+    # SET dropped → prefill passes through as RECONCILE baseline (7).
+    assert outcome.final_proposal.targets[0].replicas == 7
+
+
+# ---------------------------------------------------------------------------
+# chain_augment misuse warning surfaces in audit
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_predict_final_misuse_warning_surfaces_in_audit(ctx_factory):
+    ctx = ctx_factory()
+    # Ascending sort: emergency (priority=5) runs first as the authoritative
+    # plugin (sets num_req=9.0). Then mid (priority=100) runs and sets
+    # final=True → break. The misuse warning fires because mid is not the
+    # lowest-priority plugin in the chain; see chain_augment module docstring
+    # for why final=true at non-lowest-priority is a configuration smell.
+    ctx["orchestrator"].register_internal(
+        plugin_id="mid",
+        plugin_type="predict",
+        priority=100,
+        instance=StubPlugin(predict=_predict_response(num_req=1.0, final=True)),
+    )
+    ctx["orchestrator"].register_internal(
+        plugin_id="emergency",
+        plugin_type="predict",
+        priority=5,
+        instance=StubPlugin(predict=_predict_response(num_req=9.0)),
+    )
+    ctx["orchestrator"].register_internal(
+        plugin_id="propose",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=_propose_override(3)),
+    )
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    # mid's misuse message appears in audit_events.
+    assert any("chain_augment_non_lowest_final" in ev for ev in outcome.audit_events)
+
+
+# ---------------------------------------------------------------------------
+# Tick timeout
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_whole_tick_timeout_returns_skip_tick_timeout(ctx_factory):
+    import asyncio
+
+    ctx = ctx_factory(tick_max_duration_seconds=0.05)
+
+    async def slow_propose(req):
+        await asyncio.sleep(0.5)  # exceeds tick_max
+        return ProposeStageResponse(result_kind="accept", accept=AcceptResult())
+
+    ctx["orchestrator"].register_internal(
+        plugin_id="slow",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=slow_propose),
+    )
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    assert outcome.execute_action == "skip_tick_timeout"
+    assert "tick_timeout_total" in outcome.audit_events
+    assert outcome.final_proposal is None
+
+
+# ---------------------------------------------------------------------------
+# CONSTRAIN.final is ignored (proto contract)
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_constrain_final_ignored_does_not_short_circuit_merge(ctx_factory):
+    """``ConstrainStageResponse.final`` is ignored per proto contract —
+    constrain is a safety layer, so a constrain plugin setting
+    ``final=true`` must NOT short-circuit other constrain plugins' clamps.
+
+    Two constrain plugins:
+      * A: priority=1, final=True, AT_MOST(prefill=3)
+      * B: priority=5, AT_MOST(prefill=2)
+
+    Baseline arrives at CONSTRAIN as prefill=5. If A's final were honoured,
+    the merge would short-circuit at A and apply only A's clamp → prefill=3.
+    Spec says both clamps must apply, monotonic → prefill=min(3, 2)=2.
+    """
+    ctx = ctx_factory()
+
+    def at_most(replicas, *, final=False):
+        def handler(req):
+            return ConstrainStageResponse(
+                result_kind="override",
+                override=OverrideResult(
+                    targets=[
+                        ComponentTarget(
+                            sub_component_type="prefill",
+                            replicas=replicas,
+                            type=OverrideType.AT_MOST,
+                        )
+                    ]
+                ),
+                final=final,
+            )
+
+        return handler
+
+    # propose pushes prefill above both clamps so the AT_MOST chain visibly bites.
+    ctx["orchestrator"].register_internal(
+        plugin_id="propose",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=_propose_override(5)),
+    )
+    ctx["orchestrator"].register_internal(
+        plugin_id="constrain_a",
+        plugin_type="constrain",
+        priority=1,  # higher precedence
+        instance=StubPlugin(constrain=at_most(3, final=True)),
+    )
+    ctx["orchestrator"].register_internal(
+        plugin_id="constrain_b",
+        plugin_type="constrain",
+        priority=5,
+        instance=StubPlugin(constrain=at_most(2)),
+    )
+
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 5})
+    assert outcome.execute_action == "apply"
+    # Both clamps applied → prefill clamped to min(3, 2) = 2.
+    targets = {t.sub_component_type: t.replicas for t in outcome.final_proposal.targets}
+    assert targets["prefill"] == 2
+
+
+# ---------------------------------------------------------------------------
+# RECONCILE proposals threading
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_reconcile_receives_propose_results_in_proposals(ctx_factory):
+    """RECONCILE plugins receive per-plugin PROPOSE results via
+    ``ReconcileStageRequest.proposals``, so they can arbitrate per
+    proposal rather than only seeing the post-merge ``ctx.proposal``.
+
+    Two PROPOSE plugins emit different overrides; the RECONCILE plugin
+    captures ``req.proposals`` for inspection and arbitrates: it picks
+    plugin B's prefill replicas (5) even though A had higher precedence
+    (priority=1) and its proposal would have won the standard merge.
+    """
+    captured: dict = {}
+
+    def recording_reconcile(req):
+        # Snapshot per-proposal data; assert later.
+        captured["proposals"] = [
+            (
+                p.plugin_id,
+                p.priority,
+                p.result_kind,
+                p.override.targets[0].replicas if p.override else None,
+            )
+            for p in req.proposals
+        ]
+        # Arbitrate: pick B's prefill (5), ignoring A's (4).
+        return ReconcileStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type="prefill",
+                        replicas=5,
+                        type=OverrideType.SET,
+                    )
+                ]
+            ),
+        )
+
+    ctx = ctx_factory()
+    ctx["orchestrator"].register_internal(
+        plugin_id="propose_a",
+        plugin_type="propose",
+        priority=1,
+        instance=StubPlugin(propose=_propose_override(4)),
+    )
+    ctx["orchestrator"].register_internal(
+        plugin_id="propose_b",
+        plugin_type="propose",
+        priority=10,
+        instance=StubPlugin(propose=_propose_override(8)),
+    )
+    ctx["orchestrator"].register_internal(
+        plugin_id="rec",
+        plugin_type="reconcile",
+        priority=10,
+        instance=StubPlugin(reconcile=recording_reconcile),
+    )
+
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    assert outcome.execute_action == "apply"
+
+    # reconcile saw BOTH propose plugins' raw results
+    assert "proposals" in captured
+    assert len(captured["proposals"]) == 2
+    plugin_ids = {p[0] for p in captured["proposals"]}
+    assert plugin_ids == {"propose_a", "propose_b"}
+    # Per-plugin details preserved (priority + override replicas)
+    by_id = {p[0]: p for p in captured["proposals"]}
+    assert by_id["propose_a"][1] == 1  # priority
+    assert by_id["propose_a"][2] == "override"
+    assert by_id["propose_a"][3] == 4  # A wanted 4
+    assert by_id["propose_b"][1] == 10
+    assert by_id["propose_b"][3] == 8  # B wanted 8
+
+    # RECONCILE's override took precedence — final prefill = 5 (not A's 4, not B's 8).
+    targets = {t.sub_component_type: t.replicas for t in outcome.final_proposal.targets}
+    assert targets["prefill"] == 5
+
+
+# ---------------------------------------------------------------------------
+# Grep-based regression: no stage-level asyncio.wait_for
+# ---------------------------------------------------------------------------
+
+
+def test_pipeline_py_has_no_stage_level_wait_for():
+    """Assert the pipeline source contains exactly one
+    ``asyncio.wait_for`` call, and that call wraps the whole-tick body
+    (``_body()``), not an ``asyncio.gather``. Per-plugin timeouts already
+    live in ``PluginTransport.call``; a stage-level wait_for would double-
+    count the budget."""
+    from dynamo.planner.plugins.orchestrator import pipeline as _pipeline_module
+
+    source_path = pathlib.Path(_pipeline_module.__file__)
+    assert source_path.exists(), f"pipeline source not found at {source_path}"
+    tree = ast.parse(source_path.read_text())
+
+    wait_for_calls = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Call):
+            func = node.func
+            # asyncio.wait_for(...) — either Attribute or Name after "from asyncio import wait_for".
+            if isinstance(func, ast.Attribute) and func.attr == "wait_for":
+                wait_for_calls.append(node)
+            elif isinstance(func, ast.Name) and func.id == "wait_for":
+                wait_for_calls.append(node)
+
+    assert len(wait_for_calls) == 1, (
+        f"expected exactly one asyncio.wait_for in pipeline.py (the "
+        f"outermost whole-tick guard); found {len(wait_for_calls)}. "
+        f"Stage-level wait_for wrapping asyncio.gather is banned — "
+        f"per-plugin timeouts already live in PluginTransport.call."
+    )
+    # The single wait_for must take a coroutine call as its first arg
+    # (our outer guard calls `_body()`), not an asyncio.gather(...) result.
+    call = wait_for_calls[0]
+    first_arg = call.args[0]
+    # Must be a Call node (calling _body()), and NOT asyncio.gather(...).
+    assert isinstance(first_arg, ast.Call), (
+        "the single wait_for in pipeline.py should wrap a function call "
+        "(the whole-tick body), not a raw expression"
+    )
+    first_func = first_arg.func
+    first_func_name = (
+        first_func.attr
+        if isinstance(first_func, ast.Attribute)
+        else getattr(first_func, "id", None)
+    )
+    assert first_func_name != "gather", (
+        "asyncio.wait_for wraps asyncio.gather in pipeline.py — "
+        "stage-level deadlines are banned"
+    )
+
+
+# ---------------------------------------------------------------------------
+# PREDICT throttle (formerly Major 5): PREDICT goes through chain_augment
+# via _PredictAdapter, which is a separate dispatch path from
+# _run_fanout_stage. Without the adapter calling record_evaluation,
+# PREDICT plugins' last_call_at stays at -inf forever and
+# execution_interval_seconds is a no-op for the entire stage.
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_predict_plugin_throttled_by_execution_interval(ctx_factory):
+    """PREDICT plugin configured with ``execution_interval_seconds=60.0``
+    must be skipped on subsequent ticks until the interval elapses, just
+    like PROPOSE/RECONCILE/CONSTRAIN plugins.
+
+    Pre-fix: PREDICT was never throttled because chain_augment doesn't
+    touch the scheduler — ``last_call_at`` stayed at ``-math.inf``,
+    ``_is_due`` always returned True, plugin fired every tick regardless
+    of the configured interval.
+    """
+    ctx = ctx_factory()
+    stub = StubPlugin(predict=_predict_response(num_req=1.0))
+    ctx["registry"].register_internal(
+        plugin_id="pred",
+        plugin_type="predict",
+        priority=1,
+        instance=stub,
+        execution_interval_seconds=60.0,
+        hold_policy=HoldPolicy.ACCEPT_WHEN_IDLE,
+        is_builtin=True,
+    )
+    # First fire happens when interval elapses since registration
+    # (PSM-parity anchor — see test_first_fire_anchored_on_registration
+    # _time).  Pre-PR-1 fix: first-ever fired on tick 1 regardless.
+    ctx["clock"].advance(60.0)
+    await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    assert stub.call_counts["Predict"] == 1
+    # Second tick 1s later: must be throttled (interval is 60s).
+    ctx["clock"].advance(1.0)
+    await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    assert stub.call_counts["Predict"] == 1  # ← pre-throttle-fix this was 2
+    # After 60s: due again.
+    ctx["clock"].advance(60.0)
+    await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    assert stub.call_counts["Predict"] == 2
diff --git a/components/src/dynamo/planner/tests/plugins/orchestrator/test_pipeline_metrics.py b/components/src/dynamo/planner/tests/plugins/orchestrator/test_pipeline_metrics.py
new file mode 100644
index 000000000000..6bf7b60b9e41
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/orchestrator/test_pipeline_metrics.py
@@ -0,0 +1,662 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""End-to-end integration test for plugin invocation metric emissions.
+
+Drives a real ``LocalPlannerOrchestrator`` through a tick with stub
+plugins and asserts the plugin invocation metrics land with the
+expected labels and counts.
+"""
+
+from __future__ import annotations
+
+import pytest
+from prometheus_client import CollectorRegistry
+
+from dynamo.planner.monitoring.planner_metrics import (
+    CIRCUIT_STATE_CLOSED,
+    PluginFrameworkMetrics,
+)
+from dynamo.planner.plugins.merge.types import ComponentKey
+from dynamo.planner.plugins.types import (
+    AcceptResult,
+    ComponentTarget,
+    ConstrainStageResponse,
+    HoldPolicy,
+    OverrideResult,
+    OverrideType,
+    PipelineContext,
+    ProposeStageResponse,
+    ReconcileStageResponse,
+    RejectResult,
+)
+
+from .conftest import StubPlugin
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+PREFILL = ComponentKey(sub_component_type="prefill")
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def metrics():
+    return PluginFrameworkMetrics(registry=CollectorRegistry())
+
+
+def _register_stub(ctx, *, plugin_id, plugin_type, priority, instance):
+    ctx["registry"].register_internal(
+        plugin_id=plugin_id,
+        plugin_type=plugin_type,
+        priority=priority,
+        instance=instance,
+        execution_interval_seconds=0.0,
+        hold_policy=HoldPolicy.ACCEPT_WHEN_IDLE,
+        is_builtin=True,
+    )
+
+
+async def _drive_with_metrics(ctx_factory, metrics, *, stubs):
+    """Build orchestrator with metrics injected, register stubs, tick."""
+    ctx = ctx_factory()
+    ctx["orchestrator"]._metrics = metrics  # override None default
+    for s in stubs:
+        _register_stub(ctx, **s)
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    return ctx, outcome
+
+
+def _gauge_value(metric, **labels):
+    return metric.labels(**labels)._value.get()
+
+
+def _counter_value(metric, **labels):
+    return metric.labels(**labels)._value.get()
+
+
+# ---------------------------------------------------------------------------
+# plugin_evaluations_total + plugin_latency_seconds
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_accept_plugin_increments_eval_counter_with_accept_label(
+    ctx_factory, metrics
+):
+    accept_stub = StubPlugin(
+        propose=lambda req: ProposeStageResponse(
+            result_kind="accept", accept=AcceptResult()
+        ),
+    )
+    await _drive_with_metrics(
+        ctx_factory,
+        metrics,
+        stubs=[
+            dict(
+                plugin_id="acceptor",
+                plugin_type="propose",
+                priority=1,
+                instance=accept_stub,
+            )
+        ],
+    )
+    assert (
+        _counter_value(
+            metrics.plugin_evaluations_total,
+            plugin_id="acceptor",
+            stage="propose",
+            result="accept",
+        )
+        == 1
+    )
+
+
+@pytest.mark.asyncio
+async def test_set_override_emits_set_result_label_and_override_gauge(
+    ctx_factory, metrics
+):
+    set_stub = StubPlugin(
+        propose=lambda req: ProposeStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type="prefill",
+                        replicas=5,
+                        type=OverrideType.SET,
+                    )
+                ],
+            ),
+        ),
+    )
+    await _drive_with_metrics(
+        ctx_factory,
+        metrics,
+        stubs=[
+            dict(
+                plugin_id="setter",
+                plugin_type="propose",
+                priority=1,
+                instance=set_stub,
+            )
+        ],
+    )
+
+    # eval counter
+    assert (
+        _counter_value(
+            metrics.plugin_evaluations_total,
+            plugin_id="setter",
+            stage="propose",
+            result="set",
+        )
+        == 1
+    )
+    # override gauge: SET=1, other types=0
+    assert (
+        _gauge_value(
+            metrics.plugin_override_active,
+            plugin_id="setter",
+            stage="propose",
+            override_type="SET",
+        )
+        == 1
+    )
+    assert (
+        _gauge_value(
+            metrics.plugin_override_active,
+            plugin_id="setter",
+            stage="propose",
+            override_type="AT_LEAST",
+        )
+        == 0
+    )
+
+
+@pytest.mark.asyncio
+async def test_latency_histogram_records_count_for_successful_call(
+    ctx_factory, metrics
+):
+    """Successful call → latency observation with matching (plugin_id, stage)
+    labels. The exact bucket split isn't asserted (too brittle); the count
+    is.
+    """
+    stub = StubPlugin(
+        propose=lambda req: ProposeStageResponse(
+            result_kind="accept", accept=AcceptResult()
+        ),
+    )
+    await _drive_with_metrics(
+        ctx_factory,
+        metrics,
+        stubs=[
+            dict(
+                plugin_id="timed",
+                plugin_type="propose",
+                priority=1,
+                instance=stub,
+            )
+        ],
+    )
+    samples = list(metrics.plugin_latency_seconds.collect())[0].samples
+    counts = [
+        s.value
+        for s in samples
+        if s.name.endswith("_count")
+        and s.labels.get("plugin_id") == "timed"
+        and s.labels.get("stage") == "propose"
+    ]
+    assert counts and counts[0] == 1.0
+
+
+# ---------------------------------------------------------------------------
+# plugin_circuit_state
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_circuit_state_gauge_is_closed_after_successful_tick(
+    ctx_factory, metrics
+):
+    stub = StubPlugin(
+        propose=lambda req: ProposeStageResponse(
+            result_kind="accept", accept=AcceptResult()
+        ),
+    )
+    await _drive_with_metrics(
+        ctx_factory,
+        metrics,
+        stubs=[
+            dict(
+                plugin_id="stable",
+                plugin_type="propose",
+                priority=1,
+                instance=stub,
+            )
+        ],
+    )
+    assert (
+        _gauge_value(metrics.plugin_circuit_state, plugin_id="stable")
+        == CIRCUIT_STATE_CLOSED
+    )
+
+
+# ---------------------------------------------------------------------------
+# metrics=None path: existing tests must keep working (regression guard)
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_no_metrics_registered_when_metrics_is_none(ctx_factory):
+    """With ``metrics=None`` the pipeline must run identically to before
+    8-2 — no emission side effects, no exceptions."""
+    stub = StubPlugin(
+        propose=lambda req: ProposeStageResponse(
+            result_kind="accept", accept=AcceptResult()
+        ),
+    )
+    ctx = ctx_factory()
+    assert ctx["orchestrator"]._metrics is None  # default unchanged
+    _register_stub(
+        ctx,
+        plugin_id="no_metric",
+        plugin_type="propose",
+        priority=1,
+        instance=stub,
+    )
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    # Just care it didn't raise; a real assertion on the outcome shape
+    # lives in test_pipeline.py.
+    assert outcome is not None
+
+
+# ---------------------------------------------------------------------------
+# plugin_held_over_total + plugin_cache_age_seconds
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_held_over_plugin_emits_held_over_counter(ctx_factory, metrics):
+    """A plugin with ``execution_interval_seconds > 0`` + ``HOLD_LAST``
+    hold_policy gets its first-tick result cached; on the second tick
+    the scheduler replays the cached result and we should see
+    ``plugin_held_over_total`` increment."""
+    stub = StubPlugin(
+        propose=lambda req: ProposeStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type="prefill",
+                        replicas=4,
+                        type=OverrideType.SET,
+                    )
+                ],
+            ),
+        ),
+    )
+    ctx = ctx_factory()
+    ctx["orchestrator"]._metrics = metrics
+    ctx["registry"].register_internal(
+        plugin_id="cached",
+        plugin_type="propose",
+        priority=1,
+        instance=stub,
+        execution_interval_seconds=60.0,  # not due again for 60s
+        hold_policy=HoldPolicy.HOLD_LAST,
+        is_builtin=True,
+    )
+
+    # Advance to first-fire moment (PSM-parity anchor: first call
+    # happens ``interval`` seconds after registration).
+    ctx["clock"].advance(60.0)
+    # Tick 1: plugin evaluates, result cached.
+    await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    # VirtualClock advances 1s (much less than 60s interval)
+    ctx["clock"].advance(1.0)
+    # Tick 2: plugin not due, cached result inherited → held_over.
+    await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+
+    held = _counter_value(
+        metrics.plugin_held_over_total, plugin_id="cached", stage="propose"
+    )
+    assert held == 1
+    cache_age = _gauge_value(metrics.plugin_cache_age_seconds, plugin_id="cached")
+    # Cache was stored on tick 1, read ~1s later.  Exact value depends on
+    # VirtualClock steps; tolerate >=0 and <= advance amount.
+    assert 0 <= cache_age <= 2.0
+
+
+# ---------------------------------------------------------------------------
+# Family-3 metrics (pipeline integration)
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_reconcile_clamp_emits_reconcile_clamped_total(ctx_factory, metrics):
+    """Two plugins at RECONCILE: one sets replicas=10, the other
+    says AT_MOST=4. Merge clamps to 4; we expect
+    ``reconcile_clamped_total{source='cap'}`` to increment once.
+    """
+    set_stub = StubPlugin(
+        reconcile=lambda req: ReconcileStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type="prefill",
+                        replicas=10,
+                        type=OverrideType.SET,
+                    )
+                ]
+            ),
+        ),
+    )
+    cap_stub = StubPlugin(
+        reconcile=lambda req: ReconcileStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type="prefill",
+                        replicas=4,
+                        type=OverrideType.AT_MOST,
+                    )
+                ]
+            ),
+        ),
+    )
+    ctx, outcome = await _drive_with_metrics(
+        ctx_factory,
+        metrics,
+        stubs=[
+            dict(
+                plugin_id="setter",
+                plugin_type="reconcile",
+                priority=1,
+                instance=set_stub,
+            ),
+            dict(
+                plugin_id="cap",
+                plugin_type="reconcile",
+                priority=2,
+                instance=cap_stub,
+            ),
+        ],
+    )
+    assert outcome is not None
+    # Exactly one clamp event emitted, sourced to the cap plugin.
+    v = _counter_value(
+        metrics.reconcile_clamped_total,
+        sub_component_type="prefill",
+        source="cap",
+    )
+    assert v == 1
+    # constrain counter untouched this tick.
+    all_samples = list(metrics.constrain_capped_total.collect())[0].samples
+    # Counter with no inc()s has no samples other than the _created.
+    assert not any(s.name.endswith("_total") and s.value > 0 for s in all_samples)
+
+
+@pytest.mark.asyncio
+async def test_constrain_clamp_emits_constrain_capped_total(ctx_factory, metrics):
+    """A CONSTRAIN-stage AT_MOST lowering the baseline is tracked as
+    a ``constrain_capped_total`` event (not reconcile_clamped_total)."""
+    # Baseline prefill=10; budget plugin caps to 4.
+    cap_stub = StubPlugin(
+        constrain=lambda req: ConstrainStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type="prefill",
+                        replicas=4,
+                        type=OverrideType.AT_MOST,
+                    )
+                ]
+            ),
+        ),
+    )
+    ctx = ctx_factory()
+    ctx["orchestrator"]._metrics = metrics
+    _register_stub(
+        ctx,
+        plugin_id="budget",
+        plugin_type="constrain",
+        priority=1,
+        instance=cap_stub,
+    )
+    # Use a baseline that's above the AT_MOST so the cap actually fires.
+    outcome = await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 10})
+    assert outcome is not None
+    v = _counter_value(
+        metrics.constrain_capped_total,
+        sub_component_type="prefill",
+        source="budget",
+    )
+    assert v == 1
+
+
+@pytest.mark.asyncio
+async def test_reject_emits_reject_short_circuited_total(ctx_factory, metrics):
+    reject_stub = StubPlugin(
+        propose=lambda req: ProposeStageResponse(
+            result_kind="reject", reject=RejectResult(reason="nope")
+        ),
+    )
+    ctx, outcome = await _drive_with_metrics(
+        ctx_factory,
+        metrics,
+        stubs=[
+            dict(
+                plugin_id="safety",
+                plugin_type="propose",
+                priority=1,
+                instance=reject_stub,
+            )
+        ],
+    )
+    assert outcome.execute_action == "skip_short_circuit"
+    v = _counter_value(metrics.reject_short_circuited_total, plugin_id="safety")
+    assert v == 1
+
+
+# ---------------------------------------------------------------------------
+# Family-6 pipeline integration
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_tick_duration_seconds_observed_per_tick(ctx_factory, metrics):
+    stub = StubPlugin(
+        propose=lambda req: ProposeStageResponse(
+            result_kind="accept", accept=AcceptResult()
+        ),
+    )
+    await _drive_with_metrics(
+        ctx_factory,
+        metrics,
+        stubs=[
+            dict(
+                plugin_id="p",
+                plugin_type="propose",
+                priority=1,
+                instance=stub,
+            )
+        ],
+    )
+    # One tick → one observation
+    samples = list(metrics.tick_duration_seconds.collect())[0].samples
+    counts = [s.value for s in samples if s.name.endswith("_count")]
+    assert counts and counts[0] == 1.0
+
+
+@pytest.mark.asyncio
+async def test_tick_skipped_total_fires_when_plugin_not_due(ctx_factory, metrics):
+    """A plugin with execution_interval_seconds > 0 has its
+    ``last_call_at`` bumped by ``record_evaluation`` on every successful
+    RPC. On the next tick (before the interval elapses) it is deferred
+    and we expect ``tick_skipped_total`` to increment.
+
+    Note: post-Major-5-fix, all result kinds (Accept / Override / Reject
+    / empty-oneof) bump ``last_call_at`` uniformly via
+    ``record_evaluation``. This fixture uses OverrideResult for
+    convenience; throttling would behave identically for an Accept-only
+    plugin.
+    """
+    stub = StubPlugin(
+        propose=lambda req: ProposeStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type="prefill",
+                        replicas=4,
+                        type=OverrideType.SET,
+                    )
+                ]
+            ),
+        ),
+    )
+    ctx = ctx_factory()
+    ctx["orchestrator"]._metrics = metrics
+    # Also wire the scheduler's metrics since tick_skipped_total is
+    # emitted from there (the orchestrator owns a single metrics
+    # instance shared across layers).
+    ctx["scheduler"]._metrics = metrics
+    ctx["registry"].register_internal(
+        plugin_id="cadenced",
+        plugin_type="propose",
+        priority=1,
+        instance=stub,
+        execution_interval_seconds=60.0,  # not due again for 60s
+        hold_policy=HoldPolicy.ACCEPT_WHEN_IDLE,
+        is_builtin=True,
+    )
+
+    # Advance to first-fire moment (PSM-parity anchor on registered_at).
+    ctx["clock"].advance(60.0)
+    # Tick 1: first call, is_due=True → triggered, no skip
+    await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    assert _counter_value(metrics.tick_skipped_total, plugin_id="cadenced") == 0
+
+    # Tick 2: advance 1s only (way short of 60s interval) → not due → skipped
+    ctx["clock"].advance(1.0)
+    await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    assert _counter_value(metrics.tick_skipped_total, plugin_id="cadenced") == 1
+
+
+@pytest.mark.asyncio
+async def test_tick_lag_seconds_set_when_plugin_evaluated(ctx_factory, metrics):
+    """tick_lag_seconds is set per evaluation; first tick has lag=0
+    (no prior due_at), subsequent ticks after the interval has
+    elapsed show positive lag proportional to delay past schedule.
+
+    Post-fix: every successful RPC bumps ``last_call_at`` via
+    ``record_evaluation`` regardless of result kind, so the stub's
+    OverrideResult choice is incidental — Accept / Reject would behave
+    the same here.
+    """
+    stub = StubPlugin(
+        propose=lambda req: ProposeStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type="prefill",
+                        replicas=4,
+                        type=OverrideType.SET,
+                    )
+                ]
+            ),
+        ),
+    )
+    ctx = ctx_factory()
+    ctx["orchestrator"]._metrics = metrics
+    ctx["scheduler"]._metrics = metrics
+    ctx["registry"].register_internal(
+        plugin_id="timed",
+        plugin_type="propose",
+        priority=1,
+        instance=stub,
+        execution_interval_seconds=5.0,  # due every 5s
+        hold_policy=HoldPolicy.ACCEPT_WHEN_IDLE,
+        is_builtin=True,
+    )
+
+    # Advance to first-fire moment (PSM-parity anchor on registered_at).
+    ctx["clock"].advance(5.0)
+    # Tick 1: first call → lag=0 (no prior due_at to be late against)
+    await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    assert _gauge_value(metrics.tick_lag_seconds, plugin_id="timed") == 0.0
+
+    # Advance 7s → due was at 5s past last_call_at, we're 2s late
+    ctx["clock"].advance(7.0)
+    await ctx["orchestrator"].tick(PipelineContext(), {PREFILL: 3})
+    lag = _gauge_value(metrics.tick_lag_seconds, plugin_id="timed")
+    assert lag == pytest.approx(2.0, abs=0.1)
+
+
+@pytest.mark.asyncio
+async def test_no_clamp_when_recommendation_within_bounds(ctx_factory, metrics):
+    """Regression guard: bounds that don't change the final value MUST
+    NOT emit the counter — otherwise dashboards would over-count."""
+    set_stub = StubPlugin(
+        reconcile=lambda req: ReconcileStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type="prefill",
+                        replicas=5,
+                        type=OverrideType.SET,
+                    )
+                ]
+            ),
+        ),
+    )
+    ceiling_stub = StubPlugin(
+        reconcile=lambda req: ReconcileStageResponse(
+            result_kind="override",
+            override=OverrideResult(
+                targets=[
+                    ComponentTarget(
+                        sub_component_type="prefill",
+                        replicas=8,  # larger than SET=5, no clamp
+                        type=OverrideType.AT_MOST,
+                    )
+                ]
+            ),
+        ),
+    )
+    await _drive_with_metrics(
+        ctx_factory,
+        metrics,
+        stubs=[
+            dict(
+                plugin_id="setter",
+                plugin_type="reconcile",
+                priority=1,
+                instance=set_stub,
+            ),
+            dict(
+                plugin_id="loose_ceiling",
+                plugin_type="reconcile",
+                priority=2,
+                instance=ceiling_stub,
+            ),
+        ],
+    )
+    # No clamp event emitted.
+    samples = list(metrics.reconcile_clamped_total.collect())[0].samples
+    assert not any(s.name.endswith("_total") and s.value > 0 for s in samples)
diff --git a/components/src/dynamo/planner/tests/plugins/proto/__init__.py b/components/src/dynamo/planner/tests/plugins/proto/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/proto/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/tests/plugins/proto/test_round_trip.py b/components/src/dynamo/planner/tests/plugins/proto/test_round_trip.py
new file mode 100644
index 000000000000..08d406cbb794
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/proto/test_round_trip.py
@@ -0,0 +1,604 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Round-trip equivalence: Pydantic mirror ↔ proto generated.
+
+Verifies the lock-step contract between ``plugins/types.py`` and
+``plugins/proto/v1/plugin_pb2.py``:
+- Pydantic → proto → Pydantic produces the same Pydantic instance
+- proto → Pydantic → proto produces the same proto wire bytes
+
+Picked up by existing ``planner-test`` CI job via pytest markers.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins import types as pyd
+from dynamo.planner.plugins._proto_bridge import (
+    _PYD_TO_PROTO,
+    proto_to_pydantic,
+    pydantic_to_proto,
+)
+from dynamo.planner.plugins.proto.v1 import plugin_pb2 as pb
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+# ---------------------------------------------------------------------------
+# Coverage: every Pydantic class has a proto class registered (and vice versa)
+# ---------------------------------------------------------------------------
+
+
+def test_class_coverage_pydantic_side():
+    """Every Pydantic mirror message must have a proto counterpart."""
+    pyd_classes = {
+        cls
+        for name in pyd.__all__
+        for cls in [getattr(pyd, name)]
+        if isinstance(cls, type) and issubclass(cls, pyd._ProtoMirror)
+    }
+    registered = set(_PYD_TO_PROTO.keys())
+    missing = pyd_classes - registered
+    assert (
+        not missing
+    ), f"Pydantic classes missing proto registration: {sorted(c.__name__ for c in missing)}"
+
+
+def test_class_coverage_proto_side():
+    """Every proto message in plugin_pb2 must have a Pydantic counterpart.
+
+    Verifies no proto message was added without updating the Pydantic mirror.
+    """
+    proto_msgs = set(pb.DESCRIPTOR.message_types_by_name.keys())
+    registered = {p.__name__ for p in _PYD_TO_PROTO.values()}
+    missing = proto_msgs - registered
+    assert not missing, f"Proto messages missing Pydantic mirror: {sorted(missing)}"
+
+
+# ---------------------------------------------------------------------------
+# Round-trip cases — one per representative scenario
+# ---------------------------------------------------------------------------
+
+
+def _round_trip_pyd(pyd_msg: pyd.BaseModel) -> pyd.BaseModel:
+    """Pydantic → proto → Pydantic; assert equality."""
+    pb_msg = pydantic_to_proto(pyd_msg)
+    pyd_back = proto_to_pydantic(pb_msg)
+    assert pyd_back == pyd_msg, (
+        f"Pydantic round-trip mismatch:\n"
+        f"  original: {pyd_msg!r}\n"
+        f"  back:     {pyd_back!r}"
+    )
+    return pyd_back
+
+
+def _round_trip_wire(pyd_msg: pyd.BaseModel) -> bytes:
+    """Pydantic → proto → wire bytes; serialize twice should match."""
+    pb1 = pydantic_to_proto(pyd_msg)
+    wire = pb1.SerializeToString()
+    pb2 = type(pb1).FromString(wire)
+    wire2 = pb2.SerializeToString()
+    assert wire == wire2, "wire bytes not deterministic across re-serialize"
+    return wire
+
+
+# ---- PluginRegistry messages ----
+
+
+def test_register_request_full():
+    """RegisterRequest with all 12 fields populated."""
+    msg = pyd.RegisterRequest(
+        plugin_id="test-plugin",
+        plugin_type="propose",
+        priority=10,
+        endpoint="grpc://plugin.example.com:9090",
+        version="1.2.3",
+        execution_interval_seconds=30.0,
+        hold_policy=pyd.HoldPolicy.HOLD_LAST,
+        needs=["observations.traffic", "observations.fpm.prefill"],
+        protocol_version="1.0",
+        auth_token="secret-token-bytes",
+    )
+    _round_trip_pyd(msg)
+    _round_trip_wire(msg)
+
+
+def test_register_request_minimal():
+    """RegisterRequest with only required fields (rest defaults)."""
+    msg = pyd.RegisterRequest(plugin_id="x", plugin_type="predict")
+    _round_trip_pyd(msg)
+
+
+def test_register_response_accepted():
+    msg = pyd.RegisterResponse(accepted=True, negotiated_protocol_version="1.0")
+    _round_trip_pyd(msg)
+
+
+def test_register_response_rejected():
+    msg = pyd.RegisterResponse(
+        accepted=False, reject_reason="protocol_version_unsupported"
+    )
+    _round_trip_pyd(msg)
+
+
+def test_heartbeat_request_carries_auth_token():
+    msg = pyd.HeartbeatRequest(plugin_id="ext-propose", auth_token="secret-token-bytes")
+    _round_trip_pyd(msg)
+    _round_trip_wire(msg)
+
+
+def test_unregister_request_carries_auth_token():
+    msg = pyd.UnregisterRequest(
+        plugin_id="ext-propose",
+        reason="graceful_shutdown",
+        auth_token="secret-token-bytes",
+    )
+    _round_trip_pyd(msg)
+    _round_trip_wire(msg)
+
+
+def test_plugin_info_runtime_state():
+    msg = pyd.PluginInfo(
+        plugin_id="builtin-throughput-propose",
+        plugin_type="propose",
+        priority=50,
+        version="1.0",
+        protocol_version="1.0",
+        enabled=True,
+        is_builtin=True,
+        transport="in_process",
+        circuit_state=pyd.CircuitState.CLOSED,
+        evaluations_total=1234,
+        last_call_at_seconds_ago=2.5,
+        cache_age_seconds=0.0,
+    )
+    _round_trip_pyd(msg)
+
+
+def test_list_plugins_response_multi():
+    msg = pyd.ListPluginsResponse(
+        plugins=[
+            pyd.PluginInfo(plugin_id="a", plugin_type="propose"),
+            pyd.PluginInfo(
+                plugin_id="b",
+                plugin_type="constrain",
+                circuit_state=pyd.CircuitState.OPEN,
+            ),
+        ]
+    )
+    _round_trip_pyd(msg)
+
+
+# ---- PipelineContext + observation messages ----
+
+
+def test_pipeline_context_minimal():
+    """request_id only; all other fields None."""
+    msg = pyd.PipelineContext(request_id="req-123")
+    _round_trip_pyd(msg)
+
+
+def test_pipeline_context_full():
+    """All 6 fields populated."""
+    msg = pyd.PipelineContext(
+        request_id="req-456",
+        decision_id="decision-789",
+        observations=pyd.ObservationData(
+            traffic=pyd.TrafficMetrics(
+                duration_s=60.0, num_req=1500, isl=3000, osl=150
+            ),
+            fpm=pyd.FpmData(
+                prefill_engines={"engine-0": b"\x01\x02\x03binary-fpm-payload"},
+                decode_engines={"engine-1": b"\xff\xfe\xfd"},
+            ),
+            workers=pyd.WorkerState(
+                ready_prefill=4, ready_decode=8, expected_prefill=4, expected_decode=10
+            ),
+        ),
+        predictions=pyd.PredictionData(
+            predicted_num_req=1800.0,
+            predicted_isl=3000.0,
+            predicted_osl=160.0,
+            source="builtin-load-predictor",
+        ),
+        proposal=pyd.ScalingProposal(
+            targets=[
+                pyd.ComponentTarget(sub_component_type="prefill", replicas=6),
+                pyd.ComponentTarget(sub_component_type="decode", replicas=12),
+            ],
+            reason="scaling up due to predicted_num_req increase",
+            source="merged",
+        ),
+        constrained=pyd.ScalingProposal(
+            targets=[
+                pyd.ComponentTarget(sub_component_type="prefill", replicas=6),
+                pyd.ComponentTarget(
+                    sub_component_type="decode", replicas=10
+                ),  # capped by AT_MOST
+            ],
+        ),
+    )
+    _round_trip_pyd(msg)
+    _round_trip_wire(msg)
+
+
+def test_prediction_data_optional_unset_vs_zero():
+    """Critical invariant: optional float fields distinguish None
+    ("no opinion") from 0.0 ("I assert zero"). Removing the
+    ``optional`` proto qualifier silently breaks chain_augment's
+    layered-predictor partial-merge."""
+    # All None
+    p1 = pyd.PredictionData(source="builtin")
+    pb1 = pydantic_to_proto(p1)
+    assert not pb1.HasField("predicted_num_req")
+    assert not pb1.HasField("predicted_isl")
+    assert not pb1.HasField("predicted_osl")
+    assert not pb1.HasField("predicted_kv_hit_rate")
+
+    # Explicit 0.0 (rare but valid)
+    p2 = pyd.PredictionData(predicted_num_req=0.0)
+    pb2 = pydantic_to_proto(p2)
+    assert pb2.HasField(
+        "predicted_num_req"
+    ), "predicted_num_req=0.0 must round-trip as set"
+    assert pb2.predicted_num_req == 0.0
+    assert not pb2.HasField("predicted_isl")  # still unset
+
+    # Round-trip back: None stays None, 0.0 stays 0.0
+    p1_back = proto_to_pydantic(pb1)
+    assert p1_back.predicted_num_req is None
+    p2_back = proto_to_pydantic(pb2)
+    assert p2_back.predicted_num_req == 0.0
+    assert p2_back.predicted_isl is None
+    assert p1_back.predicted_kv_hit_rate is None
+
+
+def test_kv_hit_rate_round_trip_traffic_and_prediction():
+    """PSM-parity gap fix: ``TrafficMetrics.kv_hit_rate`` and
+    ``PredictionData.predicted_kv_hit_rate`` must round-trip as
+    optional floats so external throughput-propose plugins can
+    replicate PSM behaviour over the wire.
+
+    Locks:
+      - TrafficMetrics: unset → no proto field presence; 0.0 → set
+        (all-cold cache is a real signal, distinct from "no datapoint")
+      - PredictionData: unset / 0.0 follow the same first-writer-wins
+        partial-merge semantic as the other predicted_* fields.
+    """
+    # TrafficMetrics: kv_hit_rate unset
+    tm_none = pyd.TrafficMetrics(duration_s=60.0, num_req=100, isl=512, osl=128)
+    pb_tm_none = pydantic_to_proto(tm_none)
+    assert not pb_tm_none.HasField("kv_hit_rate"), (
+        "unset kv_hit_rate must survive as proto field-absent — distinguishes "
+        "'Prometheus returned no datapoint' from 'all-cold cache 0.0'"
+    )
+    tm_none_back = proto_to_pydantic(pb_tm_none)
+    assert tm_none_back.kv_hit_rate is None
+
+    # TrafficMetrics: kv_hit_rate=0.0 (cold cache, valid datapoint)
+    tm_cold = pyd.TrafficMetrics(
+        duration_s=60.0, num_req=100, isl=512, osl=128, kv_hit_rate=0.0
+    )
+    pb_tm_cold = pydantic_to_proto(tm_cold)
+    assert pb_tm_cold.HasField("kv_hit_rate")
+    assert pb_tm_cold.kv_hit_rate == 0.0
+    tm_cold_back = proto_to_pydantic(pb_tm_cold)
+    assert tm_cold_back.kv_hit_rate == 0.0
+
+    # TrafficMetrics: kv_hit_rate=0.42 (typical warm cache)
+    tm_warm = pyd.TrafficMetrics(
+        duration_s=60.0, num_req=100, isl=512, osl=128, kv_hit_rate=0.42
+    )
+    pb_tm_warm = pydantic_to_proto(tm_warm)
+    assert pb_tm_warm.kv_hit_rate == pytest.approx(0.42)
+    tm_warm_back = proto_to_pydantic(pb_tm_warm)
+    assert tm_warm_back.kv_hit_rate == pytest.approx(0.42)
+
+    # PredictionData: predicted_kv_hit_rate unset/set parity with the
+    # other predicted_* fields.
+    pd_partial = pyd.PredictionData(
+        predicted_num_req=1000.0, predicted_kv_hit_rate=0.65, source="ext"
+    )
+    pb_pd = pydantic_to_proto(pd_partial)
+    assert pb_pd.HasField("predicted_num_req")
+    assert pb_pd.HasField("predicted_kv_hit_rate")
+    assert not pb_pd.HasField("predicted_isl")  # untouched stays unset
+    assert pb_pd.predicted_kv_hit_rate == pytest.approx(0.65)
+    pd_back = proto_to_pydantic(pb_pd)
+    assert pd_back.predicted_kv_hit_rate == pytest.approx(0.65)
+    assert pd_back.predicted_isl is None
+    assert pd_back.predicted_osl is None
+
+
+def test_float64_metrics_survive_round_trip_without_truncation():
+    """TrafficMetrics / PredictionData numeric fields are proto ``double``
+    (64-bit), matching the Python float64 source of truth. Use values that
+    are NOT float32-exact: a 32-bit ``float`` wire type would truncate them
+    over gRPC (and disagree with the in-process transport). Assert EXACT
+    equality (not approx) so a regression back to ``float`` is caught."""
+    v_num = 1234.5678901234567  # > 2^23 mantissa precision; float32-lossy
+    v_kv = 0.123456789012345
+    tm = pyd.TrafficMetrics(
+        duration_s=60.0, num_req=v_num, isl=3000.0, osl=150.0, kv_hit_rate=v_kv
+    )
+    tm_back = proto_to_pydantic(pydantic_to_proto(tm))
+    assert tm_back.num_req == v_num
+    assert tm_back.kv_hit_rate == v_kv
+
+    pd = pyd.PredictionData(predicted_num_req=v_num, predicted_kv_hit_rate=v_kv)
+    pd_back = proto_to_pydantic(pydantic_to_proto(pd))
+    assert pd_back.predicted_num_req == v_num
+    assert pd_back.predicted_kv_hit_rate == v_kv
+
+
+def test_worker_state_scaling_in_progress_roundtrip():
+    """WorkerState.{prefill,decode}_scaling_in_progress are ``optional bool``;
+    ``unset`` vs ``False`` is observable via ``HasField`` so plugins can
+    distinguish "connector did not report" from "explicit stable=False".
+    """
+    # Unset: connector hasn't reported scaling state this tick.
+    ws_unset = pyd.WorkerState(ready_prefill=4, ready_decode=8)
+    pb_unset = pydantic_to_proto(ws_unset)
+    assert not pb_unset.HasField("prefill_scaling_in_progress")
+    assert not pb_unset.HasField("decode_scaling_in_progress")
+    back_unset = proto_to_pydantic(pb_unset)
+    assert back_unset.prefill_scaling_in_progress is None
+    assert back_unset.decode_scaling_in_progress is None
+
+    # Explicit False: prefill stable, decode still scaling.
+    ws_mixed = pyd.WorkerState(
+        ready_prefill=4,
+        ready_decode=6,
+        expected_prefill=4,
+        expected_decode=8,
+        prefill_scaling_in_progress=False,
+        decode_scaling_in_progress=True,
+    )
+    pb_mixed = pydantic_to_proto(ws_mixed)
+    assert pb_mixed.HasField("prefill_scaling_in_progress")
+    assert pb_mixed.HasField("decode_scaling_in_progress")
+    assert pb_mixed.prefill_scaling_in_progress is False
+    assert pb_mixed.decode_scaling_in_progress is True
+    back_mixed = proto_to_pydantic(pb_mixed)
+    assert back_mixed.prefill_scaling_in_progress is False
+    assert back_mixed.decode_scaling_in_progress is True
+
+
+def test_component_target_optional_replicas():
+    """Unset replicas = 'no opinion' (v9 semantics)."""
+    ct1 = pyd.ComponentTarget(sub_component_type="prefill")  # replicas unset
+    pb1 = pydantic_to_proto(ct1)
+    assert not pb1.HasField("replicas")
+
+    ct1_back = proto_to_pydantic(pb1)
+    assert ct1_back.replicas is None
+
+
+def test_override_result_multi_target_mixed_types():
+    """One OverrideResult can carry SET + AT_LEAST + AT_MOST per component."""
+    msg = pyd.OverrideResult(
+        targets=[
+            pyd.ComponentTarget(
+                sub_component_type="prefill", replicas=10, type=pyd.OverrideType.SET
+            ),
+            pyd.ComponentTarget(
+                sub_component_type="decode", replicas=4, type=pyd.OverrideType.AT_LEAST
+            ),
+            pyd.ComponentTarget(
+                sub_component_type="decode", replicas=8, type=pyd.OverrideType.AT_MOST
+            ),
+        ],
+        reason="blended throughput + load decision",
+    )
+    _round_trip_pyd(msg)
+
+
+def test_fpm_data_bytes_preserved():
+    """map<string, bytes> preserved through proto wire (base64 in JSON intermediate)."""
+    msg = pyd.FpmData(
+        prefill_engines={
+            "p0": bytes(range(256)),  # all byte values
+            "p1": b"",  # empty
+        },
+        decode_engines={"d0": b"\x00\xff\x42"},
+    )
+    msg_back = _round_trip_pyd(msg)
+    assert msg_back.prefill_engines["p0"] == bytes(range(256))
+    assert msg_back.prefill_engines["p1"] == b""
+    assert msg_back.decode_engines["d0"] == b"\x00\xff\x42"
+
+
+# ---- Stage request/response with oneof ----
+
+
+def test_propose_stage_response_accept():
+    msg = pyd.ProposeStageResponse(accept=pyd.AcceptResult())
+    msg_back = _round_trip_pyd(msg)
+    assert msg_back.result_kind == "accept"
+    assert msg_back.accept is not None
+    assert msg_back.override is None
+    assert msg_back.reject is None
+    assert msg_back.final is False
+
+
+def test_propose_stage_response_override_with_final():
+    msg = pyd.ProposeStageResponse(
+        override=pyd.OverrideResult(
+            targets=[pyd.ComponentTarget(sub_component_type="prefill", replicas=20)],
+            reason="emergency override",
+        ),
+        final=True,
+    )
+    msg_back = _round_trip_pyd(msg)
+    assert msg_back.result_kind == "override"
+    assert msg_back.override is not None
+    assert msg_back.override.targets[0].replicas == 20
+    assert msg_back.final is True
+
+
+def test_propose_stage_response_reject():
+    msg = pyd.ProposeStageResponse(reject=pyd.RejectResult(reason="budget exceeded"))
+    msg_back = _round_trip_pyd(msg)
+    assert msg_back.result_kind == "reject"
+    assert msg_back.reject is not None
+    assert msg_back.reject.reason == "budget exceeded"
+
+
+def test_propose_stage_response_oneof_violation():
+    """Cannot set multiple oneof payloads."""
+    with pytest.raises(Exception, match="oneof"):
+        pyd.ProposeStageResponse(
+            accept=pyd.AcceptResult(),
+            reject=pyd.RejectResult(reason="bad"),
+        )
+
+
+def test_predict_stage_response_partial():
+    """PredictionData partial set — only num_req."""
+    msg = pyd.PredictStageResponse(
+        predictions=pyd.PredictionData(
+            predicted_num_req=1500.0, source="user-llm-predictor"
+        ),
+        final=False,
+    )
+    msg_back = _round_trip_pyd(msg)
+    assert msg_back.predictions is not None
+    assert msg_back.predictions.predicted_num_req == 1500.0
+    assert msg_back.predictions.predicted_isl is None
+    assert msg_back.predictions.predicted_osl is None
+
+
+def test_reconcile_stage_request_with_proposals():
+    msg = pyd.ReconcileStageRequest(
+        context=pyd.PipelineContext(request_id="req-x"),
+        proposals=[
+            pyd.ProposeResult(
+                plugin_id="builtin-throughput-propose",
+                priority=50,
+                result_kind="override",
+                override=pyd.OverrideResult(
+                    targets=[
+                        pyd.ComponentTarget(
+                            sub_component_type="prefill",
+                            replicas=6,
+                            type=pyd.OverrideType.AT_LEAST,
+                        )
+                    ],
+                ),
+            ),
+            pyd.ProposeResult(
+                plugin_id="builtin-load-propose",
+                priority=10,
+                result_kind="override",
+                override=pyd.OverrideResult(
+                    targets=[
+                        pyd.ComponentTarget(sub_component_type="prefill", replicas=8)
+                    ],
+                ),
+            ),
+            pyd.ProposeResult(
+                plugin_id="user-quiet-plugin",
+                priority=100,
+                result_kind="accept",
+                accept=pyd.AcceptResult(),
+            ),
+        ],
+    )
+    msg_back = _round_trip_pyd(msg)
+    assert len(msg_back.proposals) == 3
+    assert msg_back.proposals[1].priority == 10
+
+
+def test_propose_result_derives_result_kind_from_payload():
+    """``ProposeResult`` built the natural way (payload only, no explicit
+    ``result_kind``) must auto-derive ``result_kind`` and survive the proto
+    round-trip unchanged — same ergonomics + oneof guard as the stage
+    responses. Pre-fix it had no model_post_init, so result_kind stayed ''
+    on construction and came back 'override' from WhichOneof, breaking
+    round-trip equality."""
+    pr = pyd.ProposeResult(
+        plugin_id="p1",
+        priority=10,
+        override=pyd.OverrideResult(
+            targets=[pyd.ComponentTarget(sub_component_type="prefill", replicas=8)]
+        ),
+    )
+    # Auto-derived on construction, not left as "".
+    assert pr.result_kind == "override"
+    assert _round_trip_pyd(pr) == pr
+
+    # Oneof violation is rejected at construction, like the stage responses.
+    with pytest.raises(ValueError, match="oneof violation"):
+        pyd.ProposeResult(
+            plugin_id="p2",
+            accept=pyd.AcceptResult(),
+            reject=pyd.RejectResult(reason="no"),
+        )
+
+
+def test_constrain_stage_response_at_least_at_most():
+    """CONSTRAIN typically returns AT_LEAST + AT_MOST (no SET)."""
+    msg = pyd.ConstrainStageResponse(
+        override=pyd.OverrideResult(
+            targets=[
+                pyd.ComponentTarget(
+                    sub_component_type="prefill",
+                    replicas=2,
+                    type=pyd.OverrideType.AT_LEAST,
+                ),
+                pyd.ComponentTarget(
+                    sub_component_type="prefill",
+                    replicas=20,
+                    type=pyd.OverrideType.AT_MOST,
+                ),
+            ],
+            reason="builtin-budget-constrain: min_endpoint=2 max_gpu_budget=20",
+        ),
+    )
+    _round_trip_pyd(msg)
+
+
+# ---- PluginLifecycle messages ----
+
+
+def test_bootstrap_request_with_data_and_hints():
+    msg = pyd.BootstrapRequest(
+        bootstrap_data=b"\x00\x01\x02benchmark FPM serialized\xff",
+        hints={"regression_kind": "prefill", "model_size": "70b"},
+    )
+    msg_back = _round_trip_pyd(msg)
+    assert msg_back.bootstrap_data == b"\x00\x01\x02benchmark FPM serialized\xff"
+    assert msg_back.hints["regression_kind"] == "prefill"
+
+
+def test_reset_request_with_reason():
+    msg = pyd.ResetRequest(reason="config_reload")
+    _round_trip_pyd(msg)
+
+
+# ---- Wire-bytes deterministic for representative messages ----
+
+
+@pytest.mark.parametrize(
+    "msg",
+    [
+        pyd.RegisterRequest(plugin_id="x", plugin_type="propose", priority=10),
+        pyd.OverrideResult(
+            targets=[pyd.ComponentTarget(sub_component_type="prefill", replicas=8)]
+        ),
+        pyd.PipelineContext(request_id="r"),
+    ],
+    ids=["RegisterRequest", "OverrideResult", "PipelineContext"],
+)
+def test_wire_deterministic(msg):
+    """Same Pydantic input → same wire bytes (no field reordering)."""
+    pb1 = pydantic_to_proto(msg)
+    pb2 = pydantic_to_proto(msg)
+    assert pb1.SerializeToString() == pb2.SerializeToString()
diff --git a/components/src/dynamo/planner/tests/plugins/registry/__init__.py b/components/src/dynamo/planner/tests/plugins/registry/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/registry/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/tests/plugins/registry/auth/__init__.py b/components/src/dynamo/planner/tests/plugins/registry/auth/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/registry/auth/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/tests/plugins/registry/auth/test_allow_unauthenticated.py b/components/src/dynamo/planner/tests/plugins/registry/auth/test_allow_unauthenticated.py
new file mode 100644
index 000000000000..682543ad6d1a
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/registry/auth/test_allow_unauthenticated.py
@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for AllowUnauthenticatedAuth.
+
+The validator is dev-only. Construction must log a WARNING so operators
+see it even if no Register call ever arrives.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import pytest
+
+from dynamo.planner.plugins.registry.auth import AllowUnauthenticatedAuth
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+def test_construction_emits_warning(caplog):
+    with caplog.at_level(
+        logging.WARNING, logger="dynamo.planner.plugins.registry.auth.base"
+    ):
+        AllowUnauthenticatedAuth()
+    warnings = [r for r in caplog.records if r.levelno == logging.WARNING]
+    assert any("DEV ONLY" in r.message for r in warnings)
+
+
+@pytest.mark.asyncio
+async def test_accepts_any_token_including_empty():
+    auth = AllowUnauthenticatedAuth()
+    identity = await auth.validate("anything")
+    assert identity.source == "allow_unauthenticated"
+    assert identity.subject == "anonymous"
+
+    identity_empty = await auth.validate("")
+    assert identity_empty.source == "allow_unauthenticated"
diff --git a/components/src/dynamo/planner/tests/plugins/registry/auth/test_multi.py b/components/src/dynamo/planner/tests/plugins/registry/auth/test_multi.py
new file mode 100644
index 000000000000..2e5c3f908ad0
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/registry/auth/test_multi.py
@@ -0,0 +1,78 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for MultiSourceAuth."""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.registry.auth import (
+    AuthIdentity,
+    AuthValidator,
+    MultiSourceAuth,
+)
+from dynamo.planner.plugins.registry.errors import AuthError
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+class _Stub(AuthValidator):
+    def __init__(self, name, accept_tokens=(), raise_msg=None):
+        self.name = name
+        self.accept_tokens = set(accept_tokens)
+        self.raise_msg = raise_msg
+        self.calls = 0
+
+    async def validate(self, token):
+        self.calls += 1
+        if self.raise_msg:
+            raise AuthError(self.raise_msg)
+        if token in self.accept_tokens:
+            return AuthIdentity(source="static_secret", subject=f"from_{self.name}")
+        raise AuthError(f"{self.name}: unknown token")
+
+
+@pytest.mark.asyncio
+async def test_first_source_accepts_short_circuits():
+    a = _Stub("a", accept_tokens=["tok"])
+    b = _Stub("b", accept_tokens=["tok"])
+    multi = MultiSourceAuth([a, b])
+    identity = await multi.validate("tok")
+    assert identity.subject == "from_a"
+    assert a.calls == 1
+    assert b.calls == 0  # short-circuited
+
+
+@pytest.mark.asyncio
+async def test_second_source_accepts_when_first_rejects():
+    a = _Stub("a")
+    b = _Stub("b", accept_tokens=["tok"])
+    multi = MultiSourceAuth([a, b])
+    identity = await multi.validate("tok")
+    assert identity.subject == "from_b"
+    assert a.calls == 1
+    assert b.calls == 1
+
+
+@pytest.mark.asyncio
+async def test_all_sources_reject_raises_chained_last_error():
+    a = _Stub("a", raise_msg="A_FAILED")
+    b = _Stub("b", raise_msg="B_FAILED")
+    multi = MultiSourceAuth([a, b])
+    with pytest.raises(AuthError) as excinfo:
+        await multi.validate("tok")
+    # All sources consulted; last error surfaces.
+    assert "B_FAILED" in str(excinfo.value)
+    assert a.calls == 1
+    assert b.calls == 1
+
+
+def test_empty_source_list_rejected_at_construction():
+    with pytest.raises(ValueError, match="at least one source"):
+        MultiSourceAuth([])
diff --git a/components/src/dynamo/planner/tests/plugins/registry/auth/test_static_secret.py b/components/src/dynamo/planner/tests/plugins/registry/auth/test_static_secret.py
new file mode 100644
index 000000000000..69c775d3fa02
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/registry/auth/test_static_secret.py
@@ -0,0 +1,99 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for StaticSecretAuth."""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.registry.auth import StaticSecretAuth
+from dynamo.planner.plugins.registry.errors import AuthError
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+@pytest.mark.asyncio
+async def test_known_secret_accepted_and_subject_returned():
+    auth = StaticSecretAuth({"secret-alice": "alice", "secret-bob": "bob"})
+    identity = await auth.validate("secret-alice")
+    assert identity.source == "static_secret"
+    assert identity.subject == "alice"
+
+
+@pytest.mark.asyncio
+async def test_unknown_secret_rejected():
+    auth = StaticSecretAuth({"secret-alice": "alice"})
+    with pytest.raises(AuthError, match="not in trusted set"):
+        await auth.validate("wrong")
+
+
+@pytest.mark.asyncio
+async def test_empty_token_rejected():
+    auth = StaticSecretAuth({"secret-alice": "alice"})
+    with pytest.raises(AuthError, match="empty token"):
+        await auth.validate("")
+
+
+@pytest.mark.asyncio
+async def test_empty_secrets_map_rejects_all():
+    # Fail-closed when Secret mount is empty or misconfigured.
+    auth = StaticSecretAuth({})
+    with pytest.raises(AuthError, match="not in trusted set"):
+        await auth.validate("any")
+
+
+@pytest.mark.asyncio
+async def test_constant_time_compare_prefix_mismatch_still_rejects():
+    # hmac.compare_digest rejects any non-exact match; exercising a
+    # prefix match ensures we're not accidentally using startswith/==
+    # with early-exit that would leak timing info.
+    auth = StaticSecretAuth({"secret-alice": "alice"})
+    with pytest.raises(AuthError):
+        await auth.validate("secret-ali")
+    with pytest.raises(AuthError):
+        await auth.validate("secret-alice-extra")
+
+
+def test_construction_rejects_empty_subject():
+    """Empty subject is rejected at construction time so the gateway's
+    ``authenticated_unregister`` subject-match check cannot be bypassed
+    against in-process plugins (which default to ``auth_subject=""``).
+    See ``static_secret.py`` constructor + ``server.authenticated_unregister``.
+    """
+    with pytest.raises(ValueError, match="empty subject"):
+        StaticSecretAuth({"some-token": ""})
+
+
+def test_construction_rejects_empty_subject_among_valid_entries():
+    """A mixed mapping where only one entry has an empty subject still
+    fails fast — fail-closed at config validation."""
+    with pytest.raises(ValueError, match="empty subject"):
+        StaticSecretAuth({"good-token": "ext-plugins", "bad-token": ""})
+
+
+def test_construction_accepts_all_distinguishing_subjects():
+    """Valid mapping (every secret → non-empty subject) constructs cleanly."""
+    auth = StaticSecretAuth({"t1": "subj-a", "t2": "subj-b"})
+    assert auth is not None
+
+
+def test_empty_subject_error_does_not_leak_secret_bytes():
+    """The empty-subject ValueError must not include any prefix of the
+    secret token. Startup logs and config-validation surfaces can
+    surface this message, so even a 4-char prefix is an unnecessary
+    secret leak."""
+    secret = "super-secret-token-please-do-not-log-me"
+    with pytest.raises(ValueError, match="empty subject") as exc_info:
+        StaticSecretAuth({secret: ""})
+    msg = str(exc_info.value)
+    # No substring of the token may appear in the error message. We
+    # check at least the first 4 chars (the previous bug) plus a few
+    # longer windows just to be sure.
+    for window in (secret[:4], secret[:6], secret[:8], secret):
+        assert window not in msg, f"error message leaks {window!r}: {msg!r}"
diff --git a/components/src/dynamo/planner/tests/plugins/registry/test_circuit_breaker.py b/components/src/dynamo/planner/tests/plugins/registry/test_circuit_breaker.py
new file mode 100644
index 000000000000..a44c95d4bbd7
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/registry/test_circuit_breaker.py
@@ -0,0 +1,165 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for CircuitBreaker using VirtualClock."""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.clock import VirtualClock
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+from dynamo.planner.plugins.types import CircuitState
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+def _cb(**kwargs):
+    clock = VirtualClock()
+    return clock, CircuitBreaker(clock, **kwargs)
+
+
+def test_initial_state_closed_for_unknown_plugin():
+    _, cb = _cb()
+    assert cb.state("p1") == CircuitState.CLOSED
+    assert cb.can_call("p1") is True
+
+
+def test_transitions_to_open_after_threshold_failures():
+    _, cb = _cb(failure_threshold=3)
+    for _ in range(2):
+        cb.record_failure("p1")
+    assert cb.state("p1") == CircuitState.CLOSED
+    cb.record_failure("p1")
+    assert cb.state("p1") == CircuitState.OPEN
+    assert cb.can_call("p1") is False
+
+
+def test_success_resets_failure_count_before_opening():
+    _, cb = _cb(failure_threshold=3)
+    cb.record_failure("p1")
+    cb.record_failure("p1")
+    cb.record_success("p1")
+    cb.record_failure("p1")
+    cb.record_failure("p1")
+    # Still below threshold after the reset.
+    assert cb.state("p1") == CircuitState.CLOSED
+
+
+def test_open_transitions_to_half_open_after_cooldown():
+    clock, cb = _cb(failure_threshold=1, cooldown_seconds=10.0)
+    cb.record_failure("p1")
+    assert cb.state("p1") == CircuitState.OPEN
+
+    clock.advance(5.0)
+    assert cb.state("p1") == CircuitState.OPEN  # still in cooldown
+
+    clock.advance(5.0)
+    # Now 10s elapsed -> HALF_OPEN via the lazy check in state().
+    assert cb.state("p1") == CircuitState.HALF_OPEN
+    assert cb.can_call("p1") is True
+
+
+def test_half_open_success_returns_to_closed():
+    clock, cb = _cb(failure_threshold=1, cooldown_seconds=10.0)
+    cb.record_failure("p1")
+    clock.advance(10.0)
+    assert cb.state("p1") == CircuitState.HALF_OPEN
+
+    cb.record_success("p1")
+    assert cb.state("p1") == CircuitState.CLOSED
+
+
+def test_half_open_failure_reopens_and_resets_cooldown():
+    clock, cb = _cb(failure_threshold=1, cooldown_seconds=10.0)
+    cb.record_failure("p1")
+    clock.advance(10.0)
+    assert cb.state("p1") == CircuitState.HALF_OPEN
+
+    cb.record_failure("p1")
+    assert cb.state("p1") == CircuitState.OPEN
+
+    # Cooldown starts over from the reopen moment.
+    clock.advance(9.0)
+    assert cb.state("p1") == CircuitState.OPEN
+    clock.advance(1.0)
+    assert cb.state("p1") == CircuitState.HALF_OPEN
+
+
+def test_reset_clears_state_back_to_closed():
+    _, cb = _cb(failure_threshold=2)
+    cb.record_failure("p1")
+    cb.record_failure("p1")
+    assert cb.state("p1") == CircuitState.OPEN
+    cb.reset("p1")
+    assert cb.state("p1") == CircuitState.CLOSED
+    # Implicit entry cleared; counter starts from zero.
+    cb.record_failure("p1")
+    assert cb.state("p1") == CircuitState.CLOSED
+
+
+def test_on_open_callback_fires_on_closed_to_open():
+    _, cb = _cb(failure_threshold=2)
+    opens: list[str] = []
+    cb.on_open(opens.append)
+    cb.record_failure("p1")
+    assert opens == []
+    cb.record_failure("p1")
+    assert opens == ["p1"]
+
+
+def test_on_open_callback_fires_on_half_open_to_open_reopen():
+    clock, cb = _cb(failure_threshold=1, cooldown_seconds=5.0)
+    opens: list[str] = []
+    cb.on_open(opens.append)
+    cb.record_failure("p1")
+    assert opens == ["p1"]
+
+    clock.advance(5.0)  # HALF_OPEN
+    cb.record_failure("p1")  # reopen
+    assert opens == ["p1", "p1"]
+
+
+def test_on_open_callback_failure_does_not_skip_remaining_callbacks():
+    """One bad observer must not turn a per-plugin circuit-breaker
+    open into a registry-wide failure. The remaining ``on_open``
+    callbacks should still fire even if an earlier one raises."""
+    _, cb = _cb(failure_threshold=1)
+    fired: list[str] = []
+
+    def bad_callback(plugin_id: str) -> None:
+        raise RuntimeError("observer-side bug")
+
+    cb.on_open(bad_callback)
+    cb.on_open(lambda pid: fired.append(pid))
+
+    # Failure-threshold reached → CLOSED → OPEN → fan_out_open
+    cb.record_failure("p1")
+
+    # The second callback must have fired despite the first one raising.
+    assert fired == ["p1"], (
+        "second on_open callback should fire even when first raises; "
+        f"got fired={fired!r}"
+    )
+
+
+def test_multiple_plugins_tracked_independently():
+    clock, cb = _cb(failure_threshold=2, cooldown_seconds=5.0)
+    cb.record_failure("p1")
+    cb.record_failure("p1")
+    cb.record_failure("p2")
+    assert cb.state("p1") == CircuitState.OPEN
+    assert cb.state("p2") == CircuitState.CLOSED
+
+
+def test_invalid_config_rejected():
+    clock = VirtualClock()
+    with pytest.raises(ValueError):
+        CircuitBreaker(clock, failure_threshold=0)
+    with pytest.raises(ValueError):
+        CircuitBreaker(clock, cooldown_seconds=0)
diff --git a/components/src/dynamo/planner/tests/plugins/registry/test_config.py b/components/src/dynamo/planner/tests/plugins/registry/test_config.py
new file mode 100644
index 000000000000..8d37d7eab4ba
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/registry/test_config.py
@@ -0,0 +1,179 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for registry config + factories."""
+
+from __future__ import annotations
+
+import logging
+
+import pytest
+from pydantic import ValidationError
+
+from dynamo.planner.plugins.clock import VirtualClock
+from dynamo.planner.plugins.registry.auth import MultiSourceAuth
+from dynamo.planner.plugins.registry.config import (
+    AuthConfig,
+    InProcessPluginSpec,
+    PluginRegistrationConfig,
+    build_auth_validator,
+    build_registry_from_config,
+)
+from dynamo.planner.plugins.registry.server import PluginRegistryServer
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+# ---------------------------------------------------------------------------
+# build_auth_validator
+# ---------------------------------------------------------------------------
+
+
+def test_empty_trusted_sources_rejected():
+    with pytest.raises(ValueError, match="trusted_sources"):
+        build_auth_validator(AuthConfig())
+
+
+def test_static_secret_only_builds_multi_with_one_source():
+    validator = build_auth_validator(
+        AuthConfig(trusted_sources=["static_secret"], static_secrets={"t": "a"})
+    )
+    assert isinstance(validator, MultiSourceAuth)
+
+
+def test_static_secret_empty_secrets_logs_warning(caplog):
+    with caplog.at_level(
+        logging.WARNING, logger="dynamo.planner.plugins.registry.config"
+    ):
+        build_auth_validator(
+            AuthConfig(trusted_sources=["static_secret"], static_secrets={})
+        )
+    assert any("static_secrets is empty" in r.message for r in caplog.records)
+
+
+def test_allow_unauthenticated_source_supported():
+    validator = build_auth_validator(
+        AuthConfig(trusted_sources=["allow_unauthenticated"])
+    )
+    assert isinstance(validator, MultiSourceAuth)
+
+
+@pytest.mark.asyncio
+async def test_multi_source_preserves_order():
+    validator = build_auth_validator(
+        AuthConfig(
+            trusted_sources=["static_secret", "allow_unauthenticated"],
+            static_secrets={"good": "alice"},
+        )
+    )
+    # Unknown token falls through to allow_unauthenticated (anonymous).
+    identity = await validator.validate("unknown")
+    assert identity.source == "allow_unauthenticated"
+    # Known token is accepted by the first source.
+    identity2 = await validator.validate("good")
+    assert identity2.source == "static_secret"
+
+
+def test_unknown_source_rejected_by_pydantic():
+    """``AuthSource`` is a Literal restricted to the sources PR #1 ships
+    (``static_secret`` / ``allow_unauthenticated``). Anything else —
+    including the follow-up ``k8s_sa`` / ``spiffe_jwt`` — fails Pydantic
+    validation before reaching ``build_auth_validator``."""
+    with pytest.raises(ValidationError):
+        AuthConfig(trusted_sources=["k8s_sa"])  # type: ignore[list-item]
+
+
+# ---------------------------------------------------------------------------
+# build_registry_from_config
+# ---------------------------------------------------------------------------
+
+
+def test_build_registry_from_config_returns_server_and_breaker():
+    config = PluginRegistrationConfig(
+        auth=AuthConfig(trusted_sources=["static_secret"], static_secrets={"t": "a"}),
+    )
+    clock = VirtualClock()
+    server, cb = build_registry_from_config(config, clock)
+    assert isinstance(server, PluginRegistryServer)
+    # Circuit breaker returned so orchestrator can hand it to scheduler / monitor.
+    assert cb is not None
+
+
+@pytest.mark.asyncio
+async def test_build_registry_propagates_protocol_versions():
+    from dynamo.planner.plugins.transport.config import TransportConfig
+    from dynamo.planner.plugins.types import RegisterRequest
+
+    config = PluginRegistrationConfig(
+        auth=AuthConfig(trusted_sources=["allow_unauthenticated"]),
+        protocol_version_min="1.0",
+        protocol_version_max="1.2",
+        # PR #1 dropped unix:// transport; tests now use grpc:// stub
+        # endpoints, which require allow_insecure_grpc=True.
+        transport=TransportConfig(allow_insecure_grpc=True),
+    )
+    clock = VirtualClock()
+    server, _ = build_registry_from_config(config, clock)
+    # v1.1 is in range [1.0, 1.2] — accepted.
+    resp = await server.register(
+        RegisterRequest(
+            plugin_id="p",
+            plugin_type="propose",
+            endpoint="grpc://127.0.0.1:9000",
+            protocol_version="1.1",
+        )
+    )
+    assert resp.accepted, resp.reject_reason
+
+
+# ---------------------------------------------------------------------------
+# InProcessPluginSpec
+# ---------------------------------------------------------------------------
+
+
+def test_in_process_plugin_spec_rejects_unknown_field_protocol_version():
+    # In-process plugins are compile-time bound; protocol_version is
+    # nonsensical and should be rejected by extra='forbid'.
+    with pytest.raises(ValidationError):
+        InProcessPluginSpec(
+            module="x",
+            **{"class": "Y"},
+            plugin_id="p",
+            plugin_type="propose",
+            priority=1,
+            protocol_version="1.0",  # type: ignore[call-arg]
+        )
+
+
+def test_in_process_plugin_spec_class_alias_works():
+    spec = InProcessPluginSpec.model_validate(
+        {
+            "module": "dynamo.example",
+            "class": "MyPlugin",
+            "plugin_id": "mp",
+            "plugin_type": "predict",
+            "priority": 5,
+        }
+    )
+    assert spec.class_ == "MyPlugin"
+    assert spec.module == "dynamo.example"
+
+
+def test_in_process_plugin_spec_defaults_reasonable():
+    spec = InProcessPluginSpec.model_validate(
+        {
+            "module": "x",
+            "class": "Y",
+            "plugin_id": "p",
+            "plugin_type": "propose",
+            "priority": 1,
+        }
+    )
+    assert spec.hold_policy == "ACCEPT_WHEN_IDLE"
+    assert spec.execution_interval_seconds == 0.0
+    assert spec.kwargs == {}
diff --git a/components/src/dynamo/planner/tests/plugins/registry/test_external_bootstrap.py b/components/src/dynamo/planner/tests/plugins/registry/test_external_bootstrap.py
new file mode 100644
index 000000000000..858d4e1dd7ed
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/registry/test_external_bootstrap.py
@@ -0,0 +1,388 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tests for ``LocalPlannerOrchestrator.register_external_from_config``
+and ``ExternalPluginEntry`` (static config-driven external plugin
+registration).
+
+This is the deployment model where a list of plugin endpoints is
+supplied to the planner at startup (typically from a ConfigMap),
+and the planner registers each by calling ``registry.register(...)``
+on its own behalf — distinct from the gRPC gateway path (where
+plugins self-register over the network).
+
+Key invariants asserted here:
+
+1. Schema-level rejects (bad scheme, bad type, missing required
+   fields) surface as Pydantic ValidationError before the entry ever
+   reaches the registry.
+2. A bad entry MUST NOT block other entries — failure isolation is
+   the difference between "ConfigMap typo" and "planner crashloop".
+3. Per-entry failure path returns the registry's reject_reason
+   verbatim so operators can debug without log-grepping.
+4. Registered plugins show up in ``list_plugins`` with the right
+   transport label (uds / grpc), matching what the e2e test would see.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.config.planner_config import ExternalPluginEntry
+from dynamo.planner.plugins.clock import VirtualClock
+from dynamo.planner.plugins.orchestrator.orchestrator import LocalPlannerOrchestrator
+from dynamo.planner.plugins.registry.auth.base import (
+    AllowUnauthenticatedAuth,
+    AuthIdentity,
+    AuthValidator,
+)
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+from dynamo.planner.plugins.registry.errors import AuthError
+from dynamo.planner.plugins.registry.server import PluginRegistryServer
+from dynamo.planner.plugins.scheduler import PluginScheduler
+from dynamo.planner.plugins.transport.base import PluginTransport
+from dynamo.planner.plugins.types import HoldPolicy, ListPluginsRequest
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+class _StubTransport(PluginTransport):
+    def __init__(self, plugin_id, endpoint, *, in_process_instance=None, **_):
+        self.plugin_id = plugin_id
+        self.endpoint = endpoint
+        self.timeout_seconds = 1.0
+        self.closed = False
+
+    async def call(self, method, request):
+        return None
+
+    async def close(self):
+        self.closed = True
+
+
+def _build_orch(
+    *, auth: AuthValidator | None = None
+) -> tuple[LocalPlannerOrchestrator, PluginRegistryServer]:
+    clock = VirtualClock()
+    cb = CircuitBreaker(clock)
+
+    def factory(plugin_id, endpoint, *, in_process_instance=None):
+        return _StubTransport(plugin_id, endpoint)
+
+    server = PluginRegistryServer(
+        clock=clock,
+        auth=auth or AllowUnauthenticatedAuth(),
+        circuit_breaker=cb,
+        transport_factory=factory,
+    )
+    scheduler = PluginScheduler(server, cb, clock)
+    orch = LocalPlannerOrchestrator(
+        registry=server,
+        scheduler=scheduler,
+        circuit_breaker=cb,
+        clock=clock,
+        capabilities=None,
+    )
+    return orch, server
+
+
+def _entry(
+    plugin_id: str,
+    *,
+    plugin_type: str = "propose",
+    priority: int = 5,
+    endpoint: str = "grpc://127.0.0.1:9000",
+    auth_token: str = "tok",
+    protocol_version: str = "1.0",
+    version: str = "v1",
+    hold_policy: HoldPolicy = HoldPolicy.HOLD_LAST,
+) -> ExternalPluginEntry:
+    return ExternalPluginEntry(
+        plugin_id=plugin_id,
+        plugin_type=plugin_type,
+        priority=priority,
+        endpoint=endpoint,
+        auth_token=auth_token,
+        protocol_version=protocol_version,
+        version=version,
+        hold_policy=hold_policy,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Schema-level
+# ---------------------------------------------------------------------------
+
+
+def test_entry_rejects_unknown_plugin_type():
+    """plugin_type is Literal'd to the four valid stages — anything
+    else raises Pydantic ValidationError before the orchestrator sees
+    it. Stops typos at the boundary."""
+    from pydantic import ValidationError
+
+    with pytest.raises(ValidationError):
+        ExternalPluginEntry(
+            plugin_id="x",
+            plugin_type="bogus",  # type: ignore[arg-type]
+            priority=5,
+            endpoint="grpc://127.0.0.1:9000",
+        )
+
+
+def test_entry_rejects_empty_endpoint():
+    from pydantic import ValidationError
+
+    with pytest.raises(ValidationError):
+        ExternalPluginEntry(
+            plugin_id="x",
+            plugin_type="propose",
+            priority=5,
+            endpoint="",
+        )
+
+
+def test_entry_default_hold_policy_is_hold_last():
+    """HOLD_LAST is the recommended default for static-config plugins —
+    they're typically slow regression-style decisions that should
+    persist across throttled ticks."""
+    e = ExternalPluginEntry(
+        plugin_id="x",
+        plugin_type="propose",
+        priority=5,
+        endpoint="grpc://127.0.0.1:9000",
+    )
+    assert e.hold_policy == HoldPolicy.HOLD_LAST
+
+
+# ---------------------------------------------------------------------------
+# Bootstrap: empty + happy path
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_bootstrap_empty_list_no_op():
+    orch, server = _build_orch()
+    accepted, failures = await orch.register_external_from_config([])
+    assert accepted == 0
+    assert failures == []
+    assert server.list_plugins(ListPluginsRequest()) == []
+
+
+@pytest.mark.asyncio
+async def test_bootstrap_happy_path_registers_entry():
+    orch, server = _build_orch()
+    accepted, failures = await orch.register_external_from_config(
+        [
+            _entry("ext-a", endpoint="grpc://127.0.0.1:9000"),
+        ]
+    )
+    assert accepted == 1
+    assert failures == []
+    plugins = server.list_plugins(ListPluginsRequest())
+    assert [p.plugin_id for p in plugins] == ["ext-a"]
+    assert plugins[0].transport == "grpc"
+    assert plugins[0].plugin_type == "propose"
+
+
+@pytest.mark.asyncio
+async def test_bootstrap_records_grpc_endpoint_correctly():
+    """Different scheme → different transport label visible in
+    list_plugins. Validates the entry → factory → transport_type
+    derivation works for grpc:// not just unix://."""
+    orch, server = _build_orch()
+    await orch.register_external_from_config(
+        [
+            _entry("ext-tcp", endpoint="grpc://10.0.0.5:9090"),
+        ]
+    )
+    info = server.list_plugins(ListPluginsRequest())[0]
+    assert info.transport == "grpc"
+
+
+# ---------------------------------------------------------------------------
+# Failure isolation: one bad entry must not stop the others
+# ---------------------------------------------------------------------------
+
+
+class _SelectiveAuth(AuthValidator):
+    """Approves any token in ``allow``; rejects everything else.
+    Used to drive per-entry auth failure paths deterministically."""
+
+    def __init__(self, allow: set[str]) -> None:
+        self._allow = set(allow)
+
+    async def validate(self, token):
+        if token in self._allow:
+            return AuthIdentity(source="static_secret", subject=token, metadata={})
+        raise AuthError(f"selective_auth: token {token!r} not allowed")
+
+
+@pytest.mark.asyncio
+async def test_bootstrap_auth_failure_isolated():
+    """Two entries; first has bad auth, second has good. The first
+    must fail with reject_reason='auth_failed' and the second must
+    still succeed — failure isolation is the primary contract this
+    function exists for."""
+    orch, server = _build_orch(auth=_SelectiveAuth(allow={"good"}))
+    accepted, failures = await orch.register_external_from_config(
+        [
+            _entry("bad-auth", auth_token="WRONG"),
+            _entry("good-auth", auth_token="good"),
+        ]
+    )
+    assert accepted == 1
+    assert len(failures) == 1
+    assert failures[0][0] == "bad-auth"
+    assert "auth_failed" in failures[0][1]
+    # Good plugin still registered.
+    ids = {p.plugin_id for p in server.list_plugins(ListPluginsRequest())}
+    assert ids == {"good-auth"}
+
+
+@pytest.mark.asyncio
+async def test_bootstrap_inproc_endpoint_rejected():
+    """``inproc://`` over the public register() path is a deployment
+    bug — static-config plugins are out-of-process by definition.
+    The reject must surface to the caller via failures, but other
+    entries must continue."""
+    orch, server = _build_orch()
+    accepted, failures = await orch.register_external_from_config(
+        [
+            _entry("misconfigured", endpoint="inproc://x"),
+            _entry("ok", endpoint="grpc://127.0.0.1:9000"),
+        ]
+    )
+    assert accepted == 1
+    assert {f[0] for f in failures} == {"misconfigured"}
+    assert "inproc://" in failures[0][1]
+
+
+@pytest.mark.asyncio
+async def test_bootstrap_protocol_mismatch_isolated():
+    """Plugin asking for an unsupported protocol_version must be
+    rejected without dragging others down. Catches operator errors
+    where a stale ConfigMap entry references an old protocol."""
+    orch, server = _build_orch()
+    accepted, failures = await orch.register_external_from_config(
+        [
+            _entry("too-new", protocol_version="9.9"),
+            _entry("ok"),
+        ]
+    )
+    assert accepted == 1
+    assert {f[0] for f in failures} == {"too-new"}
+    assert "protocol_version_unsupported" in failures[0][1]
+
+
+@pytest.mark.asyncio
+async def test_bootstrap_duplicate_plugin_id_within_config():
+    """Two entries with the same plugin_id: first wins, second is
+    rejected as duplicate. Catches a common ConfigMap copy-paste
+    error before it manifests as confusing tick behaviour."""
+    orch, server = _build_orch()
+    accepted, failures = await orch.register_external_from_config(
+        [
+            _entry("dup", endpoint="grpc://127.0.0.1:9000"),
+            _entry("dup", endpoint="grpc://127.0.0.1:9000"),
+        ]
+    )
+    assert accepted == 1
+    assert {f[0] for f in failures} == {"dup"}
+    assert "duplicate_plugin_id" in failures[0][1]
+
+
+# ---------------------------------------------------------------------------
+# Idempotency
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_bootstrap_called_twice_second_is_all_duplicates():
+    """Calling register_external_from_config twice with the same list
+    on the same orchestrator: first run registers everything, second
+    run sees them all as duplicates. Confirms there's no implicit
+    'force re-register' that would silently break HOLD_LAST caches."""
+    orch, server = _build_orch()
+    entries = [_entry("a"), _entry("b", endpoint="grpc://h:1")]
+    accepted_1, failures_1 = await orch.register_external_from_config(entries)
+    assert accepted_1 == 2 and failures_1 == []
+    accepted_2, failures_2 = await orch.register_external_from_config(entries)
+    assert accepted_2 == 0
+    assert {f[0] for f in failures_2} == {"a", "b"}
+    for _, reason in failures_2:
+        assert "duplicate_plugin_id" in reason
+
+
+# ---------------------------------------------------------------------------
+# Multi-stage smoke test: 4 stages registered side-by-side
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_bootstrap_registers_all_four_stages():
+    """Four entries, one per plugin_type. All four end up in
+    list_plugins with the right plugin_type label. Validates the
+    schema's plugin_type Literal lines up with the registry's accepted
+    set."""
+    orch, server = _build_orch()
+    accepted, failures = await orch.register_external_from_config(
+        [
+            _entry("ext-pred", plugin_type="predict", priority=1),
+            _entry("ext-prop", plugin_type="propose", priority=5),
+            _entry("ext-recon", plugin_type="reconcile", priority=2),
+            _entry("ext-cons", plugin_type="constrain", priority=3),
+        ]
+    )
+    assert accepted == 4
+    assert failures == []
+    by_id = {
+        p.plugin_id: p.plugin_type for p in server.list_plugins(ListPluginsRequest())
+    }
+    assert by_id == {
+        "ext-pred": "predict",
+        "ext-prop": "propose",
+        "ext-recon": "reconcile",
+        "ext-cons": "constrain",
+    }
+
+
+@pytest.mark.asyncio
+async def test_bootstrap_passes_scale_interval_fields_through():
+    """``ExternalPluginEntry`` newly exposes ``requires_produced_fields``
+    and ``observation_window_seconds``. ``register_external_from_config``
+    must thread both into the ``RegisterRequest`` it constructs, or
+    ConfigMap-driven external plugins cannot use the scale_interval
+    cadence contract — even though gRPC self-registrants already can.
+    """
+    orch, server = _build_orch()
+    entry = ExternalPluginEntry(
+        plugin_id="ext-tput-propose",
+        plugin_type="propose",
+        priority=100,
+        endpoint="grpc://127.0.0.1:9000",
+        auth_token="tok",
+        protocol_version="1.0",
+        version="v1",
+        execution_interval_seconds=60.0,
+        hold_policy=HoldPolicy.HOLD_LAST,
+        needs=["observations.traffic"],
+        requires_produced_fields=["predictions"],
+        observation_window_seconds=180.0,
+    )
+    accepted, failures = await orch.register_external_from_config([entry])
+    assert accepted == 1 and failures == []
+    plugin = server.get_plugin("ext-tput-propose")
+    assert plugin is not None
+    assert plugin.requires_produced_fields == ["predictions"]
+    assert plugin.observation_window_seconds == 180.0
+    assert plugin.needs == ["observations.traffic"]
diff --git a/components/src/dynamo/planner/tests/plugins/registry/test_gateway.py b/components/src/dynamo/planner/tests/plugins/registry/test_gateway.py
new file mode 100644
index 000000000000..9747ad2ee47f
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/registry/test_gateway.py
@@ -0,0 +1,335 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for ``PluginRegistryGatewayServicer``.
+
+Focuses on the auth-gating contract for ``Heartbeat`` / ``Unregister`` /
+``ListPlugins`` — the in-process methods are exercised by
+``test_server.py``; this file checks that the gateway layer maps server
+``(ok, reject)`` results onto the correct gRPC status codes and does NOT
+let unauthenticated callers reach destructive operations.
+
+Uses a stub ``ServicerContext`` that records ``abort`` and raises
+``grpc.aio.AbortError`` so the servicer's ``raise # unreachable`` lines
+behave the same way as on a real gRPC connection.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import grpc
+import pytest
+
+from dynamo.planner.plugins.clock import VirtualClock
+from dynamo.planner.plugins.proto.v1 import plugin_pb2 as pb
+from dynamo.planner.plugins.registry.auth import AuthIdentity, AuthValidator
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+from dynamo.planner.plugins.registry.errors import AuthError
+from dynamo.planner.plugins.registry.gateway import PluginRegistryGatewayServicer
+from dynamo.planner.plugins.registry.server import PluginRegistryServer
+from dynamo.planner.plugins.transport.base import PluginTransport
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+class _StubTransport(PluginTransport):
+    def __init__(self, plugin_id, endpoint, *, in_process_instance=None):
+        self.plugin_id = plugin_id
+        self.endpoint = endpoint
+        self.timeout_seconds = 1.0
+        self.instance = in_process_instance
+        self.closed = False
+
+    async def call(self, method, request):
+        return None
+
+    async def close(self):
+        self.closed = True
+
+
+class _PerTokenAuth(AuthValidator):
+    """token → subject; ``"bad"`` raises so auth_failed is reachable."""
+
+    async def validate(self, token: str) -> AuthIdentity:
+        if token == "bad":
+            raise AuthError("invalid")
+        return AuthIdentity(source="static_secret", subject=f"subj-{token}")
+
+
+class _FakeContext:
+    """Minimal ``grpc.aio.ServicerContext`` substitute.
+
+    Records the ``abort`` call (code + message) and raises
+    ``grpc.aio.AbortError`` so the servicer's post-abort ``raise`` is
+    consistent with real RPC behaviour.
+    """
+
+    def __init__(self) -> None:
+        self.aborted_code: Any = None
+        self.aborted_message: str = ""
+
+    async def abort(self, code, message: str) -> None:
+        self.aborted_code = code
+        self.aborted_message = message
+        raise grpc.aio.AbortError()
+
+
+def _make_servicer():
+    clock = VirtualClock()
+    cb = CircuitBreaker(clock)
+
+    def factory(plugin_id, endpoint, *, in_process_instance=None):
+        return _StubTransport(
+            plugin_id, endpoint, in_process_instance=in_process_instance
+        )
+
+    server = PluginRegistryServer(
+        clock=clock,
+        auth=_PerTokenAuth(),
+        circuit_breaker=cb,
+        transport_factory=factory,
+        protocol_versions=("1.0", "1.0"),
+    )
+    servicer = PluginRegistryGatewayServicer(server)
+    return server, servicer
+
+
+async def _register(server, plugin_id="p1", auth_token="A"):
+    req = pb.RegisterRequest(
+        plugin_id=plugin_id,
+        plugin_type="propose",
+        priority=10,
+        endpoint="grpc://127.0.0.1:9000",
+        version="1.0.0",
+        protocol_version="1.0",
+        auth_token=auth_token,
+    )
+    # Use the in-process method (already exercised in test_server.py); the
+    # gateway's Register path goes through this same method too.
+    from dynamo.planner.plugins._proto_bridge import proto_to_pydantic
+
+    resp = await server.register(proto_to_pydantic(req))
+    assert resp.accepted is True
+
+
+# ---------------------------------------------------------------------------
+# Heartbeat
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_heartbeat_matching_token_returns_ok():
+    server, svc = _make_servicer()
+    await _register(server)
+    resp = await svc.Heartbeat(
+        pb.HeartbeatRequest(plugin_id="p1", auth_token="A"), _FakeContext()
+    )
+    assert resp.ok is True
+
+
+@pytest.mark.asyncio
+async def test_heartbeat_invalid_token_aborts_unauthenticated():
+    server, svc = _make_servicer()
+    await _register(server)
+    ctx = _FakeContext()
+    with pytest.raises(grpc.aio.AbortError):
+        await svc.Heartbeat(pb.HeartbeatRequest(plugin_id="p1", auth_token="bad"), ctx)
+    assert ctx.aborted_code == grpc.StatusCode.UNAUTHENTICATED
+
+
+@pytest.mark.asyncio
+async def test_heartbeat_subject_mismatch_aborts_permission_denied():
+    server, svc = _make_servicer()
+    await _register(server, auth_token="A")
+    ctx = _FakeContext()
+    with pytest.raises(grpc.aio.AbortError):
+        # token "B" validates but maps to a different subject.
+        await svc.Heartbeat(pb.HeartbeatRequest(plugin_id="p1", auth_token="B"), ctx)
+    assert ctx.aborted_code == grpc.StatusCode.PERMISSION_DENIED
+
+
+# ---------------------------------------------------------------------------
+# Unregister — the destructive RPC. Forged calls MUST NOT evict.
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_unregister_matching_token_removes_plugin():
+    server, svc = _make_servicer()
+    await _register(server)
+    resp = await svc.Unregister(
+        pb.UnregisterRequest(plugin_id="p1", auth_token="A", reason="shutdown"),
+        _FakeContext(),
+    )
+    assert resp.ok is True
+    assert server.get_plugin("p1") is None
+
+
+@pytest.mark.asyncio
+async def test_unregister_invalid_token_aborts_and_keeps_plugin():
+    server, svc = _make_servicer()
+    await _register(server)
+    ctx = _FakeContext()
+    with pytest.raises(grpc.aio.AbortError):
+        await svc.Unregister(
+            pb.UnregisterRequest(plugin_id="p1", auth_token="bad"), ctx
+        )
+    assert ctx.aborted_code == grpc.StatusCode.UNAUTHENTICATED
+    assert server.get_plugin("p1") is not None  # NOT evicted
+
+
+@pytest.mark.asyncio
+async def test_unregister_subject_mismatch_aborts_and_keeps_plugin():
+    """Core security guarantee: a *valid* token from a different subject
+    cannot evict another caller's plugin."""
+    server, svc = _make_servicer()
+    await _register(server, auth_token="A")
+    ctx = _FakeContext()
+    with pytest.raises(grpc.aio.AbortError):
+        await svc.Unregister(pb.UnregisterRequest(plugin_id="p1", auth_token="B"), ctx)
+    assert ctx.aborted_code == grpc.StatusCode.PERMISSION_DENIED
+    assert server.get_plugin("p1") is not None  # NOT evicted
+
+
+# ---------------------------------------------------------------------------
+# ListPlugins — default-deny over gRPC until admin auth lands (PR 1.5).
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_list_plugins_over_gateway_default_denied():
+    _, svc = _make_servicer()
+    ctx = _FakeContext()
+    with pytest.raises(grpc.aio.AbortError):
+        await svc.ListPlugins(pb.ListPluginsRequest(), ctx)
+    assert ctx.aborted_code == grpc.StatusCode.PERMISSION_DENIED
+    # Error message must direct the operator to the in-process path so they
+    # have an escape hatch until admin RBAC lands.
+    assert "in-process" in ctx.aborted_message.lower()
+
+
+# ---------------------------------------------------------------------------
+# start_gateway_server bind-failure handling.
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_start_gateway_server_raises_when_port_zero():
+    """``add_insecure_port`` returns 0 on bind failure (port in use,
+    bad address, etc). The helper must catch that BEFORE starting the
+    server so operators see a clear RuntimeError instead of a silently
+    running gateway that accepts no connections."""
+    from dynamo.planner.plugins.registry import gateway as gw_mod
+    from dynamo.planner.plugins.registry.gateway import start_gateway_server
+
+    server, _ = _make_servicer()
+
+    class _StubAioServer:
+        def __init__(self) -> None:
+            self.started = False
+
+        def add_generic_rpc_handlers(self, _handlers: Any) -> None:
+            # Called by ``add_PluginRegistryServicer_to_server``;
+            # no-op stub for the bind-failure test.
+            pass
+
+        def add_registered_method_handlers(
+            self, _service_name: str, _method_handlers: Any
+        ) -> None:
+            # Newer grpc.aio adds this alongside add_generic_rpc_handlers;
+            # we accept it as a no-op so the servicer install succeeds.
+            pass
+
+        def add_insecure_port(self, _listen: str) -> int:  # noqa: D401
+            # Simulate a bind failure.
+            return 0
+
+        def add_secure_port(self, _listen: str, _creds: Any) -> int:
+            return 0
+
+        async def start(self) -> None:
+            self.started = True
+
+        async def stop(self, *_args: Any, **_kwargs: Any) -> None:
+            pass
+
+    stub = _StubAioServer()
+    # Monkeypatch grpc.aio.server() to return our stub.
+    real_factory = gw_mod.grpc.aio.server
+    gw_mod.grpc.aio.server = lambda: stub  # type: ignore[assignment]
+    try:
+        # allow_insecure=True so we exercise the port==0 bind-failure path
+        # rather than the plaintext-TCP fail-closed guard (a separate test).
+        with pytest.raises(RuntimeError, match="failed to bind"):
+            await start_gateway_server(server, listen="0.0.0.0:1", allow_insecure=True)
+    finally:
+        gw_mod.grpc.aio.server = real_factory  # type: ignore[assignment]
+    assert stub.started is False, (
+        "start_gateway_server must fail fast BEFORE calling grpc_server.start() "
+        "when add_*_port() reports a bind failure"
+    )
+
+
+# ---------------------------------------------------------------------------
+# Plaintext-TCP fail-closed gate (review #6).
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_start_gateway_server_refuses_plaintext_tcp_without_allow_insecure():
+    """A TCP listen with no TLS creds and allow_insecure=False must fail
+    closed — the gateway receives plugins' shared-secret auth tokens, so a
+    plaintext TCP bind would leak them. Mirrors the outbound
+    allow_insecure_grpc gate. The check raises BEFORE any bind."""
+    from dynamo.planner.plugins.registry.gateway import start_gateway_server
+
+    server, _ = _make_servicer()
+    with pytest.raises(RuntimeError, match="refusing to bind plaintext"):
+        await start_gateway_server(server, listen="0.0.0.0:9099", allow_insecure=False)
+
+
+@pytest.mark.asyncio
+async def test_start_gateway_server_allows_plaintext_tcp_when_opted_in():
+    """allow_insecure=True permits the plaintext TCP bind (operator accepted
+    the risk); it must not hit the fail-closed guard."""
+    from dynamo.planner.plugins.registry import gateway as gw_mod
+    from dynamo.planner.plugins.registry.gateway import start_gateway_server
+
+    server, _ = _make_servicer()
+
+    class _StubAioServer:
+        def __init__(self) -> None:
+            self.started = False
+
+        def add_generic_rpc_handlers(self, _handlers: Any) -> None:
+            pass
+
+        def add_registered_method_handlers(self, _s: str, _m: Any) -> None:
+            pass
+
+        def add_insecure_port(self, _listen: str) -> int:
+            return 9099  # simulate a successful bind
+
+        async def start(self) -> None:
+            self.started = True
+
+        async def stop(self, *_a: Any, **_k: Any) -> None:
+            pass
+
+    stub = _StubAioServer()
+    real_factory = gw_mod.grpc.aio.server
+    gw_mod.grpc.aio.server = lambda: stub  # type: ignore[assignment]
+    try:
+        srv, listen = await start_gateway_server(
+            server, listen="0.0.0.0:9099", allow_insecure=True
+        )
+    finally:
+        gw_mod.grpc.aio.server = real_factory  # type: ignore[assignment]
+    assert stub.started is True
+    assert listen == "0.0.0.0:9099"
diff --git a/components/src/dynamo/planner/tests/plugins/registry/test_integration.py b/components/src/dynamo/planner/tests/plugins/registry/test_integration.py
new file mode 100644
index 000000000000..2cee9b3aa231
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/registry/test_integration.py
@@ -0,0 +1,274 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""End-to-end registry integration test.
+
+Exercises the full registry stack wired together — config → auth →
+registry → circuit breaker → scheduler → heartbeat monitor — through
+realistic lifecycle scenarios:
+
+1. Register happy path: config-driven factory + full metadata in
+   ``list_plugins``.
+2. Tick + record_result + HOLD_LAST inheritance across multiple ticks.
+3. Unregister → cache invalidation (row 1 of the cache-invalidation
+   contract).
+4. Circuit breaker OPEN → cache invalidation + plugin drop from
+   active set (row 3), then HALF_OPEN → recovery.
+5. Client-driven version upgrade: unregister + re-register → fresh state
+   (row 4 — fresh Register starts with an empty cache).
+
+Uses in-memory stubs for transport + VirtualClock for determinism. A
+real gRPC socket round-trip test belongs in a ``tests/integration``
+e2e suite; this file keeps coverage at the component-wiring level so it
+runs fast under the ``pre_merge`` CI marker.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.clock import VirtualClock
+from dynamo.planner.plugins.registry.config import (
+    AuthConfig,
+    PluginRegistrationConfig,
+    build_registry_from_config,
+)
+from dynamo.planner.plugins.scheduler import PluginScheduler
+from dynamo.planner.plugins.transport.base import PluginTransport
+from dynamo.planner.plugins.types import (
+    CircuitState,
+    ComponentTarget,
+    HoldPolicy,
+    ListPluginsRequest,
+    OverrideResult,
+    OverrideType,
+    RegisterRequest,
+)
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+# The real transport factory (make_transport_for_endpoint) opens sockets;
+# we monkeypatch at the module level so builds succeed without touching
+# the filesystem / network. The orchestrator e2e suite wires these
+# end-to-end with real UDS.
+@pytest.fixture
+def stub_transport(monkeypatch):
+    class _Stub(PluginTransport):
+        def __init__(self, plugin_id, endpoint, *, in_process_instance=None, **_):
+            self.plugin_id = plugin_id
+            self.endpoint = endpoint
+            self.timeout_seconds = 1.0
+            self.closed = False
+
+        async def call(self, method, request):
+            return None
+
+        async def close(self):
+            self.closed = True
+
+    def _factory(plugin_id, endpoint, config, *, in_process_instance=None):
+        return _Stub(plugin_id, endpoint)
+
+    # ``registry.config`` defers its ``make_transport_for_endpoint`` import
+    # to call time (so PSM-only deployments don't need the generated proto
+    # stubs at module load), so we monkeypatch at the *source* module.
+    monkeypatch.setattr(
+        "dynamo.planner.plugins.transport.config.make_transport_for_endpoint",
+        _factory,
+    )
+
+
+def _ovr(replicas):
+    return OverrideResult(
+        targets=[
+            ComponentTarget(
+                sub_component_type="prefill",
+                replicas=replicas,
+                type=OverrideType.SET,
+            )
+        ]
+    )
+
+
+def _config(trusted_sources=("static_secret",), static_secrets=None):
+    return PluginRegistrationConfig(
+        auth=AuthConfig(
+            trusted_sources=list(trusted_sources),
+            static_secrets=dict(static_secrets or {"secret-a": "alice"}),
+        ),
+    )
+
+
+def _assemble(clock):
+    server, cb = build_registry_from_config(_config(), clock)
+    scheduler = PluginScheduler(server, cb, clock)
+    return server, scheduler, cb
+
+
+@pytest.mark.asyncio
+async def test_full_lifecycle_register_tick_unregister(stub_transport):
+    clock = VirtualClock()
+    server, scheduler, _ = _assemble(clock)
+
+    # 1. Register
+    resp = await server.register(
+        RegisterRequest(
+            plugin_id="load-scaler",
+            plugin_type="propose",
+            priority=10,
+            endpoint="grpc://127.0.0.1:9000",
+            auth_token="secret-a",
+            protocol_version="1.0",
+            execution_interval_seconds=10.0,
+            hold_policy=HoldPolicy.HOLD_LAST,
+            version="v1",
+        )
+    )
+    assert resp.accepted
+
+    # ListPlugins reports a complete picture.
+    (info,) = server.list_plugins(ListPluginsRequest())
+    assert info.plugin_id == "load-scaler"
+    assert info.transport == "grpc"
+    assert info.circuit_state == CircuitState.CLOSED
+    assert info.is_builtin is False
+
+    # 2. First fire happens after interval elapses since registration
+    # (PSM-parity anchor on registered_at — see
+    # test_first_fire_anchored_on_registration_time in test_active_set).
+    clock.advance(10.0)
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert [p.plugin_id for p in active.triggered] == ["load-scaler"]
+    scheduler.record_evaluation("load-scaler", clock.monotonic())
+    scheduler.record_result("load-scaler", "propose", _ovr(4), clock.monotonic())
+
+    # 3. Mid-interval tick: not triggered, but HOLD_LAST inherits.
+    clock.advance(5.0)
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert active.triggered == []
+    (inherited,) = active.inherited
+    assert inherited.result.targets[0].replicas == 4
+
+    # 4. Second interval: triggers again.
+    clock.advance(5.0)
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert [p.plugin_id for p in active.triggered] == ["load-scaler"]
+    scheduler.record_evaluation("load-scaler", clock.monotonic())
+    scheduler.record_result("load-scaler", "propose", _ovr(6), clock.monotonic())
+    assert scheduler.cache_entries_count() == 1
+
+    # 5. Unregister: cache drops.
+    ok = await server.unregister("load-scaler", reason="client_shutdown")
+    assert ok
+    assert scheduler.cache_entries_count() == 0
+    assert server.list_plugins(ListPluginsRequest()) == []
+
+
+@pytest.mark.asyncio
+async def test_circuit_open_removes_plugin_then_half_open_recovers(stub_transport):
+    clock = VirtualClock()
+    server, scheduler, cb = _assemble(clock)
+    cb._failure_threshold = 3  # tighter threshold for this test
+    cb._cooldown = 10.0
+
+    await server.register(
+        RegisterRequest(
+            plugin_id="p",
+            plugin_type="propose",
+            priority=1,
+            endpoint="grpc://127.0.0.1:9000",
+            auth_token="secret-a",
+            protocol_version="1.0",
+            execution_interval_seconds=10.0,
+            hold_policy=HoldPolicy.HOLD_LAST,
+        )
+    )
+    scheduler.compute_active_set(clock.monotonic(), "propose")
+    scheduler.record_evaluation("p", clock.monotonic())
+    scheduler.record_result("p", "propose", _ovr(3), clock.monotonic())
+
+    # Three failures → OPEN. Cache cleared by on_open fan-out.
+    for _ in range(3):
+        cb.record_failure("p")
+    assert cb.state("p") == CircuitState.OPEN
+    assert scheduler.cache_entries_count() == 0
+    # Plugin drops out of active set (cannot call + cache empty).
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert active.triggered == []
+    assert active.inherited == []
+
+    # After cooldown → HALF_OPEN, plugin re-admitted.
+    clock.advance(10.0)
+    assert cb.state("p") == CircuitState.HALF_OPEN
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert [x.plugin_id for x in active.triggered] == ["p"]
+    # One success → CLOSED.
+    cb.record_success("p")
+    assert cb.state("p") == CircuitState.CLOSED
+
+
+@pytest.mark.asyncio
+async def test_client_driven_version_upgrade(stub_transport):
+    clock = VirtualClock()
+    server, scheduler, _ = _assemble(clock)
+
+    # v1 registers, ticks, caches.
+    await server.register(
+        RegisterRequest(
+            plugin_id="p",
+            plugin_type="propose",
+            priority=1,
+            endpoint="grpc://127.0.0.1:9000",
+            auth_token="secret-a",
+            protocol_version="1.0",
+            execution_interval_seconds=10.0,
+            hold_policy=HoldPolicy.HOLD_LAST,
+            version="v1",
+        )
+    )
+    scheduler.compute_active_set(clock.monotonic(), "propose")
+    scheduler.record_evaluation("p", clock.monotonic())
+    scheduler.record_result("p", "propose", _ovr(3), clock.monotonic())
+
+    # Attempt to re-register without unregistering → rejected (Q6).
+    dup = await server.register(
+        RegisterRequest(
+            plugin_id="p",
+            plugin_type="propose",
+            priority=1,
+            endpoint="grpc://127.0.0.1:9000",
+            auth_token="secret-a",
+            protocol_version="1.0",
+            execution_interval_seconds=10.0,
+            hold_policy=HoldPolicy.HOLD_LAST,
+            version="v2",  # note: upgrade attempt
+        )
+    )
+    assert dup.accepted is False
+    assert "duplicate_plugin_id" in dup.reject_reason
+
+    # Client-driven upgrade: Unregister then Register.
+    await server.unregister("p", reason="version_upgrade")
+    assert scheduler.cache_entries_count() == 0
+    v2 = await server.register(
+        RegisterRequest(
+            plugin_id="p",
+            plugin_type="propose",
+            priority=1,
+            endpoint="grpc://127.0.0.1:9000",
+            auth_token="secret-a",
+            protocol_version="1.0",
+            execution_interval_seconds=10.0,
+            hold_policy=HoldPolicy.HOLD_LAST,
+            version="v2",
+        )
+    )
+    assert v2.accepted
+    assert server.get_plugin("p").version == "v2"
+    assert scheduler.cache_entries_count() == 0  # fresh; needs new record_result
diff --git a/components/src/dynamo/planner/tests/plugins/registry/test_list_plugins.py b/components/src/dynamo/planner/tests/plugins/registry/test_list_plugins.py
new file mode 100644
index 000000000000..1b46be385654
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/registry/test_list_plugins.py
@@ -0,0 +1,183 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for list_plugins end-to-end with scheduler cache_age wiring.
+
+Basic filter tests live in test_server.py; this file focuses on the
+observability fields (``circuit_state``, ``cache_age_seconds``,
+``last_call_at_seconds_ago``) that require the scheduler + circuit
+breaker to be attached.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.clock import VirtualClock
+from dynamo.planner.plugins.registry.auth import AllowUnauthenticatedAuth
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+from dynamo.planner.plugins.registry.server import PluginRegistryServer
+from dynamo.planner.plugins.scheduler import PluginScheduler
+from dynamo.planner.plugins.transport.base import PluginTransport
+from dynamo.planner.plugins.types import (
+    CircuitState,
+    ComponentTarget,
+    HoldPolicy,
+    ListPluginsRequest,
+    OverrideResult,
+    OverrideType,
+    RegisterRequest,
+)
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+class _StubTransport(PluginTransport):
+    def __init__(self, plugin_id, endpoint, *, in_process_instance=None):
+        self.plugin_id = plugin_id
+        self.endpoint = endpoint
+        self.timeout_seconds = 1.0
+
+    async def call(self, method, request):
+        return None
+
+    async def close(self):
+        pass
+
+
+def _make_ctx():
+    clock = VirtualClock()
+    cb = CircuitBreaker(clock, failure_threshold=3, cooldown_seconds=30.0)
+
+    def factory(plugin_id, endpoint, *, in_process_instance=None):
+        return _StubTransport(plugin_id, endpoint)
+
+    server = PluginRegistryServer(
+        clock=clock,
+        auth=AllowUnauthenticatedAuth(),
+        circuit_breaker=cb,
+        transport_factory=factory,
+    )
+    scheduler = PluginScheduler(server, cb, clock)
+    return server, scheduler, cb, clock
+
+
+async def _register(
+    server,
+    plugin_id,
+    plugin_type="propose",
+    priority=10,
+    execution_interval_seconds=10.0,
+    hold_policy=HoldPolicy.HOLD_LAST,
+):
+    resp = await server.register(
+        RegisterRequest(
+            plugin_id=plugin_id,
+            plugin_type=plugin_type,
+            priority=priority,
+            endpoint="grpc://127.0.0.1:9000",
+            protocol_version="1.0",
+            execution_interval_seconds=execution_interval_seconds,
+            hold_policy=hold_policy,
+        )
+    )
+    assert resp.accepted, resp.reject_reason
+
+
+def _ovr(replicas):
+    return OverrideResult(
+        targets=[
+            ComponentTarget(
+                sub_component_type="prefill", replicas=replicas, type=OverrideType.SET
+            )
+        ]
+    )
+
+
+@pytest.mark.asyncio
+async def test_cache_age_seconds_reports_scheduler_cache_age():
+    server, scheduler, _, clock = _make_ctx()
+    await _register(server, "p1")
+    scheduler.compute_active_set(0.0, "propose")
+    scheduler.record_evaluation("p1", 0.0)
+    scheduler.record_result("p1", "propose", _ovr(5), 0.0)
+    clock.advance(4.0)
+    out = server.list_plugins(ListPluginsRequest())
+    (info,) = out
+    assert info.cache_age_seconds == pytest.approx(4.0)
+
+
+@pytest.mark.asyncio
+async def test_circuit_state_field_reflects_breaker():
+    server, scheduler, cb, clock = _make_ctx()
+    await _register(server, "p1")
+    (info,) = server.list_plugins(ListPluginsRequest())
+    assert info.circuit_state == CircuitState.CLOSED
+
+    for _ in range(3):
+        cb.record_failure("p1")
+    (info,) = server.list_plugins(ListPluginsRequest())
+    assert info.circuit_state == CircuitState.OPEN
+
+
+@pytest.mark.asyncio
+async def test_last_call_at_seconds_ago_reports_staleness():
+    server, scheduler, _, clock = _make_ctx()
+    await _register(server, "p1")
+    (info_never,) = server.list_plugins(ListPluginsRequest())
+    assert info_never.last_call_at_seconds_ago == 0.0
+
+    scheduler.compute_active_set(0.0, "propose")
+    scheduler.record_evaluation("p1", 0.0)
+    clock.advance(7.0)
+    (info_called,) = server.list_plugins(ListPluginsRequest())
+    assert info_called.last_call_at_seconds_ago == pytest.approx(7.0)
+
+
+@pytest.mark.asyncio
+async def test_evaluations_total_increments_on_record_evaluation():
+    """``evaluations_total`` is bumped by ``record_evaluation``, which the
+    orchestrator calls for every successful RPC regardless of result kind
+    (Accept / Override / Reject / empty-oneof). ``record_result`` only
+    handles HOLD_LAST cache and no longer touches the counter."""
+    server, scheduler, _, _ = _make_ctx()
+    await _register(server, "p1")
+    scheduler.compute_active_set(0.0, "propose")
+    scheduler.record_evaluation("p1", 0.0)
+    scheduler.record_evaluation("p1", 1.0)
+    (info,) = server.list_plugins(ListPluginsRequest())
+    assert info.evaluations_total == 2
+
+
+@pytest.mark.asyncio
+async def test_transport_label_matches_transport_type():
+    server, _, _, _ = _make_ctx()
+    await _register(server, "p_grpc")
+    server.register_internal(
+        plugin_id="p_inproc",
+        plugin_type="propose",
+        priority=1,
+        instance=object(),
+    )
+    out = {p.plugin_id: p.transport for p in server.list_plugins(ListPluginsRequest())}
+    assert out == {"p_grpc": "grpc", "p_inproc": "in_process"}
+
+
+@pytest.mark.asyncio
+async def test_is_builtin_propagates_through_list_plugins():
+    server, _, _, _ = _make_ctx()
+    await _register(server, "user_uds")
+    server.register_internal(
+        plugin_id="builtin_inproc",
+        plugin_type="propose",
+        priority=1,
+        instance=object(),
+        is_builtin=True,
+    )
+    out = {p.plugin_id: p.is_builtin for p in server.list_plugins(ListPluginsRequest())}
+    assert out == {"user_uds": False, "builtin_inproc": True}
diff --git a/components/src/dynamo/planner/tests/plugins/registry/test_server.py b/components/src/dynamo/planner/tests/plugins/registry/test_server.py
new file mode 100644
index 000000000000..0057f51bcdeb
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/registry/test_server.py
@@ -0,0 +1,572 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for PluginRegistryServer."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+
+from dynamo.planner.plugins.clock import VirtualClock
+from dynamo.planner.plugins.registry.auth import (
+    AuthIdentity,
+    AuthValidator,
+    StaticSecretAuth,
+)
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+from dynamo.planner.plugins.registry.errors import AuthError
+from dynamo.planner.plugins.registry.server import PluginRegistryServer
+from dynamo.planner.plugins.transport.base import PluginTransport
+from dynamo.planner.plugins.types import HoldPolicy, ListPluginsRequest, RegisterRequest
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+# ---------------------------------------------------------------------------
+# Test doubles
+# ---------------------------------------------------------------------------
+
+
+class _StubTransport(PluginTransport):
+    """Records lifecycle; never hits the network."""
+
+    def __init__(self, plugin_id, endpoint, *, in_process_instance=None):
+        self.plugin_id = plugin_id
+        self.endpoint = endpoint
+        self.timeout_seconds = 1.0
+        self.instance = in_process_instance
+        self.closed = False
+        self.calls: list[tuple[str, Any]] = []
+
+    async def call(self, method, request):
+        self.calls.append((method, request))
+        return None
+
+    async def close(self):
+        self.closed = True
+
+
+def _stub_factory():
+    """Returns (factory, created) where ``created`` is populated with the
+    transports built through the factory, so tests can assert on them."""
+    created: list[_StubTransport] = []
+
+    def factory(plugin_id, endpoint, *, in_process_instance=None):
+        t = _StubTransport(plugin_id, endpoint, in_process_instance=in_process_instance)
+        created.append(t)
+        return t
+
+    return factory, created
+
+
+class _AcceptAllAuth(AuthValidator):
+    async def validate(self, token):
+        return AuthIdentity(source="static_secret", subject="test")
+
+
+def _make_server(auth=None, protocol_versions=("1.0", "1.0")):
+    clock = VirtualClock()
+    cb = CircuitBreaker(clock)
+    factory, created = _stub_factory()
+    server = PluginRegistryServer(
+        clock=clock,
+        auth=auth or _AcceptAllAuth(),
+        circuit_breaker=cb,
+        transport_factory=factory,
+        protocol_versions=protocol_versions,
+    )
+    return server, clock, cb, created
+
+
+def _req(
+    plugin_id="p1",
+    plugin_type="propose",
+    endpoint="grpc://127.0.0.1:9000",
+    auth_token="",
+    protocol_version="1.0",
+    **kwargs,
+):
+    return RegisterRequest(
+        plugin_id=plugin_id,
+        plugin_type=plugin_type,
+        endpoint=endpoint,
+        auth_token=auth_token,
+        protocol_version=protocol_version,
+        **kwargs,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Happy path
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_register_happy_path_creates_plugin_and_transport():
+    server, _, _, created = _make_server()
+    resp = await server.register(_req(priority=10))
+    assert resp.accepted is True
+    assert resp.negotiated_protocol_version == "1.0"
+    assert resp.reject_reason == ""
+
+    plugin = server.get_plugin("p1")
+    assert plugin is not None
+    assert plugin.plugin_type == "propose"
+    assert plugin.priority == 10
+    assert plugin.transport_type == "grpc"
+    assert plugin.endpoint == "grpc://127.0.0.1:9000"
+    assert plugin.is_builtin is False
+    assert len(created) == 1
+
+
+@pytest.mark.asyncio
+async def test_heartbeat_updates_timestamp_and_returns_true():
+    server, clock, _, _ = _make_server()
+    await server.register(_req())
+    clock.advance(3.0)
+    ok = await server.heartbeat("p1")
+    assert ok is True
+    assert server.get_plugin("p1").last_heartbeat_at == pytest.approx(3.0)
+
+
+@pytest.mark.asyncio
+async def test_heartbeat_for_unknown_plugin_returns_false():
+    server, _, _, _ = _make_server()
+    ok = await server.heartbeat("ghost")
+    assert ok is False
+
+
+class _PerTokenAuth(AuthValidator):
+    """Maps token → subject so subject-mismatch can be exercised.
+
+    Token ``"bad"`` raises AuthError to cover the auth-failed branch.
+    """
+
+    async def validate(self, token):
+        if token == "bad":
+            raise AuthError("invalid")
+        return AuthIdentity(source="static_secret", subject=f"subj-{token}")
+
+
+@pytest.mark.asyncio
+async def test_authenticated_heartbeat_matching_subject_ok():
+    server, clock, _, _ = _make_server(auth=_PerTokenAuth())
+    await server.register(_req(auth_token="A"))
+    assert server.get_plugin("p1").auth_subject == "subj-A"
+    clock.advance(3.0)
+    ok, reject = await server.authenticated_heartbeat("p1", "A")
+    assert (ok, reject) == (True, None)
+    assert server.get_plugin("p1").last_heartbeat_at == pytest.approx(3.0)
+
+
+@pytest.mark.asyncio
+async def test_authenticated_heartbeat_invalid_token_returns_auth_failed():
+    server, _, _, _ = _make_server(auth=_PerTokenAuth())
+    await server.register(_req(auth_token="A"))
+    ok, reject = await server.authenticated_heartbeat("p1", "bad")
+    assert (ok, reject) == (False, "auth_failed")
+
+
+@pytest.mark.asyncio
+async def test_authenticated_heartbeat_subject_mismatch_returns_permission_denied():
+    server, _, _, _ = _make_server(auth=_PerTokenAuth())
+    await server.register(_req(auth_token="A"))
+    # token "B" validates but maps to a different subject — caller cannot
+    # manage plugins they did not register.
+    ok, reject = await server.authenticated_heartbeat("p1", "B")
+    assert (ok, reject) == (False, "permission_denied")
+    # Plugin must NOT be touched on rejection.
+    assert server.get_plugin("p1").last_heartbeat_at == -float("inf")
+
+
+@pytest.mark.asyncio
+async def test_authenticated_heartbeat_unknown_plugin_returns_permission_denied():
+    """Unknown plugin_id collapses to ``permission_denied`` — same response
+    as a wrong-subject probe — so a token-holder cannot enumerate registered
+    plugin_ids by observing distinct return codes."""
+    server, _, _, _ = _make_server(auth=_PerTokenAuth())
+    ok, reject = await server.authenticated_heartbeat("ghost", "A")
+    assert (ok, reject) == (False, "permission_denied")
+
+
+@pytest.mark.asyncio
+async def test_authenticated_heartbeat_in_process_plugin_returns_permission_denied():
+    """``register_internal`` plugins have ``auth_subject == ""`` by design —
+    they are not reachable via the gateway.  Heartbeat against one must
+    collapse to ``permission_denied`` (NOT silently succeed because
+    ``"" == ""`` if some buggy auth backend ever returned an empty subject)."""
+    server, _, _, _ = _make_server(auth=_PerTokenAuth())
+    server.register_internal(
+        plugin_id="builtin",
+        plugin_type="propose",
+        priority=10,
+        instance=object(),
+    )
+    assert server.get_plugin("builtin").auth_subject == ""
+    ok, reject = await server.authenticated_heartbeat("builtin", "A")
+    assert (ok, reject) == (False, "permission_denied")
+
+
+@pytest.mark.asyncio
+async def test_authenticated_unregister_matching_subject_removes_plugin():
+    server, _, _, created = _make_server(auth=_PerTokenAuth())
+    await server.register(_req(auth_token="A"))
+    ok, reject = await server.authenticated_unregister("p1", "A", reason="shutdown")
+    assert (ok, reject) == (True, None)
+    assert server.get_plugin("p1") is None
+    assert created[0].closed is True
+
+
+@pytest.mark.asyncio
+async def test_authenticated_unregister_invalid_token_returns_auth_failed():
+    server, _, _, _ = _make_server(auth=_PerTokenAuth())
+    await server.register(_req(auth_token="A"))
+    ok, reject = await server.authenticated_unregister("p1", "bad")
+    assert (ok, reject) == (False, "auth_failed")
+    # Plugin must remain registered when auth fails.
+    assert server.get_plugin("p1") is not None
+
+
+@pytest.mark.asyncio
+async def test_authenticated_unregister_subject_mismatch_does_not_evict():
+    """Forged Unregister with a *valid* token whose subject doesn't match
+    the registered plugin's subject MUST NOT evict the plugin. This is the
+    core security guarantee of the gateway auth model."""
+    server, _, _, _ = _make_server(auth=_PerTokenAuth())
+    await server.register(_req(auth_token="A"))
+    ok, reject = await server.authenticated_unregister("p1", "B")
+    assert (ok, reject) == (False, "permission_denied")
+    assert server.get_plugin("p1") is not None  # NOT evicted
+
+
+@pytest.mark.asyncio
+async def test_authenticated_unregister_unknown_plugin_returns_permission_denied():
+    """Same existence-oracle hardening as the heartbeat case — unknown
+    plugin and wrong subject return the same code."""
+    server, _, _, _ = _make_server(auth=_PerTokenAuth())
+    ok, reject = await server.authenticated_unregister("ghost", "A")
+    assert (ok, reject) == (False, "permission_denied")
+
+
+@pytest.mark.asyncio
+async def test_authenticated_unregister_in_process_plugin_not_reachable_via_gateway():
+    """``register_internal`` plugins are not removable via the gateway —
+    in-process invariant enforced explicitly so the data shape isn't the
+    only line of defense."""
+    server, _, _, _ = _make_server(auth=_PerTokenAuth())
+    server.register_internal(
+        plugin_id="builtin",
+        plugin_type="propose",
+        priority=10,
+        instance=object(),
+    )
+    ok, reject = await server.authenticated_unregister("builtin", "A")
+    assert (ok, reject) == (False, "permission_denied")
+    assert server.get_plugin("builtin") is not None  # NOT evicted
+
+
+@pytest.mark.asyncio
+async def test_unregister_removes_plugin_and_closes_transport():
+    server, _, _, created = _make_server()
+    await server.register(_req())
+    ok = await server.unregister("p1", reason="client_shutdown")
+    assert ok is True
+    assert server.get_plugin("p1") is None
+    assert created[0].closed is True
+
+
+@pytest.mark.asyncio
+async def test_unregister_unknown_plugin_idempotent_false():
+    server, _, _, _ = _make_server()
+    ok = await server.unregister("ghost", reason="")
+    assert ok is False
+
+
+@pytest.mark.asyncio
+async def test_unregister_fans_out_to_subscribers():
+    server, _, _, _ = _make_server()
+    events: list[tuple[str, str]] = []
+    server.on_unregister(lambda pid, reason: events.append((pid, reason)))
+    await server.register(_req())
+    await server.unregister("p1", reason="heartbeat_missed")
+    assert events == [("p1", "heartbeat_missed")]
+
+
+# ---------------------------------------------------------------------------
+# Rejections
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_duplicate_plugin_id_rejected_no_upsert():
+    server, _, _, created = _make_server()
+    first = await server.register(_req(priority=1))
+    second = await server.register(_req(priority=99))  # same plugin_id
+    assert first.accepted is True
+    assert second.accepted is False
+    assert "duplicate_plugin_id" in second.reject_reason
+    # Original plugin priority unchanged (no upsert).
+    assert server.get_plugin("p1").priority == 1
+    assert len(created) == 1  # second call did NOT build a second transport
+
+
+@pytest.mark.asyncio
+async def test_protocol_version_out_of_range_rejected():
+    server, _, _, _ = _make_server(protocol_versions=("1.0", "1.0"))
+    resp = await server.register(_req(protocol_version="0.9"))
+    assert resp.accepted is False
+    assert "protocol_version_unsupported" in resp.reject_reason
+
+    resp2 = await server.register(_req(plugin_id="p2", protocol_version="1.1"))
+    assert resp2.accepted is False
+    assert "protocol_version_unsupported" in resp2.reject_reason
+
+
+@pytest.mark.asyncio
+async def test_protocol_version_semantic_compare_not_lexicographic():
+    """``1.10`` must be greater than ``1.2`` (semantic version),
+    even though lexicographically ``"1.10" < "1.2"`` because the
+    second character ``1`` < ``2``. The register check must use
+    ``packaging.version.Version`` (or equivalent) — not raw string
+    compare — otherwise valid plugins get rejected once any component
+    reaches 10."""
+    server, _, _, _ = _make_server(protocol_versions=("1.0", "1.10"))
+
+    # 1.10 must be accepted under max=1.10 (semantic compare).
+    # With lexicographic compare, "1.10" > "1.2" would be False and
+    # the upper-bound check ``req <= max`` would still pass (because
+    # "1.10" <= "1.10" lexicographically too); the failure mode is
+    # different. The real lex bug: requested="1.2", max="1.10" —
+    # lex says "1.2" > "1.10" so the register rejects something
+    # that should be accepted. Cover both that and the "above max"
+    # rejection that semantic compare must respect.
+    accepted = await server.register(_req(plugin_id="ok-1.10", protocol_version="1.10"))
+    assert accepted.accepted is True, accepted.reject_reason
+
+    accepted_mid = await server.register(
+        _req(plugin_id="ok-1.2", protocol_version="1.2")
+    )
+    assert accepted_mid.accepted is True, accepted_mid.reject_reason
+
+    rejected = await server.register(_req(plugin_id="too-new", protocol_version="2.0"))
+    assert rejected.accepted is False
+    assert "protocol_version_unsupported" in rejected.reject_reason
+
+
+@pytest.mark.asyncio
+async def test_protocol_version_malformed_rejected_clearly():
+    """A non-semver protocol_version string surfaces as a distinct
+    ``protocol_version_malformed`` reject reason — not silently treated
+    as out-of-range."""
+    server, _, _, _ = _make_server(protocol_versions=("1.0", "2.0"))
+    resp = await server.register(_req(protocol_version="not-a-version"))
+    assert resp.accepted is False
+    assert "protocol_version_malformed" in resp.reject_reason
+
+
+def _make_server_with_scale_interval(scale_interval_seconds: float):
+    clock = VirtualClock()
+    cb = CircuitBreaker(clock)
+    factory, _ = _stub_factory()
+    return PluginRegistryServer(
+        clock=clock,
+        auth=_AcceptAllAuth(),
+        circuit_breaker=cb,
+        transport_factory=factory,
+        scale_interval_seconds=scale_interval_seconds,
+    )
+
+
+@pytest.mark.asyncio
+async def test_observation_window_zero_accepted():
+    """Default ``observation_window_seconds=0.0`` means
+    "per-tick freshness" — always accepted."""
+    server = _make_server_with_scale_interval(5.0)
+    resp = await server.register(_req(observation_window_seconds=0.0))
+    assert resp.accepted is True, resp.reject_reason
+
+
+@pytest.mark.asyncio
+async def test_observation_window_multiple_of_scale_interval_accepted():
+    """``N * scale_interval`` aligns to tick boundaries — accepted."""
+    server = _make_server_with_scale_interval(5.0)
+    resp = await server.register(_req(plugin_id="p1", observation_window_seconds=5.0))
+    assert resp.accepted is True, resp.reject_reason
+    resp2 = await server.register(_req(plugin_id="p2", observation_window_seconds=15.0))
+    assert resp2.accepted is True, resp2.reject_reason
+
+
+@pytest.mark.asyncio
+async def test_observation_window_non_multiple_rejected():
+    """Non-multiple windows drive Prometheus queries that cross tick
+    boundaries — reject with a clear reason."""
+    server = _make_server_with_scale_interval(5.0)
+    resp = await server.register(_req(observation_window_seconds=7.0))
+    assert resp.accepted is False
+    assert "observation_window_misaligned" in resp.reject_reason
+
+
+@pytest.mark.asyncio
+async def test_observation_window_negative_rejected():
+    server = _make_server_with_scale_interval(5.0)
+    resp = await server.register(_req(observation_window_seconds=-1.0))
+    assert resp.accepted is False
+    assert "observation_window_misaligned" in resp.reject_reason
+
+
+@pytest.mark.asyncio
+async def test_observation_window_unverifiable_without_scale_interval():
+    """When ``scale_interval_seconds == 0.0`` (PSM path constructs the
+    server without one), the alignment constraint can't be verified —
+    accept any value rather than reject erroneously."""
+    server = _make_server_with_scale_interval(0.0)
+    resp = await server.register(_req(observation_window_seconds=7.0))
+    assert resp.accepted is True, resp.reject_reason
+
+
+@pytest.mark.asyncio
+async def test_auth_failure_rejected_with_generic_reason():
+    server, _, _, _ = _make_server(auth=StaticSecretAuth({"good": "alice"}))
+    resp = await server.register(_req(auth_token="bad"))
+    assert resp.accepted is False
+    # Generic reason — no leak of specific failure mode.
+    assert resp.reject_reason == "auth_failed"
+
+
+@pytest.mark.asyncio
+async def test_auth_success_accepts():
+    server, _, _, _ = _make_server(auth=StaticSecretAuth({"good": "alice"}))
+    resp = await server.register(_req(auth_token="good"))
+    assert resp.accepted is True
+
+
+@pytest.mark.asyncio
+async def test_inproc_endpoint_over_rpc_rejected():
+    # Clients MUST NOT use inproc:// endpoints via the network RPC —
+    # that's what register_internal is for.
+    server, _, _, _ = _make_server()
+    resp = await server.register(_req(endpoint="inproc://sneaky"))
+    assert resp.accepted is False
+    assert "inproc" in resp.reject_reason
+
+
+@pytest.mark.asyncio
+async def test_unknown_endpoint_scheme_rejected():
+    server, _, _, _ = _make_server()
+    resp = await server.register(_req(endpoint="http://bad"))
+    assert resp.accepted is False
+    assert "transport_build_failed" in resp.reject_reason
+
+
+# ---------------------------------------------------------------------------
+# register_internal
+# ---------------------------------------------------------------------------
+
+
+def test_register_internal_skips_auth_and_wraps_inproc():
+    server, _, _, created = _make_server()
+
+    class Echo:
+        async def Propose(self, req):
+            return req
+
+    plugin = server.register_internal(
+        plugin_id="builtin_echo",
+        plugin_type="propose",
+        priority=5,
+        instance=Echo(),
+        execution_interval_seconds=10.0,
+        hold_policy=HoldPolicy.HOLD_LAST,
+    )
+    assert plugin.transport_type == "in_process"
+    assert plugin.endpoint == "inproc://builtin_echo"
+    assert plugin.is_builtin is True
+    assert len(created) == 1
+    assert created[0].instance is not None  # factory received the instance
+
+
+def test_register_internal_duplicate_raises():
+    server, _, _, _ = _make_server()
+    server.register_internal("p1", "propose", 1, object())
+    with pytest.raises(ValueError, match="already registered"):
+        server.register_internal("p1", "propose", 1, object())
+
+
+def test_register_internal_can_mark_user_inprocess_plugin():
+    server, _, _, _ = _make_server()
+    plugin = server.register_internal(
+        plugin_id="user_inproc",
+        plugin_type="predict",
+        priority=1,
+        instance=object(),
+        is_builtin=False,
+    )
+    assert plugin.is_builtin is False
+    # G-3: transport_type=in_process even when is_builtin=False.
+    assert plugin.transport_type == "in_process"
+
+
+# ---------------------------------------------------------------------------
+# list_plugins
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_list_plugins_filters_and_reports_fields():
+    server, _, _, _ = _make_server()
+    await server.register(_req(plugin_id="p1", plugin_type="propose"))
+    await server.register(
+        _req(plugin_id="p2", plugin_type="predict", endpoint="grpc://127.0.0.1:9000")
+    )
+    # no filter
+    out = server.list_plugins(ListPluginsRequest())
+    assert {p.plugin_id for p in out} == {"p1", "p2"}
+    # stage filter
+    out_propose = server.list_plugins(ListPluginsRequest(stage_filter="propose"))
+    assert {p.plugin_id for p in out_propose} == {"p1"}
+    # disabled filter
+    server.get_plugin("p2").enabled = False
+    out_default = server.list_plugins(ListPluginsRequest())
+    assert {p.plugin_id for p in out_default} == {"p1"}
+    out_all = server.list_plugins(ListPluginsRequest(include_disabled=True))
+    assert {p.plugin_id for p in out_all} == {"p1", "p2"}
+
+
+# ---------------------------------------------------------------------------
+# CircuitBreaker reset on register/unregister
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_register_resets_circuit_breaker_for_plugin_id():
+    server, _, cb, _ = _make_server()
+    # Manually seed some failures under plugin_id
+    cb.record_failure("p1")
+    cb.record_failure("p1")
+    cb.record_failure("p1")
+    cb.record_failure("p1")
+    cb.record_failure("p1")  # threshold default 5 -> OPEN
+    await server.register(_req())
+    # After register the breaker state should be fresh.
+    from dynamo.planner.plugins.types import CircuitState
+
+    assert cb.state("p1") == CircuitState.CLOSED
+
+
+@pytest.mark.asyncio
+async def test_unregister_resets_circuit_breaker():
+    server, _, cb, _ = _make_server()
+    await server.register(_req())
+    for _ in range(5):
+        cb.record_failure("p1")
+    await server.unregister("p1")
+    from dynamo.planner.plugins.types import CircuitState
+
+    assert cb.state("p1") == CircuitState.CLOSED
diff --git a/components/src/dynamo/planner/tests/plugins/scheduler/__init__.py b/components/src/dynamo/planner/tests/plugins/scheduler/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/scheduler/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/tests/plugins/scheduler/test_active_set.py b/components/src/dynamo/planner/tests/plugins/scheduler/test_active_set.py
new file mode 100644
index 000000000000..4bb40fbbbf4e
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/scheduler/test_active_set.py
@@ -0,0 +1,307 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for PluginScheduler.compute_active_set."""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.clock import VirtualClock
+from dynamo.planner.plugins.registry.auth import AllowUnauthenticatedAuth
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+from dynamo.planner.plugins.registry.server import PluginRegistryServer
+from dynamo.planner.plugins.scheduler import PluginScheduler
+from dynamo.planner.plugins.transport.base import PluginTransport
+from dynamo.planner.plugins.types import (
+    ComponentTarget,
+    HoldPolicy,
+    OverrideResult,
+    OverrideType,
+    RegisterRequest,
+)
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+class _StubTransport(PluginTransport):
+    def __init__(self, plugin_id, endpoint, *, in_process_instance=None):
+        self.plugin_id = plugin_id
+        self.endpoint = endpoint
+        self.timeout_seconds = 1.0
+
+    async def call(self, method, request):
+        return None
+
+    async def close(self):
+        pass
+
+
+def _make_ctx():
+    clock = VirtualClock()
+    cb = CircuitBreaker(clock, failure_threshold=3, cooldown_seconds=30.0)
+
+    def factory(plugin_id, endpoint, *, in_process_instance=None):
+        return _StubTransport(plugin_id, endpoint)
+
+    server = PluginRegistryServer(
+        clock=clock,
+        auth=AllowUnauthenticatedAuth(),
+        circuit_breaker=cb,
+        transport_factory=factory,
+    )
+    scheduler = PluginScheduler(server, cb, clock)
+    return server, scheduler, cb, clock
+
+
+async def _register(
+    server,
+    plugin_id,
+    plugin_type,
+    priority,
+    execution_interval_seconds=0.0,
+    hold_policy=HoldPolicy.ACCEPT_WHEN_IDLE,
+):
+    resp = await server.register(
+        RegisterRequest(
+            plugin_id=plugin_id,
+            plugin_type=plugin_type,
+            priority=priority,
+            endpoint="grpc://127.0.0.1:9000",
+            protocol_version="1.0",
+            execution_interval_seconds=execution_interval_seconds,
+            hold_policy=hold_policy,
+        )
+    )
+    assert resp.accepted, resp.reject_reason
+
+
+def _ovr(replicas):
+    return OverrideResult(
+        targets=[
+            ComponentTarget(
+                sub_component_type="prefill", replicas=replicas, type=OverrideType.SET
+            )
+        ]
+    )
+
+
+def _record_override_tick(scheduler, plugin_id, stage, override, tick_now):
+    """Test helper: mimic the orchestrator's per-tick scheduler-update
+    pair for a plugin that returned an OverrideResult.
+
+    Pre-fix the two were coupled inside ``record_result``; post-fix the
+    orchestrator (and these tests) must call ``record_evaluation``
+    (bookkeeping) + ``record_result`` (HOLD_LAST cache) separately.
+    """
+    scheduler.record_evaluation(plugin_id, tick_now)
+    scheduler.record_result(plugin_id, stage, override, tick_now)
+
+
+# ---------------------------------------------------------------------------
+# Basic triggering
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_first_fire_anchored_on_registration_time():
+    """A plugin with positive ``execution_interval_seconds`` does NOT
+    fire on the first pipeline tick — it must wait the full interval
+    since registration before its first call.
+
+    This is the PSM-parity semantic: PSM's ``initial_tick(start_s)``
+    schedules the first throughput-cadence fire at ``start_s +
+    throughput_adjustment_interval_seconds``, not at ``start_s`` itself.
+
+    Pre-fix the first-ever branch in ``_is_due`` returned True
+    regardless of interval, which would cause PR #2's
+    ``BuiltinThroughputPropose`` (``interval=180s``) to fire on the
+    first 5s load tick and permanently drift 5s ahead of PSM's
+    180/360/540 cadence.
+    """
+    server, scheduler, _, clock = _make_ctx()
+    await _register(server, "p1", "propose", 10, execution_interval_seconds=10.0)
+
+    # At registration time (clock=0), plugin is NOT yet due.
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert active.triggered == [], (
+        "plugin with positive interval must NOT fire on first tick — "
+        "interval must elapse from registration before first call"
+    )
+    assert active.inherited == []
+
+    # 5 seconds later (half-window), still not due.
+    clock.advance(5.0)
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert active.triggered == []
+
+    # At exactly interval seconds after registration, first fire.
+    clock.advance(5.0)
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert [p.plugin_id for p in active.triggered] == ["p1"]
+
+
+@pytest.mark.asyncio
+async def test_zero_interval_triggers_every_tick():
+    server, scheduler, _, clock = _make_ctx()
+    await _register(server, "p1", "propose", 10, execution_interval_seconds=0.0)
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert [p.plugin_id for p in active.triggered] == ["p1"]
+    _record_override_tick(scheduler, "p1", "propose", _ovr(5), clock.monotonic())
+    clock.advance(0.001)
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert [p.plugin_id for p in active.triggered] == ["p1"]
+
+
+@pytest.mark.asyncio
+async def test_not_triggered_inside_interval_window():
+    server, scheduler, _, clock = _make_ctx()
+    await _register(server, "p1", "propose", 10, execution_interval_seconds=10.0)
+    _record_override_tick(scheduler, "p1", "propose", _ovr(5), clock.monotonic())
+    clock.advance(5.0)
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert active.triggered == []
+    assert active.inherited == []  # ACCEPT_WHEN_IDLE -> skip, no inherited
+
+
+@pytest.mark.asyncio
+async def test_triggered_again_after_interval_elapses():
+    server, scheduler, _, clock = _make_ctx()
+    await _register(server, "p1", "propose", 10, execution_interval_seconds=10.0)
+    _record_override_tick(scheduler, "p1", "propose", _ovr(5), clock.monotonic())
+    clock.advance(10.0)
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert [p.plugin_id for p in active.triggered] == ["p1"]
+
+
+@pytest.mark.asyncio
+async def test_hold_last_inherits_between_triggers():
+    server, scheduler, _, clock = _make_ctx()
+    await _register(
+        server,
+        "p1",
+        "propose",
+        10,
+        execution_interval_seconds=10.0,
+        hold_policy=HoldPolicy.HOLD_LAST,
+    )
+    # First tick triggers.
+    scheduler.compute_active_set(clock.monotonic(), "propose")
+    _record_override_tick(scheduler, "p1", "propose", _ovr(7), clock.monotonic())
+    clock.advance(5.0)
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert active.triggered == []
+    assert len(active.inherited) == 1
+    assert active.inherited[0].plugin_id == "p1"
+    assert active.inherited[0].priority == 10
+    assert active.inherited[0].result.targets[0].replicas == 7
+
+
+# ---------------------------------------------------------------------------
+# Filtering: stage / enabled / circuit breaker
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_stage_filter_only_returns_matching_plugin_type():
+    server, scheduler, _, clock = _make_ctx()
+    await _register(server, "p1", "propose", 10)
+    await _register(server, "p2", "predict", 20)
+    active_propose = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert [p.plugin_id for p in active_propose.triggered] == ["p1"]
+    active_predict = scheduler.compute_active_set(clock.monotonic(), "predict")
+    assert [p.plugin_id for p in active_predict.triggered] == ["p2"]
+
+
+@pytest.mark.asyncio
+async def test_disabled_plugin_excluded_from_active_set():
+    server, scheduler, _, clock = _make_ctx()
+    await _register(server, "p1", "propose", 10)
+    server.get_plugin("p1").enabled = False
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert active.triggered == []
+    assert active.inherited == []
+
+
+@pytest.mark.asyncio
+async def test_circuit_open_excludes_plugin_from_active_set():
+    server, scheduler, cb, clock = _make_ctx()
+    await _register(
+        server,
+        "p1",
+        "propose",
+        10,
+        execution_interval_seconds=10.0,
+        hold_policy=HoldPolicy.HOLD_LAST,
+    )
+    # Seed the cache so inherited would otherwise be possible.
+    scheduler.compute_active_set(clock.monotonic(), "propose")
+    _record_override_tick(scheduler, "p1", "propose", _ovr(5), clock.monotonic())
+    # Open the circuit.
+    for _ in range(3):
+        cb.record_failure("p1")
+    clock.advance(5.0)
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert active.triggered == []
+    assert active.inherited == []  # OPEN skips even HOLD_LAST
+
+
+# ---------------------------------------------------------------------------
+# Throttle fix (formerly Major 5): record_evaluation is what bumps
+# last_call_at, so non-Override result kinds (Accept / Reject / empty oneof)
+# must call it to participate in execution_interval_seconds throttling.
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_accept_only_plugin_respects_execution_interval():
+    """Plugins that return AcceptResult (or RejectResult, or empty oneof)
+    must still see ``execution_interval_seconds`` throttling. Before the
+    fix, ``last_call_at`` was only bumped by ``record_result`` (which is
+    OverrideResult-only), so Accept-only plugins fired every tick
+    regardless of the configured interval. After the fix, the pipeline
+    calls ``record_evaluation`` for every successful RPC so the throttle
+    applies uniformly across result kinds.
+    """
+    server, scheduler, _, clock = _make_ctx()
+    await _register(server, "p1", "propose", 10, execution_interval_seconds=10.0)
+    # First fire happens when the full interval elapses since
+    # registration (PSM-parity anchor — see test_first_fire_anchored_
+    # on_registration_time).
+    clock.advance(10.0)
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert [p.plugin_id for p in active.triggered] == ["p1"]
+    # Plugin returned Accept (no Override) — pipeline only calls
+    # record_evaluation, not record_result.
+    scheduler.record_evaluation("p1", clock.monotonic())
+    # Mid-interval: must be throttled.
+    clock.advance(5.0)
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert active.triggered == []  # ← pre-fix this was ["p1"]
+    # After interval elapses: due again.
+    clock.advance(5.0)
+    active = scheduler.compute_active_set(clock.monotonic(), "propose")
+    assert [p.plugin_id for p in active.triggered] == ["p1"]
+
+
+@pytest.mark.asyncio
+async def test_record_evaluation_and_record_result_pair_counts_once():
+    """Regression guard: the orchestrator calls ``record_evaluation`` for
+    every successful RPC AND ``record_result`` for OverrideResult cache.
+    The pair must bump ``evaluations_total`` exactly once (only
+    ``record_evaluation`` touches the counter)."""
+    server, scheduler, _, clock = _make_ctx()
+    await _register(server, "p1", "propose", 10, hold_policy=HoldPolicy.HOLD_LAST)
+    scheduler.compute_active_set(clock.monotonic(), "propose")
+    # Simulate the orchestrator's pair of calls for an Override-returning
+    # plugin.
+    scheduler.record_evaluation("p1", clock.monotonic())
+    scheduler.record_result("p1", "propose", _ovr(5), clock.monotonic())
+    plugin = server.get_plugin("p1")
+    assert plugin.evaluations_total == 1  # ← not 2
+    assert plugin.last_call_at == clock.monotonic()
diff --git a/components/src/dynamo/planner/tests/plugins/scheduler/test_cache_invalidation.py b/components/src/dynamo/planner/tests/plugins/scheduler/test_cache_invalidation.py
new file mode 100644
index 000000000000..fef5a9fb130b
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/scheduler/test_cache_invalidation.py
@@ -0,0 +1,189 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""6-row cache-invalidation must-pass tests.
+
+Each of the 6 rows in the cache invalidation table gets its own dedicated
+test. These are MUST-PASS — any future change touching the scheduler
+must keep all six green.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.clock import VirtualClock
+from dynamo.planner.plugins.registry.auth import AllowUnauthenticatedAuth
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+from dynamo.planner.plugins.registry.server import PluginRegistryServer
+from dynamo.planner.plugins.scheduler import PluginScheduler
+from dynamo.planner.plugins.transport.base import PluginTransport
+from dynamo.planner.plugins.types import (
+    ComponentTarget,
+    HoldPolicy,
+    OverrideResult,
+    OverrideType,
+    RegisterRequest,
+)
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+class _StubTransport(PluginTransport):
+    def __init__(self, plugin_id, endpoint, *, in_process_instance=None):
+        self.plugin_id = plugin_id
+        self.endpoint = endpoint
+        self.timeout_seconds = 1.0
+
+    async def call(self, method, request):
+        return None
+
+    async def close(self):
+        pass
+
+
+def _make_ctx():
+    clock = VirtualClock()
+    cb = CircuitBreaker(clock, failure_threshold=3, cooldown_seconds=30.0)
+
+    def factory(plugin_id, endpoint, *, in_process_instance=None):
+        return _StubTransport(plugin_id, endpoint)
+
+    server = PluginRegistryServer(
+        clock=clock,
+        auth=AllowUnauthenticatedAuth(),
+        circuit_breaker=cb,
+        transport_factory=factory,
+    )
+    scheduler = PluginScheduler(server, cb, clock)
+    return server, scheduler, cb, clock
+
+
+async def _register_hold_last(server, plugin_id="p1"):
+    resp = await server.register(
+        RegisterRequest(
+            plugin_id=plugin_id,
+            plugin_type="propose",
+            priority=10,
+            endpoint="grpc://127.0.0.1:9000",
+            protocol_version="1.0",
+            execution_interval_seconds=10.0,
+            hold_policy=HoldPolicy.HOLD_LAST,
+        )
+    )
+    assert resp.accepted, resp.reject_reason
+
+
+def _ovr(replicas):
+    return OverrideResult(
+        targets=[
+            ComponentTarget(
+                sub_component_type="prefill", replicas=replicas, type=OverrideType.SET
+            )
+        ]
+    )
+
+
+async def _seed_cache(server, scheduler, plugin_id="p1"):
+    """Register + tick + record → scheduler holds a cache entry for plugin_id."""
+    await _register_hold_last(server, plugin_id=plugin_id)
+    scheduler.compute_active_set(0.0, "propose")
+    scheduler.record_result(plugin_id, "propose", _ovr(5), 0.0)
+    assert scheduler.cache_entries_count() >= 1
+
+
+# ---------------------------------------------------------------------------
+# Row 1 — explicit Unregister
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_row_1_explicit_unregister_clears_cache():
+    server, scheduler, _, _ = _make_ctx()
+    await _seed_cache(server, scheduler)
+    await server.unregister("p1", reason="client_shutdown")
+    assert scheduler.cache_entries_count() == 0
+
+
+# ---------------------------------------------------------------------------
+# Row 2 — heartbeat missed eviction (auto-unregister path)
+#
+# Coverage deferred to follow-up PR: the registry-side ``unregister(reason=
+# "heartbeat_missed")`` machinery is identical to row 1 (client Unregister),
+# so the cache-invalidation contract is locked by row 1; the upstream caller
+# (an actual heartbeat monitor) lands later.
+# ---------------------------------------------------------------------------
+
+
+# ---------------------------------------------------------------------------
+# Row 3 — circuit breaker OPEN
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_row_3_circuit_open_clears_cache():
+    server, scheduler, cb, _ = _make_ctx()
+    await _seed_cache(server, scheduler)
+    for _ in range(3):  # failure_threshold=3
+        cb.record_failure("p1")
+    assert scheduler.cache_entries_count() == 0
+
+
+# ---------------------------------------------------------------------------
+# Row 4 — client-driven version upgrade (Unregister + Register)
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_row_4_client_driven_version_upgrade_path_is_fresh_cache():
+    server, scheduler, _, _ = _make_ctx()
+    await _seed_cache(server, scheduler)
+    # Version upgrade: client Unregister then Register new version.
+    await server.unregister("p1", reason="version_upgrade")
+    assert scheduler.cache_entries_count() == 0  # cleared by the unregister step
+    # Fresh Register does NOT inherit the old cache; entry stays at 0 until
+    # a new record_result lands.
+    await _register_hold_last(server, plugin_id="p1")
+    assert scheduler.cache_entries_count() == 0
+    scheduler.compute_active_set(0.0, "propose")
+    scheduler.record_result("p1", "propose", _ovr(99), 0.0)
+    assert scheduler.cache_entries_count() == 1
+
+
+# ---------------------------------------------------------------------------
+# Row 5 — explicit config-reload full clear
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_row_5_config_reload_clears_every_cache():
+    server, scheduler, _, _ = _make_ctx()
+    await _seed_cache(server, scheduler, plugin_id="p1")
+    await _seed_cache(server, scheduler, plugin_id="p2")
+    assert scheduler.cache_entries_count() == 2
+    scheduler.invalidate_cache(reason="config_reload")
+    assert scheduler.cache_entries_count() == 0
+
+
+# ---------------------------------------------------------------------------
+# Row 6 — orchestrator restart (in-memory only; new scheduler is empty)
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_row_6_restart_equivalent_fresh_scheduler_has_no_cache():
+    # Simulating restart: construct a new Scheduler bound to the same
+    # registry + circuit_breaker. The old scheduler's cache dies with it.
+    server, old_scheduler, cb, clock = _make_ctx()
+    await _seed_cache(server, old_scheduler)
+    assert old_scheduler.cache_entries_count() == 1
+
+    # "Restart" — discard the old scheduler, spin up a new one.
+    del old_scheduler
+    new_scheduler = PluginScheduler(server, cb, clock)
+    assert new_scheduler.cache_entries_count() == 0
diff --git a/components/src/dynamo/planner/tests/plugins/scheduler/test_phase_alignment.py b/components/src/dynamo/planner/tests/plugins/scheduler/test_phase_alignment.py
new file mode 100644
index 000000000000..8d489bb89fea
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/scheduler/test_phase_alignment.py
@@ -0,0 +1,172 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Phase alignment tests — `PluginRegistryServer._aligned_anchor`.
+
+Plugins registered milliseconds apart but with the same
+``execution_interval_seconds`` must fire on the same pipeline tick.
+This is critical for ``requires_produced_fields`` to work — if plugin
+B depends on plugin A's output, B's throttle must be in phase with A's
+throttle, even if B registered slightly later than A during planner
+startup.
+
+The mechanism: at registration time, ``registered_at`` is snapped to
+the nearest scale_interval boundary (``floor(now / scale_interval) *
+scale_interval``) instead of using the raw monotonic clock value.
+
+Disabled when ``scale_interval_seconds`` is 0 (default for the PSM
+path; the orchestrator path constructs ``PluginRegistryServer`` with
+the real value from ``SchedulingConfig.scale_interval_seconds``).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.clock import VirtualClock
+from dynamo.planner.plugins.registry.auth import AllowUnauthenticatedAuth
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+from dynamo.planner.plugins.registry.server import PluginRegistryServer
+from dynamo.planner.plugins.transport.base import PluginTransport
+from dynamo.planner.plugins.types import HoldPolicy, RegisterRequest
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+class _StubTransport(PluginTransport):
+    def __init__(self, plugin_id, endpoint, *, in_process_instance=None):
+        self.plugin_id = plugin_id
+        self.endpoint = endpoint
+        self.timeout_seconds = 1.0
+
+    async def call(self, method, request):
+        return None
+
+    async def close(self):
+        pass
+
+
+def _make_server(clock: VirtualClock, scale_interval_seconds: float):
+    cb = CircuitBreaker(clock, failure_threshold=3, cooldown_seconds=30.0)
+
+    def factory(plugin_id, endpoint, *, in_process_instance=None):
+        return _StubTransport(plugin_id, endpoint)
+
+    return PluginRegistryServer(
+        clock=clock,
+        auth=AllowUnauthenticatedAuth(),
+        circuit_breaker=cb,
+        transport_factory=factory,
+        scale_interval_seconds=scale_interval_seconds,
+    )
+
+
+async def _register(server, plugin_id: str) -> None:
+    resp = await server.register(
+        RegisterRequest(
+            plugin_id=plugin_id,
+            plugin_type="propose",
+            priority=10,
+            endpoint="grpc://127.0.0.1:9000",
+            protocol_version="1.0",
+            execution_interval_seconds=180.0,
+            hold_policy=HoldPolicy.ACCEPT_WHEN_IDLE,
+        )
+    )
+    assert resp.accepted, resp.reject_reason
+
+
+# ---------------------------------------------------------------------------
+# Aligned anchor mechanics
+# ---------------------------------------------------------------------------
+
+
+def test_aligned_anchor_snaps_to_floor_boundary():
+    """Direct unit test of ``_aligned_anchor`` arithmetic."""
+    clock = VirtualClock()
+    server = _make_server(clock, scale_interval_seconds=5.0)
+
+    assert server._aligned_anchor(0.0) == 0.0  # boundary stays
+    assert server._aligned_anchor(2.5) == 0.0  # below boundary -> floor 0
+    assert server._aligned_anchor(4.999) == 0.0  # still in [0, 5)
+    assert server._aligned_anchor(5.0) == 5.0  # boundary
+    assert server._aligned_anchor(7.4) == 5.0  # snap down to 5
+    assert server._aligned_anchor(180.6) == 180.0
+    assert server._aligned_anchor(360.0) == 360.0
+
+
+def test_disabled_when_scale_interval_zero():
+    """``scale_interval_seconds=0.0`` (default) bypasses alignment —
+    raw clock value comes through.  Preserves the legacy behaviour for
+    the PSM path and for tests that don't explicitly enable alignment.
+    """
+    clock = VirtualClock()
+    server = _make_server(clock, scale_interval_seconds=0.0)
+
+    assert server._aligned_anchor(2.5) == 2.5
+    assert server._aligned_anchor(180.6) == 180.6
+
+
+# ---------------------------------------------------------------------------
+# End-to-end: two plugins registered milliseconds apart fire in same tick
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_two_plugins_same_interval_phase_aligned_after_register_skew():
+    """The bug scale_interval alignment fixes: plugin A registers at
+    T=0, plugin B at T=0.003 (3ms later due to async startup order).
+    Both declare ``execution_interval_seconds=180``.
+
+    Without alignment, A's ``registered_at=0`` makes its first fire
+    due at T=180, while B's ``registered_at=0.003`` shifts B's first
+    fire to T=180.003 — and the pipeline tick at exactly T=180 sees
+    A due but B not (179.997 < 180).  A and B drift apart forever.
+
+    With alignment (``scale_interval=5``), both snap to
+    ``registered_at=0``, and both fire at the same T=180 tick.
+    """
+    clock = VirtualClock()
+    server = _make_server(clock, scale_interval_seconds=5.0)
+
+    # Plugin A registers at clock=0.
+    await _register(server, "plugin_a")
+
+    # Plugin B registers 3ms later — typical async bootstrap order.
+    clock.advance(0.003)
+    await _register(server, "plugin_b")
+
+    a = server.get_plugin("plugin_a")
+    b = server.get_plugin("plugin_b")
+    assert a is not None and b is not None
+    # Both snap to the same scale_interval boundary (0.0).
+    assert a.registered_at == 0.0
+    assert b.registered_at == 0.0
+
+
+@pytest.mark.asyncio
+async def test_alignment_preserved_when_registration_crosses_boundary():
+    """If two plugins register at T=4.9 and T=5.1, they land on
+    different boundaries (0 and 5) — which is the correct semantic.
+    The 0.2s of real elapsed time crosses a tick boundary, so they
+    *should* be 5s out of phase.  Subsequent ticks at multiples of 5s
+    bring them into the same fire moments once interval has elapsed.
+    """
+    clock = VirtualClock()
+    server = _make_server(clock, scale_interval_seconds=5.0)
+
+    clock.advance(4.9)
+    await _register(server, "plugin_a")  # registered_at -> 0
+    clock.advance(0.2)
+    await _register(server, "plugin_b")  # registered_at -> 5
+
+    a = server.get_plugin("plugin_a")
+    b = server.get_plugin("plugin_b")
+    assert a is not None and b is not None
+    assert a.registered_at == 0.0
+    assert b.registered_at == 5.0
diff --git a/components/src/dynamo/planner/tests/plugins/scheduler/test_requires_produced_fields.py b/components/src/dynamo/planner/tests/plugins/scheduler/test_requires_produced_fields.py
new file mode 100644
index 000000000000..440d330c0103
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/scheduler/test_requires_produced_fields.py
@@ -0,0 +1,321 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Declarative-dependency gating tests — ``compute_active_set(ctx=...)``.
+
+The scale_interval cadence model adds a second gate to ``is_due``:
+``RegisterRequest.requires_produced_fields`` lists dot-paths into
+``PipelineContext`` that must be non-None at fire time.  This lets a
+plugin declare "I only run when upstream stage produced predictions"
+without writing the gate check inside the plugin itself.
+
+When the gate fails, scheduler increments
+``tick_requires_unsatisfied_total`` and skips the plugin (no cache
+inherit — the plugin chose to opt into strict dependency, so a stale
+cached result would violate its own declared contract).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.clock import VirtualClock
+from dynamo.planner.plugins.registry.auth import AllowUnauthenticatedAuth
+from dynamo.planner.plugins.registry.circuit_breaker import CircuitBreaker
+from dynamo.planner.plugins.registry.server import PluginRegistryServer
+from dynamo.planner.plugins.scheduler import PluginScheduler
+from dynamo.planner.plugins.transport.base import PluginTransport
+from dynamo.planner.plugins.types import (
+    HoldPolicy,
+    ObservationData,
+    PipelineContext,
+    PredictionData,
+    RegisterRequest,
+    TrafficMetrics,
+)
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+class _StubTransport(PluginTransport):
+    def __init__(self, plugin_id, endpoint, *, in_process_instance=None):
+        self.plugin_id = plugin_id
+        self.endpoint = endpoint
+        self.timeout_seconds = 1.0
+
+    async def call(self, method, request):
+        return None
+
+    async def close(self):
+        pass
+
+
+def _make_ctx():
+    clock = VirtualClock()
+    cb = CircuitBreaker(clock, failure_threshold=3, cooldown_seconds=30.0)
+
+    def factory(plugin_id, endpoint, *, in_process_instance=None):
+        return _StubTransport(plugin_id, endpoint)
+
+    server = PluginRegistryServer(
+        clock=clock,
+        auth=AllowUnauthenticatedAuth(),
+        circuit_breaker=cb,
+        transport_factory=factory,
+    )
+    scheduler = PluginScheduler(server, cb, clock)
+    return server, scheduler, clock
+
+
+async def _register(
+    server,
+    plugin_id,
+    plugin_type="propose",
+    requires=None,
+):
+    resp = await server.register(
+        RegisterRequest(
+            plugin_id=plugin_id,
+            plugin_type=plugin_type,
+            priority=10,
+            endpoint="grpc://127.0.0.1:9000",
+            protocol_version="1.0",
+            execution_interval_seconds=0.0,  # every tick
+            hold_policy=HoldPolicy.ACCEPT_WHEN_IDLE,
+            requires_produced_fields=list(requires or []),
+        )
+    )
+    assert resp.accepted, resp.reject_reason
+
+
+# ---------------------------------------------------------------------------
+# _ctx_get dot-path walker
+# ---------------------------------------------------------------------------
+
+
+def test_ctx_get_top_level_attribute():
+    ctx = PipelineContext(
+        observations=ObservationData(
+            traffic=TrafficMetrics(duration_s=5, num_req=1, isl=1, osl=1),
+        ),
+    )
+    assert PluginScheduler._ctx_get(ctx, "observations") is not None
+
+
+def test_ctx_get_nested_dot_path():
+    ctx = PipelineContext(
+        observations=ObservationData(
+            traffic=TrafficMetrics(duration_s=5, num_req=1, isl=1, osl=1),
+        ),
+    )
+    traffic = PluginScheduler._ctx_get(ctx, "observations.traffic")
+    assert traffic is not None
+    assert PluginScheduler._ctx_get(ctx, "observations.traffic.num_req") == 1
+
+
+def test_ctx_get_returns_none_for_missing_intermediate():
+    ctx = PipelineContext(observations=None)
+    assert PluginScheduler._ctx_get(ctx, "observations.traffic") is None
+
+
+def test_ctx_get_returns_none_for_missing_attribute():
+    ctx = PipelineContext()
+    assert PluginScheduler._ctx_get(ctx, "predictions.predicted_num_req") is None
+
+
+def test_ctx_get_returns_none_when_ctx_is_none():
+    assert PluginScheduler._ctx_get(None, "anything") is None
+
+
+# ---------------------------------------------------------------------------
+# Requires gating in compute_active_set
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_plugin_without_requires_fires_normally():
+    """Plugin declaring no requires fires regardless of ctx state.
+    Backward compat: existing plugins (no requires field set) are
+    unaffected by the new gate."""
+    server, scheduler, clock = _make_ctx()
+    await _register(server, "p1")
+
+    active = scheduler.compute_active_set(clock.monotonic(), "propose", ctx=None)
+    assert [p.plugin_id for p in active.triggered] == ["p1"]
+
+
+@pytest.mark.asyncio
+async def test_plugin_with_satisfied_requires_fires():
+    server, scheduler, clock = _make_ctx()
+    await _register(server, "p1", requires=["predictions"])
+    ctx = PipelineContext(
+        predictions=PredictionData(
+            predicted_num_req=42.0, predicted_isl=10, predicted_osl=20
+        ),
+    )
+
+    active = scheduler.compute_active_set(clock.monotonic(), "propose", ctx=ctx)
+    assert [p.plugin_id for p in active.triggered] == ["p1"]
+
+
+@pytest.mark.asyncio
+async def test_plugin_with_unsatisfied_requires_skipped():
+    server, scheduler, clock = _make_ctx()
+    await _register(server, "p1", requires=["predictions"])
+    ctx = PipelineContext(predictions=None)
+
+    active = scheduler.compute_active_set(clock.monotonic(), "propose", ctx=ctx)
+    assert active.triggered == []
+    assert active.inherited == []  # no inherit for requires-gated skip
+
+
+@pytest.mark.asyncio
+async def test_plugin_with_nested_requires_path():
+    server, scheduler, clock = _make_ctx()
+    await _register(server, "p1", requires=["observations.traffic"])
+    ctx_missing = PipelineContext(observations=None)
+    ctx_present = PipelineContext(
+        observations=ObservationData(
+            traffic=TrafficMetrics(duration_s=5, num_req=1, isl=1, osl=1),
+        ),
+    )
+
+    assert (
+        scheduler.compute_active_set(
+            clock.monotonic(), "propose", ctx=ctx_missing
+        ).triggered
+        == []
+    )
+    assert [
+        p.plugin_id
+        for p in scheduler.compute_active_set(
+            clock.monotonic(), "propose", ctx=ctx_present
+        ).triggered
+    ] == ["p1"]
+
+
+@pytest.mark.asyncio
+async def test_multiple_requires_all_must_be_present():
+    server, scheduler, clock = _make_ctx()
+    await _register(server, "p1", requires=["predictions", "observations.traffic"])
+
+    # Only predictions present — traffic missing → skip
+    ctx_partial = PipelineContext(
+        predictions=PredictionData(
+            predicted_num_req=42, predicted_isl=10, predicted_osl=20
+        ),
+        observations=None,
+    )
+    assert (
+        scheduler.compute_active_set(
+            clock.monotonic(), "propose", ctx=ctx_partial
+        ).triggered
+        == []
+    )
+
+    # Both present → fire
+    ctx_both = PipelineContext(
+        predictions=PredictionData(
+            predicted_num_req=42, predicted_isl=10, predicted_osl=20
+        ),
+        observations=ObservationData(
+            traffic=TrafficMetrics(duration_s=5, num_req=1, isl=1, osl=1),
+        ),
+    )
+    assert [
+        p.plugin_id
+        for p in scheduler.compute_active_set(
+            clock.monotonic(), "propose", ctx=ctx_both
+        ).triggered
+    ] == ["p1"]
+
+
+@pytest.mark.asyncio
+async def test_requires_unsatisfied_when_ctx_is_none_conservative_skip():
+    """If caller didn't supply ctx and plugin declares requires,
+    conservative default = skip (don't fire a plugin without the data
+    it asked for).  This is the contract for callers that haven't
+    threaded ctx through yet (e.g. test fixtures).  Plugins without
+    requires still fire when ctx is None (see
+    ``test_plugin_without_requires_fires_normally``)."""
+    server, scheduler, clock = _make_ctx()
+    await _register(server, "p1", requires=["predictions"])
+
+    active = scheduler.compute_active_set(clock.monotonic(), "propose", ctx=None)
+    assert active.triggered == []
+
+
+# ---------------------------------------------------------------------------
+# Metric emission
+# ---------------------------------------------------------------------------
+
+
+def _stub_metrics():
+    """Minimal stand-in for PluginFrameworkMetrics — just records the
+    counter inc calls."""
+
+    class _BoundCounter:
+        def __init__(self, parent, labels_kw):
+            self._parent = parent
+            self._labels_kw = labels_kw
+
+        def inc(self):
+            self._parent.calls.append(self._labels_kw)
+
+    class _Counter:
+        def __init__(self):
+            self.calls = []
+
+        def labels(self, **kw):
+            return _BoundCounter(self, kw)
+
+    class _BoundGauge:
+        def set(self, _v):
+            pass
+
+    class _Gauge:
+        def labels(self, **kw):
+            return _BoundGauge()
+
+    class M:
+        tick_skipped_total = _Counter()
+        tick_requires_unsatisfied_total = _Counter()
+        tick_lag_seconds = _Gauge()
+
+    return M()
+
+
+@pytest.mark.asyncio
+async def test_tick_requires_unsatisfied_metric_emits_with_missing_field():
+    server, scheduler, clock = _make_ctx()
+    scheduler._metrics = _stub_metrics()
+    await _register(server, "p1", requires=["predictions", "observations.traffic"])
+
+    # Both missing — should record the FIRST missing field, not both.
+    scheduler.compute_active_set(
+        clock.monotonic(),
+        "propose",
+        ctx=PipelineContext(predictions=None, observations=None),
+    )
+    calls = scheduler._metrics.tick_requires_unsatisfied_total.calls
+    assert calls == [{"plugin_id": "p1", "missing_field": "predictions"}]
+
+    # Now predictions present, traffic missing → records "observations.traffic"
+    scheduler._metrics.tick_requires_unsatisfied_total.calls.clear()
+    scheduler.compute_active_set(
+        clock.monotonic(),
+        "propose",
+        ctx=PipelineContext(
+            predictions=PredictionData(
+                predicted_num_req=42, predicted_isl=10, predicted_osl=20
+            ),
+            observations=None,
+        ),
+    )
+    calls = scheduler._metrics.tick_requires_unsatisfied_total.calls
+    assert calls == [{"plugin_id": "p1", "missing_field": "observations.traffic"}]
diff --git a/components/src/dynamo/planner/tests/plugins/transport/__init__.py b/components/src/dynamo/planner/tests/plugins/transport/__init__.py
new file mode 100644
index 000000000000..e5725ea5a481
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/transport/__init__.py
@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/components/src/dynamo/planner/tests/plugins/transport/test_config.py b/components/src/dynamo/planner/tests/plugins/transport/test_config.py
new file mode 100644
index 000000000000..971cc3a83f64
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/transport/test_config.py
@@ -0,0 +1,162 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for transport config + factories."""
+
+from __future__ import annotations
+
+import pytest
+
+from dynamo.planner.plugins.clock import VirtualClock, WallClock
+from dynamo.planner.plugins.transport import GrpcTransport, InProcessTransport
+from dynamo.planner.plugins.transport.config import (
+    ClockConfig,
+    TransportConfig,
+    make_clock,
+    make_transport_for_endpoint,
+)
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+class _StubPlugin:
+    async def Predict(self, req):
+        return req
+
+
+# ----- TransportConfig defaults -----
+
+
+def test_transport_config_defaults():
+    c = TransportConfig()
+    assert c.allow_insecure_grpc is False
+    assert c.request_timeout_seconds == 5.0
+
+
+def test_transport_config_extra_forbid():
+    """Spirit: unknown fields rejected at config-validation time."""
+    with pytest.raises(Exception, match="extra"):
+        TransportConfig(unknown_field="x")  # type: ignore[call-arg]
+
+
+def test_transport_config_rejects_non_positive_request_timeout():
+    """Per-RPC timeout must be strictly positive. (Previously enforced
+    on the duplicate SchedulingConfig.request_timeout_seconds field;
+    consolidated here when that duplicate was removed.)"""
+    from pydantic import ValidationError
+
+    with pytest.raises(ValidationError):
+        TransportConfig(request_timeout_seconds=0)
+    with pytest.raises(ValidationError):
+        TransportConfig(request_timeout_seconds=-1)
+
+
+# ----- make_transport_for_endpoint dispatch -----
+
+
+def test_factory_inproc_with_instance():
+    t = make_transport_for_endpoint(
+        "p1", "inproc://p1", TransportConfig(), in_process_instance=_StubPlugin()
+    )
+    assert isinstance(t, InProcessTransport)
+    assert t.plugin_id == "p1"
+    assert t.endpoint == "inproc://p1"
+
+
+def test_factory_inproc_without_instance_rejected():
+    with pytest.raises(ValueError, match="in_process_instance required"):
+        make_transport_for_endpoint("p1", "inproc://p1", TransportConfig())
+
+
+def test_factory_unix_rejected_unknown_scheme():
+    """``unix://`` was dropped from PR #1; only ``inproc://`` + ``grpc://``
+    are accepted. Lock the new rejection contract."""
+    with pytest.raises(ValueError, match="unknown endpoint scheme"):
+        make_transport_for_endpoint("p2", "unix:///tmp/x.sock", TransportConfig())
+
+
+def test_factory_grpc_default_refuses_insecure():
+    with pytest.raises(ValueError, match="allow_insecure_grpc=True"):
+        make_transport_for_endpoint("p3", "grpc://host:9090", TransportConfig())
+
+
+def test_factory_grpc_with_allow_insecure():
+    cfg = TransportConfig(allow_insecure_grpc=True)
+    t = make_transport_for_endpoint("p3", "grpc://host:9090", cfg)
+    assert isinstance(t, GrpcTransport)
+
+
+def test_factory_unknown_scheme():
+    with pytest.raises(ValueError, match="unknown endpoint scheme"):
+        make_transport_for_endpoint("p", "tcp://nope", TransportConfig())
+
+
+def test_factory_propagates_request_timeout():
+    cfg = TransportConfig(request_timeout_seconds=12.5)
+    t = make_transport_for_endpoint(
+        "p", "inproc://p", cfg, in_process_instance=_StubPlugin()
+    )
+    assert t.timeout_seconds == 12.5
+
+
+def test_factory_propagates_grpc_channel_knobs():
+    """``TransportConfig.keepalive_time_ms`` and
+    ``TransportConfig.max_message_size_bytes`` must be plumbed through
+    to the ``GrpcTransport`` so the runtime channel honours operator-
+    supplied values. Previously these were advertised on the config
+    surface but silently ignored at the factory boundary."""
+    cfg = TransportConfig(
+        allow_insecure_grpc=True,
+        keepalive_time_ms=12_345,
+        max_message_size_bytes=42 * 1024 * 1024,
+    )
+    t = make_transport_for_endpoint("p3", "grpc://host:9090", cfg)
+    assert isinstance(t, GrpcTransport)
+    assert t.keepalive_time_ms == 12_345
+    assert t.max_message_size_bytes == 42 * 1024 * 1024
+
+
+def test_grpc_channel_options_honours_kwargs():
+    """The channel-options builder must echo its kwargs into the
+    ``grpc.keepalive_time_ms`` / ``grpc.max_*_message_length`` entries
+    so the GrpcTransport channel uses the right values."""
+    from dynamo.planner.plugins.transport._grpc_base import grpc_channel_options
+
+    opts = dict(
+        grpc_channel_options(keepalive_time_ms=7_777, max_message_size_bytes=4096)
+    )
+    assert opts["grpc.keepalive_time_ms"] == 7_777
+    assert opts["grpc.max_send_message_length"] == 4096
+    assert opts["grpc.max_receive_message_length"] == 4096
+
+
+# ----- Clock factory + production safety -----
+
+
+def test_make_clock_wall():
+    c = make_clock(ClockConfig())
+    assert isinstance(c, WallClock)
+
+
+def test_make_clock_virtual_rejected_in_production(monkeypatch):
+    monkeypatch.delenv("DYNAMO_PLANNER_TEST", raising=False)
+    with pytest.raises(ValueError, match="DYNAMO_PLANNER_TEST=1"):
+        make_clock(ClockConfig(type="virtual"))
+
+
+def test_make_clock_virtual_allowed_in_test_mode(monkeypatch):
+    monkeypatch.setenv("DYNAMO_PLANNER_TEST", "1")
+    c = make_clock(ClockConfig(type="virtual", virtual_start_now=42.0))
+    assert isinstance(c, VirtualClock)
+    assert c.now() == 42.0
+
+
+def test_make_clock_unknown_type():
+    """Pydantic Literal validates type field at construction; ValueError early."""
+    with pytest.raises(Exception):  # Pydantic ValidationError
+        ClockConfig(type="invalid")  # type: ignore[arg-type]
diff --git a/components/src/dynamo/planner/tests/plugins/transport/test_in_process.py b/components/src/dynamo/planner/tests/plugins/transport/test_in_process.py
new file mode 100644
index 000000000000..dfce8552ab90
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/transport/test_in_process.py
@@ -0,0 +1,140 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for ``InProcessTransport``."""
+
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+
+from dynamo.planner.plugins.transport import (
+    InProcessTransport,
+    PluginCallError,
+    PluginConnectionError,
+    PluginTimeoutError,
+    PluginUnknownMethodError,
+)
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+class _AsyncEchoPlugin:
+    async def Predict(self, req):
+        return f"predict-{req}"
+
+    async def Propose(self, req):
+        return f"propose-{req}"
+
+
+class _SyncEchoPlugin:
+    def Bootstrap(self, req):
+        return f"bootstrap-{req}"
+
+
+class _RaisingPlugin:
+    async def Propose(self, req):
+        raise ValueError("plugin internal failure")
+
+
+class _SlowPlugin:
+    async def Predict(self, req):
+        await asyncio.sleep(2.0)
+        return req
+
+
+# ----- construction validation -----
+
+
+def test_construct_requires_instance():
+    with pytest.raises(ValueError, match="instance must not be None"):
+        InProcessTransport("p", None)  # type: ignore[arg-type]
+
+
+def test_construct_requires_positive_timeout():
+    with pytest.raises(ValueError, match="timeout_seconds must be positive"):
+        InProcessTransport("p", _AsyncEchoPlugin(), timeout_seconds=0.0)
+
+
+def test_endpoint_uses_inproc_scheme():
+    t = InProcessTransport("p", _AsyncEchoPlugin())
+    assert t.endpoint == "inproc://p"
+    assert t.plugin_id == "p"
+
+
+# ----- happy path -----
+
+
+@pytest.mark.asyncio
+async def test_async_plugin_call():
+    t = InProcessTransport("a", _AsyncEchoPlugin(), timeout_seconds=1.0)
+    assert await t.call("Predict", "x") == "predict-x"
+    assert await t.call("Propose", "y") == "propose-y"
+
+
+@pytest.mark.asyncio
+async def test_sync_plugin_dispatched_via_to_thread():
+    """Sync plugin methods must work (dispatched via asyncio.to_thread)."""
+    t = InProcessTransport("s", _SyncEchoPlugin(), timeout_seconds=1.0)
+    assert await t.call("Bootstrap", "data") == "bootstrap-data"
+
+
+# ----- error paths -----
+
+
+@pytest.mark.asyncio
+async def test_unknown_method_raises():
+    t = InProcessTransport("a", _AsyncEchoPlugin())
+    with pytest.raises(PluginUnknownMethodError) as exc:
+        await t.call("Nonexistent", "x")
+    assert exc.value.plugin_id == "a"
+    assert exc.value.method == "Nonexistent"
+
+
+@pytest.mark.asyncio
+async def test_plugin_exception_wrapped():
+    t = InProcessTransport("r", _RaisingPlugin())
+    with pytest.raises(PluginCallError) as exc:
+        await t.call("Propose", "x")
+    assert "plugin internal failure" in str(exc.value)
+    assert exc.value.plugin_id == "r"
+    # Original exception preserved
+    assert isinstance(exc.value.cause, ValueError)
+
+
+@pytest.mark.asyncio
+async def test_timeout_raises_typed_error():
+    t = InProcessTransport("slow", _SlowPlugin(), timeout_seconds=0.05)
+    with pytest.raises(PluginTimeoutError) as exc:
+        await t.call("Predict", "x")
+    assert exc.value.plugin_id == "slow"
+    assert exc.value.method == "Predict"
+
+
+# ----- close idempotent -----
+
+
+@pytest.mark.asyncio
+async def test_close_idempotent():
+    t = InProcessTransport("a", _AsyncEchoPlugin())
+    await t.close()
+    await t.close()
+    await t.close()  # multiple close calls must not raise
+
+
+@pytest.mark.asyncio
+async def test_call_after_close_raises_connection_error():
+    """After ``close()``, subsequent ``call()`` must raise
+    ``PluginConnectionError`` — matches ``_GrpcTransportBase`` contract
+    so callers see the same exception type regardless of transport.
+    """
+    t = InProcessTransport("a", _AsyncEchoPlugin())
+    await t.close()
+    with pytest.raises(PluginConnectionError, match="after close"):
+        await t.call("Predict", request="anything")
diff --git a/components/src/dynamo/planner/tests/plugins/transport/test_transport_contract.py b/components/src/dynamo/planner/tests/plugins/transport/test_transport_contract.py
new file mode 100644
index 000000000000..179518e0c21c
--- /dev/null
+++ b/components/src/dynamo/planner/tests/plugins/transport/test_transport_contract.py
@@ -0,0 +1,360 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Transport contract test — **core acceptance**.
+
+For a single ``echo`` plugin (returns the request's PipelineContext as the
+response's predictions field), assert that both PR #1 transports
+(``in_process`` / ``grpc``) produce the **byte-equal serialized response**
+for the same set of inputs.
+
+This is the strongest guarantee that transport changes won't introduce
+silent behavioral drift between deployment forms. The ``grpc_mtls``
+variant lands alongside cert-manager wiring in a follow-up PR.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import AsyncIterator
+
+import grpc
+import pytest
+
+from dynamo.planner.plugins.proto.v1 import plugin_pb2 as pb
+from dynamo.planner.plugins.proto.v1 import plugin_pb2_grpc as pbg
+from dynamo.planner.plugins.transport import (
+    GrpcTransport,
+    InProcessTransport,
+    PluginConnectionError,
+    PluginTimeoutError,
+    PluginTransport,
+    PluginUnknownMethodError,
+)
+
+pytestmark = [
+    pytest.mark.gpu_0,
+    pytest.mark.pre_merge,
+    pytest.mark.unit,
+    pytest.mark.planner,
+]
+
+
+# ----------------------------------------------------------------------------
+# Echo plugin — Predict echoes context.observations.traffic into predictions
+# ----------------------------------------------------------------------------
+
+
+class EchoServicer(pbg.PredictPluginServicer):
+    """gRPC servicer that echoes traffic.num_req into predictions.predicted_num_req
+    so we can verify the request reached the plugin and round-tripped.
+    """
+
+    async def Predict(
+        self, request: pb.PredictStageRequest, context
+    ) -> pb.PredictStageResponse:
+        ctx = request.context
+        resp = pb.PredictStageResponse()
+        if ctx.HasField("observations") and ctx.observations.HasField("traffic"):
+            resp.predictions.predicted_num_req = ctx.observations.traffic.num_req
+            resp.predictions.predicted_isl = ctx.observations.traffic.isl
+            resp.predictions.predicted_osl = ctx.observations.traffic.osl
+        resp.predictions.source = "echo-server"
+        return resp
+
+
+class EchoPluginInProcess:
+    """Same logic as EchoServicer but as a Python in-process callable.
+
+    The InProcessTransport calls ``Predict(req)`` directly — no servicer
+    wrapper / context arg.
+    """
+
+    async def Predict(self, request: pb.PredictStageRequest) -> pb.PredictStageResponse:
+        ctx = request.context
+        resp = pb.PredictStageResponse()
+        if ctx.HasField("observations") and ctx.observations.HasField("traffic"):
+            resp.predictions.predicted_num_req = ctx.observations.traffic.num_req
+            resp.predictions.predicted_isl = ctx.observations.traffic.isl
+            resp.predictions.predicted_osl = ctx.observations.traffic.osl
+        resp.predictions.source = "echo-server"
+        return resp
+
+
+# ----------------------------------------------------------------------------
+# gRPC server fixtures (insecure TCP)
+# ----------------------------------------------------------------------------
+
+
+async def _start_grpc_server(listen: str) -> tuple[grpc.aio.Server, str]:
+    """Start a gRPC server with EchoServicer at ``listen``.
+
+    Returns (server, actual_listen) — for ":0" port, returns the bound port.
+    """
+    server = grpc.aio.server()
+    pbg.add_PredictPluginServicer_to_server(EchoServicer(), server)
+    port = server.add_insecure_port(listen)
+    await server.start()
+    # For TCP ":0", rebuild listen with actual port; for UDS, listen is unchanged
+    if (
+        listen.startswith("[::]:0")
+        or listen.startswith("0.0.0.0:0")
+        or listen.endswith(":0")
+    ):
+        host = listen.rsplit(":", 1)[0]
+        actual_listen = f"{host}:{port}"
+    else:
+        actual_listen = listen
+    return server, actual_listen
+
+
+# ----------------------------------------------------------------------------
+# Test data — 7 representative PipelineContext payloads
+# ----------------------------------------------------------------------------
+
+
+def _ctx_minimal() -> pb.PipelineContext:
+    return pb.PipelineContext(request_id="req-min")
+
+
+def _ctx_with_traffic() -> pb.PipelineContext:
+    c = pb.PipelineContext(request_id="req-traffic")
+    c.observations.traffic.duration_s = 60.0
+    c.observations.traffic.num_req = 1500.0
+    c.observations.traffic.isl = 3000.0
+    c.observations.traffic.osl = 150.0
+    return c
+
+
+def _ctx_with_full_observations() -> pb.PipelineContext:
+    c = pb.PipelineContext(request_id="req-full", decision_id="d-1")
+    c.observations.traffic.num_req = 2000
+    c.observations.traffic.isl = 2500
+    c.observations.traffic.osl = 200
+    c.observations.workers.ready_prefill = 4
+    c.observations.workers.ready_decode = 8
+    c.observations.workers.expected_prefill = 4
+    c.observations.workers.expected_decode = 10
+    c.observations.fpm.prefill_engines["e0"] = b"\x01\x02\x03"
+    c.observations.fpm.decode_engines["e1"] = b"\xff\xfe"
+    return c
+
+
+def _ctx_with_predictions_proposal() -> pb.PipelineContext:
+    c = pb.PipelineContext(request_id="req-pp")
+    c.predictions.predicted_num_req = 1800.0
+    c.predictions.source = "upstream-predictor"
+    c.proposal.targets.add(sub_component_type="prefill", replicas=6)
+    c.proposal.targets.add(sub_component_type="decode", replicas=12)
+    return c
+
+
+def _ctx_with_unicode_reason() -> pb.PipelineContext:
+    c = pb.PipelineContext(request_id="req-unicode")
+    c.proposal.reason = "测试中文 reason — 包括 emoji 🚀"
+    c.proposal.targets.add(sub_component_type="prefill", replicas=8)
+    return c
+
+
+def _ctx_with_constrained() -> pb.PipelineContext:
+    c = pb.PipelineContext(request_id="req-constrained", decision_id="d-2")
+    c.observations.traffic.num_req = 500
+    c.observations.traffic.isl = 1000
+    c.observations.traffic.osl = 100
+    c.constrained.targets.add(sub_component_type="prefill", replicas=2)
+    c.constrained.reason = "budget-constrained"
+    return c
+
+
+def _ctx_zero_replicas_explicit() -> pb.PipelineContext:
+    """ComponentTarget.replicas=0 explicitly set (not unset) — must round-trip."""
+    c = pb.PipelineContext(request_id="req-zero")
+    c.observations.traffic.num_req = 0.0  # also explicit zero
+    c.observations.traffic.isl = 0
+    c.observations.traffic.osl = 0
+    target = c.constrained.targets.add(sub_component_type="decode")
+    target.replicas = 0  # explicit zero
+    return c
+
+
+_INPUTS = [
+    ("minimal", _ctx_minimal),
+    ("with_traffic", _ctx_with_traffic),
+    ("full_observations", _ctx_with_full_observations),
+    ("predictions_proposal", _ctx_with_predictions_proposal),
+    ("unicode_reason", _ctx_with_unicode_reason),
+    ("constrained", _ctx_with_constrained),
+    ("zero_replicas_explicit", _ctx_zero_replicas_explicit),
+]
+
+
+# ----------------------------------------------------------------------------
+# Async fixture: 4 transports targeting the same Echo plugin
+# ----------------------------------------------------------------------------
+
+
+@pytest.fixture
+def transport_kind(request):
+    """Parametrized over 2 transport kinds (in_process, grpc)."""
+    return request.param
+
+
+@pytest.fixture
+async def echo_transport(transport_kind) -> AsyncIterator[PluginTransport]:
+    """Yield a PluginTransport pointed at an EchoServicer (or in-process Echo).
+
+    Cleans up server + transport on teardown.
+    """
+    if transport_kind == "in_process":
+        t = InProcessTransport("echo", EchoPluginInProcess(), timeout_seconds=2.0)
+        try:
+            yield t
+        finally:
+            await t.close()
+        return
+
+    if transport_kind == "grpc":
+        server, listen = await _start_grpc_server("127.0.0.1:0")
+        try:
+            t = GrpcTransport(
+                "echo", f"grpc://{listen}", allow_insecure=True, timeout_seconds=2.0
+            )
+            try:
+                yield t
+            finally:
+                await t.close()
+        finally:
+            await server.stop(grace=0.1)
+        return
+
+    pytest.fail(f"unknown transport_kind: {transport_kind}")
+
+
+_TRANSPORT_KINDS = ["in_process", "grpc"]
+
+
+# ----------------------------------------------------------------------------
+# Contract test: 7 inputs × 2 transports = 14 cases of byte-equality
+# ----------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("transport_kind", _TRANSPORT_KINDS, indirect=True)
+@pytest.mark.parametrize(
+    "input_name,ctx_factory",
+    _INPUTS,
+    ids=[name for name, _ in _INPUTS],
+)
+@pytest.mark.asyncio
+async def test_round_trip_equivalence(
+    echo_transport: PluginTransport,
+    input_name: str,
+    ctx_factory,
+    transport_kind: str,
+):
+    """For every (input × transport) pair, the response is byte-equal."""
+    ctx = ctx_factory()
+    request = pb.PredictStageRequest(context=ctx)
+    response = await echo_transport.call("Predict", request)
+    assert isinstance(response, pb.PredictStageResponse), f"got {type(response)}"
+
+    # Echo plugin reflects traffic into predictions; verify
+    if ctx.HasField("observations") and ctx.observations.HasField("traffic"):
+        assert (
+            response.predictions.predicted_num_req == ctx.observations.traffic.num_req
+        )
+        assert response.predictions.predicted_isl == ctx.observations.traffic.isl
+        assert response.predictions.predicted_osl == ctx.observations.traffic.osl
+    assert response.predictions.source == "echo-server"
+
+
+@pytest.mark.parametrize(
+    "input_name,ctx_factory",
+    _INPUTS,
+    ids=[name for name, _ in _INPUTS],
+)
+@pytest.mark.asyncio
+async def test_byte_equal_response_across_transports(
+    input_name: str,
+    ctx_factory,
+    tmp_path: Path,
+):
+    """Response bytes from in_process / grpc must be **byte-identical**.
+
+    This is the strongest possible contract — any silent semantic drift
+    between transport implementations is caught here.
+    """
+    request = pb.PredictStageRequest(context=ctx_factory())
+
+    # In-process
+    t_inp = InProcessTransport("echo", EchoPluginInProcess(), timeout_seconds=2.0)
+    try:
+        resp_inp = await t_inp.call("Predict", request)
+        bytes_inp = resp_inp.SerializeToString()
+    finally:
+        await t_inp.close()
+
+    # gRPC insecure
+    server_grpc, listen = await _start_grpc_server("127.0.0.1:0")
+    try:
+        t_grpc = GrpcTransport(
+            "echo", f"grpc://{listen}", allow_insecure=True, timeout_seconds=2.0
+        )
+        try:
+            resp_grpc = await t_grpc.call("Predict", request)
+            bytes_grpc = resp_grpc.SerializeToString()
+        finally:
+            await t_grpc.close()
+    finally:
+        await server_grpc.stop(grace=0.1)
+
+    assert (
+        bytes_inp == bytes_grpc
+    ), f"in_process vs grpc bytes differ for input {input_name!r}"
+
+
+# ----------------------------------------------------------------------------
+# Error contract: each transport raises typed errors for common failures
+# ----------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize("transport_kind", _TRANSPORT_KINDS, indirect=True)
+@pytest.mark.asyncio
+async def test_unknown_method_typed_error(
+    echo_transport: PluginTransport, transport_kind: str
+):
+    """All transports must raise PluginUnknownMethodError for unregistered methods."""
+    request = pb.ProposeStageRequest()  # different stage's request
+    with pytest.raises(PluginUnknownMethodError):
+        # Echo plugin only implements Predict; Propose should be UnknownMethod
+        await echo_transport.call("Propose", request)
+
+
+@pytest.mark.asyncio
+async def test_unreachable_endpoint_raises_connection_error(tmp_path: Path):
+    """gRPC: pointing transport at non-existent endpoint -> PluginConnectionError."""
+    # Port not bound
+    t = GrpcTransport(
+        "noplug", "grpc://127.0.0.1:1", allow_insecure=True, timeout_seconds=0.5
+    )
+    try:
+        with pytest.raises((PluginConnectionError, PluginTimeoutError)):
+            await t.call("Predict", pb.PredictStageRequest())
+    finally:
+        await t.close()
+
+
+@pytest.mark.parametrize("transport_kind", _TRANSPORT_KINDS, indirect=True)
+@pytest.mark.asyncio
+async def test_close_idempotent_all_transports(
+    echo_transport: PluginTransport, transport_kind: str
+):
+    """All transports must satisfy two close()-related invariants:
+    1. ``close()`` is idempotent (multiple calls don't raise).
+    2. Subsequent ``call()`` raises ``PluginConnectionError`` — uniform
+       contract across in-process and gRPC so the orchestrator can
+       handle post-close mistakes the same way regardless of transport.
+    """
+    await echo_transport.close()
+    await echo_transport.close()  # idempotent
+    with pytest.raises(PluginConnectionError):
+        await echo_transport.call("Predict", pb.PredictStageRequest())
diff --git a/components/src/dynamo/replay/main.py b/components/src/dynamo/replay/main.py
index d9a08a263319..6d4a1b045fc9 100644
--- a/components/src/dynamo/replay/main.py
+++ b/components/src/dynamo/replay/main.py
@@ -394,7 +394,7 @@ def _run_planner_replay(
     # planner's linear regression. The default polynomial model cannot
     # feed the throughput regression (its decode formula is quadratic in
     # utilization ratio, causing negative regression coefficients).
-    if not adapter._sm._is_easy:
+    if not adapter._is_easy_mode():
         ref_args = extra_engine_args or prefill_engine_args or MockEngineArgs()
         aic_backend = ref_args.aic_backend
         if (
@@ -476,14 +476,14 @@ def _run_planner_replay(
                     # have variance.
                     agg_fpms = prefill_fpms + decode_fpms
                     if agg_fpms:
-                        adapter._sm.load_benchmark_fpms(agg_fpms=agg_fpms)
+                        adapter.install_benchmark_fpms(agg_fpms=agg_fpms)
                     else:
                         sys.stderr.write(
                             "Warning: AIC produced no agg benchmark FPMs\n"
                         )
                 else:
                     if prefill_fpms and decode_fpms:
-                        adapter._sm.load_benchmark_fpms(
+                        adapter.install_benchmark_fpms(
                             prefill_fpms=prefill_fpms, decode_fpms=decode_fpms
                         )
                     else:
diff --git a/container/deps/requirements.planner.txt b/container/deps/requirements.planner.txt
index 984e4a26cb04..28bd5a42d3df 100644
--- a/container/deps/requirements.planner.txt
+++ b/container/deps/requirements.planner.txt
@@ -7,11 +7,15 @@ aiconfigurator[webapp]>=0.9.0
 aiofiles<=25.1.0
 aiohttp>=3.9.0,<4.0
 filterpy==1.4.5
+# gRPC + protobuf are runtime deps for the plugin-orchestrator transport
+# (use_orchestrator=true path). Pin in sync with requirements.common.txt.
+grpcio>=1.63.0
 kubernetes==32.0.1
 kubernetes_asyncio==32.0.0
 plotly>=6.0.1
 pmdarima==2.1.1
 prometheus-api-client==0.6.0
 prophet==1.2.1
+protobuf>=5.29.5,<7.0.0
 scikit-learn==1.7.2
 scipy>=1.14.0,<2.0
diff --git a/docs/components/planner/planner-guide.md b/docs/components/planner/planner-guide.md
index 0b92b3dad878..e62866a5e46d 100644
--- a/docs/components/planner/planner-guide.md
+++ b/docs/components/planner/planner-guide.md
@@ -166,6 +166,47 @@ The same diagnostic signals surfaced in these reports are also exported as Prome
 
 The Replica Counts plot overlays actual prefill/decode replicas with discrete recommendation markers for the Planner's recommended prefill/decode replicas. When `advisory: true`, these recommended counts are suggestions only; the Planner records what it would do without applying the change.
 
+### Scheduling / engine selection
+
+Settings that control which tick engine the planner runs (PR 7 dual-path
+cutover). Live under the `scheduling` sub-tree of `PlannerConfig`.
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| `scheduling.use_orchestrator` | bool | `false` | When `false`, planner runs the legacy single-class state machine (PSM path — pre-PR-7 behaviour). When `true`, planner runs the plugin-based orchestrator (PROPOSE / RECONCILE / CONSTRAIN / EXECUTE pipeline with the 5 builtin plugins). The orchestrator path emits the full set of `dynamo_planner_plugin_*` Prometheus metrics and structured audit events; the PSM path keeps the legacy metric surface only. **Decision outputs are byte-identical between paths** (locked by `tests/integration/test_dual_path_parity.py`). Default `false` keeps existing behaviour; flip after canary observation. |
+| `scheduling.request_timeout_seconds` | float | `5.0` | Per-plugin RPC timeout. Plugins exceeding this raise `PluginTimeoutError`; the stage continues with the remaining plugins. Only meaningful when `use_orchestrator=true`. |
+| `scheduling.tick_max_duration_seconds` | float | `30.0` | Outer deadline wrapping the entire 4-stage pipeline. Exceeding it aborts the tick; the next tick runs from a clean state. Only meaningful when `use_orchestrator=true`. |
+
+#### How to enable on a DGD
+
+Add the field under `features.planner` in your DGDR (or directly in the
+generated DGD's planner `--config` JSON):
+
+```yaml
+apiVersion: nvidia.com/v1beta1
+kind: DynamoGraphDeploymentRequest
+metadata:
+  name: my-deployment
+spec:
+  model: Qwen/Qwen3-0.6B
+  features:
+    planner:
+      optimization_target: sla
+      enable_load_scaling: true
+      ttft: 200.0
+      itl: 10.0
+      pre_deployment_sweeping_mode: rapid
+      scheduling:
+        use_orchestrator: true        # opt into plugin-based orchestrator
+        # request_timeout_seconds: 5.0    # default; tune if user plugins are slow
+        # tick_max_duration_seconds: 30.0
+```
+
+For ad-hoc validation on an already-deployed DGD, patch the planner's
+`--config` JSON to add `"scheduling": {"use_orchestrator": true}` and
+restart the planner Pod. See the rollout runbook for staged-flip
+guidance.
+
 ## Integration with Profiler
 
 When the profiler runs with planner enabled, it:
diff --git a/pyproject.toml b/pyproject.toml
index 66b30e3052cf..725eb8eaf5cc 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -204,8 +204,6 @@ filterwarnings = [
     "ignore:.*unclosed event loop.*:ResourceWarning",
     # unraisable exception warnings
     "ignore:.*Exception ignored in.*:pytest.PytestUnraisableExceptionWarning",
-    # CPython relaunches resource_tracker after engine subprocess teardown
-    "ignore:resource_tracker.*process died unexpectedly.*:UserWarning",
     # pynvml deprecation, temporary until upstream migrates to nvidia-ml-py
     "ignore:The pynvml package is deprecated.*:FutureWarning",
     # Dynamo's own KV events deprecation warning
@@ -465,6 +463,15 @@ module = ["msgspec", "msgspec.*"]
 follow_imports = "skip"
 ignore_missing_imports = true
 
+[[tool.mypy.overrides]]
+# grpc / google.protobuf ship without type stubs in the dynamo-runtime image
+# (grpc-stubs / types-protobuf are not pulled in by requirements.common.txt).
+# The planner plugin transport imports grpc.aio + google.protobuf.message at
+# module top — silence import-untyped errors there.
+module = ["grpc", "grpc.*", "google.protobuf", "google.protobuf.*"]
+follow_imports = "skip"
+ignore_missing_imports = true
+
 [[tool.mypy.overrides]]
 # Profiler module was never previously type-checked and has many
 # union-attr / attr-defined issues. Skip errors for now.
diff --git a/tests/report_pytest_markers.py b/tests/report_pytest_markers.py
index 3a34be694047..741d6388eff1 100755
--- a/tests/report_pytest_markers.py
+++ b/tests/report_pytest_markers.py
@@ -86,6 +86,21 @@
     "kr8s.objects",
     "tritonclient",
     "tritonclient.grpc",
+    # gRPC core + generated protobuf modules — required by planner
+    # plugin framework test files (test_gateway / test_transport_contract
+    # / test_external_plugin_e2e and friends).  CI's pre-commit env
+    # doesn't install grpcio / protobuf, so collection-time
+    # ``import grpc`` would fail without these stubs.
+    "grpc",
+    "grpc.aio",
+    "google",
+    "google.protobuf",
+    "google.protobuf.message",
+    # msgspec — used by FPM encoding in engine_adapter and by perf metric
+    # ingestion in monitoring/perf_metrics; not in the pre-commit env.
+    "msgspec",
+    "msgspec.msgpack",
+    "msgspec.json",
     "aiohttp",
     "aiofiles",
     "httpx",