meridian-cli 0.3.34__tar.gz → 0.3.35__tar.gz

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meridian-cli
-Version: 0.3.34
+Version: 0.3.35
 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

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.3.34"
+__version__ = "0.3.35"

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/cli/spawn_inject.py

@@ -6,13 +6,20 @@ import asyncio
 import errno
 import json
 import sys
+import time
 from typing import cast
 
+from meridian.lib.core.spawn_lifecycle import ACTIVE_SPAWN_STATUSES
 from meridian.lib.ops.runtime import (
     resolve_runtime_root,
     resolve_runtime_root_and_config,
 )
 from meridian.lib.platform import IS_WINDOWS
+from meridian.lib.state import spawn_store
+
+_INJECT_RESPONSE_TIMEOUT_SECONDS = 30.0
+_ENDPOINT_DISCOVERY_TIMEOUT_SECONDS = 30.0
+_ENDPOINT_DISCOVERY_POLL_SECONDS = 0.1
 
 
 def _fail(message: str) -> None:
@@ -55,7 +62,9 @@ async def _send_and_receive(
     try:
         writer.write((json.dumps(request, separators=(",", ":")) + "\n").encode("utf-8"))
         await writer.drain()
-        return await asyncio.wait_for(reader.readline(), timeout=10.0)
+        return await asyncio.wait_for(
+            reader.readline(), timeout=_INJECT_RESPONSE_TIMEOUT_SECONDS
+        )
     finally:
         writer.close()
         await writer.wait_closed()
@@ -87,19 +96,18 @@ async def inject_message(
     if not normalized_message:
         _fail("message is required")
 
-    # The control socket/port may not be visible immediately after spawn start.
-    # Retry briefly to tolerate the startup race.
-    _SOCKET_WAIT_ATTEMPTS = 3
-    _SOCKET_WAIT_INTERVAL = 1.0
-
     discovery_path = port_file if IS_WINDOWS else socket_path
-    for _attempt in range(_SOCKET_WAIT_ATTEMPTS):
+    discovery_deadline = time.monotonic() + _ENDPOINT_DISCOVERY_TIMEOUT_SECONDS
+    while True:
+        record = spawn_store.get_spawn(runtime_root, normalized_spawn_id)
+        if record is None or record.status not in ACTIVE_SPAWN_STATUSES:
+            _fail(f"spawn not running: {normalized_spawn_id} has no control endpoint")
         if discovery_path.exists():
             break
-        if _attempt < _SOCKET_WAIT_ATTEMPTS - 1:
-            await asyncio.sleep(_SOCKET_WAIT_INTERVAL)
-    else:
-        _fail(f"spawn not running: {normalized_spawn_id} has no control endpoint")
+        remaining = discovery_deadline - time.monotonic()
+        if remaining <= 0:
+            _fail(f"spawn not running: {normalized_spawn_id} has no control endpoint")
+        await asyncio.sleep(min(_ENDPOINT_DISCOVERY_POLL_SECONDS, remaining))
 
     request: dict[str, str] = {"type": "user_message", "text": normalized_message}
 

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/lib/core/clock.py

@@ -19,4 +19,4 @@ class RealClock:
         return time.time()
 
     def utc_now_iso(self) -> str:
-        return datetime.now(UTC).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+        return datetime.now(UTC).isoformat(timespec="milliseconds").replace("+00:00", "Z")

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/lib/harness/connections/.context/CONTEXT.md

@@ -31,6 +31,13 @@ connection validates this (`_validate_initial_prompt_requirement()`) and enforce
 30-second timeout for the first stdout event after the prompt
 (`_FIRST_STDOUT_AFTER_INITIAL_PROMPT_TIMEOUT_SECONDS`).
 
+**Pi injected prompts are acknowledged commands.** Every prompt carries an RPC `id`
+and `streamingBehavior: "followUp"`; the field is valid whether Pi is busy or idle.
+Injected prompts wait for the matching `response` before `send_user_message()` returns.
+A rejected inject is annotated as control-action response evidence, persisted, and
+reported to the injector without becoming a terminal event for the running spawn.
+Initial-prompt rejection remains spawn-fatal.
+
 **`opencode_http.py` imports `OPENCODE_CONFIG_CONTENT_ENV` from
 `meridian.lib.launch.workspace_projection`** to preserve the required bootstrap
 dependency direction; see [launch context](../../../launch/.context/CONTEXT.md).

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/lib/harness/connections/pi_rpc.py

@@ -68,6 +68,7 @@ _PI_SPAWNED_PROMPT_REQUIRED_REASON: Final[str] = "pi_rpc_spawned_prompt_required
 _FIRST_STDOUT_AFTER_INITIAL_PROMPT_TIMEOUT_SECONDS: Final[float] = 30.0
 _BLOCKED_CHILD_ENV_VARS: Final[frozenset[str]] = BLOCKED_CHILD_ENV_VARS
 _PI_SESSION_DIR_FLAG: Final[str] = "--session-dir"
+PI_SUBPROCESS_EXIT_ERROR_PREFIX: Final[str] = "Pi subprocess exited with code "
 _PI_CHILD_WAVE_TIMEOUT_MS_ENV: Final[str] = "MERIDIAN_PI_CHILD_WAVE_TIMEOUT_MS"
 _PI_TASK_PING_INTERVAL_MS_ENV: Final[str] = "MERIDIAN_PI_TASK_PING_INTERVAL_MS"
 _PI_TASK_PING_RESET_ON_ACTIVITY_ENV: Final[str] = "MERIDIAN_PI_TASK_PING_RESET_ON_ACTIVITY"
@@ -76,6 +77,16 @@ _STREAM_EOF_KIND: Final[Literal["eof"]] = "eof"
 _STREAM_ERROR_KIND: Final[Literal["error"]] = "error"
 
 
+def pi_subprocess_exit_error(return_code: int) -> str:
+    """Return the canonical failure emitted for a non-zero Pi process exit."""
+    return f"{PI_SUBPROCESS_EXIT_ERROR_PREFIX}{return_code}."
+
+
+def is_pi_subprocess_exit_error(error: str | None) -> bool:
+    """Whether an error originated from the canonical Pi process-exit failure."""
+    return error is not None and error.startswith(PI_SUBPROCESS_EXIT_ERROR_PREFIX)
+
+
 class PiRpcConnection(HarnessConnection[ResolvedLaunchSpec]):
     """Full-duplex Pi RPC connection over JSONL stdio."""
 
@@ -126,6 +137,8 @@ class PiRpcConnection(HarnessConnection[ResolvedLaunchSpec]):
         self._launch_cwd: str | None = None
         self._launch_session_role: str | None = None
         self._events_stream_active = False
+        self._prompt_command_seq = 0
+        self._pending_prompt_acks: dict[str, asyncio.Future[None]] = {}
 
     @property
     def state(self) -> ConnectionState:
@@ -250,11 +263,28 @@ class PiRpcConnection(HarnessConnection[ResolvedLaunchSpec]):
         return self._state == "connected"
 
     async def send_user_message(self, text: str) -> None:
+        await self._send_prompt(text, wait_for_ack=True)
+
+    async def _send_prompt(self, text: str, *, wait_for_ack: bool) -> None:
+        command_id = f"meridian-prompt-{self._prompt_command_seq}"
+        self._prompt_command_seq += 1
         payload: dict[str, object] = {
+            "id": command_id,
             "type": "prompt",
             "message": text,
+            "streamingBehavior": "followUp",
         }
-        await self._send_rpc_message(payload, event="prompt")
+        if not wait_for_ack:
+            await self._send_rpc_message(payload, event="prompt")
+            return
+
+        ack = asyncio.get_running_loop().create_future()
+        self._pending_prompt_acks[command_id] = ack
+        try:
+            await self._send_rpc_message(payload, event="prompt")
+            await ack
+        finally:
+            self._pending_prompt_acks.pop(command_id, None)
 
     async def send_steer(self, text: str) -> None:
         payload: dict[str, object] = {
@@ -381,7 +411,7 @@ class PiRpcConnection(HarnessConnection[ResolvedLaunchSpec]):
                         break
                     if return_code != 0 and self._state not in {"stopping", "stopped"}:
                         detail = self._failure_detail_with_stderr(
-                            f"Pi subprocess exited with code {return_code}."
+                            pi_subprocess_exit_error(return_code)
                         )
                         self._mark_failed(detail)
                         yield self._error_event(detail)
@@ -622,6 +652,10 @@ class PiRpcConnection(HarnessConnection[ResolvedLaunchSpec]):
                 raw_line=payload_text,
             )
 
+        if normalized_type == "response" and self._resolve_prompt_ack(payload):
+            payload = dict(payload)
+            payload["meridian_control_action"] = "inject"
+
         return HarnessEvent(
             event_type=normalized_type,
             payload=payload,
@@ -629,6 +663,27 @@ class PiRpcConnection(HarnessConnection[ResolvedLaunchSpec]):
             raw_text=line,
         )
 
+    def _resolve_prompt_ack(self, payload: dict[str, object]) -> bool:
+        if str(payload.get("command", "")).strip().lower() != "prompt":
+            return False
+        command_id = payload.get("id")
+        if not isinstance(command_id, str):
+            return False
+        pending = self._pending_prompt_acks.get(command_id)
+        if pending is None or pending.done():
+            return False
+        if payload.get("success") is True:
+            pending.set_result(None)
+        else:
+            error = payload.get("error")
+            detail = (
+                error.strip()
+                if isinstance(error, str) and error.strip()
+                else "pi_prompt_rejected"
+            )
+            pending.set_exception(RuntimeError(detail))
+        return True
+
     def _has_unsupported_lifecycle_schema_version(
         self,
         *,
@@ -713,7 +768,7 @@ class PiRpcConnection(HarnessConnection[ResolvedLaunchSpec]):
         if not prompt.strip():
             self._initial_prompt_sent = True
             return False
-        await self.send_user_message(prompt)
+        await self._send_prompt(prompt, wait_for_ack=False)
         self._initial_prompt_sent = True
         return True
 
@@ -785,6 +840,7 @@ class PiRpcConnection(HarnessConnection[ResolvedLaunchSpec]):
         )
 
     async def _cleanup_resources(self, *, terminate_process: bool) -> bool:
+        self._fail_pending_prompt_acks()
         stop_escalated = False
         if terminate_process:
             stop_escalated = await self._terminate_process()
@@ -792,6 +848,15 @@ class PiRpcConnection(HarnessConnection[ResolvedLaunchSpec]):
             self._close_log_handles()
         return stop_escalated
 
+    def _fail_pending_prompt_acks(self) -> None:
+        for pending in self._pending_prompt_acks.values():
+            if not pending.done():
+                pending.set_exception(
+                    ConnectionNotReady(
+                        "Pi RPC connection closed before prompt acknowledgement."
+                    )
+                )
+
     async def _terminate_process(self) -> bool:
         process = self._process
         if process is None:

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/lib/harness/semantics.py

@@ -218,7 +218,8 @@ def terminal_outcome(
 
     if event.harness_id == HarnessId.PI.value and event.event_type == "response":
         command = str(event.payload.get("command", "")).strip().lower()
-        if command == "prompt" and event.payload.get("success") is False:
+        is_inject_response = event.payload.get("meridian_control_action") == "inject"
+        if command == "prompt" and event.payload.get("success") is False and not is_inject_response:
             error = _stringify_terminal_error(event.payload.get("error")) or "pi_prompt_rejected"
             return TerminalEventOutcome(status="failed", exit_code=1, error=error)
 

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/lib/launch/report.py

@@ -203,7 +203,8 @@ def _pi_failure_from_payload(payload: dict[str, object]) -> str | None:
     event_type = _event_name(payload)
     if event_type == "response":
         command = str(payload.get("command", "")).strip().lower()
-        if command == "prompt" and payload.get("success") is False:
+        is_inject_response = payload.get("meridian_control_action") == "inject"
+        if command == "prompt" and payload.get("success") is False and not is_inject_response:
             error = _text_from_value(payload.get("error"))
             return error or "pi_prompt_rejected"
     if event_type == _PI_LIFECYCLE_PHASE_EVENT:

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/lib/launch/streaming_runner.py

@@ -780,10 +780,9 @@ async def _run_streaming_attempt(
             timed_out = True
             await manager.stop_spawn(
                 run.spawn_id,
-                status="failed",
+                status="timed_out",
                 exit_code=3,
                 error="timeout",
-                prefer_drain_outcome=True,
             )
             drain_exit_code = 3
         elif decision.trigger == TriggerKind.WATCHDOG:

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/lib/state/history.py

@@ -8,6 +8,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, cast
 
+from meridian.lib.core.clock import Clock, RealClock
 from meridian.lib.harness.connections.base import HarnessEvent
 from meridian.lib.state.atomic import append_text_line
 from meridian.lib.state.managed_primary import ManagedPrimaryCausalTracker
@@ -27,6 +28,7 @@ class HarnessHistoryWriter:
     """Append-only writer for seq-enveloped raw harness events."""
 
     history_path: Path
+    clock: Clock = field(default_factory=RealClock)
     _seq: int = field(default=0, init=False)
     _byte_offset: int = field(default=0, init=False)
     _causal_tracker: ManagedPrimaryCausalTracker = field(
@@ -60,6 +62,7 @@ class HarnessHistoryWriter:
         envelope = {
             "seq": self._seq,
             "byte_offset": self._byte_offset,
+            "timestamp": self.clock.utc_now_iso(),
             "turn_id": causal.turn_id,
             "item_id": causal.item_id,
             "request_id": causal.request_id,
@@ -211,6 +214,7 @@ def strip_seq_envelope(envelope: dict[str, Any]) -> dict[str, Any]:
         not in (
             "seq",
             "byte_offset",
+            "timestamp",
             "turn_id",
             "item_id",
             "request_id",

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/lib/state/spawn/model.py

@@ -99,6 +99,7 @@ class SpawnRecord(BaseModel):
     error: str | None
     terminal_origin: SpawnOrigin | None
     launch_policy_snapshot: LaunchPolicySnapshot | None = None
+    published_at: str | None = None
 
 
 __all__ = [

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/lib/state/spawn/repository.py

@@ -75,6 +75,7 @@ class StoredSpawnState(BaseModel):
     runner_exit_at: str | None = None
     cancel_intent: CancelIntent | None = None
     finished_at: str | None = None
+    published_at: str | None = None
     exit_code: int | None = None
     duration_secs: float | None = None
     total_cost_usd: float | None = None
@@ -150,6 +151,7 @@ def record_to_stored_state(
         runner_exit_at=record.runner_exit_at,
         cancel_intent=record.cancel_intent,
         finished_at=record.finished_at,
+        published_at=record.published_at,
         exit_code=record.exit_code,
         duration_secs=record.duration_secs,
         total_cost_usd=record.total_cost_usd,
@@ -210,6 +212,7 @@ def stored_state_to_record(
         runner_exit_at=stored.runner_exit_at,
         cancel_intent=stored.cancel_intent,
         finished_at=stored.finished_at,
+        published_at=stored.published_at,
         exit_code=stored.exit_code,
         duration_secs=stored.duration_secs,
         total_cost_usd=stored.total_cost_usd,

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/lib/state/spawn/transitions.py

@@ -116,6 +116,7 @@ def apply_finalize(
     *,
     origin: SpawnOrigin,
     finished_at: str,
+    published_at: str,
     duration_secs: float | None = None,
     usage: TokenUsage | None = None,
     error: str | None = None,
@@ -135,6 +136,7 @@ def apply_finalize(
             "status": status,
             "exit_code": exit_code,
             "finished_at": finished_at,
+            "published_at": published_at,
             "duration_secs": duration_secs,
             "total_cost_usd": usage.total_cost_usd if usage is not None else None,
             "input_tokens": usage.input_tokens if usage is not None else None,

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/lib/state/spawn_store.py

@@ -691,12 +691,14 @@ def finalize_spawn(
             )
             raise _FinalizeRejected(current)
         was_active = is_active_spawn_status(current.status)
+        published_at = resolved_clock.utc_now_iso()
         return apply_finalize(
             current,
             status,
             exit_code,
             origin=origin,
-            finished_at=finished_at or resolved_clock.utc_now_iso(),
+            finished_at=finished_at or published_at,
+            published_at=published_at,
             duration_secs=duration_secs,
             usage=usage,
             error=error,

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/lib/streaming/.context/CONTEXT.md

@@ -29,8 +29,12 @@ SpawnSession
   ├─ control_server: ControlSocketServer
   ├─ completion_future: Future[DrainOutcome]
   ├─ teardown: DrainSessionTeardown
+  ├─ drain_plan: DrainPlan           ← full plan for terminal publication
   ├─ cancel_sent: bool               ← double-cancel guard
-  └─ control_actions: ControlActionCoordinator
+  ├─ control_actions: ControlActionCoordinator
+  ├─ authoritative_stop_outcome: DrainOutcome | None  ← explicit stop intent
+  ├─ terminal_published: bool        ← idempotent publication guard
+  └─ cleanup_task: Task | None       ← per-spawn post-publication teardown
 ```
 
 The implementation is split by responsibility:
@@ -98,15 +102,24 @@ so resident and plain drain paths never see it as a parent completion candidate.
 `PrimaryEventScope` is the only scope contract passed through the drain stack; do
 not preserve or add compatibility side channels such as a Codex-only thread-id path.
 
-### DrainOutcome Priority
+### DrainOutcome Classification
 
-When the drain loop exits, the outcome is determined in this order:
+The drain loop classifies its outcome, but does not own publication.
+Classification order:
 
-1. `asyncio.CancelledError` raised → `cancelled`
-2. Unhandled exception → `failed`
-3. `session.cancel_sent` is True → `cancelled` (exit code 143)
-4. `recorded_terminal_outcome` from harness → use its status/exit_code/error
-5. Connection closed without a terminal event → `failed` with `connection_closed_without_terminal_event`
+1. `recorded_terminal_outcome` with `status == "succeeded"` → `succeeded`
+   (success takes priority over cancellation)
+2. `asyncio.CancelledError` raised → `cancelled`
+3. Unhandled exception → `failed`
+4. `session.cancel_sent` is True → `cancelled` (exit code 143)
+5. Non-success `recorded_terminal_outcome` from harness → use its status/exit_code/error
+6. Connection closed without a terminal event → `failed` with `connection_closed_without_terminal_event`
+
+After classification, `SpawnManager._publish_terminal()` applies
+`resolve_terminal_outcome()` which resolves competing sources: success wins;
+otherwise an authoritative stop outcome (from `stop_spawn()`) wins; otherwise the
+drain classification stands. Publication is idempotent — `terminal_published` on
+`SpawnSession` guards against double publication.
 
 ### Subscriber Queue Backpressure
 
@@ -122,6 +135,18 @@ concurrent `start_spawn` calls from different event loops.
 
 ### Terminal Publication and Recovery
 
+`SpawnManager._publish_terminal()` is the idempotent barrier that owns terminal
+lifecycle publication. It resolves competing terminal sources via
+`resolve_terminal_outcome()` (success > authoritative stop > drain classification),
+runs the plan finalizer, resolves the completion future, notifies observers, and
+starts one per-spawn cleanup task. Both the drain loop's natural exit path and
+`stop_spawn()` call it; the `terminal_published` guard ensures exactly one publication.
+
+Cleanup tasks are keyed per spawn (`_cleanup_tasks: dict[SpawnId, Task]`).
+`stop_spawn()` awaits only its own spawn's cleanup. `shutdown()` drains all
+remaining cleanup tasks. This prevents cross-spawn coupling where stopping one
+spawn would block on another's unrelated cleanup.
+
 Terminal outcomes publish before plan-owned teardown runs asynchronously and best-effort;
 startup reaper reconciliation recovers incomplete cleanup. Completion deadlines use
 process-local monotonic time and are not persisted or crash-stable.

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/lib/streaming/AGENTS.md

@@ -68,6 +68,10 @@ fail, or clear signals for the parent.
 inject, interrupt, permission reply, and user-input-reply actions. Calling the
 connection directly breaks this serialization.
 
+**Terminal publication belongs to `SpawnManager`.** The drain loop supplies its
+classification, but `stop_spawn()` must still publish the finalized lifecycle row,
+resolve completion, and start that spawn's cleanup when a bounded drain is cancelled.
+
 **Drain loop ordering is not negotiable: persist → observe → fan-out.** A failed
 write — including the tenth consecutive failure that aborts the loop with a
 `failed` outcome — is never delivered to the coordinator, observers, or the
@@ -110,7 +114,7 @@ means the manager died or the spawn is orphaned.
 
 - `spawn_manager.py` — `SpawnManager`: public live-spawn registry/control API
 - `spawn_dispatch.py` — connection creation/start dispatch
-- `spawn_drain_loop.py` — event drain, persistence/observer/fan-out ordering, outcome priority
+- `spawn_drain_loop.py` — event drain, persistence/observer/fan-out ordering, outcome classification, `resolve_terminal_outcome` priority resolver
 - `drain_coordinator.py` — `DrainCoordinator` protocol seam for harness-specific completion policy
 - `drain_plan_factory.py` — plain/resident/Pi plan selection and capability wiring
 - `drain_teardown.py` — harness-neutral plan-owned connection-stop contract and default

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/lib/streaming/drain_wait.py

@@ -3,14 +3,16 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 from collections.abc import AsyncIterator
-from contextlib import suppress
 from dataclasses import dataclass
 from typing import Any
 
 from meridian.lib.harness.connections.base import HarnessEvent
 from meridian.lib.streaming.drain_coordinator import AuxWakeCoordinator
 
+logger = logging.getLogger(__name__)
+
 
 @dataclass(frozen=True)
 class DrainEventWake:
@@ -43,9 +45,12 @@ class DrainInputWaiter:
         self,
         events_iter: AsyncIterator[HarnessEvent],
         aux_wake: AuxWakeCoordinator,
+        *,
+        task_context: str = "drain input",
     ) -> None:
         self._events_iter = events_iter
         self._aux_wake = aux_wake
+        self._task_context = task_context
         self._pending_event_task: asyncio.Future[HarnessEvent] | None = None
         self._pending_disk_task: asyncio.Task[None] | None = None
 
@@ -98,7 +103,7 @@ class DrainInputWaiter:
             self._pending_event_task = None
             return DrainClosedWake()
         finally:
-            await _cancel_task(timeout_task)
+            await _cancel_task(timeout_task, task_context=f"{self._task_context} timeout")
 
     def _consume_ready_disk_change(self) -> bool:
         if self._pending_disk_task is None or not self._pending_disk_task.done():
@@ -108,13 +113,47 @@ class DrainInputWaiter:
         return True
 
     async def close(self) -> None:
-        await _cancel_task(self._pending_event_task)
-        await _cancel_task(self._pending_disk_task)
-
-
-async def _cancel_task(task: asyncio.Future[Any] | None) -> None:
-    if task is None or task.done():
+        await _cancel_task(
+            self._pending_event_task,
+            task_context=f"{self._task_context} event source",
+        )
+        await _cancel_task(
+            self._pending_disk_task,
+            task_context=f"{self._task_context} auxiliary wake",
+        )
+
+
+async def _cancel_task(
+    task: asyncio.Future[Any] | None,
+    *,
+    task_context: str = "drain task",
+) -> None:
+    if task is None:
+        return
+    if task.done():
+        if task.cancelled():
+            return
+        try:
+            task.result()
+        except (StopAsyncIteration, asyncio.CancelledError):
+            pass
+        except Exception as exc:
+            logger.warning(
+                "Unexpected %s failure while closing: %s",
+                task_context,
+                exc,
+                exc_info=True,
+            )
         return
     task.cancel()
-    with suppress(asyncio.CancelledError):
+    try:
         await task
+    except (StopAsyncIteration, asyncio.CancelledError):
+        pass
+    except Exception as exc:
+        logger.warning(
+            "Unexpected %s failure while closing: %s",
+            task_context,
+            exc,
+            exc_info=True,
+        )

{meridian_cli-0.3.34 → meridian_cli-0.3.35}/src/meridian/lib/streaming/pi_completion_profile.py

@@ -9,6 +9,7 @@ from typing import TYPE_CHECKING, Protocol
 
 from meridian.lib.core.domain import SpawnStatus
 from meridian.lib.core.types import SpawnId
+from meridian.lib.harness.connections.pi_rpc import is_pi_subprocess_exit_error
 from meridian.lib.harness.pi_lifecycle_events import pi_notification_id
 from meridian.lib.state.spawn_signals import consume_resident_signals
 from meridian.lib.streaming.completion_contracts import (
@@ -266,8 +267,15 @@ class PiCompletionProfile:
         recorded_outcome: TerminalEventOutcome | None,
     ) -> ProfileExitDecision:
         del state
-        pending_children = self.pending_children_at_exit()
-        if pending_children and recorded_outcome is None:
+        pending_tracked_work = self.pending_children_at_exit()
+        if pending_tracked_work and (
+            recorded_outcome is None
+            or (
+                recorded_outcome.status == "failed"
+                and recorded_outcome.exit_code == 1
+                and is_pi_subprocess_exit_error(recorded_outcome.error)
+            )
+        ):
             recorded_outcome = _terminal_outcome(
                 status="failed",
                 exit_code=1,
@@ -277,7 +285,9 @@ class PiCompletionProfile:
             recorded_outcome=recorded_outcome,
             fallback_error=self.fallback_error_without_recorded_outcome(),
             cleanup_reason=(
-                "pi_process_exit_with_tracked_children" if pending_children else None
+                "pi_process_exit_with_tracked_children"
+                if pending_tracked_work
+                else None
             ),
         )
 
@@ -344,7 +354,14 @@ class PiCompletionProfile:
         return None
 
     def pending_children_at_exit(self) -> bool:
-        return self.quiescence_enabled and self.evidence.has_pending_children()
+        if not self.quiescence_enabled:
+            return False
+        work = self.evidence.classify_outstanding_work()
+        return (
+            work.spawn_children
+            or work.unknown_spawn_children
+            or work.non_spawn_processes
+        )
 
     def fallback_error_without_recorded_outcome(self) -> str | None:
         return self.tracker.notification_failure_error