Agent identity and cross-restart history (coordination v2.1)

ClaudeR 0.11.0 / clauder-mcp 0.13.0 (40 tools). From field reports of
a multi-day three-agent session.

- set_agent_name tool: an agent sets its working name once and
  execution history, message attribution, presence, and its read
  cursor all carry it. Fixes the identity collapse both testers hit:
  agents or personas sharing one MCP connection resolve to a single
  random per-connection id that get_session_history cannot separate.
  Identity is now step 1 of the coordination check-in; CLAUDER_AGENT_ID
  remains the permanent-name alternative.
- get_session_history include_past: parses prior clauder_*.R session
  logs from disk (newest five, excluding the live log), so the audit
  of who ran what survives R restarts. Entries carry a {logfile} tag.
- Agent intro briefs multi-agent sessions to name themselves first.

CI: past-log parsing functional 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

@@ -412,5 +412,30 @@ r <- tryCatch({
 }, error = function(e) conditionMessage(e))
 if (isTRUE(r)) pass("response letter export + undrafted gate") else fail("response letter:", r)
 
+# --- 13. cross-restart history from past session logs ---
+r <- tryCatch({
+  logdir <- tempfile("logs"); dir.create(logdir)
+  writeLines(c(
+    "# --- [2026-08-10 12:01:00] ---",
+    "# Code executed by Claude-Stasis:",
+    "x <- rnorm(10)",
+    "",
+    "# --- [2026-08-10 12:02:00] ---",
+    "# Code executed by Claude-Gatherers (ERROR):",
+    "lm(y ~ broken)",
+    "# Error: object not found",
+    ""
+  ), file.path(logdir, "clauder_t_8787_20260810_120000.R"))
+  live <- file.path(logdir, "clauder_t_8787_20260811_090000.R")
+  writeLines("# live", live)
+  assign("load_claude_settings",
+         function() list(log_to_file = TRUE, log_file_path = live), envir = env)
+  o1 <- env$query_agent_history("all", "t", 20, include_past = TRUE)
+  o2 <- env$query_agent_history("Claude-Stasis", "t", 20, include_past = TRUE)
+  grepl("Claude-Gatherers \\(ERR\\)", o1) && grepl("\\{clauder_t_8787_20260810", o1) &&
+    grepl("Claude-Stasis", o2) && !grepl("Gatherers", o2)
+}, error = function(e) conditionMessage(e))
+if (isTRUE(r)) pass("cross-restart history: past logs parsed, agent filter works") else fail("past history:", r)
+
 if (!ok) quit(status = 1)
 cat("\nAll checks passed.\n")

DESCRIPTION

@@ -1,6 +1,6 @@
 Package: ClaudeR
 Title: R Integration for Claude AI
-Version: 0.10.0
+Version: 0.11.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/ui.R

@@ -1564,18 +1564,71 @@ execute_code_in_session <- function(code, settings = NULL, agent_id = NULL) {
   })
 }
 
+# Parse execution entries out of past session log files on disk. The
+# in-memory history dies with the R session; the timestamped logs do not,
+# so they are the cross-restart audit trail of who ran what.
+past_history_entries <- function(max_files = 5L) {
+  settings <- load_claude_settings()
+  if (is.null(settings$log_file_path) || !nzchar(settings$log_file_path)) {
+    return(list())
+  }
+  log_dir <- dirname(settings$log_file_path)
+  if (!dir.exists(log_dir)) return(list())
+  files <- list.files(log_dir, pattern = "^clauder_.*\\.R$", full.names = TRUE)
+  files <- setdiff(files, normalizePath(settings$log_file_path, mustWork = FALSE))
+  if (length(files) == 0) return(list())
+  files <- files[order(file.info(files)$mtime, decreasing = TRUE)]
+  files <- utils::head(files, max_files)
+
+  entries <- list()
+  for (f in files) {
+    lines <- tryCatch(readLines(f, warn = FALSE), error = function(e) character(0))
+    starts <- grep("^# --- \\[", lines)
+    if (length(starts) == 0) next
+    ends <- c(starts[-1] - 1L, length(lines))
+    for (k in seq_along(starts)) {
+      block <- lines[starts[k]:ends[k]]
+      ts <- sub("^# --- \\[(.*)\\] ---$", "\\1", block[1])
+      agent_line <- if (length(block) >= 2) block[2] else ""
+      agent <- sub("^# Code executed by ([^ ]+).*$", "\\1", agent_line)
+      agent <- sub(":$", "", agent)
+      code_lines <- block[!grepl("^# --- \\[|^# Code executed by |^# Error: ", block)]
+      code_lines <- code_lines[nzchar(trimws(code_lines))]
+      entries[[length(entries) + 1L]] <- list(
+        timestamp = suppressWarnings(as.POSIXct(ts)),
+        agent_id = agent,
+        code = paste(code_lines, collapse = "\n"),
+        success = !grepl("(ERROR)", agent_line, fixed = TRUE),
+        has_plot = FALSE,
+        source_log = basename(f)
+      )
+    }
+  }
+  entries
+}
+
 #' Query agent execution history
 #'
 #' @param agent_filter "all", or a specific agent ID to filter by
 #' @param requesting_agent The agent making the request (for context)
 #' @param last_n Number of entries to return
+#' @param include_past Also parse prior session log files on disk, so the
+#'   audit trail survives R restarts
 #' @return Character string with formatted history
-
-query_agent_history <- function(agent_filter = "all", requesting_agent = NULL, last_n = 20) {
+query_agent_history <- function(agent_filter = "all", requesting_agent = NULL,
+                                last_n = 20, include_past = FALSE) {
   entries <- .claude_history_env$entries
 
+  if (isTRUE(include_past)) {
+    entries <- c(past_history_entries(), entries)
+  }
+
   if (length(entries) == 0) {
-    return("No execution history recorded yet.")
+    return(if (isTRUE(include_past)) {
+      "No execution history in memory and no past session logs found."
+    } else {
+      "No execution history recorded yet. Pass include_past = TRUE to search prior session logs on disk."
+    })
   }
 
   # Filter by agent if requested
@@ -1584,7 +1637,11 @@ query_agent_history <- function(agent_filter = "all", requesting_agent = NULL, l
   }
 
   if (length(entries) == 0) {
-    return(sprintf("No history found for agent '%s'.", agent_filter))
+    return(sprintf(
+      "No history found for agent '%s'.%s", agent_filter,
+      if (isTRUE(include_past)) "" else
+        " Pass include_past = TRUE to also search prior session logs."
+    ))
   }
 
   # Take last N
@@ -1596,9 +1653,12 @@ query_agent_history <- function(agent_filter = "all", requesting_agent = NULL, l
   lines <- vapply(entries, function(e) {
     status <- if (e$success) "OK" else "ERR"
     plot_flag <- if (e$has_plot) " [plot]" else ""
+    src <- if (!is.null(e$source_log)) paste0(" {", e$source_log, "}") else ""
     code_preview <- substr(gsub("\n", " ", e$code), 1, 80)
-    sprintf("[%s] %s (%s%s): %s",
-            format(e$timestamp, "%H:%M:%S"), e$agent_id, status, plot_flag, code_preview)
+    ts_txt <- tryCatch(format(e$timestamp, "%Y-%m-%d %H:%M:%S"),
+                       error = function(err) as.character(e$timestamp))
+    sprintf("[%s] %s (%s%s)%s: %s",
+            ts_txt, e$agent_id, status, plot_flag, src, code_preview)
   }, character(1))
 
   paste(lines, collapse = "\n")

README.md

@@ -50,6 +50,8 @@ claudeAddin()
 <details>
 <summary><b>Recent Updates</b> (click to expand)</summary>
 
+- **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.
 
 - **Coordination v2 + consensus gate (R 0.9.0 / clauder-mcp 0.11.0).** The multi-agent board is now a typed, append-only event log on disk, designed from field reports of real multi-hour multi-agent sessions: typed signals instead of prose-grepping, per-agent read cursors (the shared-dataframe race is structurally impossible), reply threading, lease-based task claims, a fact store for shared state, auto-stamped presence, and a `wait_for_message` tool that blocks until a partner's event arrives, without touching the busy R session. New consensus gate: after `propose_plan()`, every execution response carries an agreement banner until all agents run `confirm_agreement()` with the required sentence verbatim. Only then is the plan marked approved. Plus `referee_prompt(stance = "reviewer2")`: a hostile-but-fair Reviewer 2 that opens with an unprimed three-sentence read (central claim, and would a strong venue accept it?) and ranks findings fatal / must-fix / minor, each tagged to the study it concerns.

clauder-mcp/pyproject.toml

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

clauder-mcp/src/clauder_mcp/server.py

@@ -300,6 +300,10 @@ async def get_agent_introduction() -> str:
     lines.append("  ClaudeR::r_best_practices_prompt()   - Statistical analysis protocol")
     lines.append("  ClaudeR::multi_agent_prompt()        - Multi-agent coordination protocol")
     lines.append("")
+    lines.append("Multi-agent identity: call set_agent_name with your working name (e.g.")
+    lines.append("'Claude-Stasis') BEFORE other work, so history and messages carry a name")
+    lines.append("your partners recognize instead of the random id above.")
+    lines.append("")
     lines.append("Safety: call checkpoint_session before risky changes (overwrites, removals,")
     lines.append("destructive transformations); restore_session rolls the environment back.")
     lines.append("")
@@ -1228,6 +1232,10 @@ async def list_tools() -> List[types.Tool]:
                     "last_n": {
                         "type": "number",
                         "description": "Number of recent entries to return (default 20)"
+                    },
+                    "include_past": {
+                        "type": "boolean",
+                        "description": "Also parse prior session log files on disk, so the audit trail survives R restarts. Entries from past logs are tagged {logfile}. Default false."
                     }
                 }
             },
@@ -1477,6 +1485,36 @@ async def list_tools() -> List[types.Tool]:
                 "openWorldHint": False,
             }
         ),
+        types.Tool(
+            name="set_agent_name",
+            description=(
+                "Set this agent's working identity for the rest of the session. Call this "
+                "FIRST in any multi-agent work, before executing code or sending messages, "
+                "so execution history, message attribution, presence, and your read cursor "
+                "all carry your working name (e.g. 'Claude-Stasis') instead of a random "
+                "per-connection id. Critical when several agents or personas share one MCP "
+                "connection (subagents), where the default id cannot tell them apart. Pick "
+                "a short name unique to you and reuse it across sessions. For a permanent "
+                "name, set the CLAUDER_AGENT_ID environment variable in the MCP server "
+                "registration instead."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "type": "string",
+                        "description": "The identity to use: 1-40 chars, letters, digits, dash, underscore; must start with a letter or digit."
+                    }
+                },
+                "required": ["name"]
+            },
+            annotations={
+                "readOnlyHint": False,
+                "destructiveHint": False,
+                "idempotentHint": True,
+                "openWorldHint": False,
+            }
+        ),
         types.Tool(
             name="send_message",
             description=(
@@ -1770,7 +1808,7 @@ async def list_tools() -> List[types.Tool]:
 @server.call_tool()
 async def call_tool(name: str, arguments: Dict[str, Any]) -> List[types.TextContent | types.ImageContent]:
     """Handle R tool calls."""
-    global _target_session, _agent_introduced
+    global _target_session, _agent_introduced, _agent_id
 
     # These tools check Python-side state only — skip addin check
     _skip_addin_check = {"list_sessions", "connect_session", "load_annotation_data", "annotate", "run_annotation_job", "get_annotation_job_status", "cancel_annotation_job",
@@ -2338,7 +2376,8 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> List[types.TextCont
         else:
             filter_value = escape_r_string(agent_filter)
 
-        r_code = f'ClaudeR:::query_agent_history("{filter_value}", "{escape_r_string(_agent_id or "unknown")}", {last_n})'
+        include_past = "TRUE" if arguments.get("include_past") else "FALSE"
+        r_code = f'ClaudeR:::query_agent_history("{filter_value}", "{escape_r_string(_agent_id or "unknown")}", {last_n}, include_past = {include_past})'
         result = await execute_r_code_via_addin(r_code)
 
         if not result.get("success", False):
@@ -2937,6 +2976,25 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> List[types.TextCont
         ))
         return result_contents
 
+    elif name == "set_agent_name":
+        new_name = (arguments.get("name") or "").strip()
+        if not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_-]{0,39}", new_name):
+            return [types.TextContent(
+                type="text",
+                text="Error: invalid name. Use 1-40 characters: letters, digits, dash, underscore; start with a letter or digit."
+            )]
+        old_name = _agent_id
+        _agent_id = new_name
+        return [types.TextContent(
+            type="text",
+            text=(
+                f"Agent identity set: {old_name} -> {new_name}. Execution history, "
+                f"coordination messages, presence, and your read cursor now use this name. "
+                f"If you had already sent messages as {old_name}, mention the rename to "
+                f"your partners so they can map the two."
+            )
+        )]
+
     elif name == "send_message":
         body = arguments.get("body")
         if body is None or (isinstance(body, str) and not body.strip()):

inst/prompts/multi_agent.md

@@ -19,9 +19,16 @@ Two ways to use it, same log underneath:
 
 ## Phase 0: Check in
 
-1. `coordination_roster` -- who is here, who is stale.
-2. `check_messages` -- read everything unread addressed to you or to all.
-3. `consensus_status()` (via execute_r) -- is there a plan already, and is
+1. `set_agent_name` -- set your working identity FIRST (e.g. "Claude-Stasis").
+   Do this before any code execution or message. It names your execution
+   history, message attribution, presence, and read cursor. Without it,
+   agents that share one MCP connection (subagents, personas) collapse into
+   one random id and cannot be told apart afterward. Reuse the same name
+   every session; for a permanent name, set the CLAUDER_AGENT_ID environment
+   variable in your MCP registration.
+2. `coordination_roster` -- who is here, who is stale.
+3. `check_messages` -- read everything unread addressed to you or to all.
+4. `consensus_status()` (via execute_r) -- is there a plan already, and is
    it approved?
 
 If a plan exists and is approved, skip negotiation: claim an open task and