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

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

@@ -4,6 +4,52 @@ 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.7] — 2026-08-30
+
+### Fixed
+- A periodic (timer) wake no longer publishes its throwaway session as the
+  global lane. 0.5.6 closed `set_last_session_id` but not `write_last_spawn`,
+  which rewrites `last-spawn.json` wholesale — and `last_session_id()` reads
+  that file's `session_id` back as the global lane. A patrol therefore still
+  left its thread there, and the next wake without a conversation resumed it:
+  the same bleed 0.5.6 set out to remove, one door further along. Caught on a
+  live host, not in review — after upgrading, the tick correctly dropped
+  `--resume` and left the room's lane alone, but `last-spawn.json` still moved.
+
+### Notes
+- `read_analyze` already carried the owner's value through this call for the
+  same reason; periodic wakes now share that path. The spawn record still
+  captures the tick's rc/stderr, so operators lose no diagnostics.
+- Anyone who ran 0.5.6 should check `.meta/last-spawn.json`: if its
+  `session_id` points at a patrol session, setting it to `null` makes the next
+  conversation-less wake start clean.
+
+## [0.5.6] — 2026-08-30
+
+### Changed
+- Every claude_code wake now passes `--autocompact 200k`. A lane is re-read in
+  full on every wake, so an unbounded one charges its whole history each time —
+  one agent's lane climbed to 1.07M cached tokens and was replaying all of it 96
+  times a day to add a few thousand tokens of new content. An explicit size is
+  used rather than `auto` because `auto` tracks the model's own window (1M on
+  opus), which is precisely the runaway being bounded. This prevents what
+  `_is_context_exhausted` (0.5.x, #114) only cures after a wake has already
+  failed and its session been discarded.
+- A timer-fired wake (`message_id="remind:<id>:<n>"`) now runs in a throwaway
+  session: it does not resume a lane, does not record one, and its failure may
+  not clear one. A reminder tick is a stateless patrol — what it must decide
+  comes from the room's current state, which it reads live, not from what it
+  said on the previous tick.
+
+### Notes
+- Recording a patrol's session as the room's lane was the same bleed as #95,
+  arriving by another door: the next human to speak in that room inherited the
+  timer's accumulated history. Ordinary wakes are unaffected — a human message
+  in that same room still resumes the room's lane and still records its session.
+- Hosts on 0.5.5 will see supervision-style agents start each tick fresh. That
+  is the change, not a regression: such an agent should be reading the room, not
+  replaying itself.
+
 ## [0.5.5] — 2026-08-27
 
 ### Changed

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

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

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

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

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

@@ -474,6 +474,16 @@ class ClaudeRunner:
         "no rollout found for thread",
     )
 
+    #: #114 followup — ``--autocompact`` window for claude_code wakes.
+    #:
+    #: An explicit size rather than ``auto``: ``auto`` tracks the model's own
+    #: window (1M on opus), which is the runaway this exists to bound — a lane
+    #: is replayed in full on every wake, so "compacts just before overflow"
+    #: still means every wake pays for a near-window-sized history. 200k keeps
+    #: days of one room's working context while cutting per-wake replay ~5x.
+    #: The CLI accepts ``auto`` or 100k–1M (``claude --help``).
+    AUTOCOMPACT_WINDOW: str = "200k"
+
     #: #114 — 上下文窗口撑满。这是**永久性**前提失败,不是瞬时错误:退避几秒
     #: 再把同一份历史送一次,必然再次溢出。codex 自己给出的处置就是 "Start a
     #: new thread or clear earlier history",与 stale-session 的补救动作完全
@@ -692,6 +702,10 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
             context_exhausted = self._is_context_exhausted(attempt)
             if (
                 self._run_mode_for(payload) != "read_analyze"
+                # A periodic wake resumed nothing, so a stale/exhausted session
+                # is not its to drop — clearing here would evict the lane the
+                # room's humans are still using.
+                and not self._is_periodic_wake(payload)
                 and attempt.exit_code != 0
                 and (
                     any(
@@ -781,6 +795,10 @@ 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"
+        # #114 followup — a periodic wake ran in a throwaway session (it never
+        # resumed one). Recording it would hand the room's humans a lane whose
+        # history is a patrol tick, which is the bleed we just removed.
+        is_periodic = self._is_periodic_wake(payload)
         # #95 — 所有引擎都按 conversation_id 分轨存会话；全局 last_session 仍写
         # （last-spawn.json 可观测性 + 非平台唤醒兜底），但平台唤醒的 resume
         # 只读 lane（见 _build_cmd），不会被别的频道的会话覆盖。
@@ -792,7 +810,7 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
         # 把 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 not is_read_analyze and not is_periodic:
                 if conv_for_lane:
                     self._set_lane(ws, conv_for_lane, captured_session)
                 ws.set_last_session_id(captured_session)
@@ -977,8 +995,13 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
         # 的读取源(下次 resume 依据)。read_analyze 若把自己的 thread 写进去就会
         # 渗进 owner 的 full 会话,故这里保留 owner 轨原有 session_id(仍记录本次
         # 的 exit_code/stderr 供调试),read_analyze 的 thread 不落任何持久轨。
+        # A periodic wake is throwaway for the SAME reason: it resumed nothing,
+        # so recording its thread here would publish it as the global lane and
+        # the next wake without a conversation would resume the patrol.
         spawn_record_session = (
-            ws.last_session_id() if is_read_analyze else captured_session
+            ws.last_session_id()
+            if (is_read_analyze or is_periodic)
+            else captured_session
         )
         ws.write_last_spawn(rc, spawn_record_session, stderr_tail)
 
@@ -1380,6 +1403,7 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
         model, reasoning_effort = self._model_and_effort_for(ws, payload)
         runtime_env = self._runtime_env_for(ws, payload)
         run_mode = self._run_mode_for(payload)
+        periodic = self._is_periodic_wake(payload)
         scratch_dir = (
             self._readonly_scratch_dir(ws, payload)
             if run_mode == "read_analyze"
@@ -1395,6 +1419,7 @@ The daemon discards stdout — only the mcp tool call reaches the channel.
             reasoning_effort=reasoning_effort,
             run_mode=run_mode,
             scratch_dir=scratch_dir,
+            periodic=periodic,
             conversation_id=(
                 str(payload["conversation_id"])
                 if payload.get("conversation_id") else None
@@ -1918,6 +1943,27 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
         raw = payload.get("run_mode")
         return "read_analyze" if raw == "read_analyze" else "full"
 
+    @staticmethod
+    def _is_periodic_wake(payload: dict) -> bool:
+        """True for a timer-fired wake — one occurrence of a reminder.
+
+        Backend stamps these with the synthetic message id
+        ``remind:<reminder_id>:<occurrence>``.
+
+        A periodic wake is a *stateless patrol*: what it has to decide comes
+        from the room's CURRENT state, which it reads live (platform_read),
+        not from what it said on the previous tick. So it neither resumes a
+        lane nor writes one back — it runs in its own throwaway session.
+
+        Before this, a 15-minute supervision timer resumed its channel's lane
+        96 times a day, replaying an ever-growing history to contribute a few
+        thousand tokens of new content — the replay reached ~1M tokens per
+        wake — and left that history behind for the humans in the room to
+        inherit on their next message.
+        """
+        mid = payload.get("message_id")
+        return isinstance(mid, str) and mid.startswith("remind:")
+
     def _readonly_scratch_dir(
         self, ws: AgentWorkspaceLike, payload: dict
     ) -> "Path":
@@ -2217,6 +2263,7 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
         run_mode: str = "full",
         scratch_dir: "Path | None" = None,
         conversation_id: str | None = None,
+        periodic: bool = False,
     ) -> list[str]:
         """Build the ``claude`` argv list for one wake.
 
@@ -2243,7 +2290,7 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
         # 在哪个频道被唤醒都 --resume 同一条会话。
         last_session = (
             self._lane_session(ws, conversation_id)
-            if (with_resume and not read_analyze) else None
+            if (with_resume and not read_analyze and not periodic) else None
         )
         if runtime_engine == "codex":
             binary = self.runtime_binaries.get("codex") or "codex"
@@ -2378,6 +2425,16 @@ TASKS (频道任务板) — 频道里的分工协作走任务认领原语，纪
             cmd += ["--model", model]
         if reasoning_effort:
             cmd += ["--effort", reasoning_effort]
+        # #114 followup — cap the context BEFORE it overflows.
+        #
+        # ``_is_context_exhausted`` is the cure and it is expensive: the wake
+        # has already failed, and the remedy throws the whole session away.
+        # ``--autocompact`` is the prevention — the CLI folds older turns into
+        # a summary at the threshold, so a long-lived lane keeps its thread
+        # instead of being discarded whole. It also bounds what every wake
+        # REPLAYS, which is the larger bill: a lane is re-read in full on each
+        # wake, so an unbounded one charges its entire history every time.
+        cmd += ["--autocompact", self.AUTOCOMPACT_WINDOW]
         if last_session:
             cmd += ["--resume", last_session]
         # 1i Bug F — inject operational contract via --append-system-prompt.

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

@@ -3846,3 +3846,140 @@ async def test_no_conversation_id_means_no_notice_but_never_a_crash_of_the_wake(
         if inv.get("tool_name") == "platform_send"
     ]
     assert not sends
+
+
+# ---------------------------------------------------------------------------
+# #114 followup — bound what a wake replays (A: --autocompact), and keep
+# timers off the room's thread (B: a periodic wake is a throwaway session).
+#
+# Both target the same bill from opposite ends. A lane is re-read IN FULL on
+# every wake, so an unbounded one charges its whole history each time; a
+# 15-minute timer made that 96 times a day while contributing a few thousand
+# tokens of new content, and left the accumulated patrol history behind for
+# whoever spoke in the room next.
+# ---------------------------------------------------------------------------
+
+
+def _reminder_payload(reminder_id: str = "rem_1", occurrence: int = 0, **extra) -> dict:
+    """A timer wake as the backend stamps it: ``remind:<reminder_id>:<n>``."""
+    return {
+        **_make_payload(message_id=f"remind:{reminder_id}:{occurrence}"),
+        **extra,
+    }
+
+
+async def test_every_claude_wake_caps_its_context_window(
+    stateful_fake_claude, tmp_path
+):
+    """A — the cap is on every wake, not only the ones that already grew."""
+    mcp_cfg = tmp_path / "mcp.json"; mcp_cfg.write_text("{}")
+    ws = FakeWorkspace(FakeAgentWorkspace(mcp_path=mcp_cfg, last_session=None))
+    runner = _build_runner(
+        stateful_fake_claude([_claude_ok("s1")]), ws, FakeOutbound()
+    )
+
+    await runner.run_one("agent-A", _make_payload())
+
+    argv = _read_argv_n(tmp_path, 0)
+    assert argv[argv.index("--autocompact") + 1] == ClaudeRunner.AUTOCOMPACT_WINDOW
+
+
+async def test_periodic_wake_does_not_resume_the_rooms_lane(
+    stateful_fake_claude, tmp_path
+):
+    """B — a patrol reads the room's CURRENT state; it must not replay its past."""
+    mcp_cfg = tmp_path / "mcp.json"; mcp_cfg.write_text("{}")
+    (tmp_path / ".meta").mkdir(exist_ok=True)
+    (tmp_path / ".meta" / "sessions.json").write_text(
+        json.dumps({"conv_room": "human_thread"})
+    )
+    ws = FakeWorkspace(FakeAgentWorkspace(mcp_path=mcp_cfg, last_session=None))
+    runner = _build_runner(
+        stateful_fake_claude([_claude_ok("patrol_thread")]), ws, FakeOutbound()
+    )
+
+    await runner.run_one("agent-A", _reminder_payload(conversation_id="conv_room"))
+
+    assert "--resume" not in _read_argv_n(tmp_path, 0)
+
+
+async def test_periodic_wake_leaves_the_rooms_lane_untouched(
+    stateful_fake_claude, tmp_path
+):
+    """B — and it writes nothing back: neither the room's lane nor the global.
+
+    This is the regression itself. A timer that records its throwaway session
+    hands its patrol history to the next human who speaks in that room.
+    """
+    mcp_cfg = tmp_path / "mcp.json"; mcp_cfg.write_text("{}")
+    (tmp_path / ".meta").mkdir(exist_ok=True)
+    (tmp_path / ".meta" / "sessions.json").write_text(
+        json.dumps({"conv_room": "human_thread"})
+    )
+    agent_ws = FakeAgentWorkspace(mcp_path=mcp_cfg, last_session=None)
+    runner = _build_runner(
+        stateful_fake_claude([_claude_ok("patrol_thread")]),
+        FakeWorkspace(agent_ws),
+        FakeOutbound(),
+    )
+
+    await runner.run_one("agent-A", _reminder_payload(conversation_id="conv_room"))
+
+    lanes = json.loads((tmp_path / ".meta" / "sessions.json").read_text())
+    assert lanes == {"conv_room": "human_thread"}   # patrol_thread did NOT land
+    assert agent_ws.set_calls == []                 # nor did the global lane move
+
+
+async def test_periodic_wake_does_not_publish_itself_as_the_global_lane(
+    stateful_fake_claude, tmp_path
+):
+    """B — the global lane has TWO writers; a patrol may use neither.
+
+    ``set_last_session_id`` is the obvious one, but ``write_last_spawn``
+    rewrites last-spawn.json wholesale — and ``last_session_id()`` reads its
+    ``session_id`` back as the global lane. Blocking only the first still let
+    a patrol publish its throwaway thread, so the next wake with no
+    conversation resumed it. read_analyze already carried the owner's value
+    through here for exactly this reason; a periodic wake now does too.
+    """
+    mcp_cfg = tmp_path / "mcp.json"; mcp_cfg.write_text("{}")
+    agent_ws = FakeAgentWorkspace(mcp_path=mcp_cfg, last_session="owner_thread")
+    runner = _build_runner(
+        stateful_fake_claude([_claude_ok("patrol_thread")]),
+        FakeWorkspace(agent_ws),
+        FakeOutbound(),
+    )
+
+    await runner.run_one("agent-A", _reminder_payload(conversation_id="conv_room"))
+
+    assert agent_ws.write_last_spawn_calls, "the spawn record is still written"
+    recorded_session = agent_ws.write_last_spawn_calls[-1][1]
+    assert recorded_session == "owner_thread"   # NOT patrol_thread
+
+
+async def test_ordinary_wake_in_that_room_still_resumes_and_records(
+    stateful_fake_claude, tmp_path
+):
+    """B control — only TIMER wakes are throwaway. A human message in the same
+    room still resumes that room's lane and still records its session."""
+    mcp_cfg = tmp_path / "mcp.json"; mcp_cfg.write_text("{}")
+    (tmp_path / ".meta").mkdir(exist_ok=True)
+    (tmp_path / ".meta" / "sessions.json").write_text(
+        json.dumps({"conv_room": "human_thread"})
+    )
+    agent_ws = FakeAgentWorkspace(mcp_path=mcp_cfg, last_session=None)
+    runner = _build_runner(
+        stateful_fake_claude([_claude_ok("human_thread_2")]),
+        FakeWorkspace(agent_ws),
+        FakeOutbound(),
+    )
+
+    await runner.run_one(
+        "agent-A", {**_make_payload(), "conversation_id": "conv_room"}
+    )
+
+    argv = _read_argv_n(tmp_path, 0)
+    assert argv[argv.index("--resume") + 1] == "human_thread"
+    lanes = json.loads((tmp_path / ".meta" / "sessions.json").read_text())
+    assert lanes == {"conv_room": "human_thread_2"}
+    assert agent_ws.set_calls == ["human_thread_2"]

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

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

cloudagent_daemon-0.5.5/src/cloudagent_daemon/__init__.py

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