@salesforce/afv-skills 1.14.0 → 1.16.0

package/skills/investigating-agentforce-d360/scripts/tests/test_render_dc_branches.py

@@ -0,0 +1,256 @@
+"""Additional ``render_dc`` tests targeting branches not covered by
+``test_render_dc_integration.py``:
+
+- ``main_for_session``     reads tree + manifest from disk; emits markdown
+- ``main``                  argparse → main_for_session
+- ``_parse_finish_reason``  HTML-escaped JSON parsing
+- ``_decoded_line``         tool-call JSON detection
+- mermaid sequence diagram  (requires ≥2 ACTION_STEPs OR an error_text)
+- mermaid topic flowchart   (requires repeating topics across turns)
+- schema-version refusal    on unsupported _schema_version
+"""
+from __future__ import annotations
+
+import json
+import unittest
+from pathlib import Path
+from tempfile import TemporaryDirectory
+from unittest import mock
+
+from . import _bootstrap  # noqa: F401  — sys.path setup
+
+import assemble_dc  # type: ignore
+import render_dc  # type: ignore
+from config import paths  # type: ignore
+from .fixtures.synthetic_session import IDS, write_to_disk  # type: ignore
+
+
+# -----------------------------------------------------------------------------
+# main_for_session — disk-backed entry point
+# -----------------------------------------------------------------------------
+
+
+class MainForSessionTests(unittest.TestCase):
+
+    def test_reads_tree_writes_summary_md(self):
+        with TemporaryDirectory() as t:
+            tmp = Path(t)
+            sdir = write_to_disk(tmp)
+            with mock.patch.object(paths, "DATA_ROOT", tmp):
+                tree, _ = assemble_dc.assemble(IDS.SID)
+                (sdir / "dc._session_tree.json").write_text(
+                    json.dumps(tree, default=str)
+                )
+                rc = render_dc.main_for_session(IDS.SID)
+                self.assertEqual(rc, 0)
+                summary_path = sdir / "dc._session_summary.md"
+                self.assertTrue(summary_path.is_file())
+                self.assertGreater(len(summary_path.read_text()), 1000)
+
+    def test_raises_when_tree_missing(self):
+        with TemporaryDirectory() as t:
+            tmp = Path(t)
+            write_to_disk(tmp)  # creates session dir but not tree
+            with mock.patch.object(paths, "DATA_ROOT", tmp):
+                with self.assertRaises(SystemExit) as ctx:
+                    render_dc.main_for_session(IDS.SID)
+        self.assertIn("tree not found", str(ctx.exception))
+
+    def test_tolerates_missing_manifest_with_warning(self):
+        with TemporaryDirectory() as t:
+            tmp = Path(t)
+            sdir = write_to_disk(tmp)
+            with mock.patch.object(paths, "DATA_ROOT", tmp):
+                tree, _ = assemble_dc.assemble(IDS.SID)
+                (sdir / "dc._session_tree.json").write_text(
+                    json.dumps(tree, default=str)
+                )
+                # Wipe the manifest. main_for_session should still succeed
+                # (manifest is optional; missing → no manifest-driven sections).
+                (sdir / "dc._session_manifest.json").unlink()
+                rc = render_dc.main_for_session(IDS.SID)
+                self.assertEqual(rc, 0)
+
+
+# -----------------------------------------------------------------------------
+# main — argparse + resolve
+# -----------------------------------------------------------------------------
+
+
+class MainTests(unittest.TestCase):
+
+    def test_main_invokes_main_for_session_with_resolved_sid(self):
+        with TemporaryDirectory() as t:
+            tmp = Path(t)
+            sdir = write_to_disk(tmp)
+            with mock.patch.object(paths, "DATA_ROOT", tmp):
+                tree, _ = assemble_dc.assemble(IDS.SID)
+                (sdir / "dc._session_tree.json").write_text(
+                    json.dumps(tree, default=str)
+                )
+                with mock.patch.object(
+                    render_dc.sys, "argv",
+                    ["render_dc.py", "--session", IDS.SID],
+                ):
+                    rc = render_dc.main()
+        self.assertEqual(rc, 0)
+
+
+# -----------------------------------------------------------------------------
+# _parse_finish_reason — HTML-escaped JSON
+# -----------------------------------------------------------------------------
+
+
+class ParseFinishReasonTests(unittest.TestCase):
+
+    def test_extracts_stop_from_double_escaped_json(self):
+        # Real wire format: `{"finish_reason":"\"stop\""}`
+        params = '{"finish_reason":"\\"stop\\""}'
+        self.assertEqual(render_dc._parse_finish_reason(params), "stop")
+
+    def test_returns_none_for_empty(self):
+        self.assertIsNone(render_dc._parse_finish_reason(None))
+        self.assertIsNone(render_dc._parse_finish_reason(""))
+
+    def test_returns_none_for_unparseable_json(self):
+        self.assertIsNone(render_dc._parse_finish_reason("<<<not json>>>"))
+
+    def test_returns_none_when_finish_reason_not_string(self):
+        params = '{&quot;finish_reason&quot;: 42}'
+        self.assertIsNone(render_dc._parse_finish_reason(params))
+
+
+# -----------------------------------------------------------------------------
+# _decoded_line — tool-call JSON detection
+# -----------------------------------------------------------------------------
+
+
+class DecodedLineTests(unittest.TestCase):
+
+    def test_returns_dash_for_empty(self):
+        self.assertEqual(render_dc._decoded_line(None), "—")
+        self.assertEqual(render_dc._decoded_line(""), "—")
+
+    def test_renders_quoted_truncated_text_for_plain_string(self):
+        out = render_dc._decoded_line("Hello world")
+        self.assertEqual(out, '"Hello world"')
+
+    def test_summarizes_tool_call_json(self):
+        # Real wire shape: HTML-escaped JSON with toolInvocations array.
+        body = (
+            '{"toolInvocations":[{'
+            '"function":{"name":"search_orders",'
+            '"arguments":"{\\"query\\":\\"refund\\"}"}}],'
+            '"content":"I will search for orders."}'
+        )
+        out = render_dc._decoded_line(body)
+        self.assertIn("1 tool call", out)
+        self.assertIn("search_orders", out)
+        self.assertIn("query=", out)
+
+
+# -----------------------------------------------------------------------------
+# Multi-turn fixture for mermaid branches
+# -----------------------------------------------------------------------------
+
+
+def _add_extra_turn_to_tree(tree: dict) -> None:
+    """Mutate the assembled tree to have a 2nd TURN with a topic that
+    repeats — triggers both the sequence diagram and the topic flowchart.
+    """
+    # Tag the existing turn with a topic
+    sess = tree["session"]
+    for iv in sess["interactions"]:
+        if iv["type"] == "TURN":
+            iv["topic"] = "Refunds"
+            # Inject a 2nd action step so sequence diagram passes its
+            # has_error/len(actions)>=2 gate.
+            iv["steps"].append({
+                "id": "step-extra-action",
+                "type": "ACTION_STEP",
+                "name": "ExtraAction",
+                "start_ts": "2026-04-22T10:00:42.000Z",
+                "end_ts":   "2026-04-22T10:00:48.000Z",
+                "error_text": None,
+                "generation": None,
+                "gateway_request": None,
+            })
+            break
+    # Append a 2nd TURN that uses the same topic — triggers flowchart edges.
+    sess["interactions"].append({
+        "id": "ixn-turn-002b",
+        "type": "TURN",
+        "topic": "Refunds",
+        "trace_id": "trace-2nd",
+        "start_ts": "2026-04-22T10:01:05.000Z",
+        "end_ts":   "2026-04-22T10:01:25.000Z",
+        "steps": [
+            {"id": "step-2a", "type": "ACTION_STEP",
+             "name": "ActionA",
+             "start_ts": "2026-04-22T10:01:08.000Z",
+             "end_ts":   "2026-04-22T10:01:12.000Z",
+             "error_text": None,
+             "generation": None,
+             "gateway_request": None},
+            {"id": "step-2b", "type": "ACTION_STEP",
+             "name": "ActionB",
+             "start_ts": "2026-04-22T10:01:13.000Z",
+             "end_ts":   "2026-04-22T10:01:18.000Z",
+             "error_text": "Action B failed: timeout",
+             "generation": None,
+             "gateway_request": None},
+        ],
+        "messages": [
+            {"role": "USER", "text": "I want to escalate.", "ts": None},
+            {"role": "AGENT", "text": "Connecting you to a human.", "ts": None},
+        ],
+        "tag_associations": [], "telemetry_spans": [],
+        "timestamp_bound_gateway_calls": [],
+    })
+
+
+class MultiTurnRenderTests(unittest.TestCase):
+
+    def _assemble_and_render(self, tree_mutator):
+        with TemporaryDirectory() as t:
+            tmp = Path(t)
+            sdir = write_to_disk(tmp)
+            with mock.patch.object(paths, "DATA_ROOT", tmp):
+                tree, _ = assemble_dc.assemble(IDS.SID)
+                tree_mutator(tree)
+                manifest = json.loads(
+                    (sdir / "dc._session_manifest.json").read_text()
+                )
+                return render_dc.render(tree, manifest=manifest, session_dir=sdir)
+
+    def test_sequence_diagram_emitted_when_turn_has_two_actions(self):
+        md = self._assemble_and_render(_add_extra_turn_to_tree)
+        self.assertIn("sequenceDiagram", md)
+        self.assertIn("participant U as USER", md)
+        self.assertIn("participant P as Planner", md)
+
+    def test_topic_flowchart_emitted_when_topics_repeat(self):
+        md = self._assemble_and_render(_add_extra_turn_to_tree)
+        self.assertIn("flowchart LR", md)
+        self.assertIn("Refunds", md)
+
+
+# -----------------------------------------------------------------------------
+# Schema-version guard
+# -----------------------------------------------------------------------------
+
+
+class SchemaVersionGuardTests(unittest.TestCase):
+
+    def test_render_refuses_unsupported_schema_version(self):
+        # _assert_schema_version reads session._schema_version (per impl).
+        bad_tree = {
+            "session": {"id": IDS.SID, "interactions": [], "_schema_version": 999},
+        }
+        with self.assertRaises(SystemExit) as ctx:
+            render_dc.render(bad_tree)
+        self.assertIn("unsupported tree _schema_version", str(ctx.exception))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/investigating-agentforce-d360/scripts/tests/test_render_dc_gateway_direct.py

@@ -0,0 +1,130 @@
+"""Tests for ``render_dc._render_gateway_direct``.
+
+Feeds a gateway-direct tree (built by ``_assemble_gateway_direct``)
+through the public ``render()`` entry point and asserts on the emitted
+markdown. The intent is to pin the section contract without coupling to
+exact whitespace:
+
+  - lag banner appears
+  - gateway chain table has the expected header
+  - one H4 per gateway_request_id in per-call detail
+  - per-call detail includes a fenced code block for the prompt
+  - Interaction-dependent sections are ABSENT (Hierarchical trace,
+    Per-turn summary, Transcript, Session counts)
+"""
+from __future__ import annotations
+
+import unittest
+
+from . import _bootstrap  # noqa: F401  — sys.path setup
+
+from assemble_dc import _assemble_gateway_direct  # type: ignore
+from render_dc import render  # type: ignore
+
+from .test_assemble_dc_gateway_direct import (
+    _SID,
+    _make_manifest,
+    _make_rows,
+)
+
+
+class RenderGatewayDirectTests(unittest.TestCase):
+
+    def setUp(self):
+        rows = _make_rows()
+        manifest = _make_manifest()
+        self.tree = _assemble_gateway_direct(_SID, rows, manifest, parse_warnings=[])
+        # Opt into prompt rendering — these tests exercise the *content* of
+        # the per-call detail block, not the default-gating contract. The
+        # default-gating tests live in test_render_dc_show_prompts_gating.py.
+        self.md = render(self.tree, manifest, show_prompts=True)
+
+    def test_starts_with_session_heading(self):
+        self.assertTrue(self.md.startswith(f"# Session {_SID}"))
+
+    def test_lag_banner_present(self):
+        self.assertIn("STDM Interaction/Step/Message DMOs have not yet "
+                      "materialized", self.md)
+        self.assertIn("Re-run in 24–72h", self.md)
+
+    def test_gateway_chain_table_header(self):
+        self.assertIn("| Model | Provider", self.md)
+        self.assertIn("Prompt tok", self.md)
+        self.assertIn("Response ts", self.md)
+
+    def test_h4_per_gateway_call(self):
+        """3 fixture gateway_requests → 3 `#### LLM call N` headings."""
+        h4_count = self.md.count("#### LLM call ")
+        self.assertGreaterEqual(h4_count, 3)
+
+    def test_prompt_fenced_code_block(self):
+        """Per-call detail wraps the prompt in a fenced code block."""
+        self.assertIn("```", self.md)
+        self.assertIn("This is the prompt body for gw-1.", self.md)
+
+    def test_no_hierarchical_trace_section(self):
+        self.assertNotIn("Hierarchical trace", self.md)
+        self.assertNotIn("Complete hierarchical trace", self.md)
+
+    def test_no_per_turn_summary_section(self):
+        self.assertNotIn("Per-turn summary", self.md)
+
+    def test_no_transcript_section(self):
+        self.assertNotIn("## Transcript", self.md)
+
+    def test_session_identity_section_present(self):
+        self.assertIn("## Session identity", self.md)
+
+    def test_prompt_with_triple_backticks_uses_longer_fence(self):
+        """Prompts containing ``` must get a 4+-backtick fence.
+
+        LLM prompt templates commonly embed triple-backtick tool-use
+        examples. A hardcoded ``` fence would close early and corrupt
+        every section after the first such prompt.
+        """
+        rows = _make_rows()
+        rows["gateway_requests"][0]["prompt__c"] = (
+            "See this example:\n"
+            "```python\n"
+            "print('hi')\n"
+            "```\n"
+            "End of example."
+        )
+        manifest = _make_manifest()
+        tree = _assemble_gateway_direct(_SID, rows, manifest, parse_warnings=[])
+        md = render(tree, manifest, show_prompts=True)
+        self.assertIn("````", md)  # 4-backtick fence
+        self.assertIn("print('hi')", md)
+        # The inner triple-backticks survive intact.
+        self.assertIn("```python", md)
+
+    def test_prompt_with_four_backticks_uses_five_backtick_fence(self):
+        """Fence length scales with the longest inner run of backticks."""
+        rows = _make_rows()
+        rows["gateway_requests"][0]["prompt__c"] = (
+            "Edge case:\n````\nnested\n````\nDone."
+        )
+        manifest = _make_manifest()
+        tree = _assemble_gateway_direct(_SID, rows, manifest, parse_warnings=[])
+        md = render(tree, manifest, show_prompts=True)
+        self.assertIn("`````", md)  # 5-backtick fence
+
+    def test_prompt_truncation_marker_for_oversized_prompt(self):
+        """Display-only 64 KB cap: prompts over the limit carry a truncation marker.
+
+        Raw JSON on disk is untouched — the cap only applies to markdown.
+        """
+        rows = _make_rows()
+        # Inflate the first prompt to 80 KB of ASCII.
+        rows["gateway_requests"][0]["prompt__c"] = "x" * 80_000
+        manifest = _make_manifest()
+        tree = _assemble_gateway_direct(_SID, rows, manifest, parse_warnings=[])
+        md = render(tree, manifest, show_prompts=True)
+        self.assertIn("[truncated; full prompt in dc.gateway_requests.json]", md)
+        # The on-tree prompt_text is still the full 80 KB — the cap is render-only.
+        self.assertEqual(len(tree["session"]["gateway_chain"][0]["prompt_text"]),
+                         80_000)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/skills/investigating-agentforce-d360/scripts/tests/test_render_dc_helpers.py

@@ -0,0 +1,291 @@
+"""Tests for ``render_dc`` pure-function helpers.
+
+The renderer is large (863 stmts); covering its end-to-end markdown
+output requires a complex tree fixture. These tests target the small,
+pure helpers — they're cheap to test and account for ~150 stmts of the
+gap.
+"""
+from __future__ import annotations
+
+import unittest
+from datetime import datetime, timezone
+
+from . import _bootstrap  # noqa: F401  — sys.path setup
+
+import render_dc  # type: ignore
+
+
+# -----------------------------------------------------------------------------
+# _parse_iso
+# -----------------------------------------------------------------------------
+
+
+class ParseIsoTests(unittest.TestCase):
+
+    def test_returns_none_for_falsy_input(self):
+        self.assertIsNone(render_dc._parse_iso(None))
+        self.assertIsNone(render_dc._parse_iso(""))
+
+    def test_parses_z_terminated(self):
+        self.assertEqual(
+            render_dc._parse_iso("2026-04-22T10:00:00Z"),
+            datetime(2026, 4, 22, 10, 0, 0, tzinfo=timezone.utc),
+        )
+
+    def test_returns_none_for_unparseable(self):
+        self.assertIsNone(render_dc._parse_iso("not-a-timestamp"))
+
+
+# -----------------------------------------------------------------------------
+# _fmt_offset
+# -----------------------------------------------------------------------------
+
+
+class FmtOffsetTests(unittest.TestCase):
+
+    def test_returns_dash_when_timestamp_or_start_missing(self):
+        anchor = datetime(2026, 4, 22, 10, 0, 0, tzinfo=timezone.utc)
+        self.assertEqual(render_dc._fmt_offset(None, anchor), "—")
+        self.assertEqual(render_dc._fmt_offset("2026-04-22T10:00:00Z", None), "—")
+
+    def test_formats_offset_with_3_decimals(self):
+        anchor = datetime(2026, 4, 22, 10, 0, 0, tzinfo=timezone.utc)
+        out = render_dc._fmt_offset("2026-04-22T10:00:01.234Z", anchor)
+        self.assertEqual(out, "+1.234s")
+
+
+# -----------------------------------------------------------------------------
+# _fmt_duration_ms
+# -----------------------------------------------------------------------------
+
+
+class FmtDurationMsTests(unittest.TestCase):
+
+    def test_dash_when_either_side_missing(self):
+        self.assertEqual(render_dc._fmt_duration_ms(None, "2026-04-22T10:00:00Z"), "—")
+        self.assertEqual(render_dc._fmt_duration_ms("2026-04-22T10:00:00Z", None), "—")
+
+    def test_returns_int_ms_with_unit(self):
+        out = render_dc._fmt_duration_ms(
+            "2026-04-22T10:00:00.000Z", "2026-04-22T10:00:00.123Z",
+        )
+        self.assertEqual(out, "123ms")
+
+
+# -----------------------------------------------------------------------------
+# _decode + _truncate
+# -----------------------------------------------------------------------------
+
+
+class DecodeTruncateTests(unittest.TestCase):
+
+    def test_decode_unescapes_html_and_collapses_newlines(self):
+        self.assertEqual(render_dc._decode(""hi"\nthere"), '"hi" there')
+
+    def test_decode_returns_empty_for_falsy(self):
+        self.assertEqual(render_dc._decode(None), "")
+        self.assertEqual(render_dc._decode(""), "")
+
+    def test_truncate_pads_with_ellipsis_when_over_n(self):
+        long = "a" * 100
+        out = render_dc._truncate(long, n=10)
+        self.assertEqual(len(out), 10)
+        self.assertTrue(out.endswith("…"))
+
+    def test_truncate_returns_input_when_under_or_equal_n(self):
+        self.assertEqual(render_dc._truncate("short", n=10), "short")
+
+    def test_truncate_returns_dash_for_falsy(self):
+        self.assertEqual(render_dc._truncate(None), "—")
+        self.assertEqual(render_dc._truncate(""), "—")
+
+
+# -----------------------------------------------------------------------------
+# _short
+# -----------------------------------------------------------------------------
+
+
+class ShortTests(unittest.TestCase):
+
+    def test_returns_dash_for_falsy(self):
+        self.assertEqual(render_dc._short(None), "—")
+        self.assertEqual(render_dc._short(""), "—")
+
+    def test_truncates_long_uuid_with_ellipsis(self):
+        out = render_dc._short("019dface-0000-7000-8000-000000000001", keep=8)
+        self.assertEqual(out, "019dface…")
+
+    def test_returns_input_when_short(self):
+        self.assertEqual(render_dc._short("abc"), "abc")
+
+
+# -----------------------------------------------------------------------------
+# _fmt_total_duration — h / m / s rollover
+# -----------------------------------------------------------------------------
+
+
+class FmtTotalDurationTests(unittest.TestCase):
+
+    def test_returns_none_when_either_side_missing(self):
+        self.assertIsNone(render_dc._fmt_total_duration(None, "2026-04-22T10:00:00Z"))
+
+    def test_seconds_only(self):
+        self.assertEqual(
+            render_dc._fmt_total_duration(
+                "2026-04-22T10:00:00.000Z", "2026-04-22T10:00:42.500Z",
+            ),
+            "42.500s",
+        )
+
+    def test_minutes_and_seconds(self):
+        self.assertEqual(
+            render_dc._fmt_total_duration(
+                "2026-04-22T10:00:00Z", "2026-04-22T10:02:30Z",
+            ),
+            "2m 30.000s",
+        )
+
+    def test_hours_minutes_seconds(self):
+        out = render_dc._fmt_total_duration(
+            "2026-04-22T10:00:00Z", "2026-04-22T11:30:45Z",
+        )
+        self.assertEqual(out, "1h 30m 45.000s")
+
+
+# -----------------------------------------------------------------------------
+# _derive_session_end
+# -----------------------------------------------------------------------------
+
+
+class DeriveSessionEndTests(unittest.TestCase):
+
+    def test_returns_session_end_ts_verbatim_when_present(self):
+        end, source = render_dc._derive_session_end(
+            {"end_ts": "2026-04-22T11:00:00Z", "interactions": []},
+        )
+        self.assertEqual(end, "2026-04-22T11:00:00Z")
+        self.assertIsNone(source)
+
+    def test_uses_session_end_interaction_start_ts(self):
+        sess = {
+            "end_ts": None,
+            "interactions": [
+                {"type": "TURN", "start_ts": "10:00", "end_ts": "10:01"},
+                {"type": "SESSION_END", "start_ts": "11:00:00Z"},
+            ],
+        }
+        end, source = render_dc._derive_session_end(sess)
+        self.assertEqual(end, "11:00:00Z")
+        self.assertEqual(source, "from SESSION_END interaction")
+
+    def test_falls_back_to_last_turn_end_ts(self):
+        sess = {
+            "end_ts": None,
+            "interactions": [
+                {"type": "TURN", "start_ts": "10:00", "end_ts": "10:01"},
+                {"type": "TURN", "start_ts": "10:02", "end_ts": "10:03"},
+            ],
+        }
+        end, source = render_dc._derive_session_end(sess)
+        self.assertEqual(end, "10:03")
+        self.assertEqual(source, "session still open (last TURN)")
+
+    def test_returns_none_pair_when_no_data(self):
+        end, source = render_dc._derive_session_end({"interactions": []})
+        self.assertIsNone(end)
+        self.assertIsNone(source)
+
+
+# -----------------------------------------------------------------------------
+# _compose_agent_cell
+# -----------------------------------------------------------------------------
+
+
+class ComposeAgentCellTests(unittest.TestCase):
+
+    def test_full_identity_concatenated(self):
+        out = render_dc._compose_agent_cell({
+            "agent_api_name": "MyAgent",
+            "agent_version": "v3",
+            "agent_label": "My Agent",
+            "agent_type": "Internal",
+        })
+        self.assertEqual(out, "MyAgent v3 — My Agent (Internal)")
+
+    def test_only_api_name(self):
+        out = render_dc._compose_agent_cell({"agent_api_name": "MyAgent"})
+        self.assertEqual(out, "MyAgent")
+
+    def test_only_label(self):
+        out = render_dc._compose_agent_cell({"agent_label": "Display Only"})
+        self.assertEqual(out, "Display Only")
+
+    def test_returns_none_for_empty_identity(self):
+        self.assertIsNone(render_dc._compose_agent_cell({}))
+
+
+# -----------------------------------------------------------------------------
+# _section_session_bootstrap — channel-aware NOT_SET wording
+# -----------------------------------------------------------------------------
+
+
+class SectionSessionBootstrapNotSetWordingTests(unittest.TestCase):
+    """`VariableText__c == NOT_SET` is a "no bootstrap variables" signal,
+    not a messaging-channel signal. Several non-messaging shapes (E&O
+    headless API, Atlas planner, generic API/integration) legitimately
+    produce NOT_SET — the rendered line must not call those "production
+    messaging path".
+    """
+
+    def _identity_with_no_bootstrap(self) -> dict:
+        # Sentinel: bootstrap_variables key is present and explicitly None
+        # (the assembler stamps None when VariableText__c is NOT_SET).
+        return {"bootstrap_variables": None}
+
+    def test_messaging_channel_keeps_messaging_path_addendum(self):
+        out = "\n".join(render_dc._section_session_bootstrap(
+            self._identity_with_no_bootstrap(),
+            channel="SCRT2 - EmbeddedMessaging",
+        ))
+        self.assertIn("no bootstrap variables", out)
+        self.assertIn("production messaging path", out)
+        # Alias.
+        out2 = "\n".join(render_dc._section_session_bootstrap(
+            self._identity_with_no_bootstrap(),
+            channel="Messaging",
+        ))
+        self.assertIn("production messaging path", out2)
+
+    def test_non_messaging_channel_omits_messaging_path(self):
+        # E&O is the wheelz that surfaced this bug — Atlas-planner
+        # session on the "E & O" channel was being mislabeled
+        # "production messaging path".
+        out = "\n".join(render_dc._section_session_bootstrap(
+            self._identity_with_no_bootstrap(),
+            channel="E & O",
+        ))
+        self.assertIn("no bootstrap variables", out)
+        self.assertNotIn("production messaging path", out)
+        self.assertNotIn("messaging", out.lower())
+
+    def test_null_channel_uses_neutral_wording(self):
+        # No channel info at all — must not assume messaging.
+        out = "\n".join(render_dc._section_session_bootstrap(
+            self._identity_with_no_bootstrap(),
+            channel=None,
+        ))
+        self.assertIn("no bootstrap variables", out)
+        self.assertNotIn("production messaging path", out)
+
+    def test_default_channel_kwarg_is_neutral(self):
+        # Backward-compat: callers that don't pass channel get the
+        # neutral wording, never the messaging-path label.
+        out = "\n".join(render_dc._section_session_bootstrap(
+            self._identity_with_no_bootstrap(),
+        ))
+        self.assertIn("no bootstrap variables", out)
+        self.assertNotIn("production messaging path", out)
+
+
+if __name__ == "__main__":
+    unittest.main()