Shared-connection personas, coordination visibility, pilot-2 fixes

ClaudeR 0.12.0 / clauder-mcp 0.14.0. Field bugs from a three-persona
game-agent session plus the queued pilot-2 items.

Identity tug-of-war fix: personas sharing one MCP connection were
renaming each other via set_agent_name (one shared global). New
as_agent parameter on send_message, check_messages, and
wait_for_message acts as that identity for one call, with a separate
read cursor per name. set_agent_name now warns it renames the whole
connection; the agent intro states where the current id came from
(env, argument, random, or rename) and steers shared connections to
as_agent; the coordination protocol documents both cases.

Coordination visibility: messaging bypasses R by design, so the
console and Shiny panel showed nothing while agents talked. The addin
now tails the session event log every 2s: new events echo to the
console (respecting print-to-console), append to the session log as
comments, and the Agents panel shows a coordination roster with
last-seen ages alongside execution agents.

Pilot-2 items: check_cross_references handles S-prefixed supplement
numbering and exempts extractor-marker ids from orphan reporting when
caption declarations exist; Step 3b documents unname() for htest
components; Pass 4c requires author-plus-year citation matching.

CI: S-prefix crossref regression test. R CMD check: Status OK.
pytest 30/30, handshake 40 tools.

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

Author: IMNMV

.github/scripts/checks.R

@@ -437,6 +437,27 @@ r <- tryCatch({
 }, error = function(e) conditionMessage(e))
 if (isTRUE(r)) pass("cross-restart history: past logs parsed, agent filter works") else fail("past history:", r)
 
+# --- 13b. crossref: S-prefixed supplement numbering, marker orphan exemption ---
+r <- tryCatch({
+  doc <- tempfile(fileext = ".txt")
+  writeLines(c(
+    "Supplemental materials. Table S1 reports response times.",
+    "[Table 1, header] a | b",
+    "[Table 1, row 2] 1 | 2",
+    "Table S1. RT descriptives.",
+    "[Table 2, header] c | d",
+    "[Table 2, row 2] 3 | 4",
+    "Table S2. Exploratory correlations."
+  ), doc)
+  invisible(capture.output(env$check_cross_references(doc)))
+  reg <- get("crossref_registry", envir = .GlobalEnv)
+  no_dangling_s1 <- !any(reg$issue == "dangling" & reg$id == "S1")
+  no_marker_orphans <- !any(reg$issue == "never_referenced" & reg$id %in% c("1", "2"))
+  s2_orphan <- any(reg$issue == "never_referenced" & reg$id == "S2")
+  no_dangling_s1 && no_marker_orphans && s2_orphan
+}, error = function(e) conditionMessage(e))
+if (isTRUE(r)) pass("crossref: S-prefix resolves, marker orphans exempt, S2 orphan real") else fail("crossref S-prefix:", r)
+
 # --- 14. DOI extraction: parenthesized DOIs, trailing junk, prose parens ---
 r <- tryCatch({
   d <- env$extract_dois(paste(

DESCRIPTION

@@ -1,6 +1,6 @@
 Package: ClaudeR
 Title: R Integration for Claude AI
-Version: 0.11.1
+Version: 0.12.0
 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

R/coordination.R

@@ -417,3 +417,35 @@ consensus_banner_needed <- function(session = NULL) {
   .claude_consensus_cache$needed <- needed
   needed
 }
+
+# --- Human observability -----------------------------------------------
+# Coordination deliberately bypasses R so a busy session cannot block
+# messaging. The cost is that the human sees nothing in the console or the
+# addin. These helpers let the addin's refresh loop surface the traffic.
+
+# One-line rendering of a coordination event for console and log display.
+format_coord_event <- function(e) {
+  body_txt <- tryCatch({
+    if (is.list(e$body) && !is.null(e$body$text)) as.character(e$body$text)
+    else as.character(jsonlite::toJSON(e$body, auto_unbox = TRUE))
+  }, error = function(err) "")
+  if (nchar(body_txt) > 160) body_txt <- paste0(substr(body_txt, 1, 157), "...")
+  sprintf("[%s] %s -> %s (%s): %s",
+          substr(e$ts, 12, 19), e$from, e$to, e$type, body_txt)
+}
+
+# Compact presence summary from the event log: who has written, how long ago.
+coord_roster_text <- function(session = NULL, stale_after = 900) {
+  evs <- tryCatch(coord_events(session), error = function(err) list())
+  if (length(evs) == 0) return(NULL)
+  last <- list()
+  for (e in evs) if (!is.null(e$from)) last[[e$from]] <- e$ts
+  now <- Sys.time()
+  parts <- vapply(names(last), function(nm) {
+    ts <- suppressWarnings(as.POSIXct(last[[nm]], format = "%Y-%m-%dT%H:%M:%OS"))
+    if (is.na(ts)) return(sprintf("%s (?)", nm))
+    ago <- round(as.numeric(difftime(now, ts, units = "secs")))
+    sprintf("%s (%ss ago%s)", nm, ago, if (ago > stale_after) ", STALE" else "")
+  }, character(1))
+  paste(parts, collapse = ", ")
+}

R/refcheck.R

@@ -39,22 +39,27 @@ expand_ref_numbers <- function(tail_text) {
 # tables/figures/theorems, single letters for appendices. Mixing them lets
 # "Table 1 and Figure 2" wrongly swallow the F of "Figure".
 scan_ref_class <- function(lines, class_name, declare_patterns, mention_labels,
-                           id_pattern = "\\d+(?:\\.\\d+)*") {
-  declared <- character(0)
-  decl_lines <- integer(0)
-  for (pat in declare_patterns) {
-    mm <- regexec(pat, lines, perl = TRUE)
-    for (i in seq_along(mm)) {
-      if (mm[[i]][1] == -1) next
-      grp <- regmatches(lines[i], mm[i])[[1]]
-      if (length(grp) >= 2 && nzchar(grp[2])) {
-        declared <- c(declared, grp[2])
-        decl_lines <- c(decl_lines, i)
+                           id_pattern = "\\d+(?:\\.\\d+)*",
+                           marker_patterns = character(0)) {
+  scan_decl <- function(pats) {
+    ids <- character(0); at <- integer(0)
+    for (pat in pats) {
+      mm <- regexec(pat, lines, perl = TRUE)
+      for (i in seq_along(mm)) {
+        if (mm[[i]][1] == -1) next
+        grp <- regmatches(lines[i], mm[i])[[1]]
+        if (length(grp) >= 2 && nzchar(grp[2])) {
+          ids <- c(ids, grp[2]); at <- c(at, i)
+        }
       }
     }
+    list(ids = unique(ids), lines = unique(at))
   }
-  declared <- unique(declared)
-  decl_lines <- unique(decl_lines)
+  cap <- scan_decl(declare_patterns)
+  mark <- scan_decl(marker_patterns)
+  declared <- unique(c(cap$ids, mark$ids))
+  declared_caption <- cap$ids
+  decl_lines <- unique(c(cap$lines, mark$lines))
 
   labels_alt <- paste(mention_labels, collapse = "|")
   mention_pat <- paste0("(?i)\\b(", labels_alt, ")\\.?\\s+(", id_pattern,
@@ -75,7 +80,8 @@ scan_ref_class <- function(lines, class_name, declare_patterns, mention_labels,
       }
     }
   }
-  list(class = class_name, declared = declared, mentions = mentions)
+  list(class = class_name, declared = declared,
+       declared_caption = declared_caption, mentions = mentions)
 }
 
 #' Check a manuscript's internal cross-references
@@ -101,11 +107,14 @@ check_cross_references <- function(document) {
 
   classes <- list(
     scan_ref_class(lines, "Table",
-      c("^\\[Table (\\d+),", "^Table (\\d+)[.:]"),
-      c("Table", "Tables", "Tab")),
+      c("^Table (S?\\d+)[.:]"),
+      c("Table", "Tables", "Tab"),
+      id_pattern = "S?\\d+(?:\\.\\d+)*",
+      marker_patterns = c("^\\[Table (\\d+),")),
     scan_ref_class(lines, "Figure",
-      c("^Figure (\\d+)[.:]", "^Fig\\.? (\\d+)[.:]"),
-      c("Figure", "Figures", "Fig", "Figs")),
+      c("^Figure (S?\\d+)[.:]", "^Fig\\.? (S?\\d+)[.:]"),
+      c("Figure", "Figures", "Fig", "Figs"),
+      id_pattern = "S?\\d+(?:\\.\\d+)*"),
     scan_ref_class(lines, "Equation",
       c("^Equation (\\d+)[.:]", "^\\((\\d+)\\)\\s*$"),
       c("Equation", "Equations", "Eq", "Eqs")),
@@ -138,8 +147,13 @@ check_cross_references <- function(document) {
     }
 
     dangling <- cl$mentions[!(cl$mentions$id %in% cl$declared), , drop = FALSE]
+    # Orphan reporting uses the author-facing numbering. When caption-style
+    # declarations exist (e.g. "Table S1."), the extractor's own [Table k]
+    # markers carry a parallel numbering that the prose never cites, and
+    # flagging those as never-referenced is noise, not signal.
+    orphan_base <- if (length(cl$declared_caption) > 0) cl$declared_caption else cl$declared
     orphans <- if (cl$class %in% c("Table", "Figure")) {
-      setdiff(cl$declared, unique(cl$mentions$id))
+      setdiff(orphan_base, unique(cl$mentions$id))
     } else character(0)
 
     report_parts <- c(report_parts, sprintf(

R/ui.R

@@ -852,11 +852,23 @@ claudeAddin <- function() {
       n_agents <- length(agent_ids)
       n_exec <- length(entries)
 
-      if (n_agents == 0) {
-        "No agents connected yet"
+      exec_txt <- if (n_agents == 0) {
+        "No code executed by agents yet"
       } else {
-        agents_str <- paste(agent_ids, collapse = ", ")
-        sprintf("Connected: %s\nExecutions: %d", agents_str, n_exec)
+        sprintf("Executed code: %s\nExecutions: %d",
+                paste(agent_ids, collapse = ", "), n_exec)
+      }
+
+      # Coordination happens on disk without touching R, so agents that only
+      # message each other never appear in the execution history. Surface
+      # them from the event log so the human can see who is actually around.
+      roster <- if (isTRUE(.claude_server_env$running)) {
+        coord_roster_text(.claude_server_env$session_name)
+      } else NULL
+      if (!is.null(roster)) {
+        paste0(exec_txt, "\nCoordinating: ", roster)
+      } else {
+        exec_txt
       }
     })
 
@@ -998,6 +1010,7 @@ claudeAddin <- function() {
           session_name <- trimws(input$session_name)
           if (session_name == "") session_name <- paste0("session_", input$port)
           .claude_server_env$session_name <- session_name
+          .claude_server_env$coord_seen <- NULL  # re-baseline coordination echo
           write_discovery_file(session_name, input$port, .claude_server_env$token)
 
           # Create log file with session name in the filename
@@ -1152,6 +1165,40 @@ claudeAddin <- function() {
       invalidateLater(2000)
     })
 
+    # Echo coordination traffic to the console and session log. Coordination
+    # bypasses the R server by design (a busy session cannot block it), so
+    # without this the human sees none of it.
+    observe({
+      invalidateLater(2000)
+      if (!isTRUE(.claude_server_env$running)) return(invisible(NULL))
+      evs <- tryCatch(coord_events(.claude_server_env$session_name),
+                      error = function(e) list())
+      if (length(evs) == 0) return(invisible(NULL))
+      max_id <- max(vapply(evs, function(e) e$id, integer(1)))
+      seen <- .claude_server_env$coord_seen
+      if (is.null(seen)) {
+        # First look at this log: do not replay history into the console
+        .claude_server_env$coord_seen <- max_id
+        return(invisible(NULL))
+      }
+      new_evs <- Filter(function(e) e$id > seen, evs)
+      if (length(new_evs) == 0) return(invisible(NULL))
+      s <- .claude_server_env$settings
+      for (e in new_evs) {
+        line <- tryCatch(format_coord_event(e), error = function(err) NULL)
+        if (is.null(line)) next
+        if (isTRUE(s$print_to_console)) {
+          cat("### coordination ###", line, "\n")
+        }
+        if (isTRUE(s$log_to_file) && !is.null(s$log_file_path) &&
+            nzchar(s$log_file_path)) {
+          try(cat(sprintf("# [coordination] %s\n", line),
+                  file = s$log_file_path, append = TRUE), silent = TRUE)
+        }
+      }
+      .claude_server_env$coord_seen <- max_id
+    })
+
     # Close handler -- just close the UI, keep the server running
     observeEvent(input$done, {
       invisible(stopApp())

clauder-mcp/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "clauder-mcp"
-version = "0.13.0"
+version = "0.14.0"
 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.13.0",
+  "version": "0.14.0",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "clauder-mcp",
-      "version": "0.13.0",
+      "version": "0.14.0",
       "transport": {
         "type": "stdio"
       }