/evidence-ledger

name: evidence-ledger
description: "Build the deterministic evidence ledger (artifact_manifest.json + claims.json) that every other Anti-Autoresearch auditor reads. One pass inventories artifacts, derives the observability level (L0 PDF-only / L1 +LaTeX / L2 +repo+results) by fixed rule, and extracts span-anchored, hashed, checkable claims (numbers, comparisons, scope, method, baselines, citations, captions, table cells) into claims.json. An OPTIONAL additive cross-model pass ADDS span-anchored semantic claims — method, theorem statements with their assumptions, definitions, proof/derivation steps and equations, scope, baselines, conclusions, the motivation span, and reproducibility-artifact references (the proof, derivation, and structure anchors the family B/D/G auditors need) — it never invents a number, emits a finding, or computes a verdict. Run FIRST, before any audit skill. Triggers: \"build the ledger\", \"extract claims\", \"prep for integrity audit\", \"evidence ledger\", \"建证据账本\"."
argument-hint: [paper-dir | arxiv-id | pdf-path]
allowed-tools: Bash(*), Read, Write, Grep, Glob, mcp__codex__codex

Evidence Ledger — the spine every auditor reads

> Infrastructure skill, **not an auditor**. It produces the *only* structure the > auditor skills are allowed to reason over, so they don't each re-read the PDF and > hallucinate a different table and a different list of numbers. It emits **no > findings and no verdict** — only `artifact_manifest.json` + `claims.json`. See > `references/integrity-forensics-contract.md` §"The pipeline" (stages [1]–[2]).

Build the ledger for: **$ARGUMENTS**

> 🔁 **Not verdict-bearing — but not a polling skill either.** The deterministic > backbone (Steps 1–2) is a *pure function of the hashed sources*: same source bytes > → byte-identical `claims.json`. Re-run it only when the sources change, never on a > wall-clock timer. The only non-deterministic part is the optional enrichment pass > (Step 3), which is additive and skippable. Do **not** wrap this skill in `/loop` / > `/schedule` / `CronCreate`; there is no verdict to re-fire and no external event to > wait on.

Why this exists

Five language-model auditors each independently parsing a PDF = five different hallucinated tables and five different number lists, none reproducible — and the obvious dismissal, *"an LLM grading another LLM's paper is just slop."* The structural answer is **one deterministic pass** that turns the paper into:

• `artifact_manifest.json` — what was observable; this fixes the **observability

level L**, the ceiling on every downstream finding's severity, and

• `claims.json` — a list of **span-anchored, hashed, checkable** claims

(`schemas/claims.schema.json`).

Every downstream finding must cite a `claim_id` from this ledger and quote a verbatim span of it. **No ledger claim → no finding** (the single most important integrity rule of the repo, enforced again by `tools/adjudicate_findings.py`). That is what makes the difference between "a model said so" and "here is the exact sentence, its file, and its content hash" (`DESIGN.md` §2).

Role in the pipeline (what this skill does and does NOT do)

| Stage | Skill / tool | Emits | Judges? | |-------|--------------|-------|:-------:| | **[1]–[2] ledger** | **evidence-ledger (this skill)** + `tools/build_manifest.py`, `tools/build_claim_ledger.py` | `artifact_manifest.json` + `claims.json` | **No.** States *what the paper says*. | | [3] auditors | `consistency-audit`, `citation-forensics`, `baseline-comparison-audit`, `experiment-forensics` | `<skill>.findings.json` (read the ledger; quote its spans) | Propose findings — not the verdict. | | [3] surface | `presentation-signals` | capped-at-`minor` surface findings (auxiliary) | Never a standalone verdict. | | [3] memo | `adversarial-case-builder` | an evidence-bound memo | No verdict weight. | | [4] **verdict** | `tools/adjudicate_findings.py` | `report.json` + `REPORT.md` | **Yes** — the ONLY verdict, by fixed rules, no model in the loop. |

This skill is stage [1]–[2] only. It states **what the paper says**, never **whether it is right**. The `finding.schema.json` `skill` enum technically lists `evidence-ledger` for completeness, but this skill never writes a finding object. If you came here for a PASS/FAIL, you want `/anti-autoresearch` (the orchestrator), not this skill.

Core principle

**Deterministic first; the model may only add, never invent, never judge.**

1. The numeric/citation/table backbone comes from **code** (`tools/`), not a model — that is what makes the whole pipeline reproducible and defensible. 2. The optional LLM pass is an **additive claim-extractor**: it may add a span-anchored *semantic* claim whose `text_span` is a verbatim substring of a hashed source file; it may **never** introduce a number, alter an extracted value, propose a finding, or assign a severity/verdict. The executor validates every added span (Step 4) and rejects anything it cannot locate. Its surface is deliberately broad — beyond method/scope/baseline it also captures **theorem statements (with their assumptions), definitions, proof/derivation steps, equations, conclusions, the motivation span, and reproducibility-artifact references** — but every one of those rides on an **existing** `claims.schema.json` `type` (`scope`/`method`/`comparison`/`artifact_ref`); enrichment widens *what content* is anchored, never the type vocabulary, the Step-4 gate, or the deterministic backbone. 3. **No span → no claim.** Every `text_span` in the ledger must be locatable in a hashed source. This is the same gate the adjudicator enforces on findings, applied one stage upstream.

Constants

• **LEDGER_VERSION = `0.1`** — stamped into `claims.json` by `build_claim_ledger.py`; never hand-edit.
• **TAXONOMY_VERSION = `0.5`** — the ledger is **taxonomy-agnostic** (it tags no `pattern_id`); patterns are applied *post-hoc* by auditors (`references/h