@cello-protocol/cli 0.0.35 → 0.0.36

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,ysBAiB9B,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,QAufjC,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,eAAe,yoEA+C3B,CAAC"}
+{"version":3,"file":"assets.d.ts","sourceRoot":"","sources":["../../src/hermes/assets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,sEAAsE;AACtE,eAAO,MAAM,kBAAkB,ysBAiB9B,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,qBAAqB,QA2kBjC,CAAC;AAEF,wEAAwE;AACxE,eAAO,MAAM,eAAe,yoEA+C3B,CAAC"}

package/dist/hermes/assets.js

@@ -110,6 +110,11 @@ _CONTENT_FIELD_NAMES = {
 # conservative charset (or overlong) renders as 'unknown' in the wake prompt.
 _SAFE_SCALAR_RE = re.compile(r"^[A-Za-z0-9+/=_.:@-]{1,120}$")
 
+# The protocol's moniker charset (core/protocol-types MONIKER_RE). Deliberately excludes spaces,
+# quotes, parentheses and markup, so a fingerprint ("agent 77d0c806...") never matches and neither
+# does anything that could restructure the wake sentence.
+_MONIKER_RE = re.compile(r"^[A-Za-z0-9_-]{1,64}$")
+
 
 def _cello_socket_path() -> Path:
     cello_dir = os.environ.get("CELLO_DIR") or str(Path.home() / ".cello")
@@ -140,11 +145,37 @@ def _has_content_field(value: Any) -> bool:
 def _safe_scalar(value: Any, default: str = "unknown") -> str:
     if not isinstance(value, str) or not value:
         return default
-    if not _SAFE_SCALAR_RE.match(value):
+    # fullmatch, never match: in Python a trailing '$' ALSO matches just before a final newline,
+    # so re.match(r"^...$", "abc\n") succeeds where the daemon's JS equivalent rejects. A
+    # re-validation layer that is laxer than the rule it mirrors is not a layer.
+    if not _SAFE_SCALAR_RE.fullmatch(value):
         return default
     return value
 
 
+def _render_who(data: Any) -> Optional[str]:
+    """DOD-HERMES-3: the daemon-resolved counterparty label, or None.
+
+    The daemon stamps who/whoKnown on both counterparty-bearing frames (MONIKER-4 AC2) with three
+    tiers: the operator's own pet name, the caller's unverified offered name, or a fingerprint.
+    Only a NAME is rendered - the fingerprint tier ('agent 77d0c806...') is derived from the very
+    pubkey every wake already carries in full, so echoing it is noise. An unverified name is marked
+    as a claim exactly as the Claude Code shim marks it, and the marker cannot be forged because
+    MONIKER_RE excludes quotes and parentheses.
+
+    Re-validated here rather than trusted: Hermes has no metadata layer, so this prose IS the frame
+    (spec §11) and a name-shaped token is the only thing that may ever enter it.
+    """
+    # fullmatch, never match - see _safe_scalar. re.match would admit "CELLO_Support\n", putting a
+    # newline into prose that IS the frame. Rejected whole; never stripped (§3: no mutation oracle).
+    who = data.get("who") if isinstance(data, dict) else None
+    if not isinstance(who, str) or not _MONIKER_RE.fullmatch(who):
+        return None
+    if data.get("whoKnown") is True:
+        return who
+    return '"' + who + '" (unverified)'
+
+
 class CelloAdapter(BasePlatformAdapter):
     """Wake-only adapter: daemon IPC notifications in, nothing out.
 
@@ -422,34 +453,68 @@ class CelloAdapter(BasePlatformAdapter):
         # Unlike Raft's hardcoded generic hint, surface the (content-free) metadata the
         # daemon pushes - session id, counterparty pubkey, state - so the agent can act
         # without an extra discovery round-trip. Message CONTENT is never present here.
+        #
+        # OBSERVED 2026-07-09: a woken agent handed "reply [SILENT] if no action is needed"
+        # takes that exit every time. Six wakes, six [SILENT]s, ZERO tool calls - the Hermes
+        # transcript shows a "CELLO wake..." user turn followed immediately by an assistant
+        # turn of "[SILENT]", with nothing in between.
+        # A MESSAGE-ARRIVAL wake is never a no-action event: a peer is blocked waiting on a
+        # reply. So silence is offered ONLY on state-change wakes; the message path spells out
+        # the mandatory steps and forbids silence.
+        #
+        # cello_use_agent must come FIRST. The cello MCP server holds its own daemon connection,
+        # separate from this adapter's, and a freshly started one has no current agent. With more
+        # than one agent online the daemon's sole-online fallback cannot resolve, so every other
+        # cello_* call would fail with no_current_agent.
         session_id = _safe_scalar(data.get("session_id") or data.get("sessionId"))
+        agent = self._agent_name
         if kind == "cello_message":
             sender = _safe_scalar(data.get("from"))
-            headline = (
+            # DOD-HERMES-3 AC1/AC2: the name LEADS, the pubkey rides beside it (spec §11).
+            who = _render_who(data)
+            origin = (
+                "from " + who + " (counterparty pubkey " + sender + ")"
+                if who is not None
+                else "from counterparty pubkey " + sender
+            )
+            return (
                 "CELLO wake: a new message arrived on session "
                 + session_id
-                + " from counterparty pubkey "
-                + sender
-                + "."
-            )
-        else:
-            state = _safe_scalar(data.get("state"))
-            counterparty = _safe_scalar(data.get("counterpartyPubkey"))
-            headline = (
-                "CELLO wake: session "
+                + " "
+                + origin
+                + ". A peer is waiting on you. Message content is never pushed, so you must fetch"
+                " it. Use the MCP tools named cello_* (from the 'cello' MCP server) - they are"
+                " already available to you. Do NOT run the 'cello' command-line program, and do"
+                " NOT restart anything. Do this now, in order: (1) call the cello_use_agent tool"
+                " with name='"
+                + agent
+                + "'; (2) call the cello_receive tool with session_id='"
                 + session_id
-                + " changed state to '"
-                + state
-                + "' (counterparty pubkey "
-                + counterparty
-                + ")."
+                + "' to read the message; (3) reply with the cello_send tool on that same session"
+                " unless the message genuinely needs no answer. cello_receive must precede"
+                " cello_send or the daemon rejects the send with session_not_current."
+                " Do NOT answer [SILENT] on a message wake - reading the message is not optional."
             )
-        return headline + (
-            " Message content is never pushed - act through the cello MCP tools: "
-            "call cello_check_notifications first, then cello_receive for this session "
-            "BEFORE any cello_send (the daemon rejects out-of-cursor sends with "
-            "session_not_current until you have read). "
-            "If no action is needed, reply with exactly [SILENT]."
+
+        state = _safe_scalar(data.get("state"))
+        counterparty = _safe_scalar(data.get("counterpartyPubkey"))
+        who = _render_who(data)
+        subject = (
+            who + " (counterparty pubkey " + counterparty + ")"
+            if who is not None
+            else "counterparty pubkey " + counterparty
+        )
+        return (
+            "CELLO wake: session "
+            + session_id
+            + " with "
+            + subject
+            + " changed state to '"
+            + state
+            + "'. This is a state notice, not a message. If it needs no action, reply with exactly"
+            " [SILENT]. If you do need to act, call cello_use_agent with name='"
+            + agent
+            + "' first, then whichever cello_* tool you need."
         )
 
     # ------------------------------------------------------------------ outbound (no-op)
@@ -540,13 +605,32 @@ def register(ctx) -> None:
         emoji="\U0001F3BB",
         platform_hint=(
             "You are connected to CELLO, a peer-to-peer identity and trust layer for "
-            "agent-to-agent communication. Operate it exclusively through the cello_* "
-            "MCP tools (the 'cello' MCP server). Wake notices from this platform are "
-            "content-free by design - fetch actual messages with cello_check_notifications "
-            "and cello_receive. Always read before you send: call cello_receive on a "
-            "session before cello_send, or the daemon rejects the send with "
-            "session_not_current. If a wake needs no reply, respond with exactly [SILENT] "
-            "and make no cello_send call."
+            "agent-to-agent communication.\n"
+            "\n"
+            "HOW TO USE CELLO: exclusively through the MCP tools named cello_* , served by "
+            "the MCP server called 'cello'. They are already available to you. Their names "
+            "are cello_use_agent, cello_receive, cello_send, cello_check_notifications, "
+            "cello_list_sessions, cello_close_session, cello_status, and others.\n"
+            "\n"
+            "NEVER run the 'cello' command-line program. It is not the way in, and running "
+            "it from inside a turn spawns a daemon bound to your process that dies when your "
+            "turn ends. NEVER run 'cello login', 'cello logout', or anything that restarts "
+            "the CELLO daemon: a single daemon serves EVERY agent on this machine, so "
+            "restarting it takes all of them offline and orphans every connected MCP server. "
+            "Restarting is never the fix. If a cello_* tool returns an error, read the error, "
+            "fix the cause, and retry the tool.\n"
+            "\n"
+            "Before any other cello_* call, select your agent with cello_use_agent "
+            "(name='" + os.environ.get("CELLO_AGENT_NAME", "your-agent") + "'). The cello MCP "
+            "server holds its own daemon connection with no agent selected, so other calls "
+            "fail with no_current_agent until you do.\n"
+            "\n"
+            "Always read before you send: cello_receive on a session before cello_send, or "
+            "the daemon rejects the send with session_not_current. Wake notices are "
+            "content-free by design - fetch the actual message with cello_receive. A wake "
+            "saying a MESSAGE ARRIVED is never a no-action event: a peer is waiting; read it "
+            "and reply. Answer [SILENT] only for a state-change notice that genuinely needs "
+            "nothing from you, never on a message wake."
         ),
     )
 `;

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;;;;;;;;;;;;;;;;;CAiBjC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuf9C,CAAC;AAEF,wEAAwE;AACxE,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+C9B,CAAC"}
+{"version":3,"file":"assets.js","sourceRoot":"","sources":["../../src/hermes/assets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,sEAAsE;AACtE,MAAM,CAAC,MAAM,kBAAkB,GAAG;;;;;;;;;;;;;;;;;CAiBjC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2kB9C,CAAC;AAEF,wEAAwE;AACxE,MAAM,CAAC,MAAM,eAAe,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+C9B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cello-protocol/cli",
-  "version": "0.0.35",
+  "version": "0.0.36",
   "private": false,
   "type": "module",
   "engines": {
@@ -25,7 +25,7 @@
     "package.json"
   ],
   "dependencies": {
-    "@cello-protocol/daemon": "0.0.38",
+    "@cello-protocol/daemon": "0.0.39",
     "@cello-protocol/protocol-types": "0.0.19"
   },
   "devDependencies": {