@cello-protocol/cli 0.0.142 → 0.0.144

package/dist/hermes/assets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../src/hermes/assets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,sEAAsE;AACtE,eAAO,MAAM,kBAAkB,w4CA6B9B,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,QAkjCjC,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,eAAe,60GAiE3B,CAAC"}
+{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../src/hermes/assets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,sEAAsE;AACtE,eAAO,MAAM,kBAAkB,w4CA6B9B,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,QAurCjC,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,eAAe,60GAiE3B,CAAC"}

package/dist/hermes/assets.js

@@ -150,6 +150,28 @@ CALL_TIMEOUT_SECONDS = 30.0
 # Server-side wait for the adapter's own cello_receive. Short on purpose: the notification that
 # triggered it means the content is already durable, so this is a fetch, not a poll.
 RECEIVE_TIMEOUT_MS = 5000
+
+# State notices that channel mode does NOT hand to the agent, because a message follows within
+# about a second and the notice's only effect is to occupy the agent at exactly the moment the
+# message needs it free. Observed live 2026-08-07: 'created' started a turn, the message then
+# found the chat busy, and the whole feature fell back to the manual path - the one time it
+# worked, the agent had answered the notice with a bare [SILENT] and freed itself in time. The
+# difference between "it works" and "it does nothing" was that race.
+#
+# A DENYLIST, deliberately: an unrecognised state is DELIVERED. Terminal ones (sealed, closed,
+# interrupted) carry the only information about themselves - nothing follows them - so dropping
+# an unknown state would be the silent kind of wrong.
+STATE_WAKES_SUPPRESSED_IN_CHANNEL = {"created"}
+
+# When the chat is mid-turn, wait for it rather than immediately downgrading to a notice. Turns
+# end in seconds; fetching DURING one is the one thing that can lose a message outright. Total
+# patience is LIMIT x DELAY before the notice fallback.
+BUSY_RETRY_LIMIT = 5
+BUSY_RETRY_DELAY_SECONDS = 2.0
+# Upper bound on one drain. A conversation that has been away a long time can have a lot
+# queued; handing an agent an unbounded turn is its own failure. Hitting this logs loudly -
+# a silent truncation would read as "the agent saw everything" when it did not.
+MAX_DRAIN_MESSAGES = 25
 # Matches the daemon IPC server's MAX_BUFFER_SIZE (4 MB).
 MAX_LINE_BYTES = 4 * 1024 * 1024
 
@@ -281,6 +303,8 @@ class CelloAdapter(BasePlatformAdapter):
         # may execute before there is one.
         self._wake_queue: Optional[asyncio.Queue] = None
         self._wake_task: Optional[asyncio.Task] = None
+        # Live references to pending busy-retry timers (see _requeue_wake_later).
+        self._retry_tasks: set = set()
         self._pending: Dict[str, asyncio.Future] = {}
         self._next_id = 1
         self._closing = False
@@ -369,6 +393,12 @@ class CelloAdapter(BasePlatformAdapter):
         for task in (self._read_task, self._reconnect_task, self._wake_task):
             if task is not None and not task.done():
                 task.cancel()
+        # Pending retries name a chat that is going away; leaving them running would re-queue
+        # wakes against a dead socket after disconnect.
+        for task in list(self._retry_tasks):
+            if not task.done():
+                task.cancel()
+        self._retry_tasks.clear()
         self._read_task = None
         self._reconnect_task = None
         self._wake_task = None
@@ -418,6 +448,29 @@ class CelloAdapter(BasePlatformAdapter):
         if self._wake_task is None or self._wake_task.done():
             self._wake_task = asyncio.create_task(self._wake_worker())
 
+    def _requeue_wake_later(self, frame: Dict[str, Any], delay: float) -> None:
+        """Put a wake back on the queue after the given delay, off the worker.
+
+        A plain sleep inside the worker would stall EVERY other agent's wake behind this one
+        chat's turn, which is the opposite of what the retry is for.
+        """
+        async def _later() -> None:
+            try:
+                await asyncio.sleep(delay)
+                if self._closing or self._wake_queue is None:
+                    return
+                self._wake_queue.put_nowait(frame)
+            except asyncio.CancelledError:
+                raise
+            except Exception:
+                logger.exception("[cello] Failed to re-queue a wake after a busy turn")
+
+        task = asyncio.create_task(_later())
+        # Hold a reference: asyncio only keeps a WEAK one, so an un-held task can be garbage
+        # collected mid-sleep and the wake would vanish with it.
+        self._retry_tasks.add(task)
+        task.add_done_callback(self._retry_tasks.discard)
+
     async def _wake_worker(self) -> None:
         while True:
             frame = await self._wake_queue.get()
@@ -591,45 +644,90 @@ class CelloAdapter(BasePlatformAdapter):
         notifications per connection (so this is the connection that was woken), and the
         read-before-send gate (M8C-CURSOR-1) tracks a per-connection cursor - so reading here is
         exactly what later lets send() through on the same socket.
+
+        DRAIN, not a single read. cello_receive serves THIS CONNECTION's oldest unread message,
+        not the one the notification just announced - the two are the same only when the
+        connection is already caught up. On a conversation with any history behind it (which is
+        every existing conversation the first time this adapter attaches) the first read returns
+        a message from minutes ago, and the agent answers the wrong thing.
+
+        Worse, it then cannot answer at all: the read-before-send gate refuses a send while
+        anything is still unread, so the reply the agent just wrote is REFUSED and lost - the
+        agent believes it answered and the peer hears nothing. Observed live 2026-08-07 on
+        session 9bc456f6: adapter read seq 0 (five minutes stale), agent replied, two
+        session.send.blocked with unreadReceived=1, reply gone.
+
+        Draining fixes both: the agent sees everything waiting, in order, and the gate is clear
+        by the time it answers.
         """
-        try:
-            # An explicit SHORT server-side wait. The daemon's default is 30 s, which is exactly
-            # CALL_TIMEOUT_SECONDS - so the two would race and the client timeout could fire on a
-            # call the daemon was about to answer. The content this notification announces is
-            # already durable, so a long wait buys nothing.
-            result = await self._call(
-                "cello_receive",
-                {"session_id": session_id, "timeout_ms": RECEIVE_TIMEOUT_MS},
-                timeout=RECEIVE_TIMEOUT_MS / 1000.0 + 5.0,
-            )
-        except Exception as exc:
-            # Name the EXCEPTION TYPE: asyncio.TimeoutError stringifies to "", so "%s" alone
-            # produced a log line that named a session and no cause at all - pointing the operator
-            # at the daemon when the fault could be entirely local.
-            logger.error(
-                "[cello] Could not fetch content for session %s (%s: %r) - falling back to a wake "
-                "notice so the agent can still read it through the cello_* MCP tools",
-                session_id, exc.__class__.__name__, exc,
-            )
-            return None
-        if not isinstance(result, dict) or result.get("ok") is False:
-            reason = result.get("reason") if isinstance(result, dict) else "malformed_response"
-            logger.error(
-                "[cello] cello_receive refused session %s (%s) - falling back to a wake notice",
-                session_id, reason,
-            )
-            return None
-        content = result.get("content")
-        if not isinstance(content, str) or not content:
-            # An 'ok' answer with nothing in it (timed out, or a sibling connection took the
-            # message). An empty user turn tells the agent nothing; the wake notice at least
-            # names the session.
+        parts: list = []
+        for attempt in range(MAX_DRAIN_MESSAGES):
+            try:
+                # First read waits briefly for the announced message; every later read is
+                # non-blocking (timeout_ms 0) because it is only draining what is ALREADY there.
+                # An explicit SHORT server-side wait on the first: the daemon's default is 30 s,
+                # exactly CALL_TIMEOUT_SECONDS, so the two would race and the client could give up
+                # on a call the daemon was about to answer.
+                wait_ms = RECEIVE_TIMEOUT_MS if attempt == 0 else 0
+                result = await self._call(
+                    "cello_receive",
+                    {"session_id": session_id, "timeout_ms": wait_ms},
+                    timeout=wait_ms / 1000.0 + 5.0,
+                )
+            except Exception as exc:
+                # Name the EXCEPTION TYPE: asyncio.TimeoutError stringifies to "", so "%s" alone
+                # produced a log line that named a session and no cause at all - pointing the
+                # operator at the daemon when the fault could be entirely local.
+                logger.error(
+                    "[cello] Could not fetch content for session %s (%s: %r) - %s",
+                    session_id, exc.__class__.__name__, exc,
+                    "delivering the %d message(s) already read" % len(parts) if parts
+                    else "falling back to a wake notice so the agent can still read it through "
+                         "the cello_* MCP tools",
+                )
+                break
+            if not isinstance(result, dict) or result.get("ok") is False:
+                reason = result.get("reason") if isinstance(result, dict) else "malformed_response"
+                # Only the FIRST read's refusal is a failure to report; a later one just means the
+                # drain reached the end (e.g. the session sealed between reads).
+                if not parts:
+                    logger.error(
+                        "[cello] cello_receive refused session %s (%s) - falling back to a wake "
+                        "notice", session_id, reason,
+                    )
+                break
+            content = result.get("content")
+            if not isinstance(content, str) or not content:
+                # 'ok' with nothing in it: the queue is empty. On the FIRST read that means the
+                # message went to a sibling connection or timed out, and an empty user turn tells
+                # the agent nothing - the wake notice at least names the session.
+                if not parts:
+                    logger.warning(
+                        "[cello] cello_receive returned no content for session %s - falling back "
+                        "to a wake notice", session_id,
+                    )
+                break
+            parts.append(content)
+        else:
+            # Hit the cap with more possibly waiting. Say so: a silent truncation here reads as
+            # "the agent saw everything" when it did not, and the unread tail will keep the
+            # read-before-send gate closed.
             logger.warning(
-                "[cello] cello_receive returned no content for session %s - falling back to a "
-                "wake notice", session_id,
+                "[cello] Stopped draining session %s at %d messages; any remaining are still "
+                "unread and may block this agent's next reply until it catches up",
+                session_id, MAX_DRAIN_MESSAGES,
             )
+
+        if not parts:
             return None
-        return content
+        if len(parts) > 1:
+            logger.info(
+                "[cello] Delivered %d queued messages for session %s as one turn",
+                len(parts), session_id,
+            )
+        # Joined into ONE turn rather than emitted as several events: they share a session, so
+        # they share an anchor, and one turn means one reply - which is what the peer expects.
+        return "\n\n".join(parts)
 
     async def _on_notification(self, frame: Dict[str, Any]) -> None:
         kind = str(frame.get("notification", ""))
@@ -666,6 +764,21 @@ class CelloAdapter(BasePlatformAdapter):
             )
             return
 
+        # The phantom doorbell. In channel mode a 'created' notice announces a conversation that
+        # the message arriving a second later announces better - and handing it to the agent
+        # starts a turn that makes the agent BUSY exactly when the message needs it free.
+        if (
+            self._delivery_mode == "channel"
+            and kind == "session_state_changed"
+            and _safe_scalar(data.get("state")) in STATE_WAKES_SUPPRESSED_IN_CHANNEL
+        ):
+            logger.debug(
+                "[cello] Not waking the agent for a '%s' state notice on session %s - the message "
+                "that follows carries everything it says", _safe_scalar(data.get("state")),
+                session_id,
+            )
+            return
+
         counterparty = self._counterparty_of(kind, data)
         chat_id = self._chat_id_for(counterparty)
         if chat_id is None:
@@ -714,12 +827,32 @@ class CelloAdapter(BasePlatformAdapter):
         # not provide is worse than no check. Computed once here and reused below.
         session_key = self._session_key_for(source)
         text = None
-        if (
-            self._delivery_mode == "channel"
-            and kind == "cello_message"
-            and session_key not in self._active_sessions
-        ):
-            text = await self._fetch_content(session_id)
+        if self._delivery_mode == "channel" and kind == "cello_message":
+            if session_key in self._active_sessions:
+                # BUSY: wait for the turn rather than downgrading on the spot. Immediately falling
+                # back to the notice sent the agent down the manual path for every message that
+                # happened to land mid-turn - which is most of them, since the agent is busy more
+                # often than not. Retrying costs the peer a couple of seconds; the alternative
+                # costs them the feature. Fetching anyway is NOT an option: it consumes the
+                # message, and a busy chat's queued event can be merged or replaced.
+                attempts = frame.get("_cello_busy_retries", 0)
+                if isinstance(attempts, int) and attempts < BUSY_RETRY_LIMIT:
+                    frame["_cello_busy_retries"] = attempts + 1
+                    logger.debug(
+                        "[cello] %s is mid-turn; re-trying the fetch for session %s in %.0fs "
+                        "(attempt %d of %d)",
+                        session_key, session_id, BUSY_RETRY_DELAY_SECONDS,
+                        attempts + 1, BUSY_RETRY_LIMIT,
+                    )
+                    self._requeue_wake_later(frame, BUSY_RETRY_DELAY_SECONDS)
+                    return
+                logger.info(
+                    "[cello] %s stayed mid-turn for %.0fs; handing the agent a notice for session "
+                    "%s instead of the message, so it can still read it with the cello_* tools",
+                    session_key, BUSY_RETRY_LIMIT * BUSY_RETRY_DELAY_SECONDS, session_id,
+                )
+            else:
+                text = await self._fetch_content(session_id)
         if text is None:
             text = self._wake_prompt(kind, data)
         event = MessageEvent(

package/dist/hermes/assets.js.map

@@ -1 +1 @@
-{"version":3,"file":"assets.js","sourceRoot":"","sources":["../../src/hermes/assets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,sEAAsE;AACtE,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BjC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkjC9C,CAAC;AAEF,wEAAwE;AACxE,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiE9B,CAAC"}
+{"version":3,"file":"assets.js","sourceRoot":"","sources":["../../src/hermes/assets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,sEAAsE;AACtE,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BjC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAurC9C,CAAC;AAEF,wEAAwE;AACxE,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiE9B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cello-protocol/cli",
-  "version": "0.0.142",
+  "version": "0.0.144",
   "private": false,
   "type": "module",
   "engines": {
@@ -17,8 +17,8 @@
     "package.json"
   ],
   "dependencies": {
-    "@cello-protocol/protocol-types": "0.0.47",
-    "@cello-protocol/daemon": "0.0.138"
+    "@cello-protocol/daemon": "0.0.138",
+    "@cello-protocol/protocol-types": "0.0.47"
   },
   "devDependencies": {
     "@types/node": "^25.6.2"