Add unified console logging (issue #27)

ClaudeR 0.13.0. The session log captured agent activity only, so a user
who hit an error in the console had no direct way to hand that context
to an agent short of re-running the work through it.

New start_console_logging() / stop_console_logging(), plus an "Also log
my own console commands" toggle under Logging. Console entries land in
the existing session log tagged "Run by user (console)" beside the
agent entries: the expression, its visible value, and any warnings,
messages, or errors.

Captured with addTaskCallback for the expression and value, and
globalCallingHandlers for conditions. The handlers observe only and
never invoke the muffle restarts, so the user still sees their own
warnings and messages. globalCallingHandlers refuses to run with
handlers on the stack, so those calls are deliberately not wrapped in
tryCatch, and the previous handler list is restored on stop so handlers
owned by other packages survive. sink(type = "message") is not used: it
cannot split, so it would swallow the console output it captures.

Off by default. R CMD check: Status OK.

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

Author: IMNMV

DESCRIPTION

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

NAMESPACE

@@ -42,6 +42,8 @@ export(reviewer_zero_prompt)
 export(revoke_plan)
 export(screening_prompt)
 export(screening_report)
+export(start_console_logging)
+export(stop_console_logging)
 export(validate_assembly_round)
 importFrom(base64enc,base64encode)
 importFrom(ggplot2,aes)

R/console_log.R

@@ -0,0 +1,131 @@
+# Console capture: record what the USER runs in the console into the same
+# session log the agent writes to, so one file holds both sides of the work.
+#
+# The pieces, and why each is needed:
+#   addTaskCallback        the expression the user typed, and its visible value
+#   globalCallingHandlers  warnings and messages (they go to stderr, so a sink
+#                          cannot see them; R >= 4.0 lets us observe without
+#                          suppressing)
+#   options(error=)        uncaught errors
+# sink(type = "message") is deliberately NOT used: it cannot split, so it would
+# swallow the user's own errors in the console.
+
+.console_state <- new.env(parent = emptyenv())
+
+console_log_path <- function() {
+  s <- tryCatch(.claude_server_env$settings, error = function(e) NULL)
+  if (is.null(s) || !isTRUE(s$log_to_file)) return(NULL)
+  p <- s$log_file_path
+  if (is.null(p) || !nzchar(p)) return(NULL)
+  p
+}
+
+# One writer for every console entry, so the format stays consistent.
+console_write <- function(text, tag = "user") {
+  p <- console_log_path()
+  if (is.null(p)) return(invisible(FALSE))
+  ts <- format(Sys.time(), "%Y-%m-%d %H:%M:%S")
+  entry <- sprintf("# --- [%s] ---\n# Run by %s (console):\n%s\n\n", ts, tag, text)
+  tryCatch(cat(entry, file = p, append = TRUE), error = function(e) NULL)
+  invisible(TRUE)
+}
+
+# Trim runaway output so one huge print cannot bloat the log.
+console_trim <- function(x, max_lines = 40L) {
+  if (length(x) <= max_lines) return(x)
+  c(x[seq_len(max_lines)],
+    sprintf("# ... %d more lines not logged", length(x) - max_lines))
+}
+
+console_note_condition <- function(kind, msg) {
+  msg <- trimws(paste(msg, collapse = " "))
+  if (!nzchar(msg)) return(invisible(NULL))
+  .console_state$pending <- c(.console_state$pending,
+                              sprintf("# %s: %s", kind, msg))
+  invisible(NULL)
+}
+
+console_task_callback <- function(expr, value, ok, visible) {
+  # Never let logging break the user's session.
+  tryCatch({
+    if (is.null(console_log_path())) return(TRUE)
+    code <- paste(deparse(expr), collapse = "\n")
+
+    # Skip our own bookkeeping so the log does not describe itself.
+    if (grepl("^(start_console_logging|stop_console_logging|ClaudeR:::)", code)) return(TRUE)
+
+    lines <- character(0)
+    if (isTRUE(visible) && isTRUE(ok)) {
+      out <- tryCatch(utils::capture.output(print(value)),
+                      error = function(e) character(0))
+      if (length(out)) lines <- paste("#", console_trim(out))
+    }
+    if (!isTRUE(ok)) lines <- c(lines, "# error: command did not complete")
+    if (length(.console_state$pending)) {
+      lines <- c(.console_state$pending, lines)
+      .console_state$pending <- NULL
+    }
+    body <- if (length(lines)) paste0(code, "\n", paste(lines, collapse = "\n")) else code
+    console_write(body, tag = "user")
+  }, error = function(e) NULL)
+  TRUE
+}
+
+#' Start logging the user's console activity
+#'
+#' Adds the user's own console commands, and their results, to the session log
+#' the agent already writes to. An agent can then read one file and see both
+#' sides of the session.
+#'
+#' @return Invisibly TRUE if capture started.
+#' @export
+start_console_logging <- function() {
+  if (isTRUE(.console_state$active)) return(invisible(TRUE))
+  .console_state$pending <- NULL
+  .console_state$handle <- addTaskCallback(console_task_callback,
+                                           name = "clauder_console_log")
+  if (getRversion() >= "4.0.0") {
+    # globalCallingHandlers() refuses to run with handlers on the stack, so it
+    # must not be wrapped in tryCatch here.
+    .console_state$old_handlers <- globalCallingHandlers()
+    # Observe only. Do NOT invoke the muffle restarts: the user must still see
+    # their own warnings and messages in the console.
+    globalCallingHandlers(
+      warning = function(w) console_note_condition("warning", conditionMessage(w)),
+      message = function(m) console_note_condition("message", conditionMessage(m))
+    )
+  }
+  .console_state$old_error <- getOption("error")
+  options(error = function() {
+    tryCatch({
+      msg <- geterrmessage()
+      console_write(sprintf("# error: %s", trimws(msg)), tag = "user")
+    }, error = function(e) NULL)
+  })
+  .console_state$active <- TRUE
+  message("ClaudeR: console logging on. Your console commands now appear in the session log.")
+  # Our own startup message must not show up as the user's first log entry.
+  .console_state$pending <- NULL
+  invisible(TRUE)
+}
+
+#' Stop logging the user's console activity
+#'
+#' @return Invisibly TRUE.
+#' @export
+stop_console_logging <- function() {
+  if (!isTRUE(.console_state$active)) return(invisible(TRUE))
+  tryCatch(removeTaskCallback("clauder_console_log"), error = function(e) NULL)
+  if (getRversion() >= "4.0.0") {
+    # Drop ours, then put back whatever was registered before, so handlers
+    # belonging to other packages survive.
+    globalCallingHandlers(NULL)
+    old <- .console_state$old_handlers
+    if (length(old)) do.call(globalCallingHandlers, old)
+  }
+  options(error = .console_state$old_error)
+  .console_state$active <- FALSE
+  .console_state$pending <- NULL
+  message("ClaudeR: console logging off.")
+  invisible(TRUE)
+}

R/ui.R

@@ -734,6 +734,8 @@ claudeAddin <- function() {
           condition = "input.log_to_file == true",
           textInput("log_file_path", "Log file path",
                            value = settings$log_file_path),
+          checkboxInput("log_console", "Also log my own console commands",
+                           value = isTRUE(settings$log_console)),
           actionButton("open_log", "Open Log File", class = "btn-sm"),
           actionButton("export_script", "Export Clean Script", class = "btn-sm")
         )
@@ -790,6 +792,11 @@ claudeAddin <- function() {
     observeEvent(input$print_to_console, {
       update_setting("print_to_console", input$print_to_console)
     }, ignoreInit = TRUE)
+    observeEvent(input$log_console, {
+      update_setting("log_console", input$log_console)
+      if (isTRUE(input$log_console)) start_console_logging() else stop_console_logging()
+    }, ignoreInit = TRUE)
+
     observeEvent(input$log_to_file, {
       update_setting("log_to_file", input$log_to_file)
     }, ignoreInit = TRUE)

README.md

@@ -50,6 +50,8 @@ claudeAddin()
 <details>
 <summary><b>Recent Updates</b> (click to expand)</summary>
 
+- **Unified console logging (R 0.13.0).** The session log recorded what the agent ran, but not what you ran, so asking an agent to explain an error you hit in the console meant re-running the work through it. Tick "Also log my own console commands" under Logging and your console activity joins the same file, tagged by who ran what: the command, its printed result, and any warnings, messages, or errors. "Read the last 100 lines of the log" is now enough for an agent to see both sides of the session. Off by default; toggle it in the addin or call `start_console_logging()` / `stop_console_logging()`.
+
 - **Editor tools fixed, plus approve-before-apply edits (R 0.12.5 / clauder-mcp 0.14.4).** From two user reports. `modify_code_section` and `insert_text` now save to disk by default and report `saved_to_disk`, so an agent no longer believes it wrote a file when the change sat unsaved in the buffer. Bounded replacements may change the line count (the old equality constraint is gone). Both tools accept a `path` to target a specific file, open and focus it, and refuse to edit a different document instead of failing silently. `get_active_document` now reports the path, the document id, and whether the buffer differs from disk, so buffer state and file state stop being confused for each other. New `suggest_edit` tool: the agent proposes a change and waits for the user to approve it, using `rstudioapi::showEditSuggestion()` when the installed rstudioapi provides it, and otherwise staging the edit unsaved so the user accepts by saving or rejects with undo.
 
 - **Reviewer Zero now reasons, not just reconciles (R 0.12.4).** Added a mandatory Pass 5 (content reasoning) to the base auditing protocol. The deterministic tools (reconcile_values, verify_references, check_cross_references, probe_scripts) find numeric, reference, cross-reference, and code defects, but they do not reason about meaning, and a manuscript can clear every one of them and still be wrong. Pass 5 is a gated, equal-weight pass with eight checks the tools cannot do: instrument and source attribution, whether each reported test is computable from the data that exists, whether each cited figure or table actually contains the claimed evidence, magnitude wording, convergence across studies, causal and generality framing, data existence for descriptive claims, and supplement and appendix integration (every supplement cited, and no body claim resting on an uncited one). In a controlled benchmark on a synthetic manuscript with a known defect set, this raised detection from below a native-tools baseline (16.8 of 24) to clearly above it (21.3 of 24), recovering exactly the reasoning defects the old tool-led protocol was missing, with no rise in false positives.