prefect 3.6.24.dev2__tar.gz → 3.6.24.dev3__tar.gz

{prefect-3.6.24.dev2 → prefect-3.6.24.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect
-Version: 3.6.24.dev2
+Version: 3.6.24.dev3
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io

{prefect-3.6.24.dev2 → prefect-3.6.24.dev3}/pyproject.toml

@@ -307,6 +307,9 @@ filterwarnings = [
     "ignore::DeprecationWarning:pendulum.*",                                                                             # TODO: remove when pendulum is removed
     "ignore::DeprecationWarning:botocore.*",
     "ignore::DeprecationWarning:coolname.*",
+    "ignore:Runner\\.execute_flow_run has been deprecated:prefect._internal.compatibility.deprecated.PrefectDeprecationWarning",
+    "ignore:Runner\\.execute_bundle has been deprecated:prefect._internal.compatibility.deprecated.PrefectDeprecationWarning",
+    "ignore:Runner\\.reschedule_current_flow_runs has been deprecated:prefect._internal.compatibility.deprecated.PrefectDeprecationWarning",
     "ignore::sqlalchemy.exc.SAWarning",
     "ignore::ResourceWarning",
     "ignore::pytest.PytestUnraisableExceptionWarning",

prefect-3.6.24.dev3/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.6.24.dev3"
+__build_date__ = "2026-03-25 08:21:32.311611+00:00"
+__git_commit__ = "506781bb04ec791fdbbe4dfd99c8ff692bbffb6f"
+__dirty__ = False

prefect-3.6.24.dev3/src/prefect/_experimental/bundles/execute.py

@@ -0,0 +1,48 @@
+import json
+import sys
+
+from prefect.utilities.asyncutils import run_coro_as_sync
+
+
+def execute_bundle_from_file(key: str):
+    """
+    Loads a bundle from a file and executes it.
+
+    Args:
+        key: The key of the bundle to execute.
+    """
+    with open(key, "r") as f:
+        bundle = json.load(f)
+
+    run_coro_as_sync(execute_bundle(bundle))
+
+
+async def execute_bundle(bundle: dict) -> None:
+    # All these imports must stay deferred to break circular imports:
+    # bundles/__init__ imports from .execute, and _starter_bundle imports from bundles/__init__
+    # _flow_run_executor → runner/__init__ → runner.py → bundles/__init__
+    from prefect._experimental.bundles import extract_flow_from_bundle
+    from prefect.client.schemas.objects import FlowRun
+    from prefect.flows import Flow
+    from prefect.runner._flow_run_executor import FlowRunExecutorContext
+    from prefect.runner._starter_bundle import BundleExecutionStarter
+
+    async def resolve_flow(fr: FlowRun) -> Flow:
+        return extract_flow_from_bundle(bundle)
+
+    async with FlowRunExecutorContext() as ctx:
+        flow_run = FlowRun.model_validate(bundle["flow_run"])
+        executor = ctx.create_executor(
+            flow_run,
+            BundleExecutionStarter(bundle=bundle),
+            resolve_flow=resolve_flow,
+        )
+        await executor.submit()
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3 and sys.argv[1] != "--key":
+        print("Please provide a key representing a path to a bundle")
+        sys.exit(1)
+    key = sys.argv[2]
+    execute_bundle_from_file(key)

{prefect-3.6.24.dev2 → prefect-3.6.24.dev3}/src/prefect/_observers.py

@@ -99,6 +99,8 @@ class FlowRunCancellingObserver:
                         "prefect.flow-run.", ""
                     )
                 )
+                if flow_run_id not in self._in_flight_flow_run_ids:
+                    continue
                 self.on_cancelling(flow_run_id)
             except ValueError:
                 self.logger.warning(

{prefect-3.6.24.dev2 → prefect-3.6.24.dev3}/src/prefect/cli/AGENTS.md

@@ -16,6 +16,7 @@ Prefect command-line interface, powered by **cyclopts**.
 - `cloud/` — `prefect cloud` subcommands (login, workspace, webhooks, IP allowlists)
 - `transfer/` — `prefect transfer` subcommands
 - `_utilities.py`, `_prompts.py`, `_server_utils.py`, `_cloud_utils.py`, `_worker_utils.py` — Internal helpers (prefixed with `_`)
+- `flow_runs_watching.py` — Command-specific support module for `flow-run watch`; provides `watch_flow_run()` and `FlowRunFormatter`. Not prefixed with `_` — command-specific helpers may omit the prefix.
 
 ## Testing
 

{prefect-3.6.24.dev2 → prefect-3.6.24.dev3}/src/prefect/cli/deploy/_commands.py

@@ -385,6 +385,7 @@ async def deploy(
     from prefect.settings import get_current_settings
 
     # Resolve default work pool from settings (typer uses a lambda callback).
+    work_pool_name_set_through_cli = work_pool_name is not None
     if work_pool_name is None:
         work_pool_name = get_current_settings().deployments.default_work_pool_name
 
@@ -444,6 +445,15 @@ async def deploy(
         )
 
         if len(deploy_configs) > 1:
+            # Multi-deploy ignores CLI `options`; omit default pool from the warning and
+            # copy it onto each config when YAML has no work_pool.name.
+            if not work_pool_name_set_through_cli and work_pool_name is not None:
+                options["work_pool_name"] = None
+                for deploy_config in deploy_configs:
+                    work_pool = deploy_config.setdefault("work_pool", {})
+                    if work_pool.get("name") is None:
+                        work_pool["name"] = work_pool_name
+
             if any(options.values()):
                 _cli.console.print(
                     (

{prefect-3.6.24.dev2 → prefect-3.6.24.dev3}/src/prefect/cli/flow_run.py

@@ -29,17 +29,21 @@ from prefect.cli._utilities import (
     exit_with_success,
     with_cli_exception_handling,
 )
+from prefect.cli.flow_runs_watching import watch_flow_run
 from prefect.client.orchestration import get_client
 from prefect.client.schemas.filters import FlowFilter, FlowRunFilter, LogFilter
 from prefect.client.schemas.objects import StateType
 from prefect.client.schemas.responses import SetStateStatus
 from prefect.client.schemas.sorting import FlowRunSort, LogSort
-from prefect.exceptions import ObjectNotFound
+from prefect.exceptions import Abort, ObjectNotFound
+from prefect.flows import load_flow_from_flow_run
 from prefect.logging import get_logger
-from prefect.runner import Runner
-from prefect.states import State, exception_to_crashed_state
+from prefect.runner._flow_run_executor import FlowRunExecutorContext
+from prefect.runner._starter_engine import EngineCommandStarter
+from prefect.states import AwaitingRetry, State, exception_to_crashed_state
 from prefect.types._datetime import human_friendly_diff
 from prefect.utilities.asyncutils import run_sync_in_worker_thread
+from prefect.utilities.engine import propose_state_sync
 from prefect.utilities.urls import url_for
 
 if TYPE_CHECKING:
@@ -624,6 +628,38 @@ async def logs(
         _cli.console.print(json_output, soft_wrap=True)
 
 
+@flow_run_app.command()
+@with_cli_exception_handling
+async def watch(
+    id: UUID,
+    *,
+    timeout: Annotated[
+        Optional[int],
+        cyclopts.Parameter("--timeout", help="Timeout in seconds."),
+    ] = None,
+):
+    """Watch a flow run until it reaches a terminal state."""
+    async with get_client() as client:
+        try:
+            flow_run = await client.read_flow_run(id)
+        except ObjectNotFound:
+            exit_with_error(f"Flow run '{id}' not found!")
+
+    state = flow_run.state
+    if state is not None and state.is_final():
+        if state.is_completed():
+            exit_with_success(f"Flow run already finished in {state.name!r}.")
+        exit_with_error(f"Flow run already finished in state {state.name!r}.", code=1)
+
+    finished = await watch_flow_run(id, _cli.console, timeout=timeout)
+    state = finished.state
+    if state is None:
+        exit_with_error("Flow run finished in an unknown state.")
+    if state.is_completed():
+        exit_with_success(f"Flow run finished successfully in {state.name!r}.")
+    exit_with_error(f"Flow run finished in state {state.name!r}.", code=1)
+
+
 @flow_run_app.command()
 @with_cli_exception_handling
 async def execute(
@@ -638,18 +674,42 @@ async def execute(
     if id is None:
         exit_with_error("Could not determine the ID of the flow run to execute.")
 
-    runner = Runner()
+    async with FlowRunExecutorContext() as ctx:
+        flow_run = await ctx.client.read_flow_run(id)
 
-    def _handle_reschedule_sigterm(_signal: int, _frame: FrameType | None):
-        logger.info("SIGTERM received, initiating graceful shutdown...")
-        runner.reschedule_current_flow_runs()
-        exit_with_success("Flow run successfully rescheduled.")
-
-    on_sigterm = os.environ.get("PREFECT_FLOW_RUN_EXECUTE_SIGTERM_BEHAVIOR", "").lower()
-    if (
-        threading.current_thread() is threading.main_thread()
-        and on_sigterm == "reschedule"
-    ):
-        signal.signal(signal.SIGTERM, _handle_reschedule_sigterm)
+        on_sigterm = os.environ.get(
+            "PREFECT_FLOW_RUN_EXECUTE_SIGTERM_BEHAVIOR", ""
+        ).lower()
+        reschedule_mode = (
+            threading.current_thread() is threading.main_thread()
+            and on_sigterm == "reschedule"
+        )
 
-    await runner.execute_flow_run(id)
+        def _handle_reschedule_sigterm(_signal: int, _frame: FrameType | None):
+            """Reschedule the flow run and kill the child process (if running)."""
+            logger.info("SIGTERM received, initiating graceful shutdown...")
+            with get_client(sync_client=True) as sync_client:
+                try:
+                    propose_state_sync(sync_client, AwaitingRetry(), flow_run_id=id)
+                except Abort:
+                    pass
+                except Exception:
+                    logger.exception("Failed to reschedule flow run")
+
+            handle = ctx.process_manager.get(id)
+            if handle and handle.pid:
+                try:
+                    os.kill(handle.pid, signal.SIGTERM)
+                except ProcessLookupError:
+                    pass
+            exit_with_success("Flow run successfully rescheduled.")
+
+        if reschedule_mode:
+            signal.signal(signal.SIGTERM, _handle_reschedule_sigterm)
+
+        executor = ctx.create_executor(
+            flow_run,
+            EngineCommandStarter(),
+            resolve_flow=lambda fr: load_flow_from_flow_run(ctx.client, fr),
+        )
+        await executor.submit()

{prefect-3.6.24.dev2 → prefect-3.6.24.dev3}/src/prefect/client/_version_checking.py

@@ -130,6 +130,13 @@ async def check_server_version(
         httpx_kwargs["verify"] = ctx
 
     headers: dict[str, str] = {}
+
+    # Include custom headers from settings (e.g. PREFECT_CLIENT_CUSTOM_HEADERS)
+    # so the version check works on deployments that authenticate via custom
+    # headers.  This mirrors PrefectHttpxAsyncClient / PrefectHttpxSyncClient.
+    for header_name, header_value in settings.client.custom_headers.items():
+        headers[header_name] = header_value
+
     auth_string = PREFECT_API_AUTH_STRING.value()
     api_key = PREFECT_API_KEY.value()
     if auth_string:

{prefect-3.6.24.dev2 → prefect-3.6.24.dev3}/src/prefect/runner/AGENTS.md

@@ -8,7 +8,7 @@ Thin facade over single-responsibility extracted classes. New behavior belongs i
 
 | Class | File | Responsibility |
 |---|---|---|
-| FlowRunExecutor | _flow_run_executor.py | Per-run lifecycle: pending -> start -> wait -> crashed/hooks |
+| FlowRunExecutor | _flow_run_executor.py | Per-run lifecycle: submitting -> start -> wait -> crashed/hooks |
 | ProcessManager | _process_manager.py | Process map, PID tracking, kill with SIGTERM->SIGKILL |
 | StateProposer | _state_proposer.py | All API state transition proposals |
 | CancellationManager | _cancellation_manager.py | Kill -> hooks -> state -> event cancellation sequence |
@@ -18,6 +18,7 @@ Thin facade over single-responsibility extracted classes. New behavior belongs i
 | DeploymentRegistry | _deployment_registry.py | Deployment/flow/storage/bundle maps |
 | ScheduledRunPoller | _scheduled_run_poller.py | Poll loop, run discovery, scheduling |
 | ProcessStarter (protocol) | _flow_run_executor.py | Strategy interface for starting processes |
+| FlowRunExecutorContext | _flow_run_executor.py | Async context manager for one-shot execution outside Runner (CLI, bundles) |
 | DirectSubprocessStarter | _starter_direct.py | Runs Flow object via run_flow_in_subprocess |
 | EngineCommandStarter | _starter_engine.py | Spawns `python -m prefect.engine` subprocess |
 | BundleExecutionStarter | _starter_bundle.py | Executes serialized bundle in SpawnProcess |
@@ -37,9 +38,11 @@ Thin facade over single-responsibility extracted classes. New behavior belongs i
 - `_flow_run_process_map` dict -- replaced by ProcessManager
 - `_kill_process()` -- replaced by ProcessManager.kill()
 - `_run_on_crashed_hooks()` / `_run_on_cancellation_hooks()` -- replaced by HookRunner
-- `execute_bundle()`'s inline lifecycle -- should use FlowRunExecutor with BundleExecutionStarter
+- `execute_flow_run()` -- deprecated (Mar 2026); use `FlowRunExecutorContext` + `EngineCommandStarter`
+- `execute_bundle()` -- deprecated (Mar 2026); use `execute_bundle()` from `prefect._experimental.bundles.execute`
+- `reschedule_current_flow_runs()` -- deprecated (Mar 2026); SIGTERM rescheduling is now handled inline by the CLI execute path
 
-These will be removed once internal callers (notably ProcessWorker) are migrated.
+These will be removed once internal callers (notably ProcessWorker) are migrated. ProcessWorker currently suppresses the deprecation warnings via `warnings.catch_warnings()`.
 
 ## AsyncExitStack LIFO Ordering
 
@@ -58,9 +61,17 @@ This ordering is a hard constraint. Getting it wrong causes ClosedResourceError
 
 Each execution mode has a ProcessStarter implementation. To add a new execution mode, implement the ProcessStarter protocol and inject it into FlowRunExecutor -- do not add a new code path to Runner.
 
+## Storage Base Path Scoping
+
+`$STORAGE_BASE_PATH` in `deployment.path` comes from `RunnerDeployment.from_storage()`. For work-pool deployments, `path` is set to `None` on create and storage is serialized into `pull_steps` instead (`deployments/runner.py:407-413`). `load_flow_from_flow_run()` only does `$STORAGE_BASE_PATH` substitution when `pull_steps` is absent (`flows.py:3084`). So the CLI `prefect flow-run execute` path (worker-based, always has `pull_steps`) does not need `tmp_dir` / `PREFECT__STORAGE_BASE_PATH`. Only Runner-served deployments (no work pool) use this substitution.
+
+## State Transition Split (ScheduledRunPoller vs FlowRunExecutor)
+
+`ScheduledRunPoller` now calls `propose_pending` (Scheduled → Pending) before handing off to `FlowRunExecutor`. `FlowRunExecutor` then calls `propose_submitting` (Pending → Submitting sub-state) as step 1 of its lifecycle. These are two separate transitions — do not collapse them. The split exists so automations listening for the Pending state fire correctly before the executor begins.
+
 ## ProcessWorker Migration (Known Gap)
 
-ProcessWorker (src/prefect/workers/process.py) calls `Runner.execute_flow_run()`, which uses the legacy `_submit_run_and_capture_errors` -> `_run_process` path. It bypasses FlowRunExecutor, ProcessManager, and ProcessStarter entirely. This is a known migration target.
+ProcessWorker (src/prefect/workers/process.py) calls `Runner.execute_flow_run()` and `Runner.execute_bundle()` via the deprecated path, suppressing `PrefectDeprecationWarning` with `warnings.catch_warnings()`. It bypasses FlowRunExecutor, ProcessManager, and ProcessStarter entirely. This is a known migration target.
 
 ## Reference
 

{prefect-3.6.24.dev2 → prefect-3.6.24.dev3}/src/prefect/runner/_flow_run_executor.py

@@ -1,18 +1,26 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Protocol
+from contextlib import AsyncExitStack
+from typing import TYPE_CHECKING, Callable, Protocol
+from uuid import UUID
 
 import anyio
 import anyio.abc
 
+from prefect._observers import FlowRunCancellingObserver
+from prefect.client.orchestration import PrefectClient, get_client
 from prefect.logging import get_logger
+from prefect.runner._cancellation_manager import CancellationManager
+from prefect.runner._event_emitter import EventEmitter
+from prefect.runner._hook_runner import HookRunner
+from prefect.runner._process_manager import ProcessHandle, ProcessManager
+from prefect.runner._state_proposer import StateProposer
+from prefect.settings.context import get_current_settings
 from prefect.utilities._infrastructure_exit_codes import get_infrastructure_exit_info
 
 if TYPE_CHECKING:
     from prefect.client.schemas.objects import FlowRun
-    from prefect.runner._hook_runner import HookRunner
-    from prefect.runner._process_manager import ProcessHandle, ProcessManager
-    from prefect.runner._state_proposer import StateProposer
+    from prefect.flows import Flow
 
 
 class ProcessStarter(Protocol):
@@ -47,7 +55,7 @@ class FlowRunExecutor:
     process exits).  This class does not interact with `LimitManager`.
 
     Lifecycle in `submit()`:
-    1. propose_pending — returns False -> return early
+    1. propose_submitting — returns False -> return early
     2. already-cancelled precheck — log skip, return early
     3. start process via starter — `task_status.started(handle)` signals caller early
     4. add handle to `process_manager`
@@ -99,8 +107,20 @@ class FlowRunExecutor:
         """
         handle: ProcessHandle | None = None
         try:
-            # Step 1: propose pending — abort if server rejects
-            if not await self._state_proposer.propose_pending(self._flow_run):
+            # Step 1: propose submitting — abort if server rejects
+            if not await self._state_proposer.propose_submitting(self._flow_run):
+                # If the run is already cancelling, move it to terminal Cancelled
+                if self._flow_run.state and self._flow_run.state.is_cancelling():
+                    self._logger.info(
+                        "Flow run '%s' is cancelling, marking as cancelled.",
+                        self._flow_run.id,
+                    )
+                    await self._state_proposer.propose_cancelled(
+                        self._flow_run,
+                        state_updates={
+                            "message": "Flow run was cancelled before execution started."
+                        },
+                    )
                 return
 
             # Step 2: already-cancelled precheck
@@ -195,3 +215,119 @@ class FlowRunExecutor:
             "Starter did not call task_status.started() -- violates ProcessStarter contract"
         )
         return captured_handle
+
+
+async def _placeholder_resolve_flow(flow_run: "FlowRun") -> "Flow":
+    raise RuntimeError("resolve_flow not configured — call create_executor() first")
+
+
+class FlowRunExecutorContext:
+    """Async context manager for standalone FlowRunExecutor usage (outside Runner).
+
+    Manages lifecycle of shared components: client, ProcessManager, StateProposer,
+    EventEmitter, CancellationManager, and FlowRunCancellingObserver.
+    The Runner manages these itself; this class is for one-shot execution paths
+    (bundle execution, CLI `prefect flow-run execute`).
+    """
+
+    client: PrefectClient
+    process_manager: ProcessManager
+
+    async def __aenter__(self) -> FlowRunExecutorContext:
+        self._stack = AsyncExitStack()
+        await self._stack.__aenter__()
+        self._logger = get_logger("runner.executor_context")
+
+        # Step 1: client
+        self.client = get_client()
+        await self._stack.enter_async_context(self.client)
+
+        # Create observer object early so we can wire ProcessManager callbacks.
+        # on_cancelling lambda captures self._cancellation_manager (assigned in step 4).
+        self._observer = FlowRunCancellingObserver(
+            on_cancelling=lambda frid: self._cancellation_task_group.start_soon(
+                self._cancellation_manager.cancel_by_id, frid
+            ),
+            on_failure=lambda flow_run_ids: self._handle_cancellation_observer_failure(
+                flow_run_ids
+            ),
+        )
+
+        # Step 2: ProcessManager with observer add/remove callbacks
+        async def _on_add(flow_run_id: UUID) -> None:
+            self._observer.add_in_flight_flow_run_id(flow_run_id)
+
+        async def _on_remove(flow_run_id: UUID) -> None:
+            self._observer.remove_in_flight_flow_run_id(flow_run_id)
+
+        self.process_manager = ProcessManager(on_add=_on_add, on_remove=_on_remove)
+        await self._stack.enter_async_context(self.process_manager)
+
+        # Step 3: StateProposer, placeholder HookRunner, EventEmitter
+        self._state_proposer = StateProposer(client=self.client)
+        self._hook_runner = HookRunner(resolve_flow=_placeholder_resolve_flow)
+        self._event_emitter = EventEmitter(runner_name="standalone", client=self.client)
+        await self._stack.enter_async_context(self._event_emitter)
+
+        # Step 3.5: Task group to track in-flight cancellation tasks
+        self._cancellation_task_group = await self._stack.enter_async_context(
+            anyio.create_task_group()
+        )
+
+        # Step 4: CancellationManager
+        self._cancellation_manager = CancellationManager(
+            process_manager=self.process_manager,
+            hook_runner=self._hook_runner,
+            state_proposer=self._state_proposer,
+            event_emitter=self._event_emitter,
+            client=self.client,
+        )
+
+        # Step 5: Observer enters LAST (starts websocket/polling)
+        await self._stack.enter_async_context(self._observer)
+
+        return self
+
+    async def __aexit__(self, *exc_info: object) -> bool | None:
+        return await self._stack.__aexit__(*exc_info)
+
+    def _handle_cancellation_observer_failure(self, flow_run_ids: set) -> None:
+        """Handle failure of both cancellation observer mechanisms.
+
+        When crash_on_cancellation_failure is enabled, kills all in-flight
+        processes (which triggers crash handling when they terminate).
+        Otherwise, logs a warning.
+        """
+        will_crash = get_current_settings().runner.crash_on_cancellation_failure
+        if will_crash:
+            self._logger.error(
+                "Cancellation observing failed — killing %d in-flight flow run(s).",
+                len(flow_run_ids),
+            )
+            for flow_run_id in flow_run_ids:
+                self._cancellation_task_group.start_soon(
+                    self.process_manager.kill, flow_run_id
+                )
+        else:
+            self._logger.warning(
+                "Cancellation observer failed. Flow run cancellation disabled. "
+                "Set PREFECT_RUNNER_CRASH_ON_CANCELLATION_FAILURE=true to "
+                "crash flow runs when this occurs."
+            )
+
+    def create_executor(
+        self,
+        flow_run: FlowRun,
+        starter: ProcessStarter,
+        resolve_flow: Callable[[FlowRun], Flow[..., ...]],
+    ) -> FlowRunExecutor:
+        hook_runner = HookRunner(resolve_flow=resolve_flow)
+        # Wire the real resolver into CancellationManager for on_cancellation hooks
+        self._cancellation_manager._hook_runner = hook_runner
+        return FlowRunExecutor(
+            flow_run=flow_run,
+            starter=starter,
+            process_manager=self.process_manager,
+            state_proposer=self._state_proposer,
+            hook_runner=hook_runner,
+        )

{prefect-3.6.24.dev2 → prefect-3.6.24.dev3}/src/prefect/runner/_scheduled_run_poller.py

@@ -163,6 +163,12 @@ class ScheduledRunPoller:
         `FlowRunExecutor` has no knowledge of `LimitManager`.
         """
         try:
+            # Propose Pending state (Scheduled → Pending) before submitting.
+            # Workers do this in their own submission path; the poller must
+            # do it here so automations listening for Pending fire correctly.
+            if not await self._state_proposer.propose_pending(flow_run):
+                return
+
             starter = self._resolve_starter(flow_run)
 
             # Adhoc storage pull: if the deployment has storage with a

{prefect-3.6.24.dev2 → prefect-3.6.24.dev3}/src/prefect/runner/_starter_engine.py

@@ -32,7 +32,7 @@ class EngineCommandStarter:
     def __init__(
         self,
         *,
-        tmp_dir: Path,
+        tmp_dir: Path | None = None,
         storage: RunnerStorage | None = None,
         entrypoint: str | None = None,
         command: str | None = None,
@@ -74,7 +74,11 @@ class EngineCommandStarter:
         env.update(
             {
                 "PREFECT__FLOW_RUN_ID": str(flow_run.id),
-                "PREFECT__STORAGE_BASE_PATH": str(self._tmp_dir),
+                **(
+                    {"PREFECT__STORAGE_BASE_PATH": str(self._tmp_dir)}
+                    if self._tmp_dir is not None
+                    else {}
+                ),
                 "PREFECT__ENABLE_CANCELLATION_AND_CRASHED_HOOKS": "false",
                 **(
                     {"PREFECT__FLOW_ENTRYPOINT": self._entrypoint}

{prefect-3.6.24.dev2 → prefect-3.6.24.dev3}/src/prefect/runner/_state_proposer.py

@@ -5,7 +5,13 @@ from typing import TYPE_CHECKING, Any
 from prefect.client.schemas.objects import StateType
 from prefect.exceptions import Abort, ObjectNotFound
 from prefect.logging import get_logger
-from prefect.states import AwaitingRetry, Crashed, Pending, exception_to_failed_state
+from prefect.states import (
+    AwaitingRetry,
+    Crashed,
+    Pending,
+    Submitting,
+    exception_to_failed_state,
+)
 from prefect.utilities.engine import propose_state, propose_state_sync
 
 if TYPE_CHECKING:
@@ -57,6 +63,49 @@ class StateProposer:
             return False
         return True
 
+    async def propose_submitting(self, flow_run: FlowRun) -> bool:
+        """Propose Submitting (Pending sub-state). Returns True if ready to submit, False if aborted/rejected.
+
+        Used by FlowRunExecutor when launched by a worker that has already moved
+        the run into Pending/Submitting. PreventPendingTransitions allows
+        Pending->Pending when the name changes and isn't "Pending".
+
+        Raises on transient errors so the caller can propose a terminal state.
+        """
+        try:
+            state = await propose_state(
+                self._client, Submitting(), flow_run_id=flow_run.id
+            )
+        except Abort as exc:
+            # Re-read authoritative state to distinguish "already Submitting"
+            # (worker/bundle paths) from a genuine rejection.
+            try:
+                current = await self._client.read_flow_run(flow_run.id)
+            except Exception:
+                current = None
+            if (
+                current is not None
+                and current.state is not None
+                and current.state.is_pending()
+                and current.state.name == "Submitting"
+            ):
+                return True
+            self._logger.info(
+                "Aborted submission of flow run '%s'. Server sent an abort signal: %s",
+                flow_run.id,
+                exc,
+            )
+            return False
+        if not state.is_pending():
+            self._logger.info(
+                "Aborted submission of flow run '%s': Server returned a non-pending"
+                " state %r",
+                flow_run.id,
+                state.type.value,
+            )
+            return False
+        return True
+
     async def propose_crashed(
         self, flow_run: FlowRun, message: str
     ) -> State[Any] | None: