Referee Mode v2: configurable lenses, reviewer stances, model tiers, cross-vendor

ClaudeR 0.8.0 (R-side only; bridge unchanged at 0.10.0).

Mode-collapse hardening for the referee lenses. Same-model parallel
reviewers share blind spots; lens mandates decorrelate attention but
not priors. New controls:

- referee_prompt(lenses, reviewers_per_lens, model, cross_vendor):
  run any lens subset; 2 reviewers per lens = adversarial prosecutor +
  verifier stances, 3 adds a backwards reader; model takes one tier for
  all subagents ("haiku" quick / "opus" submission-grade) or a named
  per-lens vector, passed through to the host CLI subagent dispatch
  (Claude Code Task tool model parameter); cross_vendor = TRUE
  dispatches logic/methods reviewers to another vendor via codex/agy/
  qwen one-shots -- the strongest decorrelation available
- Anti-collapse rules now mandatory in the protocol: reviewer prompts
  written from scratch per lens and stance (template-with-one-word-
  swapped forbidden), consistency lens reads back-to-front, findings
  carry n_independent corroboration counts through dedup and into the
  report, and the run configuration is reported honestly
- reviewer_zero_prompt(referee = TRUE) uses the configured defaults

CI: referee v2 configuration test. R CMD check: Status OK.

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

Author: IMNMV

.github/scripts/checks.R

@@ -271,5 +271,21 @@ r <- tryCatch({
 }, error = function(e) conditionMessage(e))
 if (isTRUE(r)) pass("cross-reference checker: dangling + orphans, ranges resolve") else fail("crossref:", r)
 
+# --- 12. referee mode v2 configuration ---
+r <- tryCatch({
+  assign("system.file", function(..., package = NULL) file.path("inst", ...), envir = env)
+  t1 <- capture.output(env$referee_prompt(lenses = c("logic", "methods"),
+                                          reviewers_per_lens = 2, model = "haiku"))
+  t2 <- capture.output(env$referee_prompt(model = c(logic = "opus"), cross_vendor = TRUE))
+  any(grepl("Lenses: logic, methods", t1, fixed = TRUE)) &&
+    any(grepl('model = "haiku"', t1, fixed = TRUE)) &&
+    any(grepl("PROSECUTOR", t1, fixed = TRUE)) &&
+    any(grepl('logic -> "opus"', t2, fixed = TRUE)) &&
+    any(grepl("codex exec", t2, fixed = TRUE)) &&
+    !any(grepl("{{", c(t1, t2), fixed = TRUE)) &&
+    inherits(tryCatch(env$referee_prompt(lenses = "vibes"), error = function(e) e), "error")
+}, error = function(e) conditionMessage(e))
+if (isTRUE(r)) pass("referee v2: lenses, models, stances, cross-vendor, validation") else fail("referee v2:", 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.7.0
+Version: 0.8.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

@@ -2457,15 +2457,92 @@ reviewer_zero_prompt <- function(prereg_path = NULL, robustness = FALSE,
   }
 
   if (isTRUE(referee)) {
-    ext_path <- system.file("prompts", "reviewer_zero_referee.md", package = "ClaudeR")
-    ext <- paste(readLines(ext_path, warn = FALSE), collapse = "\n")
-    txt <- paste0(txt, "\n", ext)
+    txt <- paste0(txt, "\n", build_referee_text())
   }
 
   cat(txt, "\n")
   invisible(txt)
 }
 
+# Build the Referee Mode protocol text with a concrete run configuration.
+# Shared by referee_prompt() and reviewer_zero_prompt(referee = TRUE).
+build_referee_text <- function(lenses = c("logic", "methods", "consistency",
+                                          "evidence", "framing"),
+                               reviewers_per_lens = 1L,
+                               model = NULL,
+                               cross_vendor = FALSE) {
+  valid <- c("logic", "methods", "consistency", "evidence", "framing")
+  bad <- setdiff(lenses, valid)
+  if (length(bad) > 0) {
+    stop(sprintf("Unknown lens(es): %s. Valid: %s.",
+                 paste(bad, collapse = ", "), paste(valid, collapse = ", ")),
+         call. = FALSE)
+  }
+  if (!is.numeric(reviewers_per_lens) || reviewers_per_lens < 1 ||
+      reviewers_per_lens > 3) {
+    stop("`reviewers_per_lens` must be 1, 2, or 3 (stances: balanced; prosecutor+verifier; +backwards reader).",
+         call. = FALSE)
+  }
+  reviewers_per_lens <- as.integer(reviewers_per_lens)
+
+  model_directive <- if (is.null(model)) {
+    paste0("inherit the session's model for every reviewer subagent. If the ",
+           "user asked for a quick pass, prefer a fast tier (e.g. haiku or ",
+           "sonnet); for a submission-grade review, prefer the strongest ",
+           "tier available (e.g. opus or fable).")
+  } else if (is.null(names(model)) && length(model) == 1) {
+    sprintf(paste0("pass model = \"%s\" when dispatching EVERY reviewer ",
+                   "subagent (the Task tool's model parameter on Claude ",
+                   "Code, or your host's equivalent)."), model)
+  } else {
+    if (is.null(names(model)) || any(!nzchar(names(model)))) {
+      stop("`model` must be a single tier or a fully named vector, e.g. c(logic = \"opus\", consistency = \"haiku\").",
+           call. = FALSE)
+    }
+    bad_names <- setdiff(names(model), valid)
+    if (length(bad_names) > 0) {
+      stop(sprintf("`model` names must be lenses. Unknown: %s.",
+                   paste(bad_names, collapse = ", ")), call. = FALSE)
+    }
+    paste0("per-lens models: ",
+           paste(sprintf("%s -> \"%s\"", names(model), model), collapse = "; "),
+           "; lenses not listed inherit the session's model.")
+  }
+
+  vendor_directive <- if (isTRUE(cross_vendor)) {
+    paste0(
+      "ENABLED. Where another vendor's CLI is installed (check with ",
+      "`which codex agy qwen` from Bash), dispatch at least one reviewer of ",
+      "the logic and methods lenses to a DIFFERENT model vendor as a ",
+      "one-shot subprocess: `codex exec` (pipe the reviewer prompt via ",
+      "stdin; flags: --skip-git-repo-check -c mcp_servers={}), ",
+      "`agy -p \"<prompt>\"`, or `qwen --prompt \"<prompt>\"`. First write ",
+      "the extracted manuscript to a plain-text file ",
+      "(writeLines(doc_lines, \"ms_extract.txt\")) and reference that path ",
+      "in the prompt, along with the lens mandate, stance, and the finding ",
+      "format. Cross-vendor findings enter the same registry and the same ",
+      "adjudication. Agreement across vendors is strong corroboration; ",
+      "vendor-unique findings deserve scrutiny in both directions. If no ",
+      "other vendor CLI is available, record that in the report and proceed ",
+      "single-vendor. Same-model reviewers share blind spots; a second ",
+      "vendor is the strongest decorrelation available."
+    )
+  } else {
+    "disabled for this run: all reviewers run as host-native subagents."
+  }
+
+  prompt_path <- system.file("prompts", "reviewer_zero_referee.md", package = "ClaudeR")
+  if (!nzchar(prompt_path) || !file.exists(prompt_path)) {
+    stop("Referee prompt template not found. Is ClaudeR installed correctly?")
+  }
+  txt <- paste(readLines(prompt_path, warn = FALSE), collapse = "\n")
+  txt <- gsub("{{LENSES}}", paste(lenses, collapse = ", "), txt, fixed = TRUE)
+  txt <- gsub("{{REVIEWERS_PER_LENS}}", as.character(reviewers_per_lens), txt, fixed = TRUE)
+  txt <- gsub("{{MODEL_DIRECTIVE}}", model_directive, txt, fixed = TRUE)
+  txt <- gsub("{{VENDOR_DIRECTIVE}}", vendor_directive, txt, fixed = TRUE)
+  txt
+}
+
 #' Print the Referee Mode prompt (standalone)
 #'
 #' Referee Mode is a substantive review of a manuscript's reasoning:
@@ -2476,14 +2553,34 @@ reviewer_zero_prompt <- function(prereg_path = NULL, robustness = FALSE,
 #' numeric audit passes; to run it after a full audit, use
 #' `reviewer_zero_prompt(referee = TRUE)`.
 #'
+#' @param lenses Which review lenses to run. Any subset of
+#'   `c("logic", "methods", "consistency", "evidence", "framing")`.
+#' @param reviewers_per_lens 1, 2, or 3 independent reviewers per lens.
+#'   With 2, each lens gets a prosecutor (hunts flaws) and a verifier
+#'   (confirms each step); with 3, a backwards reader is added. Opposed
+#'   stances decorrelate reviewers built on the same model.
+#' @param model Optional model directive for reviewer subagents. A single
+#'   tier applies to all lenses (e.g. `"haiku"` for a quick pass,
+#'   `"opus"` for a submission-grade review); a named vector sets tiers
+#'   per lens, e.g. `c(logic = "opus", consistency = "haiku")`. The
+#'   orchestrating agent passes this to its subagent dispatch (Claude
+#'   Code's Task tool `model` parameter). Default: inherit the session's
+#'   model.
+#' @param cross_vendor If TRUE, the protocol instructs the orchestrator to
+#'   dispatch at least one logic and one methods reviewer to a different
+#'   model vendor (codex/agy/qwen one-shot CLI calls) where installed.
+#'   Cross-vendor agreement is the strongest available guard against
+#'   same-model blind spots.
 #' @return The prompt text (invisibly), printed to the console.
 #' @export
-referee_prompt <- function() {
-  prompt_path <- system.file("prompts", "reviewer_zero_referee.md", package = "ClaudeR")
-  if (!nzchar(prompt_path) || !file.exists(prompt_path)) {
-    stop("Referee prompt template not found. Is ClaudeR installed correctly?")
-  }
-  txt <- paste(readLines(prompt_path, warn = FALSE), collapse = "\n")
+referee_prompt <- function(lenses = c("logic", "methods", "consistency",
+                                      "evidence", "framing"),
+                           reviewers_per_lens = 1L,
+                           model = NULL,
+                           cross_vendor = FALSE) {
+  txt <- build_referee_text(lenses = lenses,
+                            reviewers_per_lens = reviewers_per_lens,
+                            model = model, cross_vendor = cross_vendor)
   cat(txt, "\n")
   invisible(txt)
 }

README.md

@@ -44,6 +44,7 @@ claudeAddin()
 <details>
 <summary><b>Recent Updates</b> (click to expand)</summary>
 
+- **Referee Mode v2: configurable reviewers (R 0.8.0).** `referee_prompt()` now takes `lenses` (run any subset), `reviewers_per_lens` (2 = adversarial prosecutor + verifier pairs, 3 adds a backwards reader), `model` (a tier for all subagents, e.g. `"haiku"` for quick passes or `"opus"` for submission-grade, or a named per-lens vector), and `cross_vendor = TRUE` to dispatch logic/methods reviewers to a different model vendor via codex/agy/qwen one-shots. Anti-collapse rules are now mandatory in the protocol: reviewer prompts must be written from scratch per lens and stance, the consistency lens reads back-to-front, and every finding carries a corroboration count across independent reviewers.
 - **Referee Mode (R 0.7.0 / clauder-mcp 0.10.0).** The substantive manuscript review that paid services charge ~$50 a pass for, running free on the subscription you already have, and delivered where it belongs: as Word comments in your manuscript. `reviewer_zero_prompt(referee = TRUE)` (or standalone `referee_prompt()`) runs five content-only review lenses — argument logic, methods, internal consistency, evidence presentation, framing — as parallel subagents where the CLI supports them. Every finding must anchor to a verbatim quote and survive an independent verification pass before it lands in the document, severities are kept honest, and a clean report on a sound paper is a valid outcome. Alongside it, the new `check_cross_references` tool deterministically catches dangling references ("see Table 4" when Table 4 no longer exists) and tables or figures the text never mentions.
 
 - **Value-first auditing (R 0.6.0 / clauder-mcp 0.9.0).** Built from field feedback after a full manuscript+supplement audit. `read_file` now transparently extracts `.docx`/`.pdf` (previously returned raw bytes), and the extractor preserves structure: headings marked, table cells emitted row-wise with separators (they were previously dropped entirely). New `reconcile_values` tool: enumerates every number in a manuscript and reconciles each against the corpus your code produced, respecting displayed precision (5038.5 matches 5038.46), commas, percents, scientific notation, and `< .001` thresholds; the per-value `values_registry` makes numeric completeness a construction, not a diligence hope. Reviewer Zero now sets audit-clean print options (no more tibble 3-sig-fig false alarms), gates on the value sweep, and takes final verdicts from clean-room runs via `probe_scripts(capture_output = TRUE)`. CrossRef lookups retry with backoff instead of silently truncating the reference check on 429s.
@@ -189,6 +190,17 @@ reviewer_zero_prompt(writeback = TRUE)
 
 # All extensions together
 reviewer_zero_prompt(prereg_path = "prereg.docx", robustness = TRUE, writeback = TRUE)
+
+# Referee Mode, configured. Quick-and-dirty pass on a fast model tier:
+referee_prompt(model = "haiku")
+
+# Submission-grade: strongest tier, adversarial reviewer pairs per lens
+# (prosecutor + verifier), and lenses dispatched across model vendors
+# (codex/agy/qwen) so same-model blind spots can't hide the same flaw twice:
+referee_prompt(model = "opus", reviewers_per_lens = 2, cross_vendor = TRUE)
+
+# Mix tiers per lens: deep model where the reasoning is hard, fast elsewhere
+referee_prompt(model = c(logic = "opus", methods = "opus", consistency = "haiku"))
 ```
 
 The protocol works with `.docx`, `.pdf`, `.qmd`, `.Rmd`, `.tex`, or plain text manuscripts and supports multi-script R projects.

inst/prompts/reviewer_zero_referee.md

@@ -27,12 +27,14 @@ table/figure becomes a finding. If a class is reported unverifiable
 
 ### Step R2: Review lenses
 
-Five lenses, each with exactly one lane. If your environment supports
-subagents (Claude Code's Task tool, Codex agents), dispatch them in
-parallel, one lens per subagent, each instructed to read the ENTIRE
-manuscript via paginated `read_file` and report findings only in its lane.
-Without subagents, run the lenses sequentially yourself, completing one
-before starting the next.
+Configuration for this run:
+
+- Lenses: {{LENSES}}
+- Independent reviewers per lens: {{REVIEWERS_PER_LENS}}
+- Subagent model directive: {{MODEL_DIRECTIVE}}
+- Cross-vendor dispatch: {{VENDOR_DIRECTIVE}}
+
+The lens mandates:
 
 1. **logic** -- Does each conclusion follow from what is established?
    Unsupported leaps, circular arguments, quantifier slips, claims proved
@@ -55,46 +57,84 @@ before starting the next.
    explanations left unaddressed, positioning gaps (flag, do not demand
    specific citations).
 
+If your environment supports subagents (Claude Code's Task tool, Codex
+agents), dispatch reviewers in parallel, one subagent per reviewer, each
+instructed to read the ENTIRE manuscript via paginated `read_file` and
+report findings only in its lane. Without subagents, run the reviewers
+sequentially yourself, completing one before starting the next.
+
+#### Anti-collapse rules (mandatory)
+
+Parallel reviewers built on the same model share blind spots. These rules
+exist to break that correlation; do not skip them:
+
+1. Write each reviewer's prompt from scratch for its lens and stance. The
+   prompts may share only the output format. If two of your subagent
+   prompts differ by one sentence, rewrite them.
+2. Reviewer stances per lens, by reviewer count:
+   - 1 reviewer: balanced examiner.
+   - 2 reviewers: a PROSECUTOR ("find where this lane's reasoning fails;
+     assume there is a flaw and hunt it") and a VERIFIER ("attempt to
+     confirm each relevant step actually holds; report every step you
+     could not confirm").
+   - 3 reviewers: prosecutor, verifier, and a BACKWARDS reader.
+3. Regardless of count, the consistency lens's first reviewer reads the
+   manuscript BACK TO FRONT: conclusions first, then checking whether the
+   premises for each claim were ever established earlier. This traversal
+   catches promissory abstracts and unproven dependencies that
+   front-to-back reading normalizes.
+4. Convergence is information, not waste: findings surfaced independently
+   by multiple reviewers are corroborated. Track how many independent
+   reviewers surfaced each finding.
+
 Every finding uses this exact structure:
 
 - `lens`: which lens produced it
+- `reviewer`: which reviewer (e.g. "logic/prosecutor", "logic/verifier")
 - `severity`: `major` (undermines a conclusion) / `moderate` (weakens or
   confuses an argument) / `minor` (substantive but small)
 - `anchor`: a VERBATIM quote of 10-30 characters from the manuscript at the
   location of the issue (copy-paste; it will be existence-checked)
 - `comment`: the referee comment, written to the author: specific, concrete,
   and stating why it matters. One issue per finding.
 
-A lens that finds nothing in its lane must say so explicitly rather than
-inventing filler findings.
+A reviewer that finds nothing in its lane must say so explicitly rather
+than inventing filler findings.
 
 ### Step R3: Adjudication
 
 Merge all findings (including Step R1's) into a registry:
 
 ```r
 referee_registry <- data.frame(
-  finding_id = integer(0), lens = character(0), severity = character(0),
-  anchor = character(0), comment = character(0),
-  status = character(0),   # "confirmed" or "dropped"
-  reason = character(0),   # required when dropped
+  finding_id = integer(0), lens = character(0), reviewer = character(0),
+  severity = character(0), anchor = character(0), comment = character(0),
+  n_independent = integer(0),  # reviewers that surfaced this finding
+  status = character(0),       # "confirmed" or "dropped"
+  reason = character(0),       # required when dropped
   stringsAsFactors = FALSE
 )
 ```
 
-Then verify EVERY finding yourself; subagent output is a draft, not a
+Then verify EVERY finding yourself; reviewer output is a draft, not a
 verdict:
 
-1. Prove the anchor exists:
+1. Deduplicate first: findings from different reviewers describing the
+   same issue merge into one row with `n_independent` set to the count of
+   distinct reviewers that surfaced it.
+2. Prove the anchor exists:
    `stopifnot(any(grepl(anchor, doc_lines, fixed = TRUE)))` --
    a finding whose anchor is not in the document is dropped as
    hallucinated, whatever its content.
-2. Re-read the anchored passage with surrounding context. Drop findings
-   that misread the text, duplicate another finding, or are stylistic
-   despite the rules. Record the reason.
-3. Sanity-check severity: downgrade anything a careful author would
+3. Re-read the anchored passage with surrounding context. Drop findings
+   that misread the text or are stylistic despite the rules. Record the
+   reason.
+4. Sanity-check severity: downgrade anything a careful author would
    shrug at. `major` must be reserved for issues that change what a
-   reader should believe.
+   reader should believe. A finding with `n_independent >= 2` (and
+   especially one surfaced across model vendors) warrants extra care
+   before dropping; a single-reviewer finding warrants extra care before
+   confirming as major.
 
 #### Referee gate
 
@@ -118,8 +158,10 @@ ClaudeR::annotate_manuscript(
 )
 ```
 
-Add a "Referee Review" section to the Final Report: counts by severity and
-lens, the confirmed findings ranked most severe first, dropped findings
+Add a "Referee Review" section to the Final Report: the reviewer
+configuration that ran (lenses, reviewers per lens, models/vendors used),
+counts by severity and lens, the confirmed findings ranked most severe
+first with their `n_independent` corroboration counts, dropped findings
 with reasons (so the user can audit your filtering), the cross-reference
 results, and the annotated file path if one was written.
 
@@ -129,10 +171,12 @@ results, and the annotated file path if one was written.
    belong here.
 2. Every finding is anchored to a verbatim quote and the anchor is
    grepl-proven before the finding survives.
-3. Verify subagent findings independently; you own every comment that
+3. Verify reviewer findings independently; you own every comment that
    lands in the author's document.
 4. Severity honesty: three real major findings help the author more than
    thirty inflated ones.
 5. Absence is reportable: if a lens legitimately finds nothing, the report
    says so. A clean referee report on a sound paper is a success, not a
    failure to find things.
+6. Report the configuration honestly, including any lens you could not
+   dispatch as requested (e.g. a vendor CLI not installed).