steerable-agent-runtime 0.6.28__tar.gz → 0.6.30__tar.gz

{steerable_agent_runtime-0.6.28 → steerable_agent_runtime-0.6.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steerable-agent-runtime
-Version: 0.6.28
+Version: 0.6.30
 Summary: Steerable agent runtime: LLM, tool, storage, and transport adapters.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -59,3 +59,11 @@ pip install "steerable-agent-runtime[anthropic]"
 pip install "steerable-agent-runtime[sqlalchemy]"
 pip install "steerable-agent-runtime[fastapi]"
 ```
+
+The CoreLoop defaults to the Rust binding when
+`steerable-agent-runtime-native` is importable (`STEERABLE_RUST_CORELOOP=0`
+keeps the Python loop):
+
+```bash
+pip install steerable-agent-runtime-native
+```

{steerable_agent_runtime-0.6.28 → steerable_agent_runtime-0.6.30}/README.md

@@ -34,3 +34,11 @@ pip install "steerable-agent-runtime[anthropic]"
 pip install "steerable-agent-runtime[sqlalchemy]"
 pip install "steerable-agent-runtime[fastapi]"
 ```
+
+The CoreLoop defaults to the Rust binding when
+`steerable-agent-runtime-native` is importable (`STEERABLE_RUST_CORELOOP=0`
+keeps the Python loop):
+
+```bash
+pip install steerable-agent-runtime-native
+```

{steerable_agent_runtime-0.6.28 → steerable_agent_runtime-0.6.30}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "steerable-agent-runtime"
-version = "0.6.28"
+version = "0.6.30"
 description = "Steerable agent runtime: LLM, tool, storage, and transport adapters."
 readme = "README.md"
 requires-python = ">=3.10"

{steerable_agent_runtime-0.6.28 → steerable_agent_runtime-0.6.30}/src/steerable_agent_runtime/__init__.py

@@ -51,6 +51,7 @@ from .todo import (
     make_todo_write_tool,
     todo_write_tool_descriptor,
 )
+from .delegation_gate import RequiredDelegationGate
 from .config import (
     DEFAULT_CONFIG_PATH,
     ConfigError,
@@ -387,6 +388,7 @@ __all__ = [
     "RecordingProvider",
     "RegisteredTool",
     "RequestSink",
+    "RequiredDelegationGate",
     "RetryAction",
     "RetryHooks",
     "RewriteRequest",

steerable_agent_runtime-0.6.30/src/steerable_agent_runtime/delegation_gate.py

@@ -0,0 +1,100 @@
+"""Required-delegation completion gate.
+
+A host that names sub-agents for a turn (the desktop's ``@`` mentions) can
+only *ask* the model to delegate: the dispatch instruction is prompt text,
+and every existing discipline guard lets a narrated hand-off through. The
+claimed-execution check in ``antihallucination`` fires only on a round with
+no tool calls at all, so a turn that ran unrelated tools and then wrote "I
+launched the three agents" ends ``completed`` with zero delegations.
+
+This gate closes that hole: the host declares which profiles must receive a
+delegation, the gate watches ``delegate_subagent`` calls, and a ``completed``
+draft that skipped one is converted into a retry naming the missing
+profiles.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any
+
+from steerable_agent_protocol.generated import ToolCall, ToolResult
+
+from .hooks import CompletionAction, CompletionDraft, NoopHooks
+
+#: Retries this gate grants before accepting a turn that skipped a profile.
+#: The loop's own completion-redo budget bounds the total; this keeps one
+#: uncooperative model from spending all of it on delegation alone.
+DEFAULT_MAX_RETRIES = 2
+
+
+class RequiredDelegationGate(NoopHooks):
+    """``before_completion`` veto: every required profile must be delegated.
+
+    A profile counts as satisfied once a delegation was *attempted*, whether
+    the child succeeded or not — a child that failed (its own tool error, a
+    budget wall) is the parent's to report, and re-delegating to it would
+    spin. Only a profile the model never called at all blocks finishing.
+
+    One instance per run: it accumulates the turn's delegations.
+    """
+
+    def __init__(
+        self,
+        required_profiles: Iterable[str],
+        *,
+        tool_name: str = "delegate_subagent",
+        max_retries: int = DEFAULT_MAX_RETRIES,
+    ) -> None:
+        """
+        @param required_profiles: profile names that must each receive a
+            delegation; duplicates and blanks are dropped.
+        @param tool_name: the delegation tool to watch.
+        @param max_retries: retries granted before accepting a skip.
+        """
+        self._required = tuple(
+            dict.fromkeys(name.strip() for name in required_profiles if name.strip())
+        )
+        self._tool_name = tool_name
+        self._max_retries = max_retries
+        self._delegated: set[str] = set()
+        self._retries = 0
+
+    async def post_tool_result(
+        self, result: ToolResult, call: ToolCall, ctx: Any
+    ) -> ToolResult:
+        """Record the delegated profile, passing the result through."""
+        if call.name == self._tool_name:
+            profile = str(call.arguments.get("subagent_type") or "").strip()
+            if profile:
+                self._delegated.add(profile)
+        return result
+
+    async def before_completion(
+        self, draft: CompletionDraft, ctx: Any
+    ) -> CompletionAction:
+        """Retry while a required profile has no delegation, else accept.
+
+        Only ``completed`` is gated: ``budget_exhausted`` and error stops have
+        their own continuation paths (the host's auto-continue resumes with a
+        fresh budget), and vetoing them here would fight those.
+        """
+        if draft.status != "completed":
+            return CompletionAction(kind="accept")
+        missing = [name for name in self._required if name not in self._delegated]
+        if not missing or self._retries >= self._max_retries:
+            return CompletionAction(kind="accept")
+        self._retries += 1
+        listing = "、".join(missing)
+        return CompletionAction(
+            kind="retry",
+            message=(
+                f"用户点名的子代理还没拿到任务：{listing}。"
+                "现在就用 delegate_subagent 给每一个补上一份自包含的子任务"
+                "（subagent_type 填画像名），不要用文字描述代替调用。"
+            ),
+            reason="required_delegation_missing",
+        )
+
+
+__all__ = ["DEFAULT_MAX_RETRIES", "RequiredDelegationGate"]

{steerable_agent_runtime-0.6.28 → steerable_agent_runtime-0.6.30}/src/steerable_agent_runtime/loop.py

@@ -545,6 +545,16 @@ class CoreLoop:
         """
         self._compact_event.set()
 
+    @property
+    def record_id(self) -> str | None:
+        """Durable-record id this loop appends to, when one was configured.
+
+        Hosts that want to read a run's transcript back (a pooled child's
+        process view) need the id the loop writes under, not the one they
+        guessed.
+        """
+        return self._record_id
+
     @property
     def last_run_usage(self) -> LLMUsage | None:
         """Accumulated billable usage of the current/last run (W6-9).
@@ -848,12 +858,13 @@ class CoreLoop:
         tools: list[dict[str, Any]] | None = None,
         chat_id: str | None = None,
     ) -> AsyncIterator[LoopEvent]:
-        if os.environ.get("STEERABLE_RUST_CORELOOP") == "1":
-            from .native_bridge import run_native
+        if os.environ.get("STEERABLE_RUST_CORELOOP") != "0":
+            from .native_bridge import run_native, uses_native_coreloop
 
-            async for event in run_native(self, messages, tools=tools, chat_id=chat_id):
-                yield event
-            return
+            if uses_native_coreloop():
+                async for event in run_native(self, messages, tools=tools, chat_id=chat_id):
+                    yield event
+                return
         ctx = LoopContext(chat_id=chat_id)
         self._run_context = ctx
         # The transcript is a projection of the append-only record; nothing

{steerable_agent_runtime-0.6.28 → steerable_agent_runtime-0.6.30}/src/steerable_agent_runtime/native_bridge.py

@@ -1,7 +1,9 @@
 """Drive the Rust CoreLoop from Python via `steerable_agent_runtime_native`.
 
 Python keeps the provider, executor, and hooks (async, GIL-friendly). Rust
-owns think → act → observe. Enabled when ``STEERABLE_RUST_CORELOOP=1``.
+owns think → act → observe. The Rust binding is the default when the
+module is importable; ``STEERABLE_RUST_CORELOOP=0`` forces Python and
+``=1`` still forces Rust.
 """
 
 from __future__ import annotations
@@ -9,6 +11,7 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
+import os
 import queue
 import threading
 import time
@@ -40,7 +43,25 @@ def native_available() -> bool:
     return True
 
 
+def uses_native_coreloop() -> bool:
+    """Prefer Rust when the PyO3 module is importable.
+
+    ``STEERABLE_RUST_CORELOOP=0`` keeps the Python loop. ``=1`` selects
+    Rust even if the caller has not probed availability first (the
+    subsequent import then fails loudly). Unset follows
+    :func:`native_available`.
+    """
+    flag = os.environ.get("STEERABLE_RUST_CORELOOP")
+    if flag == "0":
+        return False
+    if flag == "1":
+        return True
+    return native_available()
+
+
 def _config_json(loop: CoreLoop) -> str:
+    import steerable_agent_runtime.loop as loop_module
+
     config = loop._config
     payload: dict[str, Any] = {
         "max_rounds": config.max_rounds,
@@ -54,6 +75,10 @@ def _config_json(loop: CoreLoop) -> str:
         "wrap_up_max_tool_rounds": config.wrap_up_max_tool_rounds,
         "wrap_up_tool_timeout_ms": config.wrap_up_tool_timeout_ms,
         "wrap_up_hard_cap_ms": config.wrap_up_hard_cap_ms,
+        "idle_stream_timeout_ms": config.idle_stream_timeout_ms,
+        "idle_stream_max_chars": config.idle_stream_max_chars,
+        "reasoning_without_progress_chars": config.reasoning_without_progress_chars,
+        "idle_reasoning_gap_ms": int(loop_module._IDLE_REASONING_GAP_SEC * 1000),
         "steer_mode": config.steer_mode,
     }
     if config.budget is not None:
@@ -167,7 +192,12 @@ async def _collect_stream(
     cancel_flag: threading.Event,
     run_started: float,
     surrogate_mode: list[bool],
-) -> str:
+    output: queue.Queue[str],
+    native_stream_id: str,
+) -> None:
+    def send(kind: str, **payload: Any) -> None:
+        output.put(json.dumps({"kind": kind, **payload}))
+
     request = json.loads(messages_json)
     if isinstance(request, dict):
         message_items = request.get("messages", [])
@@ -183,31 +213,40 @@ async def _collect_stream(
         and message.content_text.startswith("[system notice] The time budget")
         for message in messages
     )
+    stream_kwargs: dict[str, Any] = {}
+    if tool_choice:
+        stream_kwargs["tool_choice"] = tool_choice
+    if loop._config.temperature is not None:
+        stream_kwargs["temperature"] = loop._config.temperature
+    if loop._config.max_tokens is not None:
+        stream_kwargs["max_tokens"] = loop._config.max_tokens
     stream = loop._provider.stream(
         messages,
         tools=tools if tools_enabled else None,
-        **({"tool_choice": tool_choice} if tool_choice else {}),
+        **stream_kwargs,
     )
-    chunks: list[dict[str, Any]] = []
     stream_started = time.monotonic()
-    last_chunk_at = stream_started
-    active_ms = 0
-    stream_chars = 0
     tool_seen = False
     raw_content: list[str] = []
     stripper = PseudoStreamStripper()
     content_carry = ""
     cut_finish_reason: str | None = None
-    import steerable_agent_runtime.loop as loop_module
-
     try:
         while True:
             soft_timeout_ms = loop._config.soft_timeout_ms
             wait_seconds = None
-            if soft_timeout_ms is not None and not wrap_up_request:
+            timeout_finish_reason = "__soft_timeout_cut__"
+            if wrap_up_request and loop._config.wrap_up_tool_timeout_ms is not None:
+                wait_seconds = max(
+                    loop._config.wrap_up_tool_timeout_ms / 1000
+                    - (time.monotonic() - stream_started),
+                    0.05,
+                )
+                timeout_finish_reason = "__wrap_stream_cut__"
+            elif soft_timeout_ms is not None and not wrap_up_request:
                 wait_seconds = max(
                     soft_timeout_ms / 1000 - (time.monotonic() - run_started),
-                    0.000_001,
+                    0.05,
                 )
             try:
                 if wait_seconds is None:
@@ -217,13 +256,14 @@ async def _collect_stream(
             except StopAsyncIteration:
                 break
             except TimeoutError:
-                cut_finish_reason = "__soft_timeout_cut__"
+                cut_finish_reason = timeout_finish_reason
                 break
-            now = time.monotonic()
-            gap = now - last_chunk_at
-            last_chunk_at = now
-            if gap <= loop_module._IDLE_REASONING_GAP_SEC:
-                active_ms += int(gap * 1000)
+            observe_chunk = getattr(loop._hooks, "on_stream_chunk", None)
+            if callable(observe_chunk):
+                try:
+                    observe_chunk(chunk, loop._run_context)
+                except Exception:  # noqa: BLE001 — observation cannot break streaming
+                    logger.exception("native_bridge_on_stream_chunk_failed")
             payload = _chunk_to_json(chunk)
             if chunk.content_delta:
                 raw_content.append(chunk.content_delta)
@@ -235,71 +275,43 @@ async def _collect_stream(
                 ):
                     surrogate_mode[0] = True
                 payload["content_delta"] = stripper.feed(emit_text) or None
-            chunks.append(payload)
+            send("chunk", chunk=payload)
             if chunk.tool_call_delta is not None:
                 tool_seen = True
-                loop._run_context.reasoning_since_progress = 0
-            if not tool_seen:
-                delta_chars = len(chunk.reasoning_delta or "") + len(
-                    chunk.content_delta or ""
-                )
-                stream_chars += delta_chars
-                loop._run_context.reasoning_since_progress += len(
-                    chunk.reasoning_delta or ""
-                )
-                trigger = None
-                idle_ms = loop._config.idle_stream_timeout_ms
-                max_chars = loop._config.idle_stream_max_chars
-                stale_cap = loop._config.reasoning_without_progress_chars
-                if idle_ms is not None and active_ms >= idle_ms:
-                    trigger = "active_ms"
-                elif max_chars is not None and stream_chars >= max_chars:
-                    trigger = "chars"
-                elif (
-                    stale_cap is not None
-                    and loop._run_context.reasoning_since_progress >= stale_cap
-                ):
-                    trigger = "no_progress"
-                if trigger is not None:
-                    stale_chars = loop._run_context.reasoning_since_progress
-                    cut_finish_reason = (
-                        f"__idle_stream_cut__:{trigger}:{stream_chars}:"
-                        f"{stale_chars}"
-                    )
-                    if trigger == "no_progress":
-                        loop._run_context.reasoning_since_progress = 0
-                    break
             if cancel_flag.is_set() or loop._cancel_event.is_set():
                 break
+    except asyncio.CancelledError:
+        send("error", error="cancelled", error_kind="transport")
+        return
     except Exception as exc:  # noqa: BLE001 — Rust applies on_request_error
-        return json.dumps(
-            {
-                "ok": False,
-                "error": str(exc),
-                "kind": getattr(exc, "kind", "unknown"),
-                "status_code": getattr(exc, "status_code", None),
-                "provider": getattr(exc, "provider", None),
-                "retry_after_ms": getattr(exc, "retry_after_ms", None),
-            }
+        send(
+            "error",
+            error=str(exc),
+            error_kind=getattr(exc, "kind", "unknown"),
+            status_code=getattr(exc, "status_code", None),
+            provider=getattr(exc, "provider", None),
+            retry_after_ms=getattr(exc, "retry_after_ms", None),
         )
+        return
     display_tail = stripper.feed(content_carry) + stripper.flush()
     if display_tail:
-        chunks.append({"content_delta": display_tail})
+        send("chunk", chunk={"content_delta": display_tail})
     if cut_finish_reason is not None:
-        chunks.append({"finish_reason": cut_finish_reason})
+        send("chunk", chunk={"finish_reason": cut_finish_reason})
     elif not tool_seen:
         recovered, _ = extract_inline_tool_calls("".join(raw_content))
         for index, call in enumerate(recovered):
-            chunks.append(
-                {
+            send(
+                "chunk",
+                chunk={
                     "tool_call_delta": {
-                        "id": f"recovered_{index}",
+                        "id": f"recovered_{native_stream_id}_{index}",
                         "name": call["name"],
                         "arguments": call.get("arguments") or {},
                     }
-                }
+                },
             )
-    return json.dumps(chunks)
+    send("done")
 
 
 async def _exec_tool(loop: CoreLoop, call_json: str) -> str:
@@ -351,9 +363,12 @@ async def _post_tool_result(loop: CoreLoop, payload_json: str) -> str:
     )
     updated = await loop._hooks.post_tool_result(result, call, loop._run_context)
     made_progress = getattr(loop._hooks, "tool_made_progress", None)
-    if callable(made_progress) and made_progress(updated, call):
+    progressed = bool(callable(made_progress) and made_progress(updated, call))
+    if progressed:
         loop._run_context.reasoning_since_progress = 0
-    return json.dumps(_result_to_json(updated))
+    return json.dumps(
+        {"result": _result_to_json(updated), "madeProgress": progressed}
+    )
 
 
 async def _pre_step(
@@ -432,11 +447,34 @@ async def _on_request_error(
 
 
 def _native_history_kind(message: LLMMessage) -> str | None:
+    if message.role == "user" and any(
+        isinstance(part, ImagePart) for part in message.content
+    ):
+        return "tool.image"
     if (
         message.role == "user"
         and message.content_text.startswith("[system notice] The time budget")
     ):
         return "loop.soft_timeout_notice"
+    if (
+        message.role == "user"
+        and "was cut off mid-reasoning" in message.content_text
+    ):
+        return "loop.stream_cut_notice"
+    if (
+        message.role == "user"
+        and message.content_text.startswith(
+            "[system notice] The task ended without a natural-language summary"
+        )
+    ):
+        return "loop.narration_request"
+    if (
+        message.role == "user"
+        and message.content_text.startswith(
+            "[system notice] The previous reply described an intended action"
+        )
+    ):
+        return "loop.discipline_retry_notice"
     if (
         message.role == "tool"
         and "not executed" in message.content_text
@@ -455,6 +493,18 @@ def _native_history_kind(message: LLMMessage) -> str | None:
         and "mid-turn message" in message.content_text
     ):
         return "loop.steer_skip"
+    if (
+        message.role == "tool"
+        and "not executed" in message.content_text
+        and "too many consecutive tool errors" in message.content_text
+    ):
+        return "loop.breaker_skip"
+    if (
+        message.role == "tool"
+        and "not executed" in message.content_text
+        and "earlier tool ended the turn" in message.content_text
+    ):
+        return "loop.terminal_skip"
     return None
 
 
@@ -465,6 +515,12 @@ async def _sync_history(
     chat_id: str | None,
 ) -> str:
     incoming = [_msg_from_json(item) for item in json.loads(history_json)]
+    if any(
+        message.role == "user"
+        and message.content_text.startswith("[system notice] The time budget")
+        for message in incoming
+    ):
+        loop._wrap_up_active = True
     current = manager.projection
     if incoming[: len(current)] == current:
         for message in incoming[len(current) :]:
@@ -512,6 +568,7 @@ async def run_native(
     aio_loop = asyncio.get_running_loop()
     out: asyncio.Queue[tuple[LoopEvent, threading.Event] | None] = asyncio.Queue()
     loop._run_context = LoopContext(chat_id=chat_id)
+    loop._wrap_up_active = False
     record_id = loop._record_id or chat_id
     seed = list(messages)
     first_seq = 0
@@ -540,6 +597,10 @@ async def run_native(
     cancel_flag = threading.Event()
     steer_q: queue.Queue[str] = queue.Queue()
     active_tool_tasks: set[asyncio.Task[str]] = set()
+    active_stream_tasks: set[asyncio.Task[None]] = set()
+    stream_queues: dict[str, queue.Queue[str]] = {}
+    prefetched_stream_frames: dict[str, str] = {}
+    stream_counter = [0]
     tool_cancel_reason = ["cancelled"]
     run_started = time.monotonic()
     surrogate_mode = [False]
@@ -562,6 +623,8 @@ async def run_native(
         def cancel_now() -> None:
             for task in tuple(active_tool_tasks):
                 task.cancel()
+            for task in tuple(active_stream_tasks):
+                task.cancel()
 
         aio_loop.call_soon_threadsafe(cancel_now)
 
@@ -625,17 +688,78 @@ async def run_native(
         consumed.wait()
 
     def stream_llm(messages_json: str) -> str:
-        return _await_on_loop(
-            _collect_stream(
-                loop,
-                messages_json,
-                tools,
-                cancel_flag,
-                run_started,
-                surrogate_mode,
-            ),
-            aio_loop,
-        )
+        stream_counter[0] += 1
+        stream_id = f"stream-{stream_counter[0]}"
+        output: queue.Queue[str] = queue.Queue()
+        stream_queues[stream_id] = output
+
+        def start() -> None:
+            task = aio_loop.create_task(
+                _collect_stream(
+                    loop,
+                    messages_json,
+                    tools,
+                    cancel_flag,
+                    run_started,
+                    surrogate_mode,
+                    output,
+                    stream_id,
+                )
+            )
+            active_stream_tasks.add(task)
+
+            def done(completed: asyncio.Task[None]) -> None:
+                active_stream_tasks.discard(completed)
+                try:
+                    completed.result()
+                except asyncio.CancelledError:
+                    output.put(
+                        json.dumps(
+                            {
+                                "kind": "error",
+                                "error": "cancelled",
+                                "error_kind": "transport",
+                            }
+                        )
+                    )
+                except BaseException as exc:  # noqa: BLE001
+                    output.put(
+                        json.dumps(
+                            {
+                                "kind": "error",
+                                "error": str(exc),
+                                "error_kind": "unknown",
+                            }
+                        )
+                    )
+
+            task.add_done_callback(done)
+
+        aio_loop.call_soon_threadsafe(start)
+        first_frame = output.get()
+        first = json.loads(first_frame)
+        if first.get("kind") == "error":
+            stream_queues.pop(stream_id, None)
+            first["ok"] = False
+            return json.dumps(first)
+        prefetched_stream_frames[stream_id] = first_frame
+        return json.dumps({"ok": True, "stream_id": stream_id})
+
+    def next_stream_chunk(stream_id: str) -> str:
+        output = stream_queues.get(stream_id)
+        if output is None:
+            return json.dumps(
+                {
+                    "kind": "error",
+                    "error": f"unknown stream: {stream_id}",
+                    "error_kind": "unknown",
+                }
+            )
+        frame = prefetched_stream_frames.pop(stream_id, None) or output.get()
+        kind = json.loads(frame).get("kind")
+        if kind in ("done", "error"):
+            stream_queues.pop(stream_id, None)
+        return frame
 
     def exec_tool(call_json: str) -> str:
         box: queue.Queue[str] = queue.Queue()
@@ -718,6 +842,9 @@ async def run_native(
         ctx.accumulated_completion_tokens = int(
             raw.get("accumulated_completion_tokens") or 0
         )
+        ctx.reasoning_since_progress = int(
+            raw.get("reasoning_since_progress") or 0
+        )
         return json.dumps({"ok": True})
 
     def before_completion(draft_json: str) -> str:
@@ -776,6 +903,7 @@ async def run_native(
                 getattr(loop._provider, "model", "unknown"),
                 emit,
                 stream_llm,
+                next_stream_chunk,
                 exec_tool,
                 tool_concurrency_safe,
                 tool_dedup_exempt,

{steerable_agent_runtime-0.6.28 → steerable_agent_runtime-0.6.30}/src/steerable_agent_runtime/orchestration.py

@@ -384,16 +384,16 @@ class OrchestrationExecutor:
         return bool(inner_exempt and inner_exempt(call))
 
     def concurrency_safe(self, call: ToolCall) -> bool:
-        # spawn/wait/list mutate nothing themselves (the pool task does the
-        # work), so they may batch; send/close/interrupt are serialized with
-        # siblings.
+        # Spawn consumes the bounded parallel-capacity pool, so batching two
+        # spawns makes which call succeeds scheduler-dependent. Wait/list only
+        # observe pool state and may batch.
         if call.name in {
-            self._config.spawn_tool,
             self._config.wait_tool,
             self._config.list_tool,
         }:
             return True
         if call.name in {
+            self._config.spawn_tool,
             self._config.send_tool,
             self._config.close_tool,
             self._config.interrupt_tool,

{steerable_agent_runtime-0.6.28 → steerable_agent_runtime-0.6.30}/src/steerable_agent_runtime/pool.py

@@ -202,6 +202,9 @@ class AgentPool:
                 "childId": child_id,
                 "depth": self._depth + 1,
                 "task": task,
+                # Present only when the factory gave the child a durable
+                # record; hosts read that record to show the child's process.
+                **({"recordId": loop.record_id} if loop.record_id else {}),
                 **(event_extra or {}),
             },
         )