cloudagent-daemon 0.5.2__tar.gz → 0.5.4__tar.gz

{cloudagent_daemon-0.5.2 → cloudagent_daemon-0.5.4}/CHANGELOG.md

@@ -4,6 +4,59 @@ 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.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
+- A wake that dies because the model's context window is full now drops the
+  oversized session and re-spawns WITHOUT `--resume`, instead of replaying the
+  same history after an 8s backoff. Replaying could never fit, so the retry was
+  guaranteed to fail; three of them in a row crossed the crash threshold and
+  quarantined the agent — silently, since a quarantined agent stops being woken
+  (#114). The cleared session id is persisted, so later wakes do not resume the
+  oversized thread either.
+- The engine's own error text is now carried on the spawn result. Previously
+  only a bare `had_api_error` boolean survived, so the retry layer could not
+  tell a transient rate-limit (retry with resume) from a permanent
+  context-window overflow (start a new thread) and treated both the same.
+- A context-exhausted wake reports `context_exhausted` rather than the generic
+  `upstream_api_error`, so the cause is visible without reading daemon logs.
+
+### Notes
+- Detection matches an apostrophe-free substring: the engine writes "the
+  model's context window", and a smart-quote rewrite upstream would otherwise
+  silently disable the whole fix. A test pins that invariant.
+- No 0.5.2 entry exists in this file; 0.5.2 was published manually and its
+  changelog entry was never written.
+
 ## [0.5.1] — 2026-08-20
 
 ### Added

{cloudagent_daemon-0.5.2 → cloudagent_daemon-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cloudagent-daemon
-Version: 0.5.2
+Version: 0.5.4
 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.2 → cloudagent_daemon-0.5.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cloudagent-daemon"
-version = "0.5.2"
+version = "0.5.4"
 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.4/src/cloudagent_daemon/__init__.py

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

{cloudagent_daemon-0.5.2 → cloudagent_daemon-0.5.4}/src/cloudagent_daemon/claude_runner.py

@@ -338,6 +338,13 @@ class _SpawnAttempt:
     # M8 — set True when claude emitted an ``isApiErrorMessage:true``
     # event during the wake (upstream API error swallowed by the CLI).
     had_api_error: bool = False
+    # #114 — the engine's OWN explanation for that error. codex reports
+    # upstream failures as a ``turn.failed``/``error`` stdout event whose
+    # message previously reached only the log, so the retry layer saw a
+    # bare boolean and could not tell a transient rate-limit apart from a
+    # permanent context-window overflow — and retried both the same way.
+    # Keeping the text is what lets the wake layer branch on the cause.
+    api_error_text: str | None = None
 
 
 def _build_lazy_identity(agent_id: str, payload: dict) -> dict:
@@ -467,6 +474,22 @@ class ClaudeRunner:
         "no rollout found for thread",
     )
 
+    #: #114 — 上下文窗口撑满。这是**永久性**前提失败,不是瞬时错误:退避几秒
+    #: 再把同一份历史送一次,必然再次溢出。codex 自己给出的处置就是 "Start a
+    #: new thread or clear earlier history",与 stale-session 的补救动作完全
+    #: 一致(清掉会话、免 resume 重跑),故复用同一条路径而非退避重试。
+    #: 匹配按**小写子串**做,同时覆盖 codex 的自然语言提示和 OpenAI API 的
+    #: 标准错误码,避免只认一种措辞。
+    #: 刻意**不含撇号**:codex 的原文是 "the model's context window",但撇号是
+    #: 最容易被改写成弯引号(’)的字符,一旦不匹配整个修复就静默失效——而这个修复
+    #: 存在的意义正是消除静默失败。去掉撇号后的子串依然足够specific。
+    CONTEXT_EXHAUSTED_MARKERS: tuple[str, ...] = (
+        "ran out of room in the model",
+        "context_length_exceeded",
+        "maximum context length",
+        "context window",
+    )
+
     #: 会产生外部副作用的工具（发消息/建任务类）。瞬时错误重试只在本次 wake
     #: **没**调过这些工具时才做 —— 只读工具（list_messages 等）重跑无害。
     SIDE_EFFECT_TOOLS: frozenset[str] = frozenset({
@@ -662,10 +685,22 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
                 self._qoder_lane_session(ws, stale_conv)
                 if stale_is_qoder and stale_conv else None
             )
+            # #114 — 上下文撑满与 stale-session 是同一类问题：**当前会话已经
+            # 不能再用了**，区别只在于一个是引擎不认识它、另一个是它太大。补救
+            # 动作完全相同（清掉会话、免 resume 重跑一次），所以走同一条路径，
+            # 而不是掉进下面的瞬时退避重试——那会带着同一份撑满的历史重放，
+            # 注定再次失败，白烧一轮唤醒和一次计费，然后累计成 crash 进隔离。
+            context_exhausted = self._is_context_exhausted(attempt)
             if (
                 self._run_mode_for(payload) != "read_analyze"
                 and attempt.exit_code != 0
-                and any(m in attempt.stderr_tail for m in self.STALE_SESSION_STDERR_MARKERS)
+                and (
+                    any(
+                        m in attempt.stderr_tail
+                        for m in self.STALE_SESSION_STDERR_MARKERS
+                    )
+                    or context_exhausted
+                )
                 and (ws.last_session_id() is not None or qoder_lane_sid is not None)
             ):
                 stale_sid = qoder_lane_sid or ws.last_session_id()
@@ -673,11 +708,12 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
                 if stale_is_qoder and stale_conv:
                     self._qoder_set_lane(ws, stale_conv, None)
                 logger.warning(
-                    "claude_runner: resume rejected stale "
-                    "session_id=%s (stderr: %r). Clearing and "
-                    "retrying without resume.",
+                    "claude_runner: dropping unusable session_id=%s "
+                    "(cause=%s, detail=%r). Clearing and retrying "
+                    "without resume.",
                     stale_sid,
-                    attempt.stderr_tail[-160:],
+                    "context_exhausted" if context_exhausted else "stale_session",
+                    (attempt.api_error_text or attempt.stderr_tail)[-160:],
                 )
                 try:
                     ws.clear_last_session_id()
@@ -697,6 +733,12 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
                 attempt.exit_code != 0
                 and attempt.had_api_error
                 and not attempt.timeout_hit
+                # #114 — 永久性失败不走瞬时重试。退避 8 秒不会让上下文变小，
+                # 带 resume 重放同一份历史必然再次撑满；上面那条路径已经用
+                # "清会话 + 免 resume" 处理过它了。注意这里重新判定的是**重试
+                # 之后**的 attempt：若换新会话仍然撑满（例如注入的正文本身过
+                # 大），同样不该再退避重放。
+                and not self._is_context_exhausted(attempt)
                 and not any(
                     t.rsplit("__", 1)[-1] in self.SIDE_EFFECT_TOOLS
                     for t in attempt.tool_uses
@@ -942,21 +984,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
@@ -992,7 +1092,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
@@ -1004,7 +1107,13 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
             and parent_for_abort not in (None, "")
         ):
             if attempt.had_api_error:
-                reason = "upstream_api_error"
+                # #114 — 把永久性的"会话撑满"和笼统的上游错误区分开：否则频道
+                # 里那条 wake_aborted 只说"上游错误"，真实原因只能靠翻日志。
+                reason = (
+                    "context_exhausted"
+                    if self._is_context_exhausted(attempt)
+                    else "upstream_api_error"
+                )
             elif timeout_hit:
                 reason = "wake_timeout"
             else:
@@ -1465,6 +1574,7 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
             final_text,
             result_usage,
             had_api_error,
+            api_error_text,
         ) = await self._consume_stdout(
             proc,
             parse_mode=(
@@ -1495,12 +1605,34 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
             final_result_text=final_text,
             result_usage=result_usage,
             had_api_error=had_api_error,
+            api_error_text=api_error_text,
         )
 
     # ------------------------------------------------------------------
     # Internal helpers
     # ------------------------------------------------------------------
 
+    def _is_context_exhausted(self, attempt: _SpawnAttempt) -> bool:
+        """#114 — True iff *attempt* failed because the model's context
+        window is full.
+
+        A **permanent** premise failure, not a transient upstream error:
+        the same history replayed after any backoff overflows the window
+        again, so retrying with ``--resume`` burns a wake and a billing
+        cycle to reach the identical failure. The remedy is the one the
+        engine itself prints — start a new thread — which is exactly what
+        the stale-session path already does, so both share it.
+
+        Reads only :attr:`_SpawnAttempt.api_error_text` (the engine's own
+        message). An attempt that carried no explanation returns False:
+        unknown cause keeps the previous, more conservative handling
+        rather than silently discarding a session that may be fine.
+        """
+        text = (attempt.api_error_text or "").lower()
+        if not text:
+            return False
+        return any(m in text for m in self.CONTEXT_EXHAUSTED_MARKERS)
+
     #: 1i Bug E — the daemon-injected ``cloudagent`` MCP toolset MUST run
     #: unattended in ``--print`` headless mode (otherwise claude prompts
     #: the user for permission, the prompt is never answered, and the
@@ -2286,7 +2418,7 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
         *,
         partial_session_id: str | None = None,
         partial_agent_id: str | None = None,
-    ) -> tuple[str | None, list[str], str | None, dict | None, bool]:
+    ) -> tuple[str | None, list[str], str | None, dict | None, bool, str | None]:
         """Consume ``codex exec --json`` NDJSON.
 
         Codex emits ``thread.started`` with ``thread_id`` and one or more
@@ -2304,13 +2436,16 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
         # codex 把上游 API 错误（模型 at capacity / 限流）作为 turn.failed/error
         # 事件吐在 stdout —— 记为 had_api_error，wake 层据此做瞬时错误重试。
         had_api_error = False
+        # #114 — 同时留下引擎给的原因文本。只有一个布尔时，"限流"和"上下文
+        # 撑满"在 wake 层无法区分，于是永久性失败被当成瞬时错误反复重放。
+        api_error_text: str | None = None
         publish_enabled = bool(
             self._partial_publisher
             and partial_session_id
             and partial_agent_id
         )
         if proc.stdout is None:
-            return None, tool_uses, None, None, False
+            return None, tool_uses, None, None, False, None
 
         async def _emit(event_type: str, payload: "dict[str, Any]") -> None:
             if (
@@ -2468,9 +2603,12 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
                     msg = raw if isinstance(raw, str) else None
                 logger.warning("CodexRunner: stdout error event=%s msg=%r", evt_type, msg)
                 had_api_error = True
+                # 第一条为准：后续事件通常是同一个失败的级联噪声，首条才是根因。
+                if api_error_text is None and isinstance(msg, str) and msg:
+                    api_error_text = msg
 
         final_text = "\n\n".join(final_chunks) if final_chunks else None
-        return captured, tool_uses, final_text, result_usage, had_api_error
+        return captured, tool_uses, final_text, result_usage, had_api_error, api_error_text
 
     async def _consume_stdout(
         self,
@@ -2479,7 +2617,7 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
         parse_mode: str = "stream_json",
         partial_session_id: str | None = None,
         partial_agent_id: str | None = None,
-    ) -> tuple[str | None, list[str], str | None, dict | None, bool]:
+    ) -> tuple[str | None, list[str], str | None, dict | None, bool, str | None]:
         """Stream NDJSON; return ``(session_id, tool_uses, result_text, result_usage, had_api_error)``.
 
         Accepts BOTH session-init event shapes for forward/backward
@@ -2531,6 +2669,8 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
         # M8 — set True when claude emits a synthetic isApiErrorMessage
         # assistant event (upstream API error swallowed by the CLI).
         had_api_error: bool = False
+        # #114 — 与 codex 侧同构：保留引擎自己的错误文本供 wake 层判定原因。
+        api_error_text: str | None = None
         # 1k74 — running buffer for token-level streaming. claude emits
         # one ``stream_event`` per content_block_delta (~80 chars at a
         # time); we concatenate them and forward the running total to
@@ -2570,7 +2710,7 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
                 )
 
         if proc.stdout is None:
-            return None, tool_uses, final_text, result_usage, had_api_error
+            return None, tool_uses, final_text, result_usage, had_api_error, api_error_text
 
         async for line_b in proc.stdout:
             line = line_b.decode("utf-8", errors="replace").strip()
@@ -2685,6 +2825,8 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
                                 if isinstance(t, str):
                                     err_text = t[:200]
                                     break
+                    if api_error_text is None and err_text:
+                        api_error_text = err_text
                     logger.warning(
                         "ClaudeRunner: stdout isApiErrorMessage event — "
                         "wake will be marked crashed (text=%r)",
@@ -2824,7 +2966,7 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
                 "claude_runner: cache metrics publish failed", exc_info=True
             )
 
-        return captured, tool_uses, final_text, result_usage, had_api_error
+        return captured, tool_uses, final_text, result_usage, had_api_error, api_error_text
 
     async def _wait_with_timeout(
         self, proc: asyncio.subprocess.Process

{cloudagent_daemon-0.5.2 → cloudagent_daemon-0.5.4}/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"
     )
 
 
@@ -3310,3 +3321,410 @@ async def test_qoder_stale_resume_clears_only_that_lane(
     assert "--resume" not in a1
     lanes = json.loads((tmp_path / ".meta" / "qoder-sessions.json").read_text())
     assert lanes == {"conv_A": "new_A", "conv_B": "keep_B"}
+
+
+# ---------------------------------------------------------------------------
+# #114 — context-window exhaustion is a PERMANENT failure, not a transient one
+# ---------------------------------------------------------------------------
+
+
+_CTX_FULL_MSG = (
+    "Codex ran out of room in the model's context window. "
+    "Start a new thread or clear earlier history before retrying."
+)
+
+
+def _codex_turn_failed(msg: str) -> str:
+    """One codex NDJSON stdout event reporting a failed turn."""
+    return json.dumps({"type": "turn.failed", "error": {"message": msg}})
+
+
+def _codex_ok(thread_id: str = "thread_fresh") -> list[str]:
+    return [
+        json.dumps({"type": "thread.started", "thread_id": thread_id}),
+        json.dumps({
+            "type": "item.completed",
+            "item": {"type": "agent_message", "text": "ok"},
+        }),
+    ]
+
+
+def _codex_runner(fake: str, ws: FakeWorkspace, outbound: FakeOutbound):
+    return ClaudeRunner(
+        outbound=outbound,
+        workspace=ws,
+        runtime_binaries={"codex": fake},
+        single_wake_timeout=10.0,
+    )
+
+
+async def test_context_exhausted_starts_a_fresh_session_instead_of_replaying(
+    stateful_fake_claude, tmp_path
+):
+    """#114 — a wake that dies because the context window is full must drop
+    the oversized session and re-spawn WITHOUT resume.
+
+    This is the failure that took Dex down on 2026-08-21: the runner treated
+    "ran out of room in the model's context window" as a transient upstream
+    error and replayed the *same* oversized history, which cannot ever fit.
+    Three of those in a row crossed the crash threshold and the agent was
+    quarantined — silently, since a quarantined agent stops being woken.
+    """
+    mcp_cfg = tmp_path / "mcp.json"
+    mcp_cfg.write_text("{}")
+    agent_ws = FakeAgentWorkspace(mcp_path=mcp_cfg, last_session="thread_big")
+    ws = FakeWorkspace(agent_ws)
+    outbound = FakeOutbound()
+
+    fake = stateful_fake_claude([
+        {"stdout": [_codex_turn_failed(_CTX_FULL_MSG)], "stderr": [], "exit_code": 1},
+        {"stdout": _codex_ok("thread_fresh"), "stderr": [], "exit_code": 0},
+    ])
+    runner = _codex_runner(fake, ws, outbound)
+
+    result = await runner.run_one(
+        "agent-A", {**_make_payload(), "runtime_engine": "codex"}
+    )
+
+    argv0 = _read_argv_n(tmp_path, 0)
+    argv1 = _read_argv_n(tmp_path, 1)
+    # The first attempt resumed the oversized thread…
+    assert "resume" in argv0 and "thread_big" in argv0
+    # …and the retry must abandon it entirely — resuming it again is the bug.
+    assert "resume" not in argv1, (
+        "retry replayed the oversized history; that can only fail again"
+    )
+    assert "thread_big" not in argv1
+
+    # The poisoned id is cleared, so LATER wakes don't resume it either —
+    # without this the agent recovers for one wake and dies on the next.
+    assert agent_ws.clear_last_session_calls == 1
+    assert agent_ws.set_calls == ["thread_fresh"]
+
+    assert result.exit_code == 0
+    final_status = [c for c in outbound.calls if c[0] == "agent_status"][-1]
+    assert final_status == ("agent_status", "agent-A", "idle", 0)
+
+
+async def test_context_exhausted_is_not_retried_as_a_transient_error(
+    stateful_fake_claude, tmp_path
+):
+    """#114 — when even the fresh session overflows, STOP.
+
+    The transient path backs off 8s and re-spawns *with* resume. Waiting does
+    not shrink a context window, so letting an exhausted wake fall through to
+    it burns a third spawn (and a third bill) to reach the same failure.
+    Exactly two spawns may happen: the original and the fresh-session retry.
+    """
+    mcp_cfg = tmp_path / "mcp.json"
+    mcp_cfg.write_text("{}")
+    agent_ws = FakeAgentWorkspace(mcp_path=mcp_cfg, last_session="thread_big")
+    ws = FakeWorkspace(agent_ws)
+    outbound = FakeOutbound()
+
+    fake = stateful_fake_claude([
+        {"stdout": [_codex_turn_failed(_CTX_FULL_MSG)], "stderr": [], "exit_code": 1},
+        {"stdout": [_codex_turn_failed(_CTX_FULL_MSG)], "stderr": [], "exit_code": 1},
+        {"stdout": _codex_ok(), "stderr": [], "exit_code": 0},
+    ])
+    runner = _codex_runner(fake, ws, outbound)
+
+    await runner.run_one("agent-A", {**_make_payload(), "runtime_engine": "codex"})
+
+    assert (tmp_path / "argv-1.json").exists(), "fresh-session retry must happen"
+    assert not (tmp_path / "argv-2.json").exists(), (
+        "a permanently-failing wake was retried a third time via the "
+        "transient-error backoff path"
+    )
+
+
+async def test_transient_upstream_error_still_backs_off_and_resumes(
+    stateful_fake_claude, tmp_path, monkeypatch
+):
+    """#114 regression guard — narrowing the retry must not disarm it.
+
+    A genuine transient upstream error (rate limit / model at capacity) still
+    has to take the original path: back off, then retry WITH resume so the
+    conversation keeps its history. If this goes red, the fix over-matched.
+    """
+    mcp_cfg = tmp_path / "mcp.json"
+    mcp_cfg.write_text("{}")
+    agent_ws = FakeAgentWorkspace(mcp_path=mcp_cfg, last_session="thread_ok")
+    ws = FakeWorkspace(agent_ws)
+    outbound = FakeOutbound()
+
+    slept: list[float] = []
+
+    async def _no_sleep(seconds: float) -> None:
+        slept.append(seconds)
+
+    monkeypatch.setattr(claude_runner_module.asyncio, "sleep", _no_sleep)
+
+    fake = stateful_fake_claude([
+        {
+            "stdout": [_codex_turn_failed("stream error: model is at capacity")],
+            "stderr": [],
+            "exit_code": 1,
+        },
+        {"stdout": _codex_ok("thread_ok"), "stderr": [], "exit_code": 0},
+    ])
+    runner = _codex_runner(fake, ws, outbound)
+
+    await runner.run_one("agent-A", {**_make_payload(), "runtime_engine": "codex"})
+
+    assert slept == [8], "transient error must still back off before retrying"
+    argv1 = _read_argv_n(tmp_path, 1)
+    assert "resume" in argv1 and "thread_ok" in argv1, (
+        "a transient failure must keep the session — only exhaustion drops it"
+    )
+    # The session was NOT thrown away for a merely transient hiccup.
+    assert agent_ws.clear_last_session_calls == 0
+
+
+async def test_read_analyze_context_exhaustion_never_clears_the_owner_session(
+    stateful_fake_claude, tmp_path
+):
+    """§7.4 + #114 — a read_analyze wake must not touch the owner's lane.
+
+    read_analyze never resumes, so its own overflow says nothing about the
+    owner's session. Clearing it here would let a read-only round destroy
+    state it is explicitly forbidden to write.
+    """
+    mcp_cfg = tmp_path / "mcp.json"
+    mcp_cfg.write_text("{}")
+    agent_ws = FakeAgentWorkspace(mcp_path=mcp_cfg, last_session="thread_owner")
+    ws = FakeWorkspace(agent_ws)
+    outbound = FakeOutbound()
+
+    fake = stateful_fake_claude([
+        {"stdout": [_codex_turn_failed(_CTX_FULL_MSG)], "stderr": [], "exit_code": 1},
+        {"stdout": _codex_ok(), "stderr": [], "exit_code": 0},
+    ])
+    runner = _codex_runner(fake, ws, outbound)
+
+    await runner.run_one("agent-A", _ra_payload(runtime_engine="codex"))
+
+    assert agent_ws.clear_last_session_calls == 0
+    assert agent_ws.set_calls == []
+
+
+async def test_context_exhausted_survives_a_curly_apostrophe(
+    stateful_fake_claude, tmp_path
+):
+    """#114 — a pretty-quoted variant of the message is still handled.
+
+    End-to-end guard only: it asserts the wake recovers, without pinning WHICH
+    marker matched. The apostrophe-free property itself is pinned by
+    :func:`test_context_markers_avoid_rewritable_punctuation` — reverse mutation
+    showed this test alone passes via the generic ``context window`` marker, so
+    on its own it does NOT prove the hardening.
+    """
+    mcp_cfg = tmp_path / "mcp.json"
+    mcp_cfg.write_text("{}")
+    agent_ws = FakeAgentWorkspace(mcp_path=mcp_cfg, last_session="thread_big")
+    ws = FakeWorkspace(agent_ws)
+
+    curly = (
+        "Codex ran out of room in the model’s context window. "
+        "Start a new thread or clear earlier history before retrying."
+    )
+    fake = stateful_fake_claude([
+        {"stdout": [_codex_turn_failed(curly)], "stderr": [], "exit_code": 1},
+        {"stdout": _codex_ok("thread_fresh"), "stderr": [], "exit_code": 0},
+    ])
+    runner = _codex_runner(fake, ws, FakeOutbound())
+
+    await runner.run_one("agent-A", {**_make_payload(), "runtime_engine": "codex"})
+
+    assert agent_ws.clear_last_session_calls == 1, (
+        "a curly apostrophe defeated the marker — detection is punctuation-fragile"
+    )
+    assert "resume" not in _read_argv_n(tmp_path, 1)
+
+
+async def test_rate_limit_mentioning_tokens_is_not_read_as_exhaustion(
+    stateful_fake_claude, tmp_path, monkeypatch
+):
+    """#114 — pins the deliberately-broad ``context window`` marker.
+
+    Detection is intentionally generous (a missed exhaustion costs a crash
+    loop; a false positive only costs one session's history). "Generous" must
+    still exclude the common transient that talks about tokens and limits —
+    a quota error must keep its session and take the backoff path.
+    """
+    mcp_cfg = tmp_path / "mcp.json"
+    mcp_cfg.write_text("{}")
+    agent_ws = FakeAgentWorkspace(mcp_path=mcp_cfg, last_session="thread_ok")
+    ws = FakeWorkspace(agent_ws)
+
+    async def _no_sleep(seconds: float) -> None:
+        return None
+
+    monkeypatch.setattr(claude_runner_module.asyncio, "sleep", _no_sleep)
+
+    quota = (
+        "Rate limit reached: limit 30000 tokens per minute. "
+        "Please try again later."
+    )
+    fake = stateful_fake_claude([
+        {"stdout": [_codex_turn_failed(quota)], "stderr": [], "exit_code": 1},
+        {"stdout": _codex_ok("thread_ok"), "stderr": [], "exit_code": 0},
+    ])
+    runner = _codex_runner(fake, ws, FakeOutbound())
+
+    await runner.run_one("agent-A", {**_make_payload(), "runtime_engine": "codex"})
+
+    assert agent_ws.clear_last_session_calls == 0, (
+        "a rate-limit error was misread as context exhaustion — marker too broad"
+    )
+    assert "resume" in _read_argv_n(tmp_path, 1)
+
+
+def test_context_markers_avoid_rewritable_punctuation():
+    """#114 — no marker may hinge on a character that gets auto-rewritten.
+
+    Straight apostrophes and quotes are exactly what smart-quote passes
+    rewrite. A marker containing one can be silently defeated by a cosmetic
+    transformation upstream, switching the whole fix off with no signal — the
+    opposite of what this fix is for. Markers must also stay lowercase because
+    matching lowercases the text first; an uppercase marker can never match.
+    """
+    for marker in ClaudeRunner.CONTEXT_EXHAUSTED_MARKERS:
+        assert "'" not in marker and "\u2019" not in marker, (
+            f"marker {marker!r} hinges on an apostrophe — a smart-quote pass "
+            f"upstream would silently disable context-exhaustion detection"
+        )
+        assert '"' not in marker and "\u201c" not in marker, (
+            f"marker {marker!r} hinges on a quote character"
+        )
+        assert marker == marker.lower(), (
+            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.2 → cloudagent_daemon-0.5.4}/uv.lock

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

cloudagent_daemon-0.5.2/src/cloudagent_daemon/__init__.py

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