cloudagent-daemon 0.5.3__tar.gz → 0.5.5__tar.gz

{cloudagent_daemon-0.5.3 → cloudagent_daemon-0.5.5}/CHANGELOG.md

@@ -4,6 +4,58 @@ All notable changes to the local daemon. Format follows
 [Keep a Changelog](https://keepachangelog.com/); versions are
 [PEP 440](https://peps.python.org/pep-0440/). Release with `scripts/release.sh`.
 
+## [0.5.5] — 2026-08-27
+
+### Changed
+- Every engine now gets one runtime session per conversation, not one per agent.
+  An agent resumed the same CLI session no matter which channel woke it, so
+  #debug, the DM and #SSS all shared a single context: the per-channel prompt
+  leaked between rooms, and each wake replayed the union of every room's
+  history — muddled context and a token bill that grew without bound. Lanes
+  already fixed this for qoder; the bleed was never qoder-specific, so
+  claude_code and codex now resume from the same per-conversation lane, keyed
+  on the waking conversation (channel, DM and thread each carry their own).
+  Wakes with no conversation — timers, spawn chains — keep the global lane.
+
+### Notes
+- The lane file is now `.meta/sessions.json`. `qoder-sessions.json` is still
+  read so an upgraded host keeps its lanes; the first write folds it into the
+  new file and removes it, or a cleared lane would come back to life from the
+  stale value left behind.
+- Agents carrying a global session into this version start fresh on their first
+  wake in each conversation. That is the fix rather than a side effect —
+  inheriting it is precisely the bleed being removed — but expect an agent to
+  look like it "forgot" an in-flight thread once, right after the upgrade.
+
+## [0.5.4] — 2026-08-24
+
+### Changed
+- A model-side error no longer counts toward the crash quota, and can no longer
+  quarantine an agent. Three consecutive `crashed` reports quarantine an agent
+  server-side, after which every wake is dropped and nobody is told; a model
+  refusing one turn is not the same as the agent being broken. This is how a
+  whole delivery line went dark twice — six hours on 2026-08-21, four on 08-23
+  (the latter from a content-safety flag raised while reviewing security
+  material). The wake now reports `idle`, which keeps the counter still.
+
+### Added
+- A failed wake posts a notice into the originating channel carrying the
+  engine's own error text. Until now this path only wrote a log line and a
+  metric — "the silence must be VISIBLE" (U0.4) was true only for whoever reads
+  logs, and nobody does; the user found out by noticing an agent had stopped
+  answering, hours later. The notice is explicitly labelled as daemon-emitted so
+  it can never be mistaken for the agent's own answer, which is what the
+  no-fallback rule was protecting.
+
+### Notes
+- Status code and notification are now separate concerns: the code drives
+  counting, the notice does the telling. Model errors report `idle` AND still
+  trigger the a2a `wake_aborted` system reply — dropping the latter would leave
+  a dispatching chief waiting forever.
+- Process-level failures (binary missing, auth file unreadable) still count.
+  Retrying those forever fixes nothing, so the protection is kept — but they now
+  post a channel notice too, so they are no longer silent either.
+
 ## [0.5.3] — 2026-08-22
 
 ### Fixed

{cloudagent_daemon-0.5.3 → cloudagent_daemon-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cloudagent-daemon
-Version: 0.5.3
+Version: 0.5.5
 Summary: Local daemon for cloudagent — bridges Claude Code, Codex, and Qoder CLI agents to the cloudagent backend.
 Project-URL: Homepage, https://cloudagent.chat
 Project-URL: Repository, https://codeup.aliyun.com/69bd0a4d29ad98af4065ce71/cloudagent

{cloudagent_daemon-0.5.3 → cloudagent_daemon-0.5.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cloudagent-daemon"
-version = "0.5.3"
+version = "0.5.5"
 description = "Local daemon for cloudagent — bridges Claude Code, Codex, and Qoder CLI agents to the cloudagent backend."
 authors = [{name = "chaoyin", email = "tudoucyx@gmail.com"}]
 readme = "README.md"

cloudagent_daemon-0.5.5/src/cloudagent_daemon/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.5.5"

{cloudagent_daemon-0.5.3 → cloudagent_daemon-0.5.5}/src/cloudagent_daemon/claude_runner.py

@@ -680,11 +680,10 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
             stale_conv = (
                 str(payload["conversation_id"]) if payload.get("conversation_id") else None
             )
-            stale_is_qoder = self._runtime_engine_for(ws, payload) == "qoder"
-            qoder_lane_sid = (
-                self._qoder_lane_session(ws, stale_conv)
-                if stale_is_qoder and stale_conv else None
-            )
+            # #95 — the lane IS the session this wake resumed from (the
+            # global last_session only when there is no conversation), so
+            # it is also the one to drop once it proves unusable.
+            stale_lane_sid = self._lane_session(ws, stale_conv)
             # #114 — 上下文撑满与 stale-session 是同一类问题：**当前会话已经
             # 不能再用了**，区别只在于一个是引擎不认识它、另一个是它太大。补救
             # 动作完全相同（清掉会话、免 resume 重跑一次），所以走同一条路径，
@@ -701,12 +700,12 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
                     )
                     or context_exhausted
                 )
-                and (ws.last_session_id() is not None or qoder_lane_sid is not None)
+                and stale_lane_sid is not None
             ):
-                stale_sid = qoder_lane_sid or ws.last_session_id()
-                # #95 — qoder 的过期会话在 lane 里，清 lane 才能真正脱离它
-                if stale_is_qoder and stale_conv:
-                    self._qoder_set_lane(ws, stale_conv, None)
+                stale_sid = stale_lane_sid
+                # #95 — 过期会话就在 lane 里，清 lane 才能真正脱离它
+                if stale_conv:
+                    self._set_lane(ws, stale_conv, None)
                 logger.warning(
                     "claude_runner: dropping unusable session_id=%s "
                     "(cause=%s, detail=%r). Clearing and retrying "
@@ -782,21 +781,20 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
         # 防外人注入的上下文渗进 owner 后续 full 会话。仍上报 session_start
         # 供实时展示,但不落 last-spawn(下次 full 唤醒仍 resume 干净的 owner 轨)。
         is_read_analyze = self._run_mode_for(payload) == "read_analyze"
-        # #95 — qoder 按 conversation_id 分轨存会话；全局 last_session 仍写
-        # （last-spawn.json 可观测性 + 非平台唤醒兜底），但 qoder 平台唤醒的
-        # resume 只读 lane（见 _build_cmd），不会被别的频道的会话覆盖。
+        # #95 — 所有引擎都按 conversation_id 分轨存会话；全局 last_session 仍写
+        # （last-spawn.json 可观测性 + 非平台唤醒兜底），但平台唤醒的 resume
+        # 只读 lane（见 _build_cmd），不会被别的频道的会话覆盖。
         conv_for_lane = (
             str(payload["conversation_id"]) if payload.get("conversation_id") else None
         )
-        if (
-            captured_session
-            and not is_read_analyze
-            and conv_for_lane
-            and self._runtime_engine_for(ws, payload) == "qoder"
-        ):
-            self._qoder_set_lane(ws, conv_for_lane, captured_session)
-        if captured_session and captured_session != ws.last_session_id():
+        # 比较基准取**本轨**上一个会话，不是全局 last_session：分轨后全局会被
+        # 最后说话的频道盖掉，拿它比会让 A/B 频道交替唤醒每轮都像是新会话，
+        # 把 session_start 刷成噪音。必须在 _set_lane 之前读。
+        prev_lane_session = self._lane_session(ws, conv_for_lane)
+        if captured_session and captured_session != prev_lane_session:
             if not is_read_analyze:
+                if conv_for_lane:
+                    self._set_lane(ws, conv_for_lane, captured_session)
                 ws.set_last_session_id(captured_session)
             await self.outbound.send_agent_session_start(
                 agent_id, captured_session
@@ -984,21 +982,79 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
         )
         ws.write_last_spawn(rc, spawn_record_session, stderr_tail)
 
+        # 主人拍板（2026-08-24）：**大模型端的报错一律直接回报给人，不再计入崩溃
+        # 配额、不再据此隔离 agent。** 模型拒绝一次不等于这个 agent 坏了；把它锁死
+        # 的代价是整条交付线静默停摆——8-21 六小时、8-23 四小时，两次都是这么来的
+        # （连续 3 次模型侧失败 → quarantined → 此后所有唤醒静默丢弃，没人被告知）。
+        #
+        # 报 idle 而非 crashed：idle 不进 record_agent_crash 的计数，且会顺带解除
+        # 历史遗留的隔离（record_agent_recovery）。失败本身**不靠这个状态码传达**，
+        # 由下面的频道通知负责——状态码只有运维看得到，人看的是频道。
+        model_side_error = attempt.had_api_error
         if timeout_hit:
             final_status = "timeout"
-        elif attempt.had_api_error:
-            # M8 — Claude Code swallows upstream Anthropic/Bedrock API
-            # errors: it prints a synthetic ``isApiErrorMessage:true``
-            # event and exits rc=0 *without* a terminating ``type=
-            # result``. Without this branch the wake would be reported
-            # as ``idle`` (cleanly completed) — leaving the dispatching
-            # chief silently waiting for a reply that will never come.
-            final_status = "crashed"
+        elif model_side_error:
+            final_status = "idle"
         elif rc == 0:
             final_status = "idle"
         else:
             final_status = "crashed"
 
+        # 主人拍板（2026-08-24）：**模型侧报错必须直接回到人眼前。**
+        #
+        # 此前这里什么都不发：U0.4 定的口径是"频道唤醒不做 fallback，沉默必须可见
+        # （log + metric）"。出发点对——别拿 daemon 的兜底伪造 agent 的回答——但
+        # "可见"只可见于日志和指标，**没有人在看**。实际后果：agent 崩了，频道里
+        # 一个字都没有，发指令的人只能靠"叫它没反应"发现，中间隔了 4 个小时。
+        #
+        # 所以这里补的**不是 agent 的回答，是一条明确署名的系统通知**：诚实口径不破
+        # （不冒充 agent），可见性拿回来。已有的 platform_send 兜底只在 rc==0 且有
+        # 输出时触发（"说了话但没调工具"），失败路径正是它漏掉的那半边。
+        failure_note: str | None = None
+        if model_side_error:
+            failure_note = (attempt.api_error_text or "").strip() or "模型侧返回错误（无详细信息）"
+        elif timeout_hit:
+            failure_note = f"本轮超时（{int(self._single_wake_timeout)} 秒内未结束）"
+        elif rc != 0:
+            failure_note = (attempt.stderr_tail or "").strip()[-400:] or f"进程非零退出（rc={rc}）"
+        notice_conv = payload.get("conversation_id")
+        notice_session = payload.get("session_id")
+        if (
+            failure_note
+            and isinstance(notice_conv, str) and notice_conv
+            and isinstance(notice_session, str) and notice_session
+        ):
+            kind_label = "模型侧报错" if model_side_error else ("超时" if timeout_hit else "进程异常")
+            body = (
+                f"⚠️ 我这一轮没能完成：**{kind_label}**\n\n"
+                f"```\n{failure_note[:600]}\n```\n"
+                + (
+                    "这是**模型端**返回的错误，不是这个 agent 坏了——它**没有被隔离**，"
+                    "下次被唤醒会照常重试。"
+                    if model_side_error
+                    else "这是运行时/进程层面的失败，重试未必能解决，可能需要看一下机器。"
+                )
+                + "\n（本条由 daemon 代发的系统通知，不是 agent 的回答。）"
+            )
+            try:
+                await self.outbound.send_tool_call(
+                    agent_id=agent_id,
+                    session_id=notice_session,
+                    tool_name="platform_send",
+                    args={
+                        "content": body,
+                        "conversation_id": notice_conv,
+                        "acknowledge_new_messages": True,
+                        **({"delivery_id": _effective_delivery_id} if _effective_delivery_id else {}),
+                    },
+                    timeout=15.0,
+                )
+            except Exception:  # noqa: BLE001 — 通知失败绝不能再把这一轮拖垮
+                logger.warning(
+                    "claude_runner: failed to post failure notice agent=%s conv=%s",
+                    agent_id, notice_conv, exc_info=True,
+                )
+
         # Wave C #3 — surface terminal status counts for /metrics +
         # doctor. Label-keyed so a single counter renders three
         # series (idle / crashed / timeout). Failure to publish must
@@ -1034,7 +1090,10 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
             payload.get("parent_msg_id") or payload.get("message_id")
         )
         if (
-            final_status in ("crashed", "timeout")
+            # model_side_error 现在报 idle（不进崩溃配额），但**这条链仍要通知**：
+            # a2a 的 chief 是在等一条回复，不给它就是永远等下去。状态码用于计数，
+            # 这里用于告知——两件事，不能因为改了前者而丢掉后者。
+            (final_status in ("crashed", "timeout") or model_side_error)
             # This block only fires for task/peer_request/question kinds
             # (WAKE_REPLY_EXPECTED_KINDS, checked below), for which
             # fallback_tool is always send_message — so called_fallback_tool
@@ -2037,53 +2096,79 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
         )
 
     # ------------------------------------------------------------------
-    # #95 — qoder runtime-session lanes, one per conversation.
+    # #95 — runtime-session lanes, one per conversation.
     #
-    # qodercli ``--resume`` does not reliably adopt a new
-    # ``--append-system-prompt`` on a resumed session, and a single global
-    # last_session shared by DM/#debug/#SSS made the per-channel prompt
-    # (#89) bleed across rooms. Each conversation therefore gets its own
-    # lane: ``.meta/qoder-sessions.json`` = {conversation_id: session_id}.
+    # A single global last_session shared by DM/#debug/#SSS made every room
+    # bleed into every other one: the agent resumed the same CLI session no
+    # matter which channel woke it, so #89's per-channel prompt leaked
+    # across rooms and each wake replayed the union of all rooms' history
+    # (context noise + token burn). Each conversation therefore gets its own
+    # lane: ``.meta/sessions.json`` = {conversation_id: session_id}.
     # Non-platform wakes (no conversation_id) keep the legacy global lane.
+    #
+    # Lanes started out qoder-only (qodercli ``--resume`` additionally
+    # refuses to adopt a new ``--append-system-prompt``), but the bleed is
+    # engine-independent — claude_code and codex resumed one global session
+    # too. All engines now share this path; the superseded qoder file is
+    # still read so an upgraded host keeps its existing lanes.
     # ------------------------------------------------------------------
 
+    #: Superseded lane file — read-only, for hosts upgraded from the
+    #: qoder-only era. Writes always land in ``sessions.json``.
+    LEGACY_QODER_LANES_FILENAME = "qoder-sessions.json"
+
     @staticmethod
-    def _qoder_lanes_path(ws: AgentWorkspaceLike) -> "Path":
-        return ws.path / ".meta" / "qoder-sessions.json"
+    def _lanes_path(ws: AgentWorkspaceLike) -> "Path":
+        return ws.path / ".meta" / "sessions.json"
+
+    @classmethod
+    def _read_lanes(cls, ws: AgentWorkspaceLike) -> dict:
+        """Current lane file layered over the superseded qoder one."""
+        merged: dict = {}
+        for path in (
+            ws.path / ".meta" / cls.LEGACY_QODER_LANES_FILENAME,
+            cls._lanes_path(ws),
+        ):
+            try:
+                data = json.loads(path.read_text(encoding="utf-8"))
+            except (FileNotFoundError, json.JSONDecodeError, OSError):
+                continue
+            if isinstance(data, dict):
+                merged.update(data)
+        return merged
 
-    def _qoder_lane_session(
+    def _lane_session(
         self, ws: AgentWorkspaceLike, conversation_id: str | None
     ) -> str | None:
         if not conversation_id:
             return ws.last_session_id()
-        try:
-            data = json.loads(self._qoder_lanes_path(ws).read_text(encoding="utf-8"))
-        except (FileNotFoundError, json.JSONDecodeError, OSError):
-            return None
-        sid = data.get(conversation_id) if isinstance(data, dict) else None
+        # Deliberately NO fallback to the global last_session: the first
+        # wake in a conversation must start fresh, or it would inherit
+        # whatever room spoke last — the exact bleed lanes exist to remove.
+        sid = self._read_lanes(ws).get(conversation_id)
         return sid if isinstance(sid, str) and sid else None
 
-    def _qoder_set_lane(
+    def _set_lane(
         self, ws: AgentWorkspaceLike, conversation_id: str, session_id: str | None
     ) -> None:
         """Set (or clear with None) the lane. Best-effort; never raises."""
-        p = self._qoder_lanes_path(ws)
+        p = self._lanes_path(ws)
+        legacy = ws.path / ".meta" / self.LEGACY_QODER_LANES_FILENAME
         try:
-            try:
-                data = json.loads(p.read_text(encoding="utf-8"))
-                if not isinstance(data, dict):
-                    data = {}
-            except (FileNotFoundError, json.JSONDecodeError, OSError):
-                data = {}
+            data = self._read_lanes(ws)
             if session_id:
                 data[conversation_id] = session_id
             else:
                 data.pop(conversation_id, None)
             p.parent.mkdir(parents=True, exist_ok=True)
             p.write_text(json.dumps(data, indent=2), encoding="utf-8")
+            # The merge above already carried every legacy entry across, so
+            # drop the old file — otherwise a *cleared* lane would come back
+            # to life on the next read from the stale value left behind.
+            legacy.unlink(missing_ok=True)
         except OSError:
             logger.warning(
-                "claude_runner: qoder lane write failed conv=%s", conversation_id,
+                "claude_runner: lane write failed conv=%s", conversation_id,
                 exc_info=True,
             )
 
@@ -2153,8 +2238,12 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
         故此模式下 ``last_session`` 恒为 None。
         """
         read_analyze = run_mode == "read_analyze"
+        # #95 — 每个 conversation 一条轨（无 conversation_id 的非平台唤醒落回
+        # 全局轨）。原先这里直接读 ws.last_session_id()，于是同一个 agent 无论
+        # 在哪个频道被唤醒都 --resume 同一条会话。
         last_session = (
-            ws.last_session_id() if (with_resume and not read_analyze) else None
+            self._lane_session(ws, conversation_id)
+            if (with_resume and not read_analyze) else None
         )
         if runtime_engine == "codex":
             binary = self.runtime_binaries.get("codex") or "codex"
@@ -2229,14 +2318,10 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
             # 输出走既有 stream_json 消费器（联调时如发现事件形状偏差再适配）。
             # 认证：QODER_PERSONAL_ACCESS_TOKEN 环境变量或 qodercli login。
             binary = self.runtime_binaries.get("qoder") or "qodercli"
-            # #95 — 会话按 conversation_id 分轨（DM/各频道各自续聊），不再共用
-            # 全局 last_session；无 conversation_id 的非平台唤醒沿用全局轨。
+            # #95 — 分轨已上提到 last_session（所有引擎共用），这里直接复用。
             # #107 — read_analyze 与 claude/codex 一样绝不 resume owner 轨，
             # 防外部指挥上下文渗进后续 full 会话。
-            lane_session = (
-                self._qoder_lane_session(ws, conversation_id)
-                if with_resume and not read_analyze else None
-            )
+            lane_session = last_session
             cmd = [binary]
             # r6 同款：模型 + 推理强度由 chairman 在编辑页选（qoder 档位
             # low|medium|high|xhigh|max，与 claude_code 同集）。

{cloudagent_daemon-0.5.3 → cloudagent_daemon-0.5.5}/tests/unit/test_claude_runner.py

@@ -2461,11 +2461,22 @@ def _make_dispatch_payload(
     }
 
 
-async def test_isApiErrorMessage_promotes_wake_to_crashed(
+async def test_isApiErrorMessage_does_not_burn_the_crash_quota(
     fake_claude, tmp_path
 ):
-    """M8 — when claude emits ``isApiErrorMessage:true`` and exits rc=0,
-    the runner must report ``agent_status="crashed"`` (not ``idle``).
+    """2026-08-24 主人拍板改写：模型侧报错**不再**记 crashed。
+
+    这条测试原本断言的是相反的行为（M8：``isApiErrorMessage`` + rc=0 → 报
+    ``crashed``）。改写而不是删除，因为它当初的关切依然成立、只是解法换了：
+
+      当初的关切 —— "别报 idle，否则派活的 chief 会以为干完了、永远等下去"。
+      现在的解法 —— 状态码只负责**计数**，告知由 ``wake_aborted`` 的系统回复
+      和频道通知负责（见 ``test_wake_aborted_emits_system_reply_when_api_error``
+      与 ``test_model_side_error_is_reported_into_the_channel``）。两件事拆开了。
+
+    为什么必须拆：报 crashed 会累计进隔离配额，连续 3 次就把 agent 锁死，此后
+    **所有**唤醒被静默丢弃、无人被告知。模型拒绝一次不等于这个 agent 坏了。
+    2026-08-21 与 08-23 两次整条交付线停摆（6 小时 / 4 小时）都源于此。
     """
     mcp_cfg = tmp_path / "mcp.json"
     mcp_cfg.write_text("{}")
@@ -2493,8 +2504,8 @@ async def test_isApiErrorMessage_promotes_wake_to_crashed(
     statuses = [c for c in outbound.calls if c[0] == "agent_status"]
     final = [s for s in statuses if s[2] != "running"]
     assert len(final) == 1
-    assert final[0][2] == "crashed", (
-        f"isApiErrorMessage with rc=0 must report crashed, got {final[0][2]}"
+    assert final[0][2] == "idle", (
+        f"模型侧报错记成了 {final[0][2]} —— 会累计进隔离配额并最终锁死 agent"
     )
 
 
@@ -3282,14 +3293,18 @@ async def test_qoder_sessions_are_isolated_per_conversation(
     a3 = _read_argv_n(tmp_path, 3)
     assert a3[a3.index("--resume") + 1] == "sess_dm"
 
-    lanes = json.loads((tmp_path / ".meta" / "qoder-sessions.json").read_text())
+    lanes = json.loads((tmp_path / ".meta" / "sessions.json").read_text())
     assert lanes == {"conv_debug": "sess_debug", "conv_dm": "sess_dm"}
 
 
 async def test_qoder_stale_resume_clears_only_that_lane(
     stateful_fake_claude, tmp_path
 ):
-    """lane 里的过期会话被 CLI 拒绝 → 清该 lane 并免 resume 重试；别的 lane 不动。"""
+    """lane 里的过期会话被 CLI 拒绝 → 清该 lane 并免 resume 重试；别的 lane 不动。
+
+    seed 故意写在**旧** ``qoder-sessions.json`` 上，于是这条同时验收升级路径：
+    旧 lane 仍可 resume，首次写入把两条都搬进 ``sessions.json`` 并删掉旧文件。
+    """
     mcp_cfg = tmp_path / "mcp.json"; mcp_cfg.write_text("{}")
     ws = FakeWorkspace(FakeAgentWorkspace(mcp_path=mcp_cfg, last_session=None))
     (tmp_path / ".meta").mkdir(parents=True, exist_ok=True)
@@ -3308,8 +3323,122 @@ async def test_qoder_stale_resume_clears_only_that_lane(
     a0 = _read_argv_n(tmp_path, 0); a1 = _read_argv_n(tmp_path, 1)
     assert a0[a0.index("--resume") + 1] == "old_A"
     assert "--resume" not in a1
-    lanes = json.loads((tmp_path / ".meta" / "qoder-sessions.json").read_text())
+    lanes = json.loads((tmp_path / ".meta" / "sessions.json").read_text())
     assert lanes == {"conv_A": "new_A", "conv_B": "keep_B"}
+    # 迁移后旧文件必须消失，否则被清掉的 lane 会从残留值里复活
+    assert not (tmp_path / ".meta" / "qoder-sessions.json").exists()
+
+
+# ---------------------------------------------------------------------------
+# #95 — lanes are engine-independent: claude_code / codex get them too
+# ---------------------------------------------------------------------------
+
+
+def _claude_ok(sid: str) -> dict:
+    return {
+        "stdout": [
+            json.dumps({"type": "system", "subtype": "init", "session_id": sid}),
+            json.dumps({"type": "result", "subtype": "success", "result": "ok"}),
+        ],
+        "exit_code": 0,
+    }
+
+
+async def test_claude_code_sessions_are_isolated_per_conversation(
+    stateful_fake_claude, tmp_path
+):
+    """claude_code 同样按 conversation 分轨：频道/DM 各自续聊，互不串味。
+
+    这条是本次改动的本体 —— 分轨此前只有 qoder 走，claude_code 不管在哪个
+    频道被唤醒都 --resume 同一条全局会话。
+    """
+    mcp_cfg = tmp_path / "mcp.json"; mcp_cfg.write_text("{}")
+    ws = FakeWorkspace(FakeAgentWorkspace(mcp_path=mcp_cfg, last_session=None))
+    fake = stateful_fake_claude([
+        _claude_ok("sess_debug"),   # 0: #debug 首轮
+        _claude_ok("sess_dm"),      # 1: DM 首轮 —— 不得继承 #debug 的会话
+        _claude_ok("sess_debug"),   # 2: 回 #debug —— resume 自己的轨
+        _claude_ok("sess_dm"),      # 3: 回 DM —— resume DM 的轨
+    ])
+    runner = _build_runner(fake, ws, FakeOutbound())
+    dbg = {**_make_payload(), "conversation_id": "conv_debug"}
+    dm = {**_make_payload(), "conversation_id": "conv_dm"}
+
+    await runner.run_one("agent-A", dbg)
+    assert "--resume" not in _read_argv_n(tmp_path, 0)
+    await runner.run_one("agent-A", dm)
+    assert "--resume" not in _read_argv_n(tmp_path, 1)
+    await runner.run_one("agent-A", dbg)
+    a2 = _read_argv_n(tmp_path, 2)
+    assert a2[a2.index("--resume") + 1] == "sess_debug"
+    await runner.run_one("agent-A", dm)
+    a3 = _read_argv_n(tmp_path, 3)
+    assert a3[a3.index("--resume") + 1] == "sess_dm"
+
+    lanes = json.loads((tmp_path / ".meta" / "sessions.json").read_text())
+    assert lanes == {"conv_debug": "sess_debug", "conv_dm": "sess_dm"}
+
+
+async def test_new_conversation_never_inherits_the_global_session(
+    stateful_fake_claude, tmp_path
+):
+    """升级现场的回归闸：老 agent 带着全局 last_session 进入本版本，新频道
+    首轮必须从零开始 —— 继承它正是分轨要消灭的那条串味路径。"""
+    mcp_cfg = tmp_path / "mcp.json"; mcp_cfg.write_text("{}")
+    ws = FakeWorkspace(
+        FakeAgentWorkspace(mcp_path=mcp_cfg, last_session="global_old")
+    )
+    fake = stateful_fake_claude([_claude_ok("sess_fresh")])
+    runner = _build_runner(fake, ws, FakeOutbound())
+
+    await runner.run_one(
+        "agent-A", {**_make_payload(), "conversation_id": "conv_new"}
+    )
+    assert "--resume" not in _read_argv_n(tmp_path, 0)
+
+
+async def test_non_platform_wake_still_uses_the_global_lane(
+    stateful_fake_claude, tmp_path
+):
+    """无 conversation_id 的唤醒（定时器 / spawn 链）沿用全局轨，不受分轨影响。"""
+    mcp_cfg = tmp_path / "mcp.json"; mcp_cfg.write_text("{}")
+    ws = FakeWorkspace(
+        FakeAgentWorkspace(mcp_path=mcp_cfg, last_session="global_old")
+    )
+    fake = stateful_fake_claude([_claude_ok("global_old")])
+    runner = _build_runner(fake, ws, FakeOutbound())
+
+    await runner.run_one("agent-A", _make_payload())
+    a0 = _read_argv_n(tmp_path, 0)
+    assert a0[a0.index("--resume") + 1] == "global_old"
+
+
+async def test_codex_sessions_are_isolated_per_conversation(
+    stateful_fake_claude, tmp_path
+):
+    """codex 分轨；resume 形态是 ``exec resume … <thread_id> -``。"""
+    mcp_cfg = tmp_path / "mcp.json"; mcp_cfg.write_text("{}")
+    ws = FakeWorkspace(FakeAgentWorkspace(mcp_path=mcp_cfg, last_session=None))
+    fake = stateful_fake_claude([
+        {"stdout": _codex_ok("thread_a"), "exit_code": 0},   # 0: conv_A 首轮
+        {"stdout": _codex_ok("thread_b"), "exit_code": 0},   # 1: conv_B 首轮
+        {"stdout": _codex_ok("thread_a"), "exit_code": 0},   # 2: 回 conv_A
+    ])
+    runner = _codex_runner(fake, ws, FakeOutbound())
+    a = {**_make_payload(), "runtime_engine": "codex", "conversation_id": "conv_A"}
+    b = {**_make_payload(), "runtime_engine": "codex", "conversation_id": "conv_B"}
+
+    await runner.run_one("agent-A", a)
+    assert "resume" not in _read_argv_n(tmp_path, 0)
+    await runner.run_one("agent-A", b)
+    assert "resume" not in _read_argv_n(tmp_path, 1)
+    await runner.run_one("agent-A", a)
+    a2 = _read_argv_n(tmp_path, 2)
+    assert "resume" in a2
+    assert a2[-2] == "thread_a"          # …<thread_id> "-"
+
+    lanes = json.loads((tmp_path / ".meta" / "sessions.json").read_text())
+    assert lanes == {"conv_A": "thread_a", "conv_B": "thread_b"}
 
 
 # ---------------------------------------------------------------------------
@@ -3590,3 +3719,130 @@ def test_context_markers_avoid_rewritable_punctuation():
             f"marker {marker!r} is not lowercase; _is_context_exhausted "
             f"lowercases the text, so this marker can never match"
         )
+
+
+# ---------------------------------------------------------------------------
+# 2026-08-24 主人拍板：模型侧报错直接回报给人，不计入崩溃配额、不据此隔离
+# ---------------------------------------------------------------------------
+
+
+def _platform_payload(**extra):
+    """一次频道唤醒的 payload —— 带 conversation_id 才谈得上把失败发回频道。"""
+    return {
+        **_make_payload(),
+        "kind": "platform_mention",
+        "conversation_id": "conv_test_1",
+        "session_id": "sess_test_1",
+        "runtime_engine": "codex",
+        **extra,
+    }
+
+
+async def test_model_side_error_is_not_counted_as_a_crash(fake_claude, tmp_path):
+    """模型报错必须报 idle —— 报 crashed 就会累计进隔离配额。
+
+    连续 3 次 crashed 会让服务端把 agent 隔离，此后**所有**唤醒被静默丢弃、无人
+    被告知。Dex 2026-08-23 就是这样消失了 4 小时：模型侧的内容安全拦截被当成
+    "这个 agent 坏了"。模型拒绝一次不等于 agent 坏了。
+    """
+    mcp_cfg = tmp_path / "mcp.json"
+    mcp_cfg.write_text("{}")
+    ws = FakeWorkspace(FakeAgentWorkspace(mcp_path=mcp_cfg, last_session=None))
+    outbound = FakeOutbound()
+    fake = fake_claude(
+        stdout_lines=[_codex_turn_failed(
+            "This content was flagged for possible cybersecurity risk"
+        )],
+        exit_code=1,
+    )
+    runner = _codex_runner(fake, ws, outbound)
+
+    await runner.run_one("agent-A", _platform_payload())
+
+    final = [c for c in outbound.calls if c[0] == "agent_status"][-1]
+    assert final[2] == "idle", (
+        f"模型侧报错被记成了 {final[2]} —— 会累计进隔离配额"
+    )
+
+
+async def test_model_side_error_is_reported_into_the_channel(fake_claude, tmp_path):
+    """失败必须出现在人看得见的地方，而且要带原始错误文本。
+
+    此前这条路径只写日志和指标（U0.4 的"沉默必须可见"），而日志没有人看——
+    使用者只能靠"叫它没反应"发现，中间隔了几个小时。
+    """
+    mcp_cfg = tmp_path / "mcp.json"
+    mcp_cfg.write_text("{}")
+    ws = FakeWorkspace(FakeAgentWorkspace(mcp_path=mcp_cfg, last_session=None))
+    outbound = FakeOutbound()
+    flagged = "This content was flagged for possible cybersecurity risk"
+    fake = fake_claude(stdout_lines=[_codex_turn_failed(flagged)], exit_code=1)
+    runner = _codex_runner(fake, ws, outbound)
+
+    await runner.run_one("agent-A", _platform_payload())
+
+    sends = [
+        inv for inv in outbound.tool_call_invocations
+        if inv.get("tool_name") == "platform_send"
+    ]
+    assert sends, "失败没有发回频道 —— 使用者无从知道它崩了"
+    content = sends[-1]["args"]["content"]
+    assert flagged in content, f"通知里没有原始错误文本：{content}"
+    assert sends[-1]["args"]["conversation_id"] == "conv_test_1"
+    # 诚实口径：这是 daemon 的系统通知，不能冒充成 agent 的回答。
+    assert "系统通知" in content and "不是 agent 的回答" in content
+    # 并且要说清楚它没被隔离 —— 否则人会以为又要去捞它。
+    assert "没有被隔离" in content
+
+
+async def test_process_level_failure_still_counts_as_a_crash(fake_claude, tmp_path):
+    """回归护栏：放宽的只是**模型侧**报错，进程级故障的保护不能一并拆掉。
+
+    二进制起不来、auth 文件权限坏这类，重试多少次都一样，仍应计入崩溃配额。
+    """
+    mcp_cfg = tmp_path / "mcp.json"
+    mcp_cfg.write_text("{}")
+    ws = FakeWorkspace(FakeAgentWorkspace(mcp_path=mcp_cfg, last_session=None))
+    outbound = FakeOutbound()
+    # 没有任何模型事件，只有非零退出 + stderr —— 典型的进程级失败。
+    fake = fake_claude(stdout_lines=[], stderr_lines=["exec: not found"], exit_code=127)
+    runner = _codex_runner(fake, ws, outbound)
+
+    await runner.run_one("agent-A", _platform_payload())
+
+    final = [c for c in outbound.calls if c[0] == "agent_status"][-1]
+    assert final[2] == "crashed", (
+        f"进程级失败被记成了 {final[2]} —— 保护被误拆"
+    )
+    # 但它同样要让人看见。
+    sends = [
+        inv for inv in outbound.tool_call_invocations
+        if inv.get("tool_name") == "platform_send"
+    ]
+    assert sends, "进程级失败也必须发回频道"
+    assert "进程异常" in sends[-1]["args"]["content"]
+
+
+async def test_no_conversation_id_means_no_notice_but_never_a_crash_of_the_wake(
+    fake_claude, tmp_path
+):
+    """拿不到频道就不发通知 —— 但绝不能因此把这一轮弄挂。"""
+    mcp_cfg = tmp_path / "mcp.json"
+    mcp_cfg.write_text("{}")
+    ws = FakeWorkspace(FakeAgentWorkspace(mcp_path=mcp_cfg, last_session=None))
+    outbound = FakeOutbound()
+    fake = fake_claude(
+        stdout_lines=[_codex_turn_failed("boom")], exit_code=1,
+    )
+    runner = _codex_runner(fake, ws, outbound)
+
+    payload = _platform_payload()
+    payload.pop("conversation_id")
+    result = await runner.run_one("agent-A", payload)  # 不抛异常
+
+    assert result is not None
+    sends = [
+        inv for inv in outbound.tool_call_invocations
+        if inv.get("tool_name") == "platform_send"
+    ]
+    assert not sends

{cloudagent_daemon-0.5.3 → cloudagent_daemon-0.5.5}/uv.lock

@@ -122,7 +122,7 @@ wheels = [
 
 [[package]]
 name = "cloudagent-daemon"
-version = "0.5.3"
+version = "0.5.5"
 source = { editable = "." }
 dependencies = [
     { name = "h2" },

cloudagent_daemon-0.5.3/src/cloudagent_daemon/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.5.3"