Stale-session guard for coordination, README entry for the field-bug batch

ClaudeR 0.12.1 / clauder-mcp 0.14.1. Field report: an agent still
pointed at a dead R session got success from send_message while the
event landed in a coordination log no live agent reads. Root cause:
get_r_addin_url keeps the stale session name when zero sessions are
alive, so _coord_dir resolved to the dead session directory.

New _coord_target resolver runs before every coordination call
(send_message, check_messages, wait_for_message, coordination_roster).
With no live R session it fails loudly and writes nothing. When the
connection re-binds to a different live session it prepends a NOTE
saying earlier sends may sit in the old log unseen. wait_for_message
also re-checks liveness every poll so a mid-wait death aborts instead
of hanging silently.

Protocol gains a delivery-guarantees paragraph. README gains the
combined Recent Updates entry for the 0.12.x field-bug batch. Three
new pytest cases cover dead session, re-bind note, and quiet stable
binding (33 total).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: IMNMV

DESCRIPTION

@@ -1,6 +1,6 @@
 Package: ClaudeR
 Title: R Integration for Claude AI
-Version: 0.12.0
+Version: 0.12.1
 Authors@R: person("Nykko", "Vitali", email = "nykvt@icloud.com", role = c("aut", "cre"))
 Description: Connects RStudio with Claude AI to enable interactive coding sessions.
 License: MIT + file LICENSE

README.md

@@ -50,6 +50,8 @@ claudeAddin()
 <details>
 <summary><b>Recent Updates</b> (click to expand)</summary>
 
+- **Shared-connection identity, coordination visibility, and a stale-session guard (R 0.12.1 / clauder-mcp 0.14.1).** Three fixes from a live three-persona field session. (1) Personas sharing one MCP connection were renaming each other, because `set_agent_name` changes the identity of the whole connection. New `as_agent` parameter on `send_message`, `check_messages`, and `wait_for_message` acts as a named persona for one call, with a separate read cursor per name, and the agent intro now states where the current identity came from. (2) Coordination messages bypass R by design, so the console and the Agents panel showed nothing while agents talked. The addin now echoes each new coordination event to the console, appends it to the session log, and shows a live coordination roster with last-seen ages. (3) A bridge still pointed at a dead R session used to report "success" while writing to a coordination log no live agent reads. Coordination calls now fail loudly when no live session exists, and announce it when the connection re-binds to a different live session. Also from pilot 2: `check_cross_references` understands S-prefixed supplement numbering, and the audit protocol documents `unname()` for htest fields and author-plus-year citation matching.
+
 - **Agent identity and cross-restart history (R 0.11.0 / clauder-mcp 0.13.0).** Built from field reports of a multi-day, three-agent session. New `set_agent_name` tool: an agent sets its working name (for example "Claude-Stasis") once, and execution history, message attribution, presence, and its read cursor all carry that name. This fixes the case where several agents or personas share one MCP connection and collapse into a single random id. `get_session_history` gains `include_past`: it parses prior session log files on disk, so the audit of who ran what now survives R restarts. The coordination protocol now makes identity the first step of check-in.
 
 - **Researcher workflow release (R 0.10.0 / clauder-mcp 0.12.0).** Three workflows that paid tools charge for, built on machinery ClaudeR already had. (1) Systematic review screening: two independent AI screeners from different model families judge every abstract against your criteria, and the new `screening_report` tool computes agreement, Cohen's kappa, PRISMA flow counts, and the conflict set, so the human reads only the disagreements. (2) Grant Panel Mode: `grant_panel_prompt(rubric = "nih")` convenes a mock study section, one reviewer per criterion, anchored weaknesses, and a ranked list of revisions that would move the score. (3) Response to Reviewers: `reviewer_response_prompt()` parses a decision letter into a point-by-point registry, reruns analyses so answers carry real computed numbers, gates until every point is answered, and exports the response letter with `export_response_letter()` plus Word comments in the manuscript.

clauder-mcp/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "clauder-mcp"
-version = "0.14.0"
+version = "0.14.1"
 description = "MCP server connecting AI assistants to RStudio for interactive R coding and data analysis"
 readme = "README.md"
 requires-python = ">=3.10"

clauder-mcp/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/IMNMV/ClaudeR",
     "source": "github"
   },
-  "version": "0.14.0",
+  "version": "0.14.1",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "clauder-mcp",
-      "version": "0.14.0",
+      "version": "0.14.1",
       "transport": {
         "type": "stdio"
       }

clauder-mcp/src/clauder_mcp/server.py

@@ -430,6 +430,38 @@ def _coord_format(events: List[Dict[str, Any]]) -> str:
     return "\n".join(lines)
 
 
+_coord_bound: Optional[str] = None  # session whose log the last coordination call used
+
+
+def _coord_target() -> tuple:
+    """Resolve which session's log a coordination call will touch.
+
+    Returns (note, error), at most one non-None. Coordination logs are keyed
+    by session name on disk, so a bridge still bound to a dead session would
+    write to a log no live agent reads while reporting success (field bug:
+    get_r_addin_url keeps the stale name when zero sessions are alive). Fail
+    loudly in that case, and say so when the binding moves to a different
+    live session, because earlier traffic sits in the old log unseen."""
+    global _coord_bound
+    get_r_addin_url()  # re-binds _target_session to a live session if any exists
+    if not discover_sessions():
+        stale = _target_session or _coord_bound or "default"
+        return (None,
+                "FAILED: no live R session is running, so this call would use a "
+                f"stale coordination log (session '{stale}') that no live agent "
+                "reads. Nothing was written or read. Start the ClaudeR addin in "
+                "RStudio, confirm with list_sessions, then retry.")
+    session = _target_session or "default"
+    note = None
+    if _coord_bound is not None and _coord_bound != session:
+        note = (f"NOTE: this connection re-bound from session '{_coord_bound}' "
+                f"(gone) to live session '{session}' and now uses that session's "
+                "coordination log. Earlier sends may sit in the old log unseen. "
+                "Resend anything the other agents did not acknowledge.")
+    _coord_bound = session
+    return (note, None)
+
+
 # --- Annotation job helpers (subprocess-per-row batch mode) ---
 
 def _find_cli_path(tool: str) -> Optional[str]:
@@ -3015,53 +3047,71 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> List[types.TextCont
             return [types.TextContent(type="text", text="Error: 'body' is required")]
         if isinstance(body, str):
             body = {"text": body}
+        note, coord_err = _coord_target()
+        if coord_err:
+            return [types.TextContent(type="text", text=coord_err)]
         try:
             _coord_append(arguments.get("type", "message"), body,
                           to=arguments.get("to", "all"),
                           reply_to=arguments.get("reply_to"),
                           as_agent=arguments.get("as_agent"))
         except ValueError as e:
             return [types.TextContent(type="text", text=f"Error: {e}")]
-        result_contents.append(types.TextContent(
-            type="text", text="Message sent to the coordination log."
-        ))
+        reply = "Message sent to the coordination log."
+        if note:
+            reply = note + "\n" + reply
+        result_contents.append(types.TextContent(type="text", text=reply))
         return result_contents
 
     elif name == "check_messages":
         persona = arguments.get("as_agent")
+        note, coord_err = _coord_target()
+        if coord_err:
+            return [types.TextContent(type="text", text=coord_err)]
         unread = _coord_unread(as_agent=persona)
         if not unread:
-            result_contents.append(types.TextContent(
-                type="text", text="No unread coordination events."
-            ))
+            reply = "No unread coordination events."
+            if note:
+                reply = note + "\n" + reply
+            result_contents.append(types.TextContent(type="text", text=reply))
             return result_contents
         if arguments.get("ack", True):
             _coord_set_cursor(max(ev["id"] for ev in unread), as_agent=persona)
-        result_contents.append(types.TextContent(
-            type="text",
-            text=f"{len(unread)} unread event(s):\n" + _coord_format(unread)
-        ))
+        reply = f"{len(unread)} unread event(s):\n" + _coord_format(unread)
+        if note:
+            reply = note + "\n" + reply
+        result_contents.append(types.TextContent(type="text", text=reply))
         return result_contents
 
     elif name == "wait_for_message":
         timeout_s = min(float(arguments.get("timeout_s", 300)), 1800.0)
         from_agent = arguments.get("from_agent")
         ev_type = arguments.get("type")
         persona = arguments.get("as_agent")
+        note, coord_err = _coord_target()
+        if coord_err:
+            return [types.TextContent(type="text", text=coord_err)]
         waited = 0.0
         while waited < timeout_s:
             unread = _coord_unread(from_agent=from_agent, ev_type=ev_type,
                                    as_agent=persona)
             if unread:
                 _coord_set_cursor(max(ev["id"] for ev in unread), as_agent=persona)
-                result_contents.append(types.TextContent(
-                    type="text",
-                    text=(f"Event arrived after {round(waited)}s:\n" +
-                          _coord_format(unread))
-                ))
+                reply = (f"Event arrived after {round(waited)}s:\n" +
+                         _coord_format(unread))
+                if note:
+                    reply = note + "\n" + reply
+                result_contents.append(types.TextContent(type="text", text=reply))
                 return result_contents
             await asyncio.sleep(2)
             waited += 2
+            late_note, coord_err = _coord_target()
+            if coord_err:
+                return [types.TextContent(
+                    type="text",
+                    text=f"Aborted after {round(waited)}s of waiting. " + coord_err
+                )]
+            note = note or late_note
         result_contents.append(types.TextContent(
             type="text",
             text=(f"No matching event within {round(timeout_s)}s. The other "
@@ -3072,9 +3122,15 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> List[types.TextCont
 
     elif name == "coordination_roster":
         stale_after = float(arguments.get("stale_after_s", 900))
+        note, coord_err = _coord_target()
+        if coord_err:
+            return [types.TextContent(type="text", text=coord_err)]
         events = _coord_events()
         if not events:
-            return [types.TextContent(type="text", text="No coordination activity yet on this session.")]
+            reply = "No coordination activity yet on this session."
+            if note:
+                reply = note + "\n" + reply
+            return [types.TextContent(type="text", text=reply)]
         last: Dict[str, str] = {}
         for ev in events:
             last[ev.get("from", "?")] = ev.get("ts", "")
@@ -3088,9 +3144,10 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> List[types.TextCont
                 lines.append(f"  {agent_name}: last seen {round(ago)}s ago{flag}")
             except ValueError:
                 lines.append(f"  {agent_name}: last seen {ts}")
-        result_contents.append(types.TextContent(
-            type="text", text="Coordination roster:\n" + "\n".join(lines)
-        ))
+        reply = "Coordination roster:\n" + "\n".join(lines)
+        if note:
+            reply = note + "\n" + reply
+        result_contents.append(types.TextContent(type="text", text=reply))
         return result_contents
 
     elif name == "check_cross_references":

clauder-mcp/tests/test_server.py

@@ -163,3 +163,42 @@ def test_bool_variants(self):
     def test_text_accepts_anything(self):
         ok, _ = _validate_annotation({**GOOD, "note": "free text, with, commas"}, SCHEMA)
         assert ok
+
+
+# --- _coord_target (stale-session guard) --------------------------------
+
+from clauder_mcp import server as _srv
+
+
+class TestCoordTarget:
+    """A bridge bound to a dead session must not silently write to a log
+    no live agent reads (field bug, 0.14.1)."""
+
+    def test_dead_session_fails_loudly(self, monkeypatch):
+        monkeypatch.setattr(_srv, "discover_sessions", lambda: [])
+        monkeypatch.setattr(_srv, "_target_session", "runescape")
+        monkeypatch.setattr(_srv, "_coord_bound", None)
+        note, err = _srv._coord_target()
+        assert note is None
+        assert err is not None
+        assert "FAILED" in err and "runescape" in err
+
+    def test_rebind_to_live_session_produces_note(self, monkeypatch):
+        live = [{"session_name": "live", "port": 8790, "token": "t", "pid": 1}]
+        monkeypatch.setattr(_srv, "discover_sessions", lambda: live)
+        monkeypatch.setattr(_srv, "_target_session", None)
+        monkeypatch.setattr(_srv, "_coord_bound", "runescape")
+        note, err = _srv._coord_target()
+        assert err is None
+        assert note is not None
+        assert "runescape" in note and "live" in note
+        assert _srv._coord_bound == "live"
+
+    def test_stable_binding_is_quiet(self, monkeypatch):
+        live = [{"session_name": "live", "port": 8790, "token": "t", "pid": 1}]
+        monkeypatch.setattr(_srv, "discover_sessions", lambda: live)
+        monkeypatch.setattr(_srv, "_target_session", "live")
+        monkeypatch.setattr(_srv, "_coord_bound", "live")
+        note, err = _srv._coord_target()
+        assert note is None
+        assert err is None