@research-copilot/plugin 1.1.17 → 1.1.19

package/dist/skills/overleaf-sync/SKILL.md

@@ -0,0 +1,220 @@
+---
+name: overleaf-sync
+description: "Two-way sync between a local paper directory and an Overleaf project, so ARIS audit/edit workflows stay on the local copy while collaborators edit in the Overleaf web UI. Use when user says \"同步 overleaf\", \"overleaf sync\", \"推送到 overleaf\", \"connect overleaf\", \"Overleaf 桥接\", \"pull overleaf\", \"push overleaf\", or wants to bridge their ARIS paper directory with an Overleaf project."
+argument-hint: [setup <project-id> | pull | push | status]
+allowed-tools: Bash(*), Read, Grep, Glob, Edit, Write
+---
+
+# Overleaf Sync
+
+Bridge a local paper directory with an Overleaf project so that:
+
+- **You** can keep editing in the Overleaf web UI (or share editing access with collaborators)
+- **ARIS** can read your changes, run audits (`/paper-claim-audit`, `/citation-audit`, `/auto-paper-improvement-loop`), and push fixes back
+
+This uses the official **Overleaf Git bridge** (Premium feature). The agent **never sees your authentication token** — you do the one-time auth manually so the token lives in macOS Keychain, not in chat history or `.git/config`.
+
+## When to Use This Skill
+
+- You want to use Overleaf as the editing surface (better collaboration, shared with team) but still run ARIS pipelines locally
+- You want to take an existing local ARIS paper and push it to Overleaf for a co-author to edit
+- A collaborator made changes in Overleaf and you want to pull + diff them before continuing local work
+
+## Constants
+
+- **CLONE_DIR_DEFAULT** = `paper-overleaf` (sibling of existing `paper/`, NOT inside `paper/`)
+- **CREDENTIAL_HELPER** = `osxkeychain` (macOS) / `manager` (Windows) / `cache` (Linux fallback)
+- **TOKEN_HANDLING** = **NEVER write token to disk, env var, or chat**. User pastes it once into the terminal credential prompt; the OS keychain stores it from then on.
+
+## Architecture
+
+```
+┌─────────────────┐       git pull/push      ┌─────────────────┐
+│  Local paper/   │ ◄─── rsync ──── ►       │ paper-overleaf/ │ ◄──► Overleaf web
+│  (ARIS audits)  │                          │ (git bridge)    │     (collaborators)
+└─────────────────┘                          └─────────────────┘
+```
+
+The `paper-overleaf/` directory is a **git clone of the Overleaf project**. The `paper/` directory is the working copy where ARIS skills run. They are kept in sync via `rsync`.
+
+**Single-source-of-truth rule**: at any given time, treat *one* of them as authoritative for active editing. Switch directions explicitly with `pull` or `push`, and run a `status` check before either to surface unexpected divergence.
+
+## Sub-commands
+
+### `setup <project-id>` — one-time
+
+Sets up the bridge for a new Overleaf project. **The user runs this in their own terminal, never through the agent.** The skill ships with a hardened setup script that:
+
+1. Refuses to run unless stdin/stdout are a TTY (won't run inside an agent harness)
+2. Reads the token from a hidden prompt (no chat history, no shell history)
+3. Strips the token from the remote URL immediately after cloning
+4. Primes the OS keychain so subsequent agent operations are auth-free
+5. **Auto-installs a `pre-commit` hook in `paper-overleaf/.git/hooks/` that refuses to commit any blob containing the token pattern `olp_[A-Za-z0-9]{20,}`** — a hard technical block, not a behavioral rule
+
+The agent's only role here is to print the user instruction:
+
+```
+Run this in your own terminal (NOT through me):
+
+    bash <ARIS_REPO>/tools/overleaf_setup.sh <project-id-or-url>
+
+When it finishes, tell me "setup done" and I'll verify.
+```
+
+After the user reports "setup done", the agent verifies (token-free):
+
+```bash
+cd paper-overleaf
+git remote -v                    # must show URL WITHOUT token
+git config --get credential.helper
+git fetch && git log --oneline -3   # must succeed without prompting
+ls .git/hooks/pre-commit         # must exist
+bash <ARIS_REPO>/tools/overleaf_audit.sh .   # must report "Audit clean"
+```
+
+If `paper-overleaf/` exists but is empty (new Overleaf project), the agent then mirrors local `paper/` into it (see `push` workflow).
+
+### `pull` — before each editing session
+
+```bash
+cd paper-overleaf && git pull --ff-only
+
+# Show what changed since last pull
+LAST=$(git rev-parse HEAD@{1})
+git diff --stat $LAST..HEAD
+git diff $LAST..HEAD -- 'sec/*.tex'        # detailed view for prose changes
+```
+
+**Diff protocol — DO NOT blindly merge into local `paper/`.** Overleaf edits frequently include:
+
+- **Half-finished sentences** (collaborator clicked save mid-thought)
+- **Typos** that aren't in canonical references (`Lrage` for `Large`)
+- **Commented-out blocks** that may be intentional or may be a stash
+- **Number changes** that should re-trigger `/paper-claim-audit`
+- **Cite key changes** that should re-trigger `/citation-audit`
+
+For each diff hunk, decide one of:
+
+| Hunk character | Action |
+|----------------|--------|
+| Clean editorial improvement | Sync into `paper/`, no audit needed |
+| Numerical / claim change | Sync, then re-run `/paper-claim-audit` |
+| New `\cite{...}` | Sync, then re-run `/citation-audit` |
+| Half-sentence / obvious typo | Flag to user, do NOT auto-sync |
+| New section / restructure | Stop, ask user before syncing |
+
+After deciding per-hunk:
+
+```bash
+# Sync only the files the user approved into local paper/
+rsync -av paper-overleaf/sec/0.abstract.tex paper/sec/0.abstract.tex
+# (or use Edit tool for surgical changes that skip half-sentences)
+```
+
+### `push` — after local editing
+
+Use after ARIS skills have edited `paper/` and you want collaborators on Overleaf to see the changes.
+
+```bash
+# 1. Always pull first to surface remote drift
+cd paper-overleaf && git pull --ff-only
+
+# 2. If pull was a no-op, sync local paper → paper-overleaf
+rsync -av --delete \
+  --exclude='.git' --exclude='.DS_Store' \
+  --exclude='*.aux' --exclude='*.log' --exclude='*.bbl' --exclude='*.blg' \
+  --exclude='*.fls' --exclude='*.fdb_latexmk' --exclude='*.out' \
+  --exclude='*.synctex.gz' --exclude='*.toc' \
+  paper/ paper-overleaf/
+
+# 3. Show what would be pushed
+git status --short
+git diff --stat
+
+# 4. Commit + push
+git add -A
+git commit -m "<descriptive message — what ARIS changed and why>"
+git push
+```
+
+**Commit message protocol**: include the ARIS skill that produced the change so collaborators on Overleaf understand provenance. Examples:
+
+- `paper-write: regenerated sec/3.assurance after audit cascade refactor`
+- `citation-audit: fix 14 metadata entries (madaan2023, lee2024, ...)`
+- `paper-claim-audit: correct sec/5 numbers vs results/run_2026_04_19.json`
+
+**Confirmation gate**: `push` writes to a shared resource. ALWAYS show the user `git diff --stat` (and a representative hunk for prose changes) before running `git push`. Wait for explicit confirmation unless the user said `auto: true` upfront.
+
+### `status` — diagnostic
+
+```bash
+cd paper-overleaf
+git fetch
+echo "=== Remote-vs-local divergence ==="
+git log --oneline HEAD..origin/master    # remote ahead
+git log --oneline origin/master..HEAD    # local ahead
+echo "=== paper/ vs paper-overleaf/ divergence ==="
+diff -rq --brief paper/ paper-overleaf/ 2>/dev/null \
+  | grep -v "Only in paper/.*\.\(aux\|log\|out\|fls\|fdb_latexmk\|bbl\|blg\|synctex\|toc\)" \
+  | grep -v "Only in paper-overleaf/.git" \
+  | grep -v "DS_Store"
+```
+
+Three-way state assessment:
+
+| Remote ahead? | paper/ vs paper-overleaf/ differ? | Meaning | Recommended action |
+|:-------------:|:---------------------------------:|---------|--------------------|
+| No  | No  | Clean       | Nothing to do |
+| Yes | No  | Overleaf has new edits | Run `pull`, then re-run status |
+| No  | Yes | Local ARIS edits unsynced | Run `push` |
+| Yes | Yes | Diverged — needs merge | Stop, surface to user, do NOT auto-resolve |
+
+## Conflict Resolution
+
+If `git pull --ff-only` fails because of true divergence:
+
+1. **Do not** run `git pull` (which would auto-merge).
+2. **Do not** run `git reset --hard` or `git push --force` (destructive).
+3. Show the user `git log origin/master ^HEAD` (their Overleaf commits) and `git log HEAD ^origin/master` (local ARIS commits).
+4. Ask the user which side to take per file, or to manually merge in Overleaf and then re-pull.
+
+## Token Security — Defense in Depth
+
+Behavioral rules alone are not enough — the next agent reading this skill might forget them. The skill therefore relies on **technical guards** that hold even if the agent misbehaves:
+
+| Layer | Guard | Where enforced |
+|-------|-------|---------------|
+| 1. Setup | `overleaf_setup.sh` refuses to run without an interactive TTY (agents don't have one) | `tools/overleaf_setup.sh` |
+| 2. Input | Token is read by `read -s` (hidden prompt, no shell history, never enters chat) | `tools/overleaf_setup.sh` |
+| 3. Storage | Token goes straight into OS keychain via `git credential approve`; remote URL is stripped to a token-free form | `tools/overleaf_setup.sh` |
+| 4. Commits | `paper-overleaf/.git/hooks/pre-commit` greps staged content for `olp_[A-Za-z0-9]{20,}` and aborts | auto-installed by setup script |
+| 5. Audit | `overleaf_audit.sh` scans working tree, remote URLs, git history, credential files | `tools/overleaf_audit.sh` |
+
+Behavioral rules (still apply, but secondary):
+
+- **Never** ask the user to paste a token into chat. If they do anyway: (a) acknowledge it, (b) tell them to revoke it at https://www.overleaf.com/user/settings, (c) recover via keychain if already primed.
+- **Never** write a token to a file (`.env`, `.netrc`, `tools/*.sh`, etc.) committed to any repo.
+- **Never** include a token in a `git remote -v` URL — strip it after clone.
+- On `401 Unauthorized` from push/pull, tell the user the keychain entry expired and to re-run `overleaf_setup.sh`. Do **not** ask for a fresh token.
+
+## Mutual-Exclusion Rule
+
+The single biggest source of pain in two-way sync is **simultaneous editing on both sides**.
+
+- If the user is in an active Overleaf editing session, ARIS skills should **read-only** access `paper/` until the user runs `/overleaf-sync pull`.
+- If ARIS is in the middle of `/auto-paper-improvement-loop` or `/paper-write`, the user should pause Overleaf editing until the loop finishes and `/overleaf-sync push` is run.
+
+When in doubt, run `status` first.
+
+## Output Contract
+
+- `paper-overleaf/` directory at repo root, git clone of Overleaf project (origin URL has NO token)
+- `paper/` directory unchanged in role — still the ARIS working copy
+- Each `pull`/`push` operation: a one-line summary back to the user (commits pulled / pushed, file count, link to Overleaf project URL)
+
+## See Also
+
+- `/paper-claim-audit` — re-run after pulling Overleaf changes that touch numbers
+- `/citation-audit` — re-run after pulling Overleaf changes that add/edit `\cite{...}`
+- `/paper-compile` — local LaTeX build; Overleaf compiles independently in the cloud
+- Overleaf Git bridge docs: https://www.overleaf.com/learn/how-to/Using_Git_and_GitHub

package/dist/skills/paper-claim-audit/SKILL.md

@@ -0,0 +1,340 @@
+---
+name: paper-claim-audit
+description: "Zero-context verification that every number, comparison, and scope claim in the paper matches raw result files. Uses a fresh cross-model reviewer with NO prior context to prevent confirmation bias. Use when user says \"审查论文数据\", \"check paper claims\", \"verify numbers\", \"论文数字核对\", or before submission to ensure paper-to-evidence fidelity."
+argument-hint: [paper-directory]
+allowed-tools: Bash(*), Read, Write, Edit, Grep, Glob
+---
+
+# Paper Claim Audit: Zero-Context Evidence Verification
+
+Verify that every claim in the paper matches raw evidence for: **$ARGUMENTS**
+
+## Why This Exists
+
+The executor writes experiments AND writes the paper. It "knows" what the results should be. This creates confirmation bias:
+- Rounding 84.7% up to 85.3%
+- Reporting best seed instead of average
+- Citing metrics from a different experiment config
+- Claiming "improves by 15%" when the delta is actually 12.8%
+
+A **fresh reviewer with zero prior context** catches these because it has no expectations — it just compares paper text vs raw files.
+
+## How This Differs From Other Audit Skills
+
+| Skill | Question it answers |
+|-------|-------------------|
+| `/experiment-audit` | Is the experiment code honest? (fake GT, normalization fraud) |
+| `/result-to-claim` | Does the data scientifically support this claim? |
+| **`/paper-claim-audit`** | **Does the paper report the data truthfully and precisely?** |
+
+## Core Principle
+
+**Zero-context, fresh reviewer.** The auditor receives ONLY:
+- Paper .tex files (the claims)
+- Raw result files (the evidence)
+
+It does NOT receive:
+- ❌ EXPERIMENT_LOG.md
+- ❌ EXPERIMENT_TRACKER.md
+- ❌ AUTO_REVIEW.md
+- ❌ NARRATIVE_REPORT.md
+- ❌ Any executor summary or interpretation
+- ❌ Any prior audit results
+- ❌ Any conversation history
+
+This is **stricter than reviewer-independence** — it's zero-context evidence audit.
+
+## Workflow
+
+### Step 1: Collect Files (Executor — Claude)
+
+Locate paper and result files WITHOUT reading or interpreting them.
+
+**Paper files** (claims) — paths shown relative to the shell's working
+directory so you can find them with `ls`; when writing them into
+`audited_input_hashes`, use paths relative to the paper dir (no `paper/`
+prefix) per the "Submission Artifact Emission" section below:
+```
+paper/main.tex                # → hash key: main.tex
+paper/sections/*.tex          # → hash key: sections/*.tex
+paper/tables/*.tex (if separate)   # → hash key: tables/*.tex
+```
+
+**Result files** (evidence):
+```
+results/*.json, results/*.jsonl, results/*.csv, results/*.tsv
+outputs/*.json, outputs/*.csv
+wandb-summary.json (if exists)
+**/metrics.json, **/eval_results.json
+**/config.yaml, **/args.json (experiment configs)
+```
+
+**Exclude** (no summaries, no interpretations):
+```
+EXPERIMENT_LOG.md, EXPERIMENT_TRACKER.md, AUTO_REVIEW*.md
+NARRATIVE_REPORT.md, PAPER_PLAN.md, findings.md
+Any .md file that is an executor-written summary
+```
+
+### Step 2: Fresh Reviewer Audit (GPT-5.5 — NEW thread, no reply)
+
+**CRITICAL: Use a fresh reviewer agent every run.** Never reuse an old reviewer context for this audit.
+
+```text
+spawn_agent:
+  model: gpt-5.5
+  reasoning_effort: xhigh
+  message: |
+    You are a paper-to-evidence auditor. You have ZERO prior context about
+    this research. You will receive only paper source files and raw result
+    files. Your job is to verify that every number in the paper exactly
+    matches the raw evidence.
+
+    Paper files to read:
+    [list .tex file paths]
+
+    Result files to read:
+    [list .json/.csv/.yaml file paths]
+
+    ## Audit Protocol
+
+    ### A. Extract Every Quantitative Claim
+    For each number, percentage, comparison, or scope statement in the paper:
+    - Location (section, table, caption, or inline text)
+    - Exact claim text
+    - The number or comparison being made
+
+    ### B. Trace Each Claim to Evidence
+    For each extracted claim, find the supporting raw data:
+    - Which result file contains this number?
+    - What is the EXACT value in that file?
+    - Match status: exact_match / rounding_ok / mismatch
+
+    ### C. Check These Specific Failure Modes
+
+    1. **Number inflation**: Paper says 85.3%, raw file says 84.7%
+       Rule: only standard rounding to displayed precision is allowed
+
+    2. **Best-seed cherry-pick**: Paper says "achieves 90.2%" but
+       that's the best of 5 seeds; mean is 87.1%
+       Rule: check if paper specifies "average" / "best" / "median"
+
+    3. **Config mismatch**: Paper compares Method A vs Baseline B,
+       but they used different hyperparameters / datasets / splits
+       Rule: verify config files show same settings for compared methods
+
+    4. **Aggregation mismatch**: Paper says "average over 5 seeds"
+       but result files show only 3 runs
+       Rule: count actual runs vs claimed count
+
+    5. **Delta error**: Paper says "improves by 15%" but
+       actual delta is (85.3 - 73.1) / 73.1 = 16.7%
+       Rule: verify arithmetic of all relative improvements
+
+    6. **Caption-table mismatch**: Figure caption describes
+       something different from what the figure/table actually shows
+       Rule: cross-check every caption against its content
+
+    7. **Scope overclaim**: Paper says "consistently outperforms"
+       but only tested on 2 datasets
+       Rule: check if language matches actual evaluation scope
+
+    ## Output Format (per claim)
+    For each claim, report:
+    - claim_id: sequential number
+    - location: section/table/figure
+    - paper_text: exact quote from paper
+    - paper_value: the number claimed
+    - evidence_file: which raw file
+    - evidence_value: the actual number
+    - status: exact_match | rounding_ok | ambiguous_mapping |
+              missing_evidence | config_mismatch | aggregation_mismatch |
+              number_mismatch | scope_overclaim | unsupported_claim
+    - details: explanation if not exact_match
+
+    Overall verdict: PASS | WARN | FAIL
+```
+
+### Step 3: Write Report (Executor — Claude)
+
+Parse the reviewer's response and write `PAPER_CLAIM_AUDIT.md`:
+
+```markdown
+# Paper Claim Audit Report
+
+**Date**: [today]
+**Auditor**: GPT-5.5 xhigh (fresh zero-context thread)
+**Paper**: [paper title from tex]
+
+## Overall Verdict: [PASS | WARN | FAIL]
+
+## Claims Verified: [N total]
+- exact_match: [count]
+- rounding_ok: [count]
+- ambiguous_mapping: [count]
+- missing_evidence: [count]
+- mismatch: [count]
+
+## Issues Found
+
+### [FAIL/WARN] Claim #N: [description]
+- **Location**: Section X / Table Y / Figure Z
+- **Paper says**: "..."
+- **Evidence shows**: ...
+- **Status**: [status]
+- **Fix**: [specific correction needed]
+
+## All Claims (detailed)
+
+| # | Location | Paper Value | Evidence Value | Status |
+|---|----------|-------------|---------------|--------|
+| 1 | Table 2 | 85.3% | 85.28% | rounding_ok |
+| 2 | Abstract | "15% improvement" | 12.8% | number_mismatch |
+| ... |
+```
+
+Also write `PAPER_CLAIM_AUDIT.json` for machine consumption.
+
+### Step 4: Print Summary
+
+```
+📋 Paper Claim Audit Complete
+
+  Claims verified: 24
+  exact_match:     18
+  rounding_ok:      3
+  ambiguous:         1
+  ⚠️ mismatch:      2
+
+  Overall: ⚠️ WARN
+
+  See PAPER_CLAIM_AUDIT.md for details.
+```
+
+## When to Run
+
+1. **After `/paper-write`** — first check before improvement loop
+2. **After `/auto-paper-improvement-loop`** — recheck if improvement loop changed numbers
+3. **Before submission** — final verification
+
+## Integration with Other Skills
+
+### Read by `/auto-paper-improvement-loop` (if exists)
+
+```
+if PAPER_CLAIM_AUDIT.json exists:
+    read mismatched claims
+    fix them as priority items in the improvement round
+```
+
+### Advisory, Never Blocking
+
+Same pattern as `/experiment-audit`:
+- `PASS` → continue normally
+- `WARN` → print warning, continue, flag draft as "check numbers before submission"
+- `FAIL` → print alert, continue, but do NOT mark as submission-ready
+
+## Render HTML view (auto, when `RENDER_HTML = true`, default)
+
+After writing `paper/PAPER_CLAIM_AUDIT.md` and `paper/PAPER_CLAIM_AUDIT.json`, invoke `/render-html` on the audit report:
+
+```
+/render-html "paper/PAPER_CLAIM_AUDIT.md" --json "paper/PAPER_CLAIM_AUDIT.json"
+```
+
+Uses **full review gate** (audit-class artifact — render-fidelity check matches the skill's zero-context cross-model audit invariant). Output: `paper/PAPER_CLAIM_AUDIT.html` with embedded source SHA256 + `.review.json` sidecar.
+
+**Non-blocking**: if `/render-html` fails (helper missing, secondary Codex agent unavailable, file write error), log the failure and treat the audit as complete — the JSON + MD verdict files are canonical; the HTML view is a human-reader convenience.
+
+Skip if `RENDER_HTML = false` is set in `AGENTS.md` / `CLAUDE.md` or passed as `— render html: false`.
+
+## Key Rules
+
+- **Fresh thread EVERY run.** Never use a continuation reply. Never carry context.
+- **Zero executor interpretation.** Only file paths. No summaries.
+- **Only raw results.** No EXPERIMENT_LOG, no AUTO_REVIEW, no human summaries.
+- **Rounding rule.** Only standard rounding to displayed precision. 84.7% → 84.7% or 85% is OK. 84.7% → 85.3% is NOT OK.
+- **Cross-model.** Reviewer must be a different model family from executor.
+
+## Review Tracing
+
+After each reviewer agent call, save the trace following `shared-references/review-tracing.md` (Policy C — forensic; never silently skip). Use `save_trace.sh` (resolved per the chain in `shared-references/integration-contract.md` §2) or write files directly to `.aris/traces/<skill>/<date>_run<NN>/`. Respect the `--- trace:` parameter (default: `full`).
+
+## Submission Artifact Emission
+
+This skill **always** writes `paper/PAPER_CLAIM_AUDIT.json`, regardless of
+caller or detector outcome. A detector-negative run (paper has no numeric
+claims) emits verdict `NOT_APPLICABLE`; a paper-with-numeric-claims-but-no-
+raw-results run emits `BLOCKED`. Silent skip is forbidden — `paper-writing`
+Phase 6 and `verify_paper_audits.sh` both rely on this artifact
+existing at a predictable path.
+
+The artifact conforms to the schema in `shared-references/assurance-contract.md`:
+
+```json
+{
+  "audit_skill":      "paper-claim-audit",
+  "verdict":          "PASS | WARN | FAIL | NOT_APPLICABLE | BLOCKED | ERROR",
+  "reason_code":      "all_numbers_match | rounding_drift | missing_raw_results | ...",
+  "summary":          "One-line human-readable verdict summary.",
+  "audited_input_hashes": {
+    "main.tex":                              "sha256:...",
+    "sections/5.evidence.tex":               "sha256:...",
+    "/abs/path/to/results/run_2026_04_19.json": "sha256:..."
+  },
+  "trace_path":       ".aris/traces/paper-claim-audit/<date>_run<NN>/",
+  "thread_id":        "<codex mcp thread id>",
+  "reviewer_model":   "gpt-5.5",
+  "reviewer_reasoning": "xhigh",
+  "generated_at":     "<UTC ISO-8601>",
+  "details": {
+    "total_claims":   <int>,
+    "mismatches":     [ ... per-claim issue records ... ],
+    "result_files":   [ ... raw files consulted ... ]
+  }
+}
+```
+
+### `audited_input_hashes` scope
+
+Hash the **declared input set** passed into this audit invocation — i.e. the
+exact `.tex` files and raw result / config files this run read — not a
+repo-wide union and not the reviewer's self-reported subset. If a caller
+passed only `main.tex` + a single result file, hash those two files and no
+others. The external verifier rehashes these entries; any mismatch flags
+`STALE`.
+
+**Path convention** (must match what `verify_paper_audits.sh`
+expects): keys are **paths relative to the paper directory** (the arg
+passed to the verifier) for in-paper files — so `main.tex`, not
+`paper/main.tex` — and **absolute paths** for out-of-paper files such as
+external `results/` dirs. The verifier resolves relative entries via
+`os.path.join(paper_dir, key)`; prefixing with `paper/` produces
+`paper/paper/main.tex` and false-fails as STALE.
+
+### Verdict decision table
+
+| Input state                                           | Verdict          | `reason_code` example |
+|-------------------------------------------------------|------------------|-----------------------|
+| No numeric claims detected in paper                   | `NOT_APPLICABLE` | `no_numeric_claims`   |
+| Numeric claims detected, no raw result files found    | `BLOCKED`        | `no_raw_evidence`     |
+| All claims reconcile to raw data                      | `PASS`           | `all_numbers_match`   |
+| Minor rounding drift only, no material mismatch       | `WARN`           | `rounding_drift`      |
+| Any material mismatch (wrong number, config mismatch) | `FAIL`           | `claim_mismatch`      |
+| Reviewer invocation failed (network / malformed)      | `ERROR`          | `reviewer_error`      |
+
+### Thread independence
+
+Every invocation uses a fresh reviewer agent. Never continue a prior audit via
+`send_input`. Do not accept prior audit outputs (PROOF_AUDIT, CITATION_AUDIT,
+EXPERIMENT_LOG, AUTO_REVIEW summaries) as input to this audit — the fresh
+thread preserves reviewer independence per
+`shared-references/reviewer-independence.md`.
+
+### Human-readable sibling
+
+`paper/PAPER_CLAIM_AUDIT.md` is written alongside the JSON for readers.
+The JSON is authoritative for `verify_paper_audits.sh`; the Markdown
+is for humans. The parent skill (`paper-writing` Phase 6) plus the verifier
+decide whether the verdict blocks finalization — this skill itself never
+blocks; it only emits.