wade-cli 0.53.0__tar.gz → 0.53.1__tar.gz

{wade_cli-0.53.0 → wade_cli-0.53.1}/CHANGELOG.md

@@ -4,6 +4,12 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Conventional Commits](https://conventionalcommits.org/).
 
+## [v0.53.1] — 2026-08-31
+
+### Bug Fixes
+
+- relaunch Codex with implementation network policy after plan handoff (#473) (202018b)
+
 ## [v0.53.0] — 2026-08-31
 
 ### Features

{wade_cli-0.53.0 → wade_cli-0.53.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: wade-cli
-Version: 0.53.0
+Version: 0.53.1
 Summary: WADE — Workflow for AI-Driven Engineering
 Project-URL: Homepage, https://github.com/ivanviragine/wade
 Project-URL: Repository, https://github.com/ivanviragine/wade
@@ -730,6 +730,15 @@ flag enables it there. Precedence for the commands that honor it is
 enable network for a WADE-managed sandbox. Enabling network never disables the
 sandbox and never changes approval-policy semantics.
 
+An accepted single-issue plan handoff starts implementation from a planning
+session that is always network-off. When both the planning tool and resolved
+implementation tool are Codex and the implementation policy resolves to enabled,
+WADE starts a fresh detached Codex context with network explicitly enabled;
+reusing the planner process would retain its immutable network-off sandbox. If
+WADE cannot open that detached context, the handoff fails rather than reporting
+an implementation session ready. Open a new host terminal and run the displayed
+`wade implement <issue> --network` command to continue with the required policy.
+
 ### Session readiness and least-privilege remediation
 
 Every `wade` command an agent runs is a child of the AI tool. It inherits that

{wade_cli-0.53.0 → wade_cli-0.53.1}/README.md

@@ -694,6 +694,15 @@ flag enables it there. Precedence for the commands that honor it is
 enable network for a WADE-managed sandbox. Enabling network never disables the
 sandbox and never changes approval-policy semantics.
 
+An accepted single-issue plan handoff starts implementation from a planning
+session that is always network-off. When both the planning tool and resolved
+implementation tool are Codex and the implementation policy resolves to enabled,
+WADE starts a fresh detached Codex context with network explicitly enabled;
+reusing the planner process would retain its immutable network-off sandbox. If
+WADE cannot open that detached context, the handoff fails rather than reporting
+an implementation session ready. Open a new host terminal and run the displayed
+`wade implement <issue> --network` command to continue with the required policy.
+
 ### Session readiness and least-privilege remediation
 
 Every `wade` command an agent runs is a child of the AI tool. It inherits that

{wade_cli-0.53.0 → wade_cli-0.53.1}/docs/dev/architecture.md

@@ -499,6 +499,17 @@ picks (implement / batch / review). `None` (unset) still re-resolves per the
 routed command's own config, matching how a non-explicit `permission_mode` is
 threaded.
 
+Planning itself is always network-off, including when it later offers an
+accepted single-issue implementation handoff. The internal `plan_handoff`
+intent keeps implementation-network resolution at `implementation_service.start`.
+If that handoff originates in Codex, resolves the implementation tool to Codex,
+and resolves network access to enabled, implementation must create a fresh
+detached Codex launch with an explicit `network_access=True` pin. It cannot reuse
+the planner's immutable network-off sandbox. If the detached launch cannot be
+created, the handoff fails closed and prints `wade implement <issue> --network`
+for the user to run from a new host terminal; it must not fall back to an inline
+or nested agent. All other nested-agent starts retain the ordinary launch guard.
+
 ### Phase-aware session readiness (#462)
 
 `check_service.check_session_readiness()` applies the declarative

{wade_cli-0.53.0 → wade_cli-0.53.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "wade-cli"
-version = "0.53.0"
+version = "0.53.1"
 description = "WADE — Workflow for AI-Driven Engineering"
 readme = "README.md"
 license = "MIT"

{wade_cli-0.53.0 → wade_cli-0.53.1}/src/wade/__init__.py

@@ -1,3 +1,3 @@
 """WADE (Workflow for AI-Driven Engineering) — AI-agent-driven git workflow management CLI."""
 
-__version__ = "0.53.0"
+__version__ = "0.53.1"

{wade_cli-0.53.0 → wade_cli-0.53.1}/src/wade/services/implementation_service/core.py

@@ -434,6 +434,7 @@ def start(
     work_skills: list[str] | None = None,
     review_skills: list[str] | None = None,
     refresh_skills: bool = False,
+    plan_handoff: bool = False,
 ) -> ImplementResult:
     """Start an implementation session on an issue.
 
@@ -453,6 +454,10 @@ def start(
         project_root: Repository root (defaults to CWD).
         detach: If True, launch AI in a new terminal tab.
         cd_only: If True, create worktree and print path only (no AI launch).
+        plan_handoff: Internal marker for an accepted ``wade plan`` handoff.
+            A network-enabled Codex implementation must launch in a fresh
+            detached context rather than inherit the planner's network-off
+            sandbox.
 
     Returns:
         ImplementResult with success/merged status.
@@ -931,9 +936,19 @@ def start(
             return ImplementResult(success=True)
 
         # AI-initiated start guard: if we're inside an AI CLI session,
-        # don't launch another AI tool — just print the worktree path.
+        # don't launch another AI tool — just print the worktree path.  The
+        # one exception is a plan handoff from Codex to a network-enabled Codex
+        # implementation: network is a launch-time sandbox property, and the
+        # planner always ran with it disabled, so that handoff needs a fresh
+        # detached process instead of reusing this agent context.
         detected_env = _detect_ai_cli_env()
-        if detected_env:
+        requires_fresh_codex_handoff = (
+            plan_handoff
+            and detected_env == "CODEX_CLI"
+            and resolved_tool == AIToolID.CODEX.value
+            and resolved_network_access
+        )
+        if detected_env and not requires_fresh_codex_handoff:
             logger.info(
                 "implementation.ai_launch_skipped",
                 reason="inside_ai_cli",
@@ -960,8 +975,10 @@ def start(
         except OSError:
             logger.warning("implementation.transcript_dir_failed")
 
-        # Detach mode: launch AI tool in a new terminal, don't block
-        if detach and resolved_tool:
+        # Detach mode: launch AI tool in a new terminal, don't block.  A
+        # network-enabled Codex plan handoff is forced through this path so it
+        # cannot inherit the planner's immutable network-off sandbox.
+        if (detach or requires_fresh_codex_handoff) and resolved_tool:
             cmd: list[str] | None = None
             try:
                 detach_adapter = AbstractAITool.get(AIToolID(resolved_tool))
@@ -995,18 +1012,40 @@ def start(
                         effort=resolved_effort,
                         allowed_commands=config.permissions.allowed_commands,
                         working_dir=worktree_path,
-                        network_access=resolved_network_access,
+                        # ``requires_fresh_codex_handoff`` already established
+                        # the resolved value is true; pin it explicitly for the
+                        # new Codex process rather than relying on ambient config.
+                        network_access=(
+                            True if requires_fresh_codex_handoff else resolved_network_access
+                        ),
                         **permission_mode_launch_kwargs(resolved_permission_mode),
                     )
             except (ValueError, KeyError):
-                cmd = [resolved_tool]
-
-            console.step(f"Launching {resolved_tool} in new terminal...")
-            assert cmd is not None  # guaranteed by the two branches above
-            if launch_in_new_terminal(cmd, cwd=str(worktree_path), title=work_title):
-                console.success(f"Detached AI session for #{task.id}")
+                # A fresh Codex handoff must retain its explicit sandbox,
+                # network, permission, and prompt arguments.  Do not replace a
+                # failed build with bare ``codex``, which would bypass them.
+                if not requires_fresh_codex_handoff:
+                    cmd = [resolved_tool]
+
+            if cmd is not None:
+                console.step(f"Launching {resolved_tool} in new terminal...")
+                if launch_in_new_terminal(
+                    cmd,
+                    cwd=str(worktree_path),
+                    title=work_title,
+                    wait_for_ready=requires_fresh_codex_handoff,
+                ):
+                    console.success(f"Detached AI session for #{task.id}")
+                    stop_title_keeper()
+                    return ImplementResult(success=True)
+            if requires_fresh_codex_handoff:
+                console.error(
+                    "Could not launch a fresh Codex implementation session with network access."
+                )
+                console.hint("Open a new host terminal, then run:")
+                console.detail(f"wade implement {task.id} --network")
                 stop_title_keeper()
-                return ImplementResult(success=True)
+                return ImplementResult(success=False)
             console.warn("Could not launch in new terminal — falling back to inline")
             detach = False
             # Fall through to inline launch below

{wade_cli-0.53.0 → wade_cli-0.53.1}/src/wade/services/plan_service.py

@@ -1539,7 +1539,10 @@ def _offer_to_implement(
         return False
 
     try:
-        result = start_implementation_session(target=issue_number)
+        # Planning always launches with network disabled.  Tell implementation
+        # startup this is an accepted handoff so it can establish a fresh Codex
+        # context when its independently resolved policy needs network access.
+        result = start_implementation_session(target=issue_number, plan_handoff=True)
         return result.success
     except Exception:
         logger.exception("plan.work_session_start_failed", issue=issue_number)

{wade_cli-0.53.0 → wade_cli-0.53.1}/src/wade/utils/terminal.py

@@ -11,6 +11,7 @@ import sys
 import threading
 import time
 from collections.abc import Sequence
+from pathlib import Path
 
 import structlog
 
@@ -20,6 +21,9 @@ _title_keeper_thread: threading.Thread | None = None
 _title_keeper_running = False
 
 _TERMINAL_TITLE_MAX_LEN = 50
+_LAUNCH_READY_TIMEOUT_SECONDS = 5.0
+_LAUNCH_READY_POLL_SECONDS = 0.05
+_LAUNCH_STABILITY_SECONDS = 0.5
 
 
 def _truncate_terminal_title(text: str) -> str:
@@ -126,6 +130,74 @@ def _create_temp_script(command: list[str], cwd: str | None = None) -> str:
     return tmp_path
 
 
+def _create_readiness_file() -> str:
+    """Create an empty, private file used for a detached-launch acknowledgement."""
+    import tempfile
+
+    fd, path = tempfile.mkstemp(prefix="wade-launch-", suffix=".ready")
+    os.close(fd)
+    return path
+
+
+def _create_readiness_script(
+    command: list[str],
+    cwd: str | None,
+    readiness_file: str,
+) -> str:
+    """Create a launcher which acknowledges only after its child stays alive.
+
+    Terminal brokers can confirm that they accepted a tab/window request but
+    cannot observe a command executed inside it.  This wrapper reports
+    ``ready`` only after the command has remained alive briefly, which catches
+    an unavailable executable and launch-time failures before the caller
+    reports a successful handoff.
+    """
+    import tempfile
+
+    cmd_str = " ".join(shlex.quote(str(c)) for c in command)
+    quoted_cwd = shlex.quote(cwd or ".")
+    quoted_readiness_file = shlex.quote(readiness_file)
+    with tempfile.NamedTemporaryFile(prefix="wade-", suffix=".sh", delete=False, mode="w") as f:
+        tmp_path = f.name
+        f.write(
+            "#!/usr/bin/env bash\n"
+            f"cd {quoted_cwd} || {{ printf 'failed\\n' > {quoted_readiness_file}; exit 1; }}\n"
+            f"{cmd_str} &\n"
+            "child_pid=$!\n"
+            f"sleep {_LAUNCH_STABILITY_SECONDS}\n"
+            'if kill -0 "$child_pid" 2>/dev/null; then\n'
+            f"  printf 'ready\\n' > {quoted_readiness_file}\n"
+            "else\n"
+            '  wait "$child_pid"\n'
+            f"  printf 'failed\\n' > {quoted_readiness_file}\n"
+            "  exit 1\n"
+            "fi\n"
+            'wait "$child_pid"\n'
+        )
+    os.chmod(tmp_path, 0o700)
+    return tmp_path
+
+
+def _wait_for_launch_readiness(
+    readiness_file: str,
+    timeout: float = _LAUNCH_READY_TIMEOUT_SECONDS,
+) -> bool:
+    """Wait for the detached launch wrapper to acknowledge a live child."""
+    deadline = time.monotonic() + timeout
+    path = Path(readiness_file)
+    while time.monotonic() < deadline:
+        try:
+            status = path.read_text()
+        except OSError:
+            return False
+        if status == "ready\n":
+            return True
+        if status == "failed\n":
+            return False
+        time.sleep(_LAUNCH_READY_POLL_SECONDS)
+    return False
+
+
 def detect_terminal() -> str | None:
     """Detect the current terminal emulator.
 
@@ -154,12 +226,36 @@ def launch_in_new_terminal(
     command: list[str],
     cwd: str | None = None,
     title: str | None = None,
+    *,
+    wait_for_ready: bool = False,
 ) -> bool:
     """Launch a command in a new terminal window/tab.
 
     Tries Ghostty, iTerm2, Terminal.app, tmux in order.
-    Returns True if launched successfully, False otherwise.
+    Returns True if launched successfully, False otherwise.  When
+    ``wait_for_ready`` is set, require a brief child-process acknowledgement
+    rather than treating terminal-broker acceptance as success.
     """
+    if not wait_for_ready:
+        return _launch_in_new_terminal(command, cwd=cwd, title=title)
+
+    readiness_file = _create_readiness_file()
+    launcher_script = _create_readiness_script(command, cwd, readiness_file)
+    try:
+        if not _launch_in_new_terminal([launcher_script], title=title):
+            return False
+        return _wait_for_launch_readiness(readiness_file)
+    finally:
+        _safe_unlink(launcher_script)
+        _safe_unlink(readiness_file)
+
+
+def _launch_in_new_terminal(
+    command: list[str],
+    cwd: str | None = None,
+    title: str | None = None,
+) -> bool:
+    """Launch a command in a new terminal window/tab without confirmation."""
     terminal = detect_terminal()
 
     if terminal == "ghostty":

{wade_cli-0.53.0 → wade_cli-0.53.1}/tests/unit/test_services/test_implementation_launch_context.py

@@ -22,7 +22,7 @@ from unittest.mock import MagicMock, patch
 import pytest
 
 from wade.git.pr import PRLookup, PRRef
-from wade.models.config import AIConfig, ProjectConfig, ProjectSettings
+from wade.models.config import AICommandConfig, AIConfig, ProjectConfig, ProjectSettings
 from wade.models.permission import PermissionMode
 from wade.models.task import Task, TaskState
 from wade.models.worktree import Worktree
@@ -32,7 +32,15 @@ _CORE = "wade.services.implementation_service.core"
 
 
 @contextlib.contextmanager
-def _driven_start(worktree_path: Path, *, network_access_config: bool) -> Iterator[MagicMock]:
+def _driven_start(
+    worktree_path: Path,
+    *,
+    network_access_config: bool,
+    implement_network_access_config: bool | None = None,
+    detected_env: str | None = None,
+    resolved_tool: str = "codex",
+    terminal_launch_succeeds: bool = True,
+) -> Iterator[MagicMock]:
     """Patch impl start()'s prerequisites and yield the spy AI adapter.
 
     Every heavy step between ``start()`` entry and the AI launch is stubbed so the
@@ -40,7 +48,10 @@ def _driven_start(worktree_path: Path, *, network_access_config: bool) -> Iterat
     worktree at *worktree_path*, and ``network_access`` resolved from config.
     """
     config = ProjectConfig(
-        ai=AIConfig(network_access=network_access_config),
+        ai=AIConfig(
+            network_access=network_access_config,
+            implement=AICommandConfig(network_access=implement_network_access_config),
+        ),
         project=ProjectSettings(main_branch="main", branch_prefix="feat"),
     )
     task = Task(id="42", title="Fix the widget", body="broken", state=TaskState.OPEN)
@@ -80,23 +91,26 @@ def _driven_start(worktree_path: Path, *, network_access_config: bool) -> Iterat
     p(patch(f"{_CORE}.bootstrap_worktree"))
     p(patch(f"{_CORE}._catchup_and_surface_staleness", return_value=None))
     p(patch(f"{_CORE}.build_implementation_prompt", return_value="PROMPT"))
-    p(patch(f"{_CORE}.resolve_ai_tool", return_value="codex"))
+    p(patch(f"{_CORE}.resolve_ai_tool", return_value=resolved_tool))
     p(patch(f"{_CORE}.resolve_model", return_value=None))
     p(patch(f"{_CORE}.resolve_effort", return_value=None))
     p(
         patch(
             f"{_CORE}.confirm_ai_selection",
-            return_value=("codex", None, None, PermissionMode.DEFAULT),
+            return_value=(resolved_tool, None, None, PermissionMode.DEFAULT),
         )
     )
-    p(patch(f"{_CORE}._detect_ai_cli_env", return_value=None))
+    p(patch(f"{_CORE}._detect_ai_cli_env", return_value=detected_env))
     p(patch(f"{_CORE}.set_terminal_title"))
     p(patch(f"{_CORE}.start_title_keeper"))
     p(patch(f"{_CORE}.stop_title_keeper"))
     p(patch(f"{_CORE}.deliver_prompt_if_needed"))
-    p(patch(f"{_CORE}.launch_in_new_terminal", return_value=True))
+    terminal_launch = p(
+        patch(f"{_CORE}.launch_in_new_terminal", return_value=terminal_launch_succeeds)
+    )
     p(patch("crossby.ai_tools.AbstractAITool.get", return_value=spy))
     with stack:
+        spy.terminal_launch = terminal_launch
         yield spy
 
 
@@ -164,3 +178,130 @@ class TestImplementationLaunchContext:
         kwargs = spy.build_resume_command.call_args.kwargs
         assert kwargs["working_dir"] == worktree
         assert kwargs["network_access"] is True
+
+    @pytest.mark.parametrize(
+        ("global_network_access", "implement_network_access"),
+        [(True, None), (False, True)],
+        ids=["global-policy", "implement-policy"],
+    )
+    def test_network_enabled_codex_plan_handoff_launches_fresh_detached_context(
+        self,
+        worktree: Path,
+        global_network_access: bool,
+        implement_network_access: bool | None,
+    ) -> None:
+        """A Codex plan handoff cannot reuse the planner's network-off sandbox."""
+        with _driven_start(
+            worktree,
+            network_access_config=global_network_access,
+            implement_network_access_config=implement_network_access,
+            detected_env="CODEX_CLI",
+        ) as spy:
+            spy.build_launch_command.return_value = ["codex"]
+
+            result = start(target="42", plan_handoff=True)
+
+        assert result.success is True
+        assert spy.build_launch_command.call_args.kwargs["working_dir"] == worktree
+        assert spy.build_launch_command.call_args.kwargs["network_access"] is True
+        assert spy.terminal_launch.call_args.kwargs["wait_for_ready"] is True
+        spy.launch.assert_not_called()
+
+    def test_network_disabled_codex_plan_handoff_keeps_nested_launch_guard(
+        self, worktree: Path
+    ) -> None:
+        """A false policy must not gain network access merely to leave planning."""
+        with _driven_start(
+            worktree,
+            network_access_config=False,
+            detected_env="CODEX_CLI",
+        ) as spy:
+            result = start(target="42", plan_handoff=True)
+
+        assert result.success is True
+        spy.build_launch_command.assert_not_called()
+        spy.launch.assert_not_called()
+
+    def test_failed_fresh_codex_plan_handoff_fails_closed_with_restart_command(
+        self, worktree: Path
+    ) -> None:
+        """The handoff must never fall through to an inline planner context."""
+        with (
+            _driven_start(
+                worktree,
+                network_access_config=True,
+                detected_env="CODEX_CLI",
+                terminal_launch_succeeds=False,
+            ) as spy,
+            patch(f"{_CORE}.console") as mock_console,
+        ):
+            spy.build_launch_command.return_value = ["codex"]
+
+            result = start(target="42", plan_handoff=True)
+
+        assert result.success is False
+        spy.launch.assert_not_called()
+        mock_console.detail.assert_any_call("wade implement 42 --network")
+
+    @pytest.mark.parametrize("command_error", [ValueError, KeyError])
+    def test_fresh_codex_plan_handoff_fails_closed_when_command_build_fails(
+        self, worktree: Path, command_error: type[Exception]
+    ) -> None:
+        """A builder failure must not degrade to an unconfigured ``codex`` command."""
+        with (
+            _driven_start(
+                worktree,
+                network_access_config=True,
+                detected_env="CODEX_CLI",
+            ) as spy,
+            patch(f"{_CORE}.console") as mock_console,
+            patch(f"{_CORE}.launch_in_new_terminal") as mock_launch,
+        ):
+            spy.build_launch_command.side_effect = command_error("build failed")
+
+            result = start(target="42", plan_handoff=True)
+
+        assert result.success is False
+        mock_launch.assert_not_called()
+        spy.launch.assert_not_called()
+        mock_console.detail.assert_any_call("wade implement 42 --network")
+
+    def test_non_handoff_codex_session_keeps_nested_launch_guard(self, worktree: Path) -> None:
+        """Ordinary ``wade implement`` calls still do not recursively launch Codex."""
+        with _driven_start(
+            worktree,
+            network_access_config=True,
+            detected_env="CODEX_CLI",
+        ) as spy:
+            result = start(target="42")
+
+        assert result.success is True
+        spy.build_launch_command.assert_not_called()
+        spy.launch.assert_not_called()
+
+    def test_non_codex_plan_handoff_keeps_nested_launch_guard(self, worktree: Path) -> None:
+        """A plan handoff to another implementation tool cannot escape the guard."""
+        with _driven_start(
+            worktree,
+            network_access_config=True,
+            detected_env="CODEX_CLI",
+            resolved_tool="claude",
+        ) as spy:
+            result = start(target="42", plan_handoff=True)
+
+        assert result.success is True
+        spy.build_launch_command.assert_not_called()
+        spy.launch.assert_not_called()
+
+    def test_other_ai_session_marker_keeps_nested_launch_guard(self, worktree: Path) -> None:
+        """Only a Codex-originated handoff gets the fresh-context exception."""
+        with _driven_start(
+            worktree,
+            network_access_config=True,
+            detected_env="CLAUDE_CODE",
+        ) as spy:
+            result = start(target="42", plan_handoff=True)
+
+        assert result.success is True
+        spy.build_launch_command.assert_not_called()
+        spy.launch.assert_not_called()

{wade_cli-0.53.0 → wade_cli-0.53.1}/tests/unit/test_services/test_plan_service.py

@@ -1170,7 +1170,7 @@ class TestOfferToImplement:
             result = _offer_to_implement("42")
 
             assert result is True
-            mock_start.assert_called_once_with(target="42")
+            mock_start.assert_called_once_with(target="42", plan_handoff=True)
 
     def test_user_declines_returns_none(self) -> None:
         """Declining the prompt returns None without flushing or starting."""

{wade_cli-0.53.0 → wade_cli-0.53.1}/tests/unit/test_utils/test_terminal_launch.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import subprocess
+from pathlib import Path
 from unittest.mock import Mock
 
 import pytest
@@ -272,6 +273,45 @@ def test_create_temp_script_content(monkeypatch: pytest.MonkeyPatch) -> None:
     assert "exec" in script
 
 
+def test_readiness_script_reports_failed_when_child_exits_immediately(tmp_path: Path) -> None:
+    """A broker success is rejected when its child cannot stay alive."""
+    from wade.utils.terminal import _create_readiness_script
+
+    readiness_file = tmp_path / "launch.ready"
+    readiness_file.touch()
+    launcher_script = _create_readiness_script(
+        ["bash", "-c", "exit 1"],
+        str(tmp_path),
+        str(readiness_file),
+    )
+    try:
+        completed = subprocess.run([launcher_script], capture_output=True, check=False)
+    finally:
+        Path(launcher_script).unlink(missing_ok=True)
+
+    assert completed.returncode == 1
+    assert readiness_file.read_text() == "failed\n"
+
+
+def test_readiness_script_reports_ready_for_a_live_child(tmp_path: Path) -> None:
+    """A child that survives the stability window confirms the handoff."""
+    from wade.utils.terminal import _create_readiness_script, _wait_for_launch_readiness
+
+    readiness_file = tmp_path / "launch.ready"
+    readiness_file.touch()
+    launcher_script = _create_readiness_script(
+        ["bash", "-c", "sleep 1"],
+        str(tmp_path),
+        str(readiness_file),
+    )
+    process = subprocess.Popen([launcher_script])
+    try:
+        assert _wait_for_launch_readiness(str(readiness_file), timeout=2.0) is True
+        assert process.wait(timeout=2.0) == 0
+    finally:
+        Path(launcher_script).unlink(missing_ok=True)
+
+
 # ---------------------------------------------------------------------------
 # Batch launcher tests
 # ---------------------------------------------------------------------------