fix: Require openjd-sessions >= 0.10.11 and drop the version-skew guard

The declared floor could not satisfy the calls this package makes. `RunTaskAction`
passes `step_name=` to `Session.run_task` unconditionally, but that keyword does
not exist before openjd-sessions 0.10.11 -- so against the old `>= 0.10.7` floor
every task run would raise `TypeError: run_task() got an unexpected keyword
argument 'step_name'`.

0.10.11 is released and is the first version with `step_name` on **both**
`run_task` and `enter_environment`, so the floor moves there and the
feature-detection guard goes away. That guard was doing real harm rather than
providing real compatibility:

- `_ENTER_ENVIRONMENT_ACCEPTS_STEP_NAME` gated only `enter_environment`, while
  `run_task` was already unguarded. So the two call sites disagreed about which
  sessions versions this package supported, and the stricter of the two was the
  ungated one.
- **It silenced the tests that prove RFC 0007 Step.Name works.**
  `test_localsession_step_env_enter_receives_step_name` branched on the flag and,
  when it was false, asserted the keyword was *absent* -- passing while proving
  the opposite of its name. Worse,
  `test_do_run_step_name_in_step_environment`, the only end-to-end test that
  actually resolves `Step.Name` inside a step environment, was `skipif`-ed away
  entirely. In a dev environment with a sessions build predating the keyword, both
  reported success while the feature was untested.

Both are now unconditional, and both fail if either call site stops forwarding the
name: 2 mutants, 0 survivors (`EnterEnvironmentAction` and `RunTaskAction` each
stopping forwarding `step_name`).

`extra_let_bindings` keeps its `if self._extra_let_bindings:` check, and
`step_name` keeps its `is not None` check, but neither is feature-detection now --
they are "only forward what carries something". Job and external environment
enters have no owning step, so `Step.Name` must stay undefined for them rather
than be seeded with None, which the existing assertions pin.

Release ordering note: openjd-sessions 0.10.11 raises when a wrap environment is
active and no `step_name` is given, so the released CLI cannot run wrapped tasks
until this lands. That makes this the unblocking change rather than a cleanup.

Verified: 295 passed, 2 skipped (both Windows-shell tests); ruff, black, and mypy
clean.

Signed-off-by: David Leong <116610336+leongdl@users.noreply.github.com>

Author: leongdl

pyproject.toml

@@ -29,7 +29,10 @@ classifiers = [
   "Intended Audience :: End Users/Desktop"
 ]
 dependencies = [
-  "openjd-sessions >= 0.10.7,< 0.11",
+  # 0.10.11 is the first release with `step_name` on both Session.run_task and
+  # Session.enter_environment (RFC 0007/0008). Below it, run_task() raises
+  # TypeError on every task run, since this CLI passes the keyword unconditionally.
+  "openjd-sessions >= 0.10.11,< 0.11",
   "openjd-model >= 0.9,< 0.12"
 ]
 

src/openjd/cli/_run/_local_session/_actions.py

@@ -1,22 +1,12 @@
 # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 
-import inspect
 from enum import Enum
 from typing import Any, Optional
 
 from openjd.model import Step, TaskParameterSet
 from openjd.model.v2023_09 import Environment
 from openjd.sessions import Session
 
-# Version-skew guard: the step_name keyword was added to
-# Session.enter_environment alongside RFC 0007 Step.Name support. Detect it
-# once so this CLI keeps working against older openjd-sessions releases that
-# don't accept the keyword (every step-environment enter carries a step name,
-# so a value-presence check alone isn't enough here).
-_ENTER_ENVIRONMENT_ACCEPTS_STEP_NAME: bool = (
-    "step_name" in inspect.signature(Session.enter_environment).parameters
-)
-
 
 class EnvironmentType(str, Enum):
     """
@@ -97,20 +87,16 @@ def __init__(
         self._step_name = step_name
 
     def run(self):
-        # Backwards compatibility: only forward `extra_let_bindings` when the
-        # step actually defines `let` bindings (RFC 0007). Older
-        # openjd-sessions releases don't accept the keyword, so omitting it
-        # by default keeps this CLI working with any sessions version for
-        # every template that doesn't use step-level lets — the reasonable
-        # default is simply "no extra bindings". `step_name` follows the same
-        # pattern, but since every step-environment enter has a step name, it
-        # is additionally gated on the installed openjd-sessions accepting
-        # the keyword; without it, Step.Name simply stays undefined (the
-        # pre-RFC 0007 behavior).
+        # Both keywords are guaranteed by this package's `openjd-sessions`
+        # floor (>= 0.10.11), so neither is feature-detected. They are still
+        # only forwarded when they carry something: a step with no `let`
+        # bindings means "no extra bindings", and job/external environment
+        # enters have no owning step, so `Step.Name` must stay undefined for
+        # them rather than being seeded with None.
         optional_kwargs: dict[str, Any] = {}
         if self._extra_let_bindings:
             optional_kwargs["extra_let_bindings"] = self._extra_let_bindings
-        if self._step_name is not None and _ENTER_ENVIRONMENT_ACCEPTS_STEP_NAME:
+        if self._step_name is not None:
             optional_kwargs["step_name"] = self._step_name
         self._session.enter_environment(
             environment=self._environment,

test/openjd/cli/test_local_session.py

@@ -7,7 +7,6 @@
 from . import SampleSteps, SESSION_PARAMETERS
 from openjd.model import StepParameterSpaceIterator
 from openjd.sessions import Session, SessionState
-from openjd.cli._run._local_session._actions import _ENTER_ENVIRONMENT_ACCEPTS_STEP_NAME
 from openjd.cli._run._local_session._session_manager import (
     LocalSession,
     EnvironmentType,
@@ -207,8 +206,14 @@ def test_localsession_step_env_enter_receives_step_name(
 ):
     """
     RFC 0007 §7.3.1 (EXPR): a step-environment enter passes the owning step's
-    name to Session.enter_environment (when the installed openjd-sessions
-    accepts the keyword), while job/external environment enters never do.
+    name to Session.enter_environment, while job/external environment enters
+    never do.
+
+    The step-environment assertion used to be gated on feature-detecting the
+    keyword, which meant that against a sessions build without it the test took
+    the other branch and asserted the keyword was *absent* -- passing while
+    proving the opposite of its name. The `openjd-sessions >= 0.10.11` floor
+    guarantees the keyword, so the assertion is now unconditional.
     """
     sample_job, sample_job_parameters, template_dir, current_working_dir = sample_job_and_dirs
     patched_enter = patched_actions[0]
@@ -233,12 +238,7 @@ def test_localsession_step_env_enter_receives_step_name(
 
     assert step_env_calls
     for enter_call in step_env_calls:
-        if _ENTER_ENVIRONMENT_ACCEPTS_STEP_NAME:
-            assert enter_call.kwargs["step_name"] == sample_job.steps[SampleSteps.NormalStep].name
-        else:
-            # Older openjd-sessions releases don't accept the keyword; the
-            # version-skew guard must omit it.
-            assert "step_name" not in enter_call.kwargs
+        assert enter_call.kwargs["step_name"] == sample_job.steps[SampleSteps.NormalStep].name
 
     # Job/external environment enters never carry a step name.
     assert other_env_calls

test/openjd/cli/test_run_command.py

@@ -20,7 +20,6 @@
     _process_task_params,
     _process_tasks,
 )
-from openjd.cli._run._local_session._actions import _ENTER_ENVIRONMENT_ACCEPTS_STEP_NAME
 from openjd.cli._run._local_session._session_manager import LoggingTimestampFormat
 from openjd.sessions import LOG as SessionsLogger, PathMappingRule, PathFormat, Session
 
@@ -674,15 +673,17 @@ def test_run_local_session_enter_environment_raises(capsys: pytest.CaptureFixtur
     assert "Traceback" not in outerr.out + outerr.err
 
 
-@pytest.mark.skipif(
-    not _ENTER_ENVIRONMENT_ACCEPTS_STEP_NAME,
-    reason="Installed openjd-sessions does not accept step_name on enter_environment",
-)
 def test_do_run_step_name_in_step_environment(capsys: pytest.CaptureFixture) -> None:
     """
     RFC 0007 §7.3.1 (EXPR) parity with openjd-rs: a step-level `let` binding
     may reference Step.Name, and the step's environments are entered with the
     binding so their actions can echo it.
+
+    This is the end-to-end proof of the feature. It used to be `skipif`-gated on
+    feature-detecting the `step_name` keyword, which meant it did not run at all
+    against a sessions build that lacked it -- so the only test that actually
+    exercised Step.Name in a step environment was silently skipped. The
+    `openjd-sessions >= 0.10.11` floor guarantees the keyword, so it always runs.
     """
     template_dir = Path(__file__).parent / "templates"
     args = [