feat: Add WrappedAction.Cancelation.* wrap-hook template variables

Register WrappedAction.Cancelation.Mode and
WrappedAction.Cancelation.NotifyPeriodInSeconds in the environment
script's injected-symbol list so format strings referencing them pass
validation, per the RFC 0008 follow-up
(OpenJobDescription/openjd-specifications#148):

- Mode is string? — "TERMINATE", "NOTIFY_THEN_TERMINATE", or null when
  the wrapped action defines no <Cancelation>, following the EXPR
  semantics for optional data. The null case is distinct from an
  explicit TERMINATE so wrap scripts can tell "author declared
  TERMINATE" apart from "author declared nothing".
- NotifyPeriodInSeconds is int? — the effective grace period when the
  mode is NOTIFY_THEN_TERMINATE (with the Template Schemas 5.3.2
  defaults applied: 120 for a task's onRun, 30 otherwise), and null
  when a notify period does not apply.

Also make the legacy (non-EXPR) format-string node render a None value
as the empty string, matching the EXPR engine's null rendering
(RFC 0005). This is required for both nullable variables, whose None
values must not render as the Python repr "None".

Runtime seeding of the two variables lands in
openjd-sessions-for-python; this is the model-side validation and
rendering support. Mirrors the Rust implementation in
OpenJobDescription/openjd-rs#261. Verified by unit tests and the
wrap-cancelation-* conformance fixtures — the full WRAP_ACTIONS suite
(53 tests) passes against the Python CLI.

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

Author: leongdl

src/openjd/model/_format_strings/_nodes.py

@@ -66,8 +66,17 @@ def evaluate_to_str(self, *, symtab: SymbolTable, path_format: Any = None) -> st
         EXPR-backed nodes override this to use the engine's own spec-defined
         coercion (RFC 0005), so e.g. ``true``/``false``/``null`` and lists
         render per the specification rather than as Python reprs.
+
+        A ``None`` value interpolates as the empty string, matching the EXPR
+        engine's null rendering (RFC 0005) — relevant for nullable injected
+        symbols such as ``WrappedAction.Cancelation.NotifyPeriodInSeconds``
+        (RFC 0008 follow-up), which is ``None`` when no notify period
+        applies.
         """
-        return str(self.evaluate(symtab=symtab, path_format=path_format))
+        value = self.evaluate(symtab=symtab, path_format=path_format)
+        if value is None:
+            return ""
+        return str(value)
 
     @abstractmethod
     def __repr__(self) -> str:  # pragma: no cover

src/openjd/model/v2023_09/_model.py

@@ -903,6 +903,15 @@ class EnvironmentScript(OpenJDModel_v2023_09):
             "|WrappedAction.Args",
             "|WrappedAction.Environment",
             "|WrappedAction.Timeout",
+            # RFC 0008 follow-up (openjd-specifications#148): the wrapped
+            # action's cancelation config. Mode is string? — "TERMINATE",
+            # "NOTIFY_THEN_TERMINATE", or null when the wrapped action
+            # defines no <Cancelation>. NotifyPeriodInSeconds is int? — the effective
+            # grace period for NOTIFY_THEN_TERMINATE (with the schema
+            # defaults applied: 120 for a task's onRun, 30 otherwise), and
+            # null when a notify period does not apply.
+            "|WrappedAction.Cancelation.Mode",
+            "|WrappedAction.Cancelation.NotifyPeriodInSeconds",
             "|WrappedEnv.Name",
             "|WrappedStep.Name",
         },

test/openjd/model_v0/format_strings/test_format_string.py

@@ -108,6 +108,27 @@ def test_multiple_expressions(
         # THEN
         assert format_string.resolve(symtab=symtab) == expected
 
+    @pytest.mark.parametrize(
+        "input, expected",
+        [
+            pytest.param("MODE=<{{Test.val}}>", "MODE=<>", id="none-only"),
+            pytest.param("{{Test.val}}", "", id="whole-string-none"),
+        ],
+    )
+    def test_none_value_renders_as_empty(self, input: str, expected: str) -> None:
+        # A None value interpolates as the empty string, matching the EXPR
+        # engine's null rendering (RFC 0005). Relevant for the nullable
+        # WrappedAction.Cancelation.* injected symbols (RFC 0008 follow-up).
+        # GIVEN
+        symtab = SymbolTable()
+
+        # WHEN
+        format_string = FormatString(input, context=ModelParsingContext_v2023_09())
+        symtab["Test.val"] = None
+
+        # THEN
+        assert format_string.resolve(symtab=symtab) == expected
+
     def test_without_entry_in_table(self):
         # GIVEN
         input = " {{ Test.val }}-{{    Test.end}}  "

test/openjd/model_v0/format_strings/test_node.py

@@ -39,3 +39,33 @@ def test_repr(self):
 
         # THEN
         assert str(node) == "FullName(Test.Name)"
+
+    def test_evaluate_to_str_renders_none_as_empty(self):
+        # A None value interpolates as the empty string, matching the EXPR
+        # engine's null rendering (RFC 0005). Relevant for nullable injected
+        # symbols such as WrappedAction.Cancelation.Mode (string?) and
+        # WrappedAction.Cancelation.NotifyPeriodInSeconds (int?), which are
+        # None when the wrapped action defines no <Cancelation>
+        # (RFC 0008 follow-up).
+        # GIVEN
+        symtab = SymbolTable()
+        symtab["Test.Name"] = None
+        node = FullNameNode("Test.Name")
+
+        # WHEN
+        result = node.evaluate_to_str(symtab=symtab)
+
+        # THEN
+        assert result == ""
+
+    def test_evaluate_to_str_coerces_value_with_str(self):
+        # GIVEN
+        symtab = SymbolTable()
+        symtab["Test.Name"] = 45
+        node = FullNameNode("Test.Name")
+
+        # WHEN
+        result = node.evaluate_to_str(symtab=symtab)
+
+        # THEN
+        assert result == "45"