@@ -262,6 +262,19 @@ All notable changes to Raven are documented here.
 
 ### Fixed
 
+- What an agent on a registered machine writes on stderr reaches Raven even
+  when no link held the agent at the time. The node kept those lines but, when
+  a link attached, replayed only the agent's output: a run picked up after a
+  restart was reported as `exited 3` without the reason after it, a CLI that
+  names its session only on stderr (hermes) could not be bound to it by the
+  pick-up, so its next turn opened a new session, and what was written while a
+  link was down was lost the same way. The node now numbers stderr lines as it
+  numbers output lines and replays the ones the link has not seen. An ACP
+  agent is one task across every prompt its process is sent, so its pick-up
+  asks the replay from the line its record kept as the prompt went out, not
+  from the agent's first line; a CLI pick-up, whose task is the command's
+  own, reads from the first line.
+
 - A task on a registered machine ends the way it ended, whatever happened on
   either side. A Raven node killed outright (`kill -9`) used to leave its
   agents running with nobody reading them and the host reading a bare
 
@@ -443,10 +443,14 @@ whose entries name the machine, each under a task id of the host's, in its own p
 group in the machine user's login environment, forwards what they write (an ACP agent's
 frames, a CLI agent's output lines) on numbered channels of the connection that holds them
 -- a CLI agent's prompt reaches its stdin the other way (`agent/stdin`), which also closes
-it -- and keeps those lines in the task's record
+it -- and keeps those lines and the agent's stderr, each line numbered, in the task's record
 (`node_dir/tasks/<task>/`, owner-only like the host's journal), so a connection that goes
 leaves the agent running and the next
-one takes it over from the frame the host last read (`agent/attach`); and answers probes of
+one takes it over from the frame and the stderr line the host last read (`agent/attach`; a
+cli pick-up, which read none of it, gets the stderr from its first line -- a session id or a
+failure a CLI agent says only there is not lost with a link -- and an acp pick-up from the
+line its run record kept as the prompt went out, so the earlier prompts' lines are not read
+again); and answers probes of
 the machine and of an agent's command. It holds no conversation, calls no model and opens
 no network port. It runs exactly the host's code, checked by protocol and digest at every
 connection (`raven/node/bundle.py`); `raven ops connection install-node` puts it on a
 
@@ -304,19 +304,21 @@ address it by id thanks to the alias written at registration.
 Raven keeps one ssh link per machine and watches it with a heartbeat: a ping
 every 5 seconds, and 15 seconds without an answer means the link is gone. The
 agents are not: they run under the machine's daemon, which keeps every frame
-they write. Raven tries the link again on a backoff of 2, 4, 8, then 16
-seconds for as long as any agent is waiting, and a link that comes back
-attaches each agent by its task id, from the frame Raven last read. The turn
-goes on as if nothing had happened; a cancel sent while the link was down is
-delivered when it is back.
+they write and every line of their stderr. Raven tries the link again on a
+backoff of 2, 4, 8, then 16 seconds for as long as any agent is waiting, and a
+link that comes back attaches each agent by its task id, from the frame and
+the stderr line Raven last read. The turn goes on as if nothing had happened;
+a cancel sent while the link was down is delivered when it is back.
 
 Stopping Raven does the same on purpose. An agent running on a machine is left
 to the daemon; what Raven keeps is a record under
 `<raven home>/machines/runs/`. The next start reads those records, attaches
-each run from where it was, and announces the result into the conversation
-that asked, as a finished turn. Keep the machine's registration and the agent
-entry in place for that. `/restart` and a Raven that was killed are covered
-the same way.
+each run from where it was, reads what it wrote on stderr during that turn
+too (a command's whole stderr: the reason it failed, or the session id a CLI
+names only there), and announces the
+result into the conversation that asked, as a finished turn. Keep the
+machine's registration and the agent entry in place for that. `/restart` and a
+Raven that was killed are covered the same way.
 
 What is not recoverable: a machine that rebooted, or a daemon that was ended
 by hand, no longer knows the task. The turn is then announced as an error
 
@@ -245,14 +245,15 @@ grep, write_file and edit_file take that path as it is, and deliver_files fetche
 ## 7. 断线与重启 { #7-disconnects-and-restarts }
 
 Raven 对每台机器保持一条 ssh 链路，用心跳看着它：每 5 秒 ping 一次，15 秒没有回应就算
-链路断了。Agent 没有断：它们在机器的守护进程下继续运行，写出的每一帧都被守护进程保存。
+链路断了。Agent 没有断：它们在机器的守护进程下继续运行，写出的每一帧和 stderr 的每一行都被守护进程保存。
 只要还有 Agent 在等，Raven 就按 2、4、8、16 秒的退避不断重试；链路回来后按任务 id
-把每个 Agent 接回，从 Raven 上次读到的那一帧继续，这一轮像什么都没发生一样进行下去；
+把每个 Agent 接回，从 Raven 上次读到的那一帧和那一行 stderr 继续，这一轮像什么都没发生一样进行下去；
 链路断开期间发出的取消，链路回来时送达。
 
 停止 Raven 的效果是一样的，而且是有意为之。机器上的 Agent 留给守护进程，Raven 这边
 留下的是 `<Raven 主目录>/machines/runs/` 下的一条记录。下次启动时读这些记录，把每次
-运行从原来的位置接回，再把结果通告到发起它的那个对话，就像一轮正常结束一样。为此要保留
+运行从原来的位置接回，连同这一轮写在 stderr 里的内容一起读到（命令的整个 stderr：失败的原因，或只在 stderr
+里报会话 id 的 CLI 给出的 id），再把结果通告到发起它的那个对话，就像一轮正常结束一样。为此要保留
 机器的登记和 Agent 条目。`/restart` 和被强制结束的 Raven 也按同样方式处理。
 
 接不回来的情况：机器重启过，或者守护进程被手动结束，任务就不再被机器认识。这一轮会以错误
 
@@ -2037,9 +2037,10 @@ def _track_on_machine(
             session_cwd=session_cwd,
             stateful=self.is_stateful,
             received=int(getattr(endpoint, "received", 0) or 0),
+            stderr_received=int(getattr(endpoint, "stderr_received", 0) or 0),
         )
         try:
-            tracker = remote_runs.Tracker(run)
+            tracker = remote_runs.Tracker(run, stderr_count=lambda: getattr(endpoint, "stderr_received", 0))
         except OSError as exc:
             logger.warning(
                 "acp agent {!r}: the run on machine {} could not be recorded: {}", self.name, self.machine, exc
 
@@ -2,10 +2,11 @@
 
 The run's record (:mod:`raven.acp_client.remote_runs`) says which machine,
 which task its daemon runs the agent under, which ACP session the turn is in,
-which prompt is awaited and how many frames that process had read when the
-prompt went out. This module turns that into the reply the turn owes: the
-machine's daemon replays the turn from there, whole, and hands the rest over
-as it comes (``agent/attach``),
+which prompt is awaited and how many frames, and how many stderr lines, that
+process had read when the prompt went out. This module turns that into the
+reply the turn owes: the machine's daemon replays the turn from there, whole,
+with the stderr the turn wrote, and hands the rest over as it comes
+(``agent/attach``),
 a connection over that channel is taken into the pool as if started here, the
 turn's collector reads the agent's messages off it, and the answer to the
 prompt -- sent by the other process, awaited by this one -- ends the wait. What
@@ -66,7 +67,9 @@ async def pick_up(run: RemoteRun, backend: AcpAgentBackend, *, pool: Any = None)
     if run.prompt_id <= 0:
         return PickedUp("error", f"the run of {run.agent!r} on machine {target.label} ended before its prompt was sent")
     try:
-        endpoint, attached = await link.attach(run.machine, run.task, name=run.agent, after=run.received)
+        endpoint, attached = await link.attach(
+            run.machine, run.task, name=run.agent, after=run.received, stderr_after=run.stderr_received
+        )
     except remote_path.NodeCallError as exc:
         if exc.reason in ("unknown_task", None) and "no longer runs" in str(exc):
             return PickedUp("error", str(exc))
 
@@ -30,7 +30,7 @@
 import json
 import os
 import time
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
 from typing import Any
@@ -73,6 +73,11 @@ class RemoteRun:
     received: int = 0
     """How many of the agent's frames this computer had read when the prompt went out: where an attach goes on
     from, so a pick-up reads the turn from its first frame."""
+    stderr_received: int = 0
+    """How many of the agent's stderr lines had reached this computer when the prompt went out: where a pick-up
+    asks the stderr replay from. An ACP agent is one task across every prompt its process is sent, so what the
+    earlier prompts wrote is not read again into this turn's tail and journal; a cli run, whose task is the
+    command's own, keeps 0 and reads all of it."""
     started: float = field(default_factory=time.time)
     kind: str = "acp"
     """``acp`` for a turn in an ACP session, ``cli`` for a command whose whole output is the reply
@@ -344,18 +349,26 @@ class Tracker:
     It moves the record only until ``prompt_sent``: the turn's own frames are
     never checkpointed, since the reply is put together from all of them --
     the chunks before the answer as much as the answer -- and a process that
-    picks the run up has to read the turn from its first frame.
+    picks the run up has to read the turn from its first frame. ``stderr_count``
+    is read once, as the prompt goes out: the stderr lines before it are the
+    earlier prompts', and a pick-up asks the replay from past them.
     """
 
-    def __init__(self, run: RemoteRun) -> None:
+    def __init__(self, run: RemoteRun, *, stderr_count: Callable[[], Any] | None = None) -> None:
         self.run = run
         self.kept = False
+        self._stderr_count = stderr_count
         record(run)
 
     def prompt_sent(self, request_id: int) -> None:
-        """The prompt went out under ``request_id``: what a later process awaits the answer to."""
+        """The prompt went out under ``request_id``: what a later process awaits the answer to; the stderr line
+        count is taken now."""
         self.run.prompt_id = request_id
         self.run.next_id = request_id + 1
+        if self._stderr_count is not None:
+            n = self._stderr_count()
+            if isinstance(n, int) and not isinstance(n, bool) and n > self.run.stderr_received:
+                self.run.stderr_received = n
         try:
             record(self.run)
         except OSError as exc:
 
@@ -13,12 +13,13 @@
 The link is watched from here, not by ssh: a ``node/ping`` every
 :data:`HEARTBEAT_S` seconds, and one unanswered for :data:`HEARTBEAT_LOST_S`
 means the link is gone -- not the agents. They run on under the machine's
-daemon, which keeps their frames; each agent's endpoint here waits, holding
-what the host writes meanwhile, and the link is tried again on a backoff
-(:data:`RECONNECT_BACKOFF_S`) for as long as any agent is waiting. A link
-that comes back attaches each agent again by its task id, from the frame the
-host last read, and the turn goes on as if nothing had happened. Only a task
-the machine no longer knows ends an endpoint with the sentence that says so.
+daemon, which keeps their frames and their stderr; each agent's endpoint here
+waits, holding what the host writes meanwhile, and the link is tried again on
+a backoff (:data:`RECONNECT_BACKOFF_S`) for as long as any agent is waiting. A
+link that comes back attaches each agent again by its task id, from the frame
+and the stderr line the host last read, and the turn goes on as if nothing had
+happened. Only a task the machine no longer knows ends an endpoint with the
+sentence that says so.
 
 An MCP server the host lends an agent on the machine is carried on the link
 too: the agent runs the node's bridge as a stdio server, the daemon tells this
@@ -183,6 +184,9 @@ def __init__(
         self.pid: int | None = None
         self.received = 0
         """How many of the agent's frames reached here: where an attach goes on from."""
+        self.stderr_received = 0
+        """How many of the agent's stderr lines reached here: where an attach goes on from for those. What a CLI
+        agent says only there -- a session id, the reason it failed -- is replayed past it, not lost with a link."""
         self.watchers: list[Callable[[int], None]] = []
         """Told, after each frame the connection has dealt with, how many it has read: what a record of the
         run keeps until its prompt is out, so a process that comes after this one attaches from there and reads
@@ -324,8 +328,9 @@ def feed_frame(self, line: Any, n: Any = None) -> None:
             self.received = n if isinstance(n, int) and not isinstance(n, bool) else self.received + 1
             self._frames.put_nowait((self.received, line.encode("utf-8") + b"\n"))
 
-    def feed_stderr(self, text: Any) -> None:
+    def feed_stderr(self, text: Any, n: Any = None) -> None:
         if isinstance(text, str) and not self._done.is_set():
+            self.stderr_received = n if isinstance(n, int) and not isinstance(n, bool) else self.stderr_received + 1
             self._stderr.put_nowait(text.encode("utf-8") + b"\n")
 
     def exited(self, rc: Any, reason: Any = None) -> None:
@@ -609,15 +614,20 @@ async def open_channel(
         return endpoint
 
     async def attach(
-        self, machine_id: str, task: str, *, name: str, after: int = 0
+        self, machine_id: str, task: str, *, name: str, after: int = 0, stderr_after: int = 0
     ) -> tuple[ChannelEndpoint, dict[str, Any]]:
-        """``task`` on the machine, onto a channel of its link, from the frame past the ``after``-th.
+        """``task`` on the machine, onto a channel of its link, from the frame past the ``after``-th and the
+        stderr line past the ``stderr_after``-th.
 
         What a process that comes after the one that started the agent uses
         to pick the run up: the daemon replays the frames past the record's
-        count -- the turn whole, from where its prompt went out -- and hands
-        the rest over as it comes, or, for a task that has ended, replays its
-        record and says so. The endpoint returned is what an
+        count -- the turn whole, from where its prompt went out -- and the
+        agent's stderr past ``stderr_after``: from its first line for a cli
+        run, whose task is the command's own and none of whose stderr this
+        process has read, and from the line the run's record kept as the
+        prompt went out for an acp agent, which is one task across every
+        prompt its process is sent; and hands the rest over as it comes, or,
+        for a task that has ended, replays its record and says so. The endpoint returned is what an
         :class:`AcpClient` runs over; the answer says the pid, the frames
         and the exit code (``None`` while the agent runs).
         """
@@ -627,8 +637,9 @@ async def attach(
         node.next_channel += 1
         endpoint = ChannelEndpoint(node.client, channel, target=node.target, agent=name, task=task)
         endpoint.received = after
+        endpoint.stderr_received = stderr_after
         node.channels[channel] = endpoint
-        params = {"channel": channel, "task": task, "after": after}
+        params = {"channel": channel, "task": task, "after": after, "stderr_after": stderr_after}
         try:
             answer = await node.client.request(protocol.AGENT_ATTACH, params, timeout=_ATTACH_TIMEOUT_S)
         except AcpRemoteError as exc:
@@ -650,7 +661,13 @@ async def attach(
         if isinstance(answer.get("pid"), int):
             endpoint.pid = answer["pid"]
         node.used = time.monotonic()
-        logger.info("acp agent {!r}: picked up on {} from frame {}", name, endpoint.describe(), after)
+        logger.info(
+            "acp agent {!r}: picked up on {} from frame {} and stderr line {}",
+            name,
+            endpoint.describe(),
+            after,
+            stderr_after,
+        )
         return endpoint, answer
 
     def status(self, machine_id: str) -> MachineStatus:
@@ -950,7 +967,7 @@ async def _notified(
         if method == protocol.AGENT_FRAME:
             endpoint.feed_frame(params.get("line"), params.get("n"))
         elif method == protocol.AGENT_STDERR:
-            endpoint.feed_stderr(params.get("text"))
+            endpoint.feed_stderr(params.get("text"), params.get("n"))
         elif method == protocol.AGENT_EXIT:
             channels.pop(channel, None)
             endpoint.exited(params.get("rc"), params.get("reason"))
@@ -1020,7 +1037,8 @@ async def _reconnect(self, machine_id: str) -> None:
             self._reconnects.pop(machine_id, None)
 
     async def _reattach(self, machine_id: str) -> None:
-        """Every endpoint parked for the machine onto a channel of its new link, from the frame it last read.
+        """Every endpoint parked for the machine onto a channel of its new link, from the frame and the stderr line
+        it last read.
 
         A link that goes while this runs -- under the attach, or under the
         replay of what an endpoint held -- parks that endpoint and every one
@@ -1039,7 +1057,12 @@ async def _reattach(self, machine_id: str) -> None:
             channel = node.next_channel
             node.next_channel += 1
             node.channels[channel] = endpoint
-            params = {"channel": channel, "task": endpoint.task, "after": endpoint.received}
+            params = {
+                "channel": channel,
+                "task": endpoint.task,
+                "after": endpoint.received,
+                "stderr_after": endpoint.stderr_received,
+            }
             try:
                 await node.client.request(protocol.AGENT_ATTACH, params, timeout=_ATTACH_TIMEOUT_S)
                 if endpoint.returncode is None:
 
@@ -15,8 +15,9 @@
 them, a blank line included, since they are its answer; its prompt reaches
 its stdin as ``agent/stdin``) -- and a *task* id of the host's
 choosing, which outlives the connection: an agent keeps running when the ssh
-goes, its frames are kept on the machine, and a new connection picks them up
-from where the host stopped reading (``agent/attach``). Requests are answered
+goes, its frames and its stderr (``agent/stderr``) are kept on the machine,
+every line numbered, and a new connection picks them up from where the host
+stopped reading (``agent/attach``; the stderr when it asks). Requests are answered
 as they finish, not in the order they arrive: a search of a large tree does
 not hold a heartbeat behind it.
 
@@ -51,7 +52,7 @@
 SESSION_DIR = "session/dir"
 
 AGENT_LAUNCH = "agent/launch"
-AGENT_ATTACH = "agent/attach"
+AGENT_ATTACH = "agent/attach"  # ``channel``, ``task``, ``after``; ``stderr_after`` replays the stderr past that line
 AGENT_FRAME = "agent/frame"
 AGENT_STDIN = "agent/stdin"
 AGENT_STDERR = "agent/stderr"