components/src/dynamo/planner/core/base.py-997-1004 (1)

997-1004: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Reset the cached worker counts on ticks that skip inventory collection.

_last_worker_counts is only updated when this tick requested worker states, so any later tick with need_worker_states=False logs the previous tick’s replica counts as “current”. That makes the new summary line report stale deltas on the orchestrator path.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/core/base.py` around lines 997 - 1004, The
cached worker count handling currently only updates self._last_worker_counts
when tick_input.worker_counts is present, causing stale counts to persist for
later ticks that skip inventory; modify the conditional around
tick_input.worker_counts (the block that sets self._last_worker_counts) to
explicitly clear/reset self._last_worker_counts (e.g. set to None) when
tick_input.worker_counts is None so that _log_decision_summary and downstream
logic do not use stale replica counts; this change should be placed alongside
the existing code that calls engine.tick(...) and references
tick_input.worker_counts and _last_worker_counts.

components/src/dynamo/planner/config/planner_config.py-159-166 (1)

159-166: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Chain the invalid hold_policy error explicitly.

_coerce_hold_policy catches KeyError and then raises a ValueError without an explicit from ..., leaving the exception context implicit. Capture the KeyError as err and chain it.

Suggested change

-        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}"
-                )
+        if isinstance(v, str):
+            try:
+                return HoldPolicy[v.upper()]
+            except KeyError as err:
+                raise ValueError(
+                    f"hold_policy must be one of {[p.name for p in HoldPolicy]}, "
+                    f"got {v!r}"
+                ) from err

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/config/planner_config.py` around lines 159 -
166, The _coerce_hold_policy function currently catches KeyError when mapping a
string to HoldPolicy and raises ValueError without exception chaining; modify
the except block to capture the KeyError as err and re-raise the ValueError
using "raise ... from err" so the original KeyError is preserved in the
exception chain when mapping strings to HoldPolicy.

components/src/dynamo/planner/offline/replay_adapter.py-167-167 (1)

167-167: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Consider closing the event loop after replay.

The event loop created on line 167 is never explicitly closed. While Python's GC will eventually clean it up, explicit cleanup prevents resource warnings and is best practice.

Proposed fix

Add cleanup at the end of run() (after line 282):

         return ReplayPlannerReport(
             trace_report=trace_report,
             scaling_events=scaling_events,
             diagnostics_log=diagnostics_log,
             total_ticks=total_ticks,
             html_report_path=html_report_path,
         )
+        # Note: Consider adding a finally block or __del__ to close self._loop
+        # if self._loop is not None:
+        #     self._loop.close()

Or add a close() method and document that callers should invoke it, or use __del__:

def __del__(self) -> None:
    if self._loop is not None and not self._loop.is_closed():
        self._loop.close()

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/offline/replay_adapter.py` at line 167, The
asyncio event loop stored on self._loop (created in the ReplayAdapter
constructor) is never closed; update the ReplayAdapter to explicitly close it
after replay by either 1) calling self._loop.close() at the end of the run()
method (ensure you check for existence and not already closed), or 2) add a
public close() method that closes self._loop and document callers must call it,
or 3) implement __del__ to close the loop defensively; reference the _loop
attribute and the run() method (or add close()/__del__) when applying the
change.

components/src/dynamo/planner/plugins/registry/README.md-11-39 (1)

11-39: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Add fence languages to the ASCII blocks.

These unlabeled code fences trip markdownlint MD040. text is enough here.

Suggested fix

-```
+```text
             +-------------------+
             |  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
 +---------------+

@@
- +text
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)

Also applies to: 59-73

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/plugins/registry/README.md` around lines 11 -
39, The markdown has unlabeled code fences causing MD040; update the two
ASCII-art/code blocks in README.md by adding a fence language label "text"
(i.e., change ``` to ```text) so both the topology diagram block (the
PluginRegistry/CircuitBreaker/Orchestrator ASCII art) and the configuration flow
block (dev environment / multi-cluster / quick dev loop) are fenced as text;
locate these blocks by their distinctive content (the PluginRegistry diagram and
the "dev environment / single-tenant lab / pre-shared key OK?" flow) and apply
the label to each opening ``` fence.

components/src/dynamo/planner/plugins/registry/auth/__init__.py-26-32 (1)

26-32: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Sort __all__ to clear RUF022.

The exported names are out of order, so Ruff will keep reporting this file.

Suggested fix

 __all__ = [
-    "AuthValidator",
+    "AllowUnauthenticatedAuth",
     "AuthIdentity",
+    "AuthValidator",
+    "MultiSourceAuth",
     "StaticSecretAuth",
-    "MultiSourceAuth",
-    "AllowUnauthenticatedAuth",
 ]

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/plugins/registry/auth/__init__.py` around lines
26 - 32, The __all__ list is not sorted which triggers Ruff RUF022; reorder the
exported names in the __all__ tuple/list into lexicographic order so the names
(e.g., AllowUnauthenticatedAuth, AuthIdentity, AuthValidator, MultiSourceAuth,
StaticSecretAuth) are alphabetically sorted and ensure the list exactly matches
the actual exported symbols.

components/src/dynamo/planner/plugins/registry/__init__.py-30-35 (1)

30-35: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Sort __all__ to satisfy Ruff.

RUF022 will keep flagging this export list until it matches isort-style ordering.

Suggested fix

 __all__ = [
+    "AuthError",
     "RegisteredPlugin",
-    "derive_transport_type",
     "RegistryError",
-    "AuthError",
+    "derive_transport_type",
 ]

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/plugins/registry/__init__.py` around lines 30 -
35, Ruff flags the __all__ export list for not following isort-style ordering;
reorder the entries in the __all__ list so they are case-insensitively sorted
(e.g., "AuthError", "derive_transport_type", "RegisteredPlugin",
"RegistryError") to satisfy RUF022 and keep the module exports consistent;
update the __all__ variable in the registry module accordingly.

components/src/dynamo/planner/plugins/registry/auth/base.py-73-78 (1)

73-78: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Sort __all__ so Ruff stops flagging the module.

This list is out of isort-style order (RUF022).

Suggested fix

 __all__ = [
+    "AllowUnauthenticatedAuth",
+    "AuthError",
+    "AuthIdentity",
     "AuthValidator",
-    "AuthIdentity",
-    "AllowUnauthenticatedAuth",
-    "AuthError",
 ]

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/plugins/registry/auth/base.py` around lines 73
- 78, The module-level __all__ list is not in isort/ruff alphabetical order;
reorder the entries in the __all__ list so they are sorted alphabetically (e.g.,
"AllowUnauthenticatedAuth", "AuthError", "AuthIdentity", "AuthValidator") to
satisfy RUF022 and stop the Ruff warning for the symbols defined in this module.

components/src/dynamo/planner/plugins/transport/README.md-21-26 (1)

21-26: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Add a language to this fenced block.

This trips MD040 today, so the docs will keep failing or staying noisy until the fence is tagged (for example text).

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/plugins/transport/README.md` around lines 21 -
26, The fenced code block in README.md is missing a language tag which triggers
MD040; update the triple-backtick fence that wraps the plugin/orchestrator
decision diagram to include a language identifier (e.g., change ``` to ```text)
so the linter is satisfied; locate the block containing "plugin and orchestrator
in same process?" and the two arrows and add the language tag to the opening
fence.

components/src/dynamo/planner/plugins/types.py-368-411 (1)

368-411: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Sort __all__ to satisfy Ruff RUF022.

__all__ ordering is currently flagged by static analysis and may fail lint gates.

Proposed change

-__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",
-]
+__all__ = [
+    "AcceptResult",
+    "BootstrapRequest",
+    "BootstrapResponse",
+    "CircuitState",
+    "ComponentTarget",
+    "ConstrainStageRequest",
+    "ConstrainStageResponse",
+    "FpmData",
+    "HeartbeatRequest",
+    "HeartbeatResponse",
+    "HoldPolicy",
+    "ListPluginsRequest",
+    "ListPluginsResponse",
+    "ObservationData",
+    "OverrideResult",
+    "OverrideType",
+    "PipelineContext",
+    "PluginInfo",
+    "PredictStageRequest",
+    "PredictStageResponse",
+    "PredictionData",
+    "ProposeResult",
+    "ProposeStageRequest",
+    "ProposeStageResponse",
+    "ReconcileStageRequest",
+    "ReconcileStageResponse",
+    "RegisterRequest",
+    "RegisterResponse",
+    "RejectResult",
+    "ResetRequest",
+    "ResetResponse",
+    "ScalingProposal",
+    "TrafficMetrics",
+    "UnregisterRequest",
+    "UnregisterResponse",
+    "WorkerState",
+]

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/plugins/types.py` around lines 368 - 411, The
__all__ list in types.py is not alphabetically sorted and triggers Ruff RUF022;
update the __all__ variable by sorting all exported symbol strings (e.g.,
"AcceptResult", "AlertName", etc.—specifically the current entries like
"HoldPolicy", "CircuitState", "OverrideType", "RegisterRequest",
"RegisterResponse", "HeartbeatRequest", "HeartbeatResponse",
"UnregisterRequest", "UnregisterResponse", "ListPluginsRequest", "PluginInfo",
"ListPluginsResponse", "TrafficMetrics", "FpmData", "WorkerState",
"ObservationData", "PredictionData", "ComponentTarget", "ScalingProposal",
"PipelineContext", "AcceptResult", "RejectResult", "OverrideResult",
"ProposeResult", "PredictStageRequest", "PredictStageResponse",
"ProposeStageRequest", "ProposeStageResponse", "ReconcileStageRequest",
"ReconcileStageResponse", "ConstrainStageRequest", "ConstrainStageResponse",
"BootstrapRequest", "BootstrapResponse", "ResetRequest", "ResetResponse") into a
single lexicographically ordered list so Ruff RUF022 is satisfied; keep the same
string values and formatting style when replacing the __all__ declaration.

components/src/dynamo/planner/tests/core/test_engine_protocol.py-134-139 (1)

134-139: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Move _make_fpm imports to module scope.

Function-local imports violate the repo Python guideline and add avoidable per-call overhead.

Proposed change

 import pytest
 
+from dynamo.common.forward_pass_metrics import (
+    ForwardPassMetrics,
+    QueuedRequestMetrics,
+    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
@@
 def _make_fpm():
-    from dynamo.common.forward_pass_metrics import (
-        ForwardPassMetrics,
-        QueuedRequestMetrics,
-        ScheduledRequestMetrics,
-    )
-
     return ForwardPassMetrics(

As per coding guidelines: "Imports must be at module top; flag any import inside functions/methods/classes."

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/tests/core/test_engine_protocol.py` around
lines 134 - 139, The helper _make_fpm currently performs function-local imports
of ForwardPassMetrics, QueuedRequestMetrics, and ScheduledRequestMetrics; move
those three imports to the top-level of the module (module scope) and remove the
import statements from inside _make_fpm so the function simply uses the
already-imported classes; ensure the import line references the same module path
(dynamo.common.forward_pass_metrics) and run tests to confirm no import-order
issues.

components/src/dynamo/planner/tests/monitoring/test_plugin_framework_metrics.py-288-294 (1)

288-294: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Don’t skip on arbitrary ValueError from metric construction.

This currently hides any constructor regression that happens to raise ValueError, not just the intended duplicate-timeseries collision. Please narrow the skip to the known collision case and let other ValueErrors fail the test.

🛠️ Suggested guard

     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
+    except ValueError as exc:
+        if "Duplicated timeseries" not in str(exc):
+            raise
+        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

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@components/src/dynamo/planner/tests/monitoring/test_plugin_framework_metrics.py`
around lines 288 - 294, The current test broadly catches any ValueError from
PluginFrameworkMetrics(), which can mask real constructor regressions; change
the except to capture the exception (except ValueError as e) and only call
pytest.skip when the exception message matches the known
duplicate-timeseries/registration collision (e.g., contains "already registered"
or the exact phrase your constructor raises for REGISTRY collisions), otherwise
re-raise the exception so real errors fail the test; locate this change around
the PluginFrameworkMetrics() instantiation/exception handling.

components/src/dynamo/planner/tests/manual/perf_test_configs/disagg_8b_planner_orchestrator.yaml-4-7 (1)

4-7: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Remove the internal ticket reference from this YAML comment.

DEP-XXXX violates the repo rule against shipping internal Linear IDs in source/config files. Replace it with the public GitHub issue/PR reference or a plain descriptive comment.

🧹 Suggested edit

-# orchestrator tick engine (DEP-XXXX PR 7 cutover). The only diff vs
+# orchestrator tick engine (PR 7 cutover). The only diff vs

As per coding guidelines, **/*.{py,rs,go,ts,tsx,js,mjs,cjs,sh,yaml,yml,toml}: “Flag internal Linear ticket references (e.g. DIS-XXXX, DYN-XXXX, OPS-XXXX, DEP-XXXX, or any -NNNN ID) in the added lines.”

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@components/src/dynamo/planner/tests/manual/perf_test_configs/disagg_8b_planner_orchestrator.yaml`
around lines 4 - 7, Remove the internal ticket ID "DEP-XXXX" from the YAML
comment that describes the orchestrator tick engine (the comment that mentions
the planner --config JSON adding "scheduling": {"use_orchestrator": true}) and
replace it with either a public GitHub issue/PR reference or a plain descriptive
comment (e.g., "orchestrator tick engine cutover" or "plugin-based orchestrator
tick engine cutover"). Ensure the new comment conveys the same intent but
contains no internal Linear/PROJECT-NNNN identifiers.

components/src/dynamo/planner/tests/plugins/merge/test_type_aware_clamp_tracking.py-245-245 (1)

245-245: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Move RejectResult into the module import block.

test_short_circuit_leaves_clamped_empty() imports RejectResult inside the function; place it in the existing module-level dynamo.planner.plugins.types import block instead.

♻️ Proposed fix

 from dynamo.planner.plugins.types import (
     AcceptResult,
     ComponentTarget,
     OverrideResult,
     OverrideType,
+    RejectResult,
 )
@@
 def test_short_circuit_leaves_clamped_empty():
-    from dynamo.planner.plugins.types import RejectResult
-
     outcome = type_aware_merge(

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@components/src/dynamo/planner/tests/plugins/merge/test_type_aware_clamp_tracking.py`
at line 245, Move the local import of RejectResult from inside
test_short_circuit_leaves_clamped_empty() to the existing module-level import
block that already imports from dynamo.planner.plugins.types; specifically add
RejectResult to the top-level import statement (alongside other symbols from
dynamo.planner.plugins.types) and remove the in-function import so the test uses
the module-level symbol.

components/src/dynamo/planner/tests/plugins/orchestrator/test_concurrency.py-94-96 (1)

94-96: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Replace the ambiguous multiplication sign in this comment.

Ruff flags × here as RUF003, so this will fail lint until it is replaced with plain x.

Suggested fix

-    # 5 plugins × 50ms serial would be 250ms; concurrent should be closer
+    # 5 plugins x 50ms serial would be 250ms; concurrent should be closer

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/tests/plugins/orchestrator/test_concurrency.py`
around lines 94 - 96, The comment uses the Unicode multiplication sign '×' which
triggers RUF003; update the comment in test_concurrency.py (near the assert
referencing DELAY and elapsed in the test_concurrency test) to use a plain ASCII
'x' (e.g., "5 plugins x 50ms") instead of '×' so the linter stops flagging it;
no logic changes required.

components/src/dynamo/planner/tests/plugins/proto/test_round_trip.py-334-340 (1)

334-340: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Tighten the oneof-violation assertion to the specific validation error
Update test_propose_stage_response_oneof_violation to replace pytest.raises(Exception, match="oneof") with pytest.raises(pydantic.ValidationError, match="oneof violation") (import pydantic.ValidationError/ValidationError as needed).

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/tests/plugins/proto/test_round_trip.py` around
lines 334 - 340, Change the test_propose_stage_response_oneof_violation to
assert the specific Pydantic validation error: replace pytest.raises(Exception,
match="oneof") with pytest.raises(pydantic.ValidationError, match="oneof
violation") and add/import ValidationError from pydantic (or reference
pydantic.ValidationError) so the test expects pydantic.ValidationError when
constructing pyd.ProposeStageResponse with multiple oneof payloads.

components/src/dynamo/planner/tests/plugins/registry/test_list_plugins.py-68-79 (1)

68-79: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Drop the unused f prefix on the gRPC endpoint.
Line 75 uses endpoint=f"grpc://127.0.0.1:9000" with no placeholders, which triggers F541; change it to a plain string.

♻️ Proposed fix

-        endpoint=f"grpc://127.0.0.1:9000",
+        endpoint="grpc://127.0.0.1:9000",

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/tests/plugins/registry/test_list_plugins.py`
around lines 68 - 79, The endpoint string in the helper function _register
(which builds a RegisterRequest) uses an unnecessary f-string literal:
endpoint=f"grpc://127.0.0.1:9000", causing F541; change it to a plain string
literal endpoint="grpc://127.0.0.1:9000" inside the _register function where the
RegisterRequest is created to remove the unused f-prefix.

components/src/dynamo/planner/tests/plugins/transport/test_config.py-52-61 (1)

52-61: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Use ValidationError explicitly in these validation tests.

Line 56 violates the repo rule against in-function imports, and Line 131's pytest.raises(Exception) is broad enough to mask unrelated failures.

✅ Proposed cleanup

 import os
 
 import pytest
+from pydantic import ValidationError
@@
 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)
@@
 def test_make_clock_unknown_type():
     """Pydantic Literal validates type field at construction; ValueError early."""
-    with pytest.raises(Exception):  # Pydantic ValidationError
+    with pytest.raises(ValidationError):
         ClockConfig(type="invalid")  # type: ignore[arg-type]

As per coding guidelines, "Imports must be at module top; flag any import inside functions/methods/classes."

Also applies to: 129-132

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/tests/plugins/transport/test_config.py` around
lines 52 - 61, The tests import ValidationError inside
test_transport_config_rejects_non_positive_request_timeout and also use a broad
pytest.raises(Exception) elsewhere; move the pydantic.ValidationError import to
the module top and replace any in-function "from pydantic import
ValidationError" with the top-level import, and change the broad
pytest.raises(Exception) (e.g., the usage around lines referencing the other
test) to pytest.raises(ValidationError) so both tests explicitly assert
pydantic.ValidationError rather than performing in-function imports or catching
all Exceptions; update references to TransportConfig and the test names
accordingly.

docs/components/planner/orchestrator-rollout.md-149-150 (1)

149-150: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Use the actual circuit-breaker metric name here.

This runbook points operators at dynamo_planner_plugin_circuit_open_total, but the observability reference added in this PR defines dynamo_planner_plugin_circuit_state instead. As written, the alert/troubleshooting guidance sends people to a non-existent series.

🛠️ Suggested wording

-- Prometheus alert `dynamo_planner_plugin_circuit_open_total > 0`
+- Prometheus alert such as `max by (plugin_id) (dynamo_planner_plugin_circuit_state == 1) > 0`
@@
-### Symptom: `dynamo_planner_plugin_circuit_open_total` is non-zero
+### Symptom: `dynamo_planner_plugin_circuit_state == 1` for one or more plugins

Also applies to: 320-323

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@docs/components/planner/orchestrator-rollout.md` around lines 149 - 150, The
runbook references the wrong Prometheus metric name; replace every mention of
dynamo_planner_plugin_circuit_open_total with the actual metric
dynamo_planner_plugin_circuit_state (including alert expressions, example
queries, and troubleshooting guidance) and update any example alerts or
instructions that assumed the old name (also fix the other occurrences around
the section referenced as lines 320-323) so operators are pointed at the
existing series and any sample alert expressions use
dynamo_planner_plugin_circuit_state.

docs/components/planner/observability.md-55-69 (1)

55-69: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Add fence languages to these code blocks.

Markdownlint is flagging both fences here. text is enough if you just want literal enum lists.

📝 Proposed fix

-```
+```text
 unset, disabled, no_fpm_data, scaling_in_progress, worker_count_mismatch,
 insufficient_data, no_change, scale_up, scale_down,
 scale_down_capped_by_throughput, override_by_user_plugin,
 reconcile_clamped_to_floor, reconcile_clamped_to_ceiling,
 held_over, rejected_by_plugin

@@
- +text
unset, disabled, no_traffic_data, predict_failed, model_not_ready,
set_lower_bound, scale, override_by_user_plugin, held_over,
circuit_open, rejected_by_plugin

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@docs/components/planner/observability.md` around lines 55 - 69, Update the
two fenced code blocks in the observability doc to include a language tag of
"text" so Markdownlint stops flagging them: change the opening fences for the
first enum list and the second block labeled THROUGHPUT_DECISION_STATES to use
```text instead of ```; this affects the block containing the comma-separated
enum values (including entries like no_fpm_data, scaling_in_progress, etc.) and
the block for THROUGHPUT_DECISION_STATES (entries like no_traffic_data,
predict_failed, model_not_ready, etc.).

components/src/dynamo/planner/tests/plugins/scheduler/test_active_set.py-67-67 (1)

67-67: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Drop the unused f prefix here.

This literal trips Ruff F541 and will fail lint even though the value is constant.

🧹 Proposed fix

-        endpoint=f"grpc://127.0.0.1:9000",
+        endpoint="grpc://127.0.0.1:9000",

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/tests/plugins/scheduler/test_active_set.py` at
line 67, Remove the unnecessary f-string prefix on the endpoint literal used in
the test (endpoint=f"grpc://127.0.0.1:9000"); change it to a plain string
"grpc://127.0.0.1:9000" in the test_active_set test where the scheduler/plugin
is constructed (look for the endpoint= argument in test_active_set.py) to
satisfy the linter (Ruff F541).

docs/components/planner/orchestrator-rollout.md-58-64 (1)

58-64: ⚠️ Potential issue | 🟡 Minor | ⚡ Quick win

Label this fenced block with a language.

The ASCII diagram currently trips markdownlint's fenced-code-language rule.

📝 Proposed fix

-```
+```text
                  ┌─ use_orchestrator = false (default)
                  │      → _PSMEngineAdapter(PlannerStateMachine)
  NativePlannerBase.run()
                  │      → OrchestratorEngineAdapter(
                  └─ use_orchestrator = true           5 builtin plugins )

</details>

<details>
<summary>🤖 Prompt for AI Agents</summary>

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In @docs/components/planner/orchestrator-rollout.md around lines 58 - 64, The
fenced ASCII diagram block is missing a language label causing markdownlint
failures; update the fenced code block in
docs/components/planner/orchestrator-rollout.md that contains the ASCII diagram
(the block showing NativePlannerBase.run() and use_orchestrator branches) to
specify a language label such as text (e.g., change totext) so the
diagram remains rendered as plain text and satisfies the fenced-code-language
rule.

</details>

</blockquote></details>
<details>
<summary>components/src/dynamo/planner/tests/plugins/scheduler/test_cache_invalidation.py-70-70 (1)</summary><blockquote>

`70-70`: _⚠️ Potential issue_ | _🟡 Minor_ | _⚡ Quick win_

**Remove the no-op `f` prefix.**

This is another Ruff F541 hit, so the test file won't be clean until it's a plain string literal.
 
<details>
<summary>🧹 Proposed fix</summary>

```diff
-        endpoint=f"grpc://127.0.0.1:9000",
+        endpoint="grpc://127.0.0.1:9000",
```
</details>

<details>
<summary>🤖 Prompt for AI Agents</summary>

```
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@components/src/dynamo/planner/tests/plugins/scheduler/test_cache_invalidation.py`
at line 70, The endpoint argument in the test is using an unnecessary f-string
(endpoint=f"grpc://127.0.0.1:9000") which triggers Ruff F541; change it to a
plain string literal (endpoint="grpc://127.0.0.1:9000") so the test file is
clean. Locate the call that sets the endpoint keyword in
test_cache_invalidation.py and replace the f-prefixed string with the non-f
version.
```

</details>

</blockquote></details>
<details>
<summary>docs/components/planner/planner-guide.md-161-162 (1)</summary><blockquote>

`161-162`: _⚠️ Potential issue_ | _🟡 Minor_ | _⚡ Quick win_

**Field name mismatch with documented schema.**

The YAML example uses `ttft` and `itl`, but lines 83-84 document these fields as `ttft_ms` and `itl_ms`. This inconsistency will confuse users and may cause configuration errors.




<details>
<summary>📝 Proposed fix</summary>

```diff
       enable_load_scaling: true
-      ttft: 200.0
-      itl: 10.0
+      ttft_ms: 200.0
+      itl_ms: 10.0
       pre_deployment_sweeping_mode: rapid
```
</details>

<details>
<summary>🤖 Prompt for AI Agents</summary>

```
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@docs/components/planner/planner-guide.md` around lines 161 - 162, The YAML
example uses the short field names "ttft" and "itl" but the documented schema
uses "ttft_ms" and "itl_ms"; update the example to use "ttft_ms" and "itl_ms"
(or, if you prefer keeping the short names, update the schema docs to reference
"ttft" and "itl" everywhere) so the field names match; locate the example block
containing "ttft: 200.0" and "itl: 10.0" and replace them with "ttft_ms: 200.0"
and "itl_ms: 10.0" (or adjust the schema references ttft_ms/itl_ms accordingly)
to ensure consistency.
```

</details>

</blockquote></details>

</blockquote></details>

<details>
<summary>🧹 Nitpick comments (10)</summary><blockquote>

<details>
<summary>components/src/dynamo/planner/core/base.py (1)</summary><blockquote>

`250-253`: _⚡ Quick win_

**Move the `OrchestratorEngineAdapter` imports to module scope.**

These new method-local imports violate the repo’s Python guideline and make import-time failures path-dependent. If they are intentionally hiding a circular dependency, please document that inline; otherwise they should live at the top of the module. As per coding guidelines, "Imports must be at module top; flag any import inside functions/methods/classes."
  


Also applies to: 297-299

<details>
<summary>🤖 Prompt for AI Agents</summary>

```
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/core/base.py` around lines 250 - 253, The
method-local import of OrchestratorEngineAdapter (triggered by the check
self.config.scheduling.use_orchestrator in base.py) must be moved to module
scope: add the import for OrchestratorEngineAdapter at the top of the module
alongside other imports and remove the in-method import lines; if this was done
to break a circular dependency, instead add an inline comment above the method
explaining the circular import and keep a short explicit note (and consider
using a local import only with that documented justification). Ensure you update
both occurrences (around the blocks referenced by the review) so all imports are
consistent and comply with the "imports at module top" guideline.
```

</details>

</blockquote></details>
<details>
<summary>components/src/dynamo/planner/examples/external_plugin/reference_runner.py (1)</summary><blockquote>

`256-260`: _💤 Low value_

**Replace EN DASH with hyphen in help text.**

Line 259 contains an EN DASH character (`–`) which should be a standard hyphen-minus (`-`). This can cause issues with copy-paste or certain terminal encodings.


<details>
<summary>Proposed fix</summary>

```diff
         "--priority",
         type=int,
         default=5,
         help="plugin priority used during self-registration. PREDICT "
-        "wants priority=1 (lowest = chain terminator); RECONCILE / "
+        "wants priority=1 (lowest = chain terminator); RECONCILE / "
         "CONSTRAIN typically use 1 too. PROPOSE merge picks smallest "
-        "first, so for PROPOSE pick 4–10.",
+        "first, so for PROPOSE pick 4-10.",
     )
```
</details>

<details>
<summary>🤖 Prompt for AI Agents</summary>

```
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/examples/external_plugin/reference_runner.py`
around lines 256 - 260, The help string passed to the argument (the multi-line
literal containing "plugin priority used during self-registration... so for
PROPOSE pick 4–10.") includes an EN DASH (–); replace that EN DASH with a
standard hyphen-minus (-) in the help text literal (the string near "PROPOSE
pick 4–10") so the message uses "4-10" and avoids encoding/copy-paste issues.
```

</details>

</blockquote></details>
<details>
<summary>components/src/dynamo/planner/plugins/orchestrator/pipeline.py (1)</summary><blockquote>

`400-400`: _⚡ Quick win_

**Add `strict=True` to `zip()` for defensive checking.**

While `asyncio.gather` guarantees the same number of results as input awaitables, adding `strict=True` makes the invariant explicit and would surface any future bugs where the lists diverge.


<details>
<summary>♻️ Proposed fix</summary>

```diff
-    for idx, (plugin, raw) in enumerate(zip(plugins, raw_results)):
+    for idx, (plugin, raw) in enumerate(zip(plugins, raw_results, strict=True)):
```
</details>

<details>
<summary>🤖 Prompt for AI Agents</summary>

```
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/plugins/orchestrator/pipeline.py` at line 400,
The loop using enumerate(zip(plugins, raw_results)) in pipeline.py should
defensively require equal-length iterables; update the zip call to zip(plugins,
raw_results, strict=True) so any mismatch between plugins and raw_results is
raised immediately rather than silently truncating; adjust the loop at the site
where plugins and raw_results are iterated (the for idx, (plugin, raw) in
enumerate(...) line) to include strict=True.
```

</details>

</blockquote></details>
<details>
<summary>components/src/dynamo/planner/plugins/transport/base.py (1)</summary><blockquote>

`51-52`: _⚡ Quick win_

**Align the timeout docstring with the actual contract.**

These docstrings say the orchestrator wraps `call()` in `asyncio.wait_for`, but the transport layer already owns the per-RPC timeout and the README explicitly says the pipeline must not add another wrapper. Leaving the base contract wrong makes double-timeout behavior look intentional.
 


Also applies to: 72-79

<details>
<summary>🤖 Prompt for AI Agents</summary>

```
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/plugins/transport/base.py` around lines 51 -
52, Update the misleading docstrings to state that the transport layer owns the
per-RPC timeout (the timeout_seconds attribute) and that callers/orchestrator
must NOT wrap transport.call() in another asyncio.wait_for; replace references
claiming the orchestrator wraps call() with a clear contract that transport
implementations enforce per-RPC timeouts and pipelines should rely on that
single timeout. Also apply the same clarification to the other docstring block
around the call()/timeout-related docs (the second block at lines 72-79) so both
places consistently describe that timeout_seconds is enforced by the transport
and double-wrapping must be avoided.
```

</details>

</blockquote></details>
<details>
<summary>components/src/dynamo/planner/tests/integration/test_external_plugin_e2e.py (1)</summary><blockquote>

`71-76`: _⚡ Quick win_

**Use an integration-type marker here instead of `unit`.**

This module opens real gRPC servers and exercises network transport end-to-end, so marking it as `unit` will misclassify it in marker-driven test selection. Swap the type marker to `integration` (or `e2e`, if that is the intended bucket).




<details>
<summary>♻️ Suggested marker change</summary>

```diff
 pytestmark = [
     pytest.mark.gpu_0,
     pytest.mark.pre_merge,
-    pytest.mark.unit,
+    pytest.mark.integration,
     pytest.mark.planner,
 ]
```
</details>

As per coding guidelines, `**/tests/**/*.py`: “Each test must include at least one scheduling marker (`pre_merge`/`post_merge`/etc.), one GPU marker (`gpu_0`/etc.), and one type marker (`unit`/`integration`/`e2e`).”

<details>
<summary>🤖 Prompt for AI Agents</summary>

```
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/tests/integration/test_external_plugin_e2e.py`
around lines 71 - 76, The pytest markers list assigned to pytestmark currently
includes the wrong test type; update the pytestmark definition in this module
(the pytestmark variable) to replace the 'unit' marker with the appropriate
integration-type marker (e.g., 'integration' or 'e2e') so the tests that
exercise real gRPC servers are classified correctly while keeping the existing
'pytest.mark.gpu_0' and 'pytest.mark.pre_merge' markers.
```

</details>

</blockquote></details>
<details>
<summary>components/src/dynamo/planner/tests/plugins/orchestrator/test_pipeline.py (1)</summary><blockquote>

`400-403`: _⚡ Quick win_

**Move these imports to module scope.**

Line 402 and Line 579 both introduce imports inside test functions, which this repo’s Python guidelines explicitly disallow.



<details>
<summary>Suggested fix</summary>

```diff
 import ast
+import asyncio
 import pathlib
 
 import pytest
 
+from dynamo.planner.plugins.orchestrator import pipeline as _pipeline_module
 from dynamo.planner.plugins.merge.types import ComponentKey
 from dynamo.planner.plugins.types import (
     AcceptResult,
@@
 `@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)
@@
 def test_pipeline_py_has_no_stage_level_wait_for():
@@
-    from dynamo.planner.plugins.orchestrator import pipeline as _pipeline_module
-
     source_path = pathlib.Path(_pipeline_module.__file__)
```
</details>
As per coding guidelines, "Imports must be at module top; flag any import inside functions/methods/classes."


Also applies to: 579-580

<details>
<summary>🤖 Prompt for AI Agents</summary>

```
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/tests/plugins/orchestrator/test_pipeline.py`
around lines 400 - 403, The tests currently perform local imports (e.g.,
importing asyncio inside test_whole_tick_timeout_returns_skip_tick_timeout and
the import at the other test around lines 579-580); move these imports to the
module top so they are module-scope imports (add "import asyncio" and the other
module(s) to the file header), update any duplicate/unused imports accordingly,
and run tests to ensure no circular import issues—look for the functions
test_whole_tick_timeout_returns_skip_tick_timeout and the test around line ~579
to locate the offending in-function imports.
```

</details>

</blockquote></details>
<details>
<summary>components/src/dynamo/planner/tests/plugins/registry/test_config.py (1)</summary><blockquote>

`107-112`: _⚡ Quick win_

**Hoist these imports to module scope.**

`RegisterRequest` and `TransportConfig` are regular dependencies in this file, so importing them inside the test just adds noise and violates the repo’s Python import rule.

<details>
<summary>♻️ Proposed fix</summary>

```diff
 from pydantic import ValidationError
 
 from dynamo.planner.plugins.clock import VirtualClock
 from dynamo.planner.plugins.registry.auth import (
@@
 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
+from dynamo.planner.plugins.transport.config import TransportConfig
+from dynamo.planner.plugins.types import RegisterRequest
@@
 `@pytest.mark.asyncio`
 async def test_build_registry_propagates_protocol_versions():
-    from dynamo.planner.plugins.types import RegisterRequest
-
-    from dynamo.planner.plugins.transport.config import TransportConfig
-
     config = PluginRegistrationConfig(
```
</details>

  

As per coding guidelines, "Imports must be at module top; flag any import inside functions/methods/classes."

<details>
<summary>🤖 Prompt for AI Agents</summary>

```
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/tests/plugins/registry/test_config.py` around
lines 107 - 112, The test function
test_build_registry_propagates_protocol_versions currently imports
RegisterRequest and TransportConfig inside the function; move those imports to
the module scope (top of the file) so RegisterRequest (from
dynamo.planner.plugins.types) and TransportConfig (from
dynamo.planner.plugins.transport.config) are imported alongside other top-level
imports and removed from inside the test body.
```

</details>

</blockquote></details>
<details>
<summary>components/src/dynamo/planner/tests/plugins/registry/test_server.py (1)</summary><blockquote>

`411-436`: _⚡ Quick win_

**Keep `CircuitState` in the module import block.**

Both tests locally import the same symbol from a module that’s already imported at the top of the file. Hoisting `CircuitState` once keeps this module aligned with the repo’s import rule.

<details>
<summary>♻️ Proposed fix</summary>

```diff
 from dynamo.planner.plugins.types import (
+    CircuitState,
     HoldPolicy,
     ListPluginsRequest,
     RegisterRequest,
 )
@@
 async def test_register_resets_circuit_breaker_for_plugin_id():
@@
-    from dynamo.planner.plugins.types import CircuitState
-
     assert cb.state("p1") == CircuitState.CLOSED
@@
 async def test_unregister_resets_circuit_breaker():
@@
-    from dynamo.planner.plugins.types import CircuitState
-
     assert cb.state("p1") == CircuitState.CLOSED
```
</details>

  

As per coding guidelines, "Imports must be at module top; flag any import inside functions/methods/classes."

<details>
<summary>🤖 Prompt for AI Agents</summary>

```
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/tests/plugins/registry/test_server.py` around
lines 411 - 436, Move the inline imports of CircuitState out of the test
functions and into the module-level import block: remove the in-function lines
"from dynamo.planner.plugins.types import CircuitState" in
test_register_resets_circuit_breaker_for_plugin_id and
test_unregister_resets_circuit_breaker, and add a single top-level import for
CircuitState with the other imports so the tests use CircuitState directly when
asserting cb.state("p1") after server.register(_req()) and
server.unregister("p1").
```

</details>

</blockquote></details>
<details>
<summary>components/src/dynamo/planner/tests/plugins/registry/test_gateway.py (1)</summary><blockquote>

`106-120`: _⚡ Quick win_

**Hoist `proto_to_pydantic` out of the helper.**

This import is neither optional nor cycle-guarded, so keeping it inside `_register()` just obscures a normal module dependency.

<details>
<summary>♻️ Proposed fix</summary>

```diff
 import grpc
 import pytest
 
 from dynamo.planner.plugins.clock import VirtualClock
+from dynamo.planner.plugins._proto_bridge import proto_to_pydantic
 from dynamo.planner.plugins.proto.v1 import plugin_pb2 as pb
@@
 async def _register(server, plugin_id="p1", auth_token="A"):
@@
-    from dynamo.planner.plugins._proto_bridge import proto_to_pydantic
-
     resp = await server.register(proto_to_pydantic(req))
```
</details>

  

As per coding guidelines, "Imports must be at module top; flag any import inside functions/methods/classes."

<details>
<summary>🤖 Prompt for AI Agents</summary>

```
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@components/src/dynamo/planner/tests/plugins/registry/test_gateway.py` around
lines 106 - 120, The test helper _register contains a local import of
proto_to_pydantic; move the import statement for proto_to_pydantic from
dynamo.planner.plugins._proto_bridge to the module top of test_gateway.py and
remove the in-function import so the _register coroutine directly calls
proto_to_pydantic; ensure no other function-local imports remain and run tests
to verify no import cycles are introduced.
```

</details>

</blockquote></details>
<details>
<summary>components/src/dynamo/planner/tests/plugins/registry/test_external_bootstrap.py (1)</summary><blockquote>

`129-145`: _⚡ Quick win_

**Move `ValidationError` to the module imports.**

These two tests pull in the same non-optional import locally. Hoisting it once at the top keeps the file consistent with the repo’s Python import rule and removes duplication.

<details>
<summary>♻️ Proposed fix</summary>

```diff
 import pytest
+from pydantic import ValidationError
 
 from dynamo.planner.config.planner_config import ExternalPluginEntry
@@
 def test_entry_rejects_unknown_plugin_type():
@@
-    from pydantic import ValidationError
-
     with pytest.raises(ValidationError):
@@
 def test_entry_rejects_empty_endpoint():
-    from pydantic import ValidationError
-
     with pytest.raises(ValidationError):
```
</details>

  

As per coding guidelines, "Imports must be at module top; flag any import inside functions/methods/classes."

<details>
<summary>🤖 Prompt for AI Agents</summary>

```
Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@components/src/dynamo/planner/tests/plugins/registry/test_external_bootstrap.py`
around lines 129 - 145, The tests test_entry_rejects_unknown_plugin_type and
test_entry_rejects_empty_endpoint import ValidationError inside the test bodies;
move the from pydantic import ValidationError statement to the module-level
imports at the top of the file so both tests (and any others) reuse the single
import, keeping imports consistent with the repo rule; update the file-level
import block and remove the local imports inside those test functions that
reference ValidationError (used with ExternalPluginEntry).
```

</details>

</blockquote></details>

</blockquote></details>

<!-- This is an auto-generated comment by CodeRabbit for review status -->