meridian-cli 0.3.28__tar.gz → 0.3.30__tar.gz

{meridian_cli-0.3.28 → meridian_cli-0.3.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meridian-cli
-Version: 0.3.28
+Version: 0.3.30
 Summary: Orchestrate CLI + MCP server for multi-model agent workflows
 Project-URL: Homepage, https://github.com/haowjy/meridian-cli
 Project-URL: Repository, https://github.com/haowjy/meridian-cli
@@ -24,7 +24,7 @@ Requires-Dist: coolname>=4.0.0
 Requires-Dist: cyclopts>=3.0
 Requires-Dist: fastapi>=0.115
 Requires-Dist: markdown-it-py>=4.0
-Requires-Dist: mars-agents==0.10.3
+Requires-Dist: mars-agents==0.10.5
 Requires-Dist: mcp>=1.0
 Requires-Dist: pathspec>=1.1.0
 Requires-Dist: psutil>=7.2.2

{meridian_cli-0.3.28 → meridian_cli-0.3.30}/pyproject.toml

@@ -24,7 +24,7 @@ dependencies = [
   "cyclopts>=3.0",
   "fastapi>=0.115",
   "markdown-it-py>=4.0",
-  "mars-agents==0.10.3",
+  "mars-agents==0.10.5",
   "mcp>=1.0",
   "pathspec>=1.1.0",
   "psutil>=7.2.2",

{meridian_cli-0.3.28 → meridian_cli-0.3.30}/src/meridian/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.3.28"
+__version__ = "0.3.30"

{meridian_cli-0.3.28 → meridian_cli-0.3.30}/src/meridian/lib/harness/codex.py

@@ -271,6 +271,7 @@ class CodexAdapter(BaseHarnessAdapter[ResolvedLaunchSpec]):
             "mcp_tools",
             "projected_roots",
             "control_root",
+            "agent",
             "adhoc_agent_payload",
             "appended_system_prompt",
             "user_turn_content",
@@ -279,7 +280,6 @@ class CodexAdapter(BaseHarnessAdapter[ResolvedLaunchSpec]):
     _EXPLICITLY_IGNORED_FIELDS: ClassVar[frozenset[str]] = frozenset(
         {
             "skills",
-            "agent",
             "context_from_payload",
             "reference_items",
             "task_cwd",
@@ -382,6 +382,7 @@ class CodexAdapter(BaseHarnessAdapter[ResolvedLaunchSpec]):
             interactive=run.interactive,
             mcp_tools=run.mcp_tools,
             projected_roots=run.projected_roots,
+            agent_name=run.agent,
             base_instructions=run.adhoc_agent_payload.strip() or None,
             developer_instructions=run.appended_system_prompt,
             user_turn_content=run.user_turn_content,

{meridian_cli-0.3.28 → meridian_cli-0.3.30}/src/meridian/lib/harness/connections/codex_ws.py

@@ -76,7 +76,7 @@ from meridian.lib.observability.trace_helpers import (
     trace_state_change,
     trace_wire_send,
 )
-from meridian.lib.platform.detached_process import ParentDeathLink
+from meridian.lib.platform.detached_process import ParentDeathLink, release_parent_death_link
 from meridian.lib.platform.process_scope import (
     ProcessScopeSnapshot,
     ScopedProcessHandle,
@@ -240,6 +240,8 @@ class CodexConnection(HarnessConnection[ResolvedLaunchSpec]):
         self._current_turn_id: str | None = None
         self._thread_id: str | None = None
         self._main_turn_thread_id: str | None = None
+        self._last_completed_turn_id: str | None = None
+        self._turn_completed_event = asyncio.Event()
         self._tracer: DebugTracer | None = None
         self._cancel_requested = False
         self._signal_in_flight = False
@@ -361,6 +363,8 @@ class CodexConnection(HarnessConnection[ResolvedLaunchSpec]):
         self._current_turn_id = None
         self._thread_id = None
         self._main_turn_thread_id = None
+        self._last_completed_turn_id = None
+        self._turn_completed_event.clear()
         self._liveness.reset()
         self._cancel_requested = False
         self._signal_in_flight = False
@@ -440,14 +444,8 @@ class CodexConnection(HarnessConnection[ResolvedLaunchSpec]):
                 # Fresh primary sessions need a bootstrap turn to materialize the
                 # Codex rollout before the TUI can attach. Without this, Codex
                 # cannot resume a fresh thread because no rollout file exists.
-                #
-                # The load-bearing requirement is "thread is attachable", not
-                # "bootstrap response is semantically complete". We gate on
-                # rollout materialization because that is the earliest observed
-                # durable signal that `codex resume --remote` can attach.
-                # Do not optimize this by mutating Codex model/reasoning defaults.
                 self._emit_startup_phase(StartupPhase.INITIALIZING_SESSION)
-                await self._send_bootstrap_turn_and_wait()
+                await self._send_bootstrap_turn_and_wait(agent_name=spec.agent_name)
 
             self._transition("connected")
             self._liveness.mark_activity()
@@ -847,6 +845,7 @@ class CodexConnection(HarnessConnection[ResolvedLaunchSpec]):
                 process.kill()
                 await process.wait()
 
+        await asyncio.to_thread(release_parent_death_link, self._parent_death_link)
         self._parent_death_link = None
         self._fail_pending_requests(RuntimeError("Codex connection stopped"))
         await self._clear_stale_hitl_requests(reason="connection_stopped")
@@ -1198,7 +1197,7 @@ class CodexConnection(HarnessConnection[ResolvedLaunchSpec]):
             raise RuntimeError("Codex connection config is unavailable")
         return config.control_root
 
-    async def _send_bootstrap_turn_and_wait(self) -> None:
+    async def _send_bootstrap_turn_and_wait(self, *, agent_name: str | None) -> None:
         """Send a minimal bootstrap turn and wait for completion.
 
         This materializes the Codex rollout file so the TUI can later attach
@@ -1208,23 +1207,32 @@ class CodexConnection(HarnessConnection[ResolvedLaunchSpec]):
         attachability gate, not by mutating user-visible Codex defaults.
         """
         thread_id = self._require_thread_id("bootstrap_turn")
-        await self._request(
+        normalized_agent = (agent_name or "").strip()
+        prompt = _BOOTSTRAP_TURN_PROMPT
+        if normalized_agent:
+            prompt = f"{prompt} (agent: {normalized_agent})"
+        result = await self._request(
             "turn/start",
             {
                 "threadId": thread_id,
-                "input": _build_text_user_input(_BOOTSTRAP_TURN_PROMPT),
+                "input": _build_text_user_input(prompt),
             },
         )
         await self._wait_for_rollout_materialization()
+        turn_id = (
+            _extract_turn_id(result)
+            or self._current_turn_id
+            or self._last_completed_turn_id
+        )
+        if turn_id is None:
+            raise RuntimeError("Codex bootstrap turn did not provide a turn id")
+        await self._wait_for_turn_completion(turn_id)
 
     async def _wait_for_rollout_materialization(self, timeout_seconds: float = 120.0) -> None:
         """Block until Codex has created an attachable rollout for the thread.
 
-        Fresh primary attach only needs the thread to be resumable by the Codex
-        TUI. The attach-safe signal is a rollout file whose session_meta exists
-        and whose cwd matches this project. We intentionally do not wait for
-        turn/completed and do not change model/effort settings to make bootstrap
-        cheaper.
+        The attach-safe filesystem signal is a rollout file whose session_meta
+        exists and whose cwd matches this project.
         """
         config = self._config
         codex_home = self._codex_home
@@ -1257,6 +1265,31 @@ class CodexConnection(HarnessConnection[ResolvedLaunchSpec]):
             if not process_running or not ws_open:
                 raise RuntimeError("Codex connection lost during bootstrap turn")
 
+    async def _wait_for_turn_completion(
+        self,
+        turn_id: str,
+        timeout_seconds: float = 120.0,
+    ) -> None:
+        """Wait until the observer receives completion for the bootstrap turn."""
+
+        loop = asyncio.get_running_loop()
+        deadline = loop.time() + timeout_seconds
+        while self._last_completed_turn_id != turn_id:
+            self._turn_completed_event.clear()
+            if self._last_completed_turn_id == turn_id:
+                return
+            remaining = deadline - loop.time()
+            if remaining <= 0:
+                raise RuntimeError(
+                    f"Bootstrap turn timed out after {timeout_seconds}s waiting for completion"
+                )
+            try:
+                await asyncio.wait_for(self._turn_completed_event.wait(), timeout=remaining)
+            except TimeoutError as exc:
+                raise RuntimeError(
+                    f"Bootstrap turn timed out after {timeout_seconds}s waiting for completion"
+                ) from exc
+
     async def _bootstrap_thread(self, spec: ResolvedLaunchSpec) -> dict[str, object]:
         method, payload = self._thread_bootstrap_request(spec)
         return await self._request(method, payload)
@@ -1294,7 +1327,9 @@ class CodexConnection(HarnessConnection[ResolvedLaunchSpec]):
             if thread_id is not None:
                 self._main_turn_thread_id = thread_id
         if clears_signal(event, primary_event_scope=self.primary_event_scope):
+            self._last_completed_turn_id = _extract_turn_id(payload) or self._current_turn_id
             self._end_current_turn()
+            self._turn_completed_event.set()
             self._signal_in_flight = False
             self._liveness.signal_request_resolved("cancel")
             return

{meridian_cli-0.3.28 → meridian_cli-0.3.30}/src/meridian/lib/harness/connections/managed_backend.py

@@ -92,7 +92,11 @@ async def launch_managed_backend(
     except (psutil.NoSuchProcess, psutil.AccessDenied):
         birth_time = PROCESS_BIRTH_UNKNOWN_EPOCH
 
-    parent_death_link = link_child_lifetime_to_parent(pid)
+    parent_death_link = (
+        ParentDeathLink(parent_death_linked=False)
+        if subprocess_config.parent_death_linked
+        else link_child_lifetime_to_parent(pid)
+    )
     parent_death_linked = (
         subprocess_config.parent_death_linked or parent_death_link.parent_death_linked
     )

{meridian_cli-0.3.28 → meridian_cli-0.3.30}/src/meridian/lib/harness/connections/opencode_http.py

@@ -69,7 +69,7 @@ from meridian.lib.observability.trace_helpers import (
     trace_wire_recv,
     trace_wire_send,
 )
-from meridian.lib.platform.detached_process import ParentDeathLink
+from meridian.lib.platform.detached_process import ParentDeathLink, release_parent_death_link
 from meridian.lib.platform.process_scope import (
     ProcessScopeSnapshot,
     ScopedProcessHandle,
@@ -1044,6 +1044,7 @@ class OpenCodeConnection(HarnessConnection[ResolvedLaunchSpec]):
                 process.kill()
                 await process.wait()
 
+        await asyncio.to_thread(release_parent_death_link, self._parent_death_link)
         self._parent_death_link = None
         self._base_url = None
         self._session_id = None

{meridian_cli-0.3.28 → meridian_cli-0.3.30}/src/meridian/lib/launch/launch_types.py

@@ -99,7 +99,7 @@ class ResolvedLaunchSpec(BaseModel):
     # All are optional and default to their zero values so unused adapters
     # don't need to set them.
 
-    # Claude + OpenCode
+    # Harness-level agent identity. Codex also shows it in the managed bootstrap turn.
     agent_name: str | None = None
     appended_system_prompt: str | None = None
 

{meridian_cli-0.3.28 → meridian_cli-0.3.30}/src/meridian/lib/launch/process/.context/CONTEXT.md

@@ -20,6 +20,15 @@ handles Windows-specific console inheritance. Subprocess is the portable fallbac
 `captures_output_to_artifact` on `ProcessPlatformContract` is authoritative — callers must
 not assume capture based on launcher type alone.
 
+`ProcessLauncher.start()` returns a `RunningProcess` immediately after process birth.
+PID/scope recording happens before `RunningProcess.wait()` begins the blocking terminal
+relay. Keep those phases separate: managed-primary cancellation depends on having a
+concrete process identity before it can wait for exit or terminate the scope.
+`RunningProcess.cancel_wait()` must release its caller-facing wait even when scope
+termination cannot confirm child exit. Managed attach also directly terminates the
+concrete process as a fallback and bridges the synchronous wait through a daemon thread,
+so an uncooperative relay cannot be re-joined by `asyncio.run()` during loop shutdown.
+
 ## Managed Attach vs Black-Box
 
 `_execute_primary_process()` checks `harness_contract.bootstrap.mode`. When mode is

{meridian_cli-0.3.28 → meridian_cli-0.3.30}/src/meridian/lib/launch/process/ports.py

@@ -19,9 +19,6 @@ class LaunchedProcess:
     pid: int | None
 
 
-ChildStartedHook = Callable[[int], None]
-
-
 class ProcessBackendId(StrEnum):
     """Named launch backends used for local harness process execution."""
 
@@ -48,26 +45,40 @@ class ProcessPlatformContract:
     platform_family: str
 
 
-@dataclass(frozen=True)
-class SelectedProcessLauncher:
-    """Launcher instance paired with its explicit process/platform contract."""
+class RunningProcess(Protocol):
+    """A started primary process whose blocking exit wait is a separate phase."""
 
-    launcher: ProcessLauncher
-    contract: ProcessPlatformContract
+    @property
+    def pid(self) -> int: ...
+
+    def wait(self) -> LaunchedProcess: ...
+
+    def terminate(self) -> None: ...
+
+    def cancel_wait(self) -> None:
+        """Unblock a concurrent wait without assuming the child exited."""
+        ...
 
 
 class ProcessLauncher(Protocol):
-    """Protocol for primary process launch strategies."""
+    """Start a primary process and return as soon as its PID is available."""
 
-    def launch(
+    def start(
         self,
         *,
         command: tuple[str, ...],
         cwd: Path,
         env: dict[str, str],
         output_log_path: Path | None,
-        on_child_started: ChildStartedHook | None = None,
-    ) -> LaunchedProcess: ...
+    ) -> RunningProcess: ...
+
+
+@dataclass(frozen=True)
+class SelectedProcessLauncher:
+    """Launcher instance paired with its explicit process/platform contract."""
+
+    launcher: ProcessLauncher
+    contract: ProcessPlatformContract
 
 
 ProcessLauncherSelector = Callable[[Path | None], ProcessLauncher]
@@ -75,12 +86,12 @@ ProcessLauncherSelector = Callable[[Path | None], ProcessLauncher]
 
 __all__ = [
     "PRIMARY_STDERR_LOG_PATH_ENV",
-    "ChildStartedHook",
     "LaunchedProcess",
     "ProcessBackendId",
     "ProcessLauncher",
     "ProcessLauncherSelector",
     "ProcessPlatformContract",
     "ProcessSurfaceMode",
+    "RunningProcess",
     "SelectedProcessLauncher",
 ]

{meridian_cli-0.3.28 → meridian_cli-0.3.30}/src/meridian/lib/launch/process/primary_attach.py

@@ -13,10 +13,11 @@ from collections.abc import Callable
 from contextlib import suppress
 from dataclasses import dataclass, field, replace
 from pathlib import Path
-from threading import Lock
+from threading import Lock, Thread
 from typing import Any
 
 import psutil
+import structlog
 
 from meridian.lib.core.types import HarnessId, SpawnId
 from meridian.lib.harness.connections.base import ConnectionConfig, HarnessConnection, HarnessEvent
@@ -33,10 +34,46 @@ from meridian.lib.state.history import HarnessHistoryWriter
 from meridian.lib.state.primary_meta import ActivityState, PrimaryMetadata, write_primary_metadata
 from meridian.lib.state.process_scope_projection import record_scope
 
-from .ports import ProcessLauncher
+from .ports import LaunchedProcess, ProcessLauncher, RunningProcess
 
 TuiCommandBuilder = Callable[[str], tuple[str, ...]]
 MAX_PORT_RETRY_ATTEMPTS = 3
+_TUI_LAUNCH_DRAIN_TIMEOUT_SECONDS = 1.0
+_TUI_WAIT_CANCEL_TIMEOUT_SECONDS = 1.0
+
+logger = structlog.get_logger(__name__)
+
+
+def _start_process_wait(running_process: RunningProcess) -> asyncio.Future[LaunchedProcess]:
+    """Run a synchronous terminal relay without joining it during loop shutdown."""
+
+    loop = asyncio.get_running_loop()
+    result_future: asyncio.Future[LaunchedProcess] = loop.create_future()
+
+    def _publish_result(result: LaunchedProcess) -> None:
+        if not result_future.done():
+            result_future.set_result(result)
+
+    def _publish_error(error: BaseException) -> None:
+        if not result_future.done():
+            result_future.set_exception(error)
+
+    def _wait() -> None:
+        try:
+            result = running_process.wait()
+        except BaseException as exc:
+            with suppress(RuntimeError):
+                loop.call_soon_threadsafe(_publish_error, exc)
+            return
+        with suppress(RuntimeError):
+            loop.call_soon_threadsafe(_publish_result, result)
+
+    Thread(
+        target=_wait,
+        name=f"meridian-primary-wait-{running_process.pid}",
+        daemon=True,
+    ).start()
+    return result_future
 
 
 def _make_scope_snapshot(
@@ -209,6 +246,9 @@ class PrimaryAttachLauncher:
         self._history_writer = HarnessHistoryWriter(self._spawn_dir / "history.jsonl")
         connection_started = False
         session_id: str | None = None
+        running_process: RunningProcess | None = None
+        launch_task: asyncio.Future[LaunchedProcess] | None = None
+        tui_lifecycle_finished = False
         telemetry = _StartupTelemetry()
 
         try:
@@ -245,7 +285,6 @@ class PrimaryAttachLauncher:
 
             telemetry.update(f"Attaching {self._connection.harness_id.value.capitalize()} TUI...")
             command = tuple(self._tui_command_builder(session_id))
-            loop = asyncio.get_running_loop()
             running_callback = on_running if on_running is not None else self._on_running
 
             def _handle_running(pid: int) -> None:
@@ -254,19 +293,19 @@ class PrimaryAttachLauncher:
                 if running_callback is not None:
                     running_callback(pid)
 
-            def _on_child_started(pid: int) -> None:
-                loop.call_soon_threadsafe(_handle_running, pid)
-
-            launch_task = asyncio.create_task(
-                asyncio.to_thread(
-                    self._process_launcher.launch,
-                    command=command,
-                    cwd=cwd,
-                    env=env,
-                    output_log_path=None,
-                    on_child_started=_on_child_started,
-                )
+            running_process = self._process_launcher.start(
+                command=command,
+                cwd=cwd,
+                env=env,
+                output_log_path=None,
             )
+            try:
+                _handle_running(running_process.pid)
+            except Exception:
+                running_process.terminate()
+                await _start_process_wait(running_process)
+                raise
+            launch_task = _start_process_wait(running_process)
             telemetry.clear()
 
             writer_task = self._event_writer_task
@@ -281,22 +320,28 @@ class PrimaryAttachLauncher:
                 if self._connection.harness_id is HarnessId.CODEX:
                     # Codex TUI takes over the observer endpoint after attach;
                     # the displaced observer stream closing is normal.
-                    launched = await launch_task
+                    launched = await asyncio.shield(launch_task)
+                    tui_lifecycle_finished = True
                     return PrimaryAttachOutcome(
                         exit_code=launched.exit_code,
                         session_id=session_id,
                         tui_pid=launched.pid,
                     )
                 await self._connection.stop(reason="event_stream_closed")
-                await self._terminate_tui_scope()
-                launched = await launch_task
+                await self._stop_tui_launch_task(
+                    running_process,
+                    launch_task,
+                    reason="event_stream_closed",
+                )
+                tui_lifecycle_finished = True
                 return PrimaryAttachOutcome(
                     exit_code=1,
                     session_id=session_id,
-                    tui_pid=launched.pid,
+                    tui_pid=running_process.pid,
                 )
 
-            launched = await launch_task
+            launched = await asyncio.shield(launch_task)
+            tui_lifecycle_finished = True
 
             return PrimaryAttachOutcome(
                 exit_code=launched.exit_code,
@@ -314,6 +359,16 @@ class PrimaryAttachLauncher:
                 writer_task.cancel()
                 with suppress(asyncio.CancelledError):
                     await writer_task
+            if (
+                running_process is not None
+                and launch_task is not None
+                and not tui_lifecycle_finished
+            ):
+                await self._stop_tui_launch_task(
+                    running_process,
+                    launch_task,
+                    reason="primary_attach_shutdown",
+                )
             if connection_started:
                 await self._connection.stop()
 
@@ -449,7 +504,45 @@ class PrimaryAttachLauncher:
         self._tui_scope_snapshot = snapshot
         record_scope(runtime_root, self._spawn_id, snapshot)
 
-    async def _terminate_tui_scope(self) -> None:
+    async def _stop_tui_launch_task(
+        self,
+        running_process: RunningProcess,
+        launch_task: asyncio.Future[LaunchedProcess],
+        *,
+        reason: str,
+    ) -> None:
+        await self._terminate_tui_scope(reason=reason)
+        try:
+            await asyncio.wait_for(
+                asyncio.shield(launch_task),
+                timeout=_TUI_LAUNCH_DRAIN_TIMEOUT_SECONDS,
+            )
+        except TimeoutError:
+            logger.warning(
+                "primary_attach.tui_drain_timeout",
+                spawn_id=str(self._spawn_id),
+            )
+            running_process.terminate()
+            running_process.cancel_wait()
+            try:
+                await asyncio.wait_for(
+                    asyncio.shield(launch_task),
+                    timeout=_TUI_WAIT_CANCEL_TIMEOUT_SECONDS,
+                )
+            except TimeoutError:
+                logger.error(
+                    "primary_attach.tui_wait_cancel_timeout",
+                    spawn_id=str(self._spawn_id),
+                )
+                launch_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await launch_task
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            pass
+
+    async def _terminate_tui_scope(self, *, reason: str) -> None:
         snapshot = self._tui_scope_snapshot
         if snapshot is None:
             return
@@ -457,7 +550,7 @@ class PrimaryAttachLauncher:
             terminate_scope_sync,
             snapshot,
             grace_seconds=5.0,
-            reason="event_stream_closed",
+            reason=reason,
         )
 
     def _resolve_backend_port(self) -> int | None:

{meridian_cli-0.3.28 → meridian_cli-0.3.30}/src/meridian/lib/launch/process/pty_launcher.py

@@ -8,12 +8,13 @@ import struct
 import sys
 import threading
 from contextlib import ExitStack, suppress
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, BinaryIO, cast
 
 from meridian.lib.platform import IS_WINDOWS, fcntl, pty, select, termios, tty
 
-from .ports import ChildStartedHook, LaunchedProcess, ProcessLauncher
+from .ports import LaunchedProcess, ProcessLauncher
 
 
 def can_use_pty() -> bool:
@@ -78,6 +79,7 @@ def _copy_primary_pty_output(
     child_pid: int,
     master_fd: int,
     output_log_path: Path | None,
+    wait_cancelled: threading.Event | None = None,
 ) -> int:
     stdin_fd = sys.stdin.fileno()
     stdout_fd = sys.stdout.fileno()
@@ -96,10 +98,12 @@ def _copy_primary_pty_output(
                 output_handle = stack.enter_context(output_log_path.open("wb"))
 
             while True:
+                if wait_cancelled is not None and wait_cancelled.is_set():
+                    return 130
                 fds = [master_fd]
                 if stdin_open:
                     fds.append(stdin_fd)
-                ready, _, _ = select.select(fds, [], [])
+                ready, _, _ = select.select(fds, [], [], 0.1)
 
                 if master_fd in ready:
                     try:
@@ -128,18 +132,45 @@ def _copy_primary_pty_output(
     return os.waitstatus_to_exitcode(status)
 
 
+@dataclass
+class _RunningPtyProcess:
+    pid: int
+    master_fd: int
+    output_log_path: Path | None
+    wait_cancelled: threading.Event = field(default_factory=threading.Event)
+
+    def wait(self) -> LaunchedProcess:
+        try:
+            exit_code = _copy_primary_pty_output(
+                child_pid=self.pid,
+                master_fd=self.master_fd,
+                output_log_path=self.output_log_path,
+                wait_cancelled=self.wait_cancelled,
+            )
+            return LaunchedProcess(exit_code=exit_code, pid=self.pid)
+        finally:
+            with suppress(OSError):
+                os.close(self.master_fd)
+
+    def terminate(self) -> None:
+        with suppress(ProcessLookupError):
+            os.kill(self.pid, signal.SIGTERM)
+
+    def cancel_wait(self) -> None:
+        self.wait_cancelled.set()
+
+
 class PtyProcessLauncher(ProcessLauncher):
     """Unix PTY launcher with optional output capture."""
 
-    def launch(
+    def start(
         self,
         *,
         command: tuple[str, ...],
         cwd: Path,
         env: dict[str, str],
         output_log_path: Path | None,
-        on_child_started: ChildStartedHook | None = None,
-    ) -> LaunchedProcess:
+    ) -> _RunningPtyProcess:
         if IS_WINDOWS:
             raise RuntimeError("PTY launcher is not available on Windows")
 
@@ -159,25 +190,11 @@ class PtyProcessLauncher(ProcessLauncher):
                 os._exit(1)
 
         os.close(slave_fd)
-        try:
-            if on_child_started is not None:
-                try:
-                    on_child_started(child_pid)
-                except Exception:
-                    with suppress(ProcessLookupError):
-                        os.kill(child_pid, signal.SIGTERM)
-                    with suppress(ChildProcessError):
-                        os.waitpid(child_pid, 0)
-                    raise
-            exit_code = _copy_primary_pty_output(
-                child_pid=child_pid,
-                master_fd=master_fd,
-                output_log_path=output_log_path,
-            )
-            return LaunchedProcess(exit_code=exit_code, pid=child_pid)
-        finally:
-            with suppress(OSError):
-                os.close(master_fd)
+        return _RunningPtyProcess(
+            pid=child_pid,
+            master_fd=master_fd,
+            output_log_path=output_log_path,
+        )
 
 
 __all__ = [