ref-verify 1.1.2__tar.gz → 1.2.2__tar.gz

{ref_verify-1.1.2/src/ref_verify.egg-info → ref_verify-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ref-verify
-Version: 1.1.2
+Version: 1.2.2
 Summary: Executable DOI and claim verification helpers for academic citations
 Author: Moonweave Research
 License-Expression: MIT
@@ -45,6 +45,10 @@ Works with **Claude Code, Cursor, Codex**, and any agent that supports the
 
 After installation, use it like a normal agent skill. You do not start a server and you do not configure MCP for this workflow. No MCP server is required for this workflow.
 
+The skill includes its own copy of the CLI engine, and the agent runs it from the skill folder, so nothing else needs to be installed. Python 3.10 or newer must be available as `python3`.
+
+For explicit agent tool-calling rules, see [AGENT_USAGE.md](https://github.com/Moonweave-Research/ref-verify/blob/main/AGENT_USAGE.md).
+
 ---
 
 ## Use it
@@ -75,20 +79,28 @@ checks that are currently safe to automate directly:
 
 - CrossRef metadata check: `ref-verify verify-doi`
 - DOI-bound abstract claim check: `ref-verify check-claim`
+- Batch DOI-bound claim checks: `ref-verify check-file`
   - literal text claims
   - subject-matched percentage claims such as efficiency, response rate, or actuation strain
   - simple unit/count claims such as cycles, patients, voltage, temperature, and concentration
-  - CrossRef first, then DOI-bound Semantic Scholar and PubMed fallback when CrossRef has no abstract
+  - CrossRef first, then DOI-bound OpenAlex, Semantic Scholar, and PubMed fallback when CrossRef has no abstract
 - JSON output for agent-readable routing
 - Non-zero exit codes for `WARN`, `REJECT`, and `UNVERIFIABLE` results
 
-Statistical metrics such as p-values, AUC/AUROC, F1 score, hazard ratio, odds ratio, and confidence intervals still use the manual skill protocol. DOI landing-page checks still use the skill protocol. Still handled by the skill protocol: Unpaywall, arXiv, two-source existence checks, and retraction checks remain in `SKILL.md`.
+Statistical metrics such as p-values, AUC/AUROC, F1 score, hazard ratio, odds ratio, and confidence intervals still use the manual skill protocol. DOI landing-page checks still use the skill protocol. The CLI rejects a DOI that CrossRef records as retracted (via its retraction notice); retraction banners CrossRef does not know about, Unpaywall, arXiv, and two-source existence checks remain in the `SKILL.md` protocol.
 
 The CLI has zero third-party Python runtime dependencies, but it is not an
 offline verifier. Functional checks require outbound HTTPS access to public
-academic APIs such as CrossRef, Semantic Scholar, and PubMed.
+academic APIs such as CrossRef, OpenAlex, Semantic Scholar, and PubMed.
 
-Install the CLI from a local checkout:
+To run the CLI yourself, install it from PyPI:
+
+```bash
+uvx ref-verify --help            # run without installing (uv)
+pipx install ref-verify          # or install the `ref-verify` command
+```
+
+Or install it from a local checkout:
 
 ```bash
 git clone https://github.com/Moonweave-Research/ref-verify.git
@@ -127,7 +139,7 @@ ref-verify check-claim 10.1126/science.287.5454.836 \
   --json
 ```
 
-By default, `check-claim` uses CrossRef first. If CrossRef has no abstract, it tries DOI-bound Semantic Scholar and PubMed fallback sources. Use `--source crossref`, `--source semantic-scholar`, or `--source pubmed` for source-specific debugging; explicit non-CrossRef source selection bypasses CrossRef.
+By default, `check-claim` uses CrossRef first. If CrossRef has no abstract, it tries DOI-bound OpenAlex, Semantic Scholar, and PubMed fallback sources. Use `--source crossref`, `--source openalex`, `--source semantic-scholar`, or `--source pubmed` for source-specific debugging; explicit non-CrossRef source selection bypasses CrossRef.
 
 Source-checkout equivalents:
 
@@ -169,6 +181,50 @@ normal CI does not fail because an upstream API is temporarily unavailable.
 
 ---
 
+## Scope — optional CLI versus manual audit
+
+`ref-verify` is a conservative guard, not an oracle. It errs toward flagging: an
+`ACCEPT` is high-confidence, and **anything else means "not auto-verifiable —
+check it yourself", not "the citation is wrong."**
+
+**The optional CLI verifies**
+
+- DOI metadata: title, first-author surname, and year against CrossRef.
+- Whether a DOI-bound **abstract** explicitly supports a specific numeric or
+  literal claim, quoted verbatim. If no abstract is reachable, it returns
+  `UNVERIFIABLE` rather than guessing.
+
+**The optional CLI does not verify** (out of scope by design, not bugs)
+
+- **Full-text, figure, table, or supplementary values** — abstract-only. A number
+  that appears only in the body stays `UNVERIFIABLE`.
+- **Relational or qualitative claims** — proportionalities, mechanisms,
+  "broader/stronger than". Only value+unit and literal claims are checked.
+- **Papers whose publisher withholds the abstract** — some titles expose no
+  abstract to CrossRef or OpenAlex. No abstract → `UNVERIFIABLE`, which reflects
+  reachability, not the claim.
+- **Statistical metrics** (p-value, AUC/AUROC, F1, hazard/odds ratio, confidence
+  intervals) — handled by the manual skill protocol, not the CLI.
+- **Paper quality, novelty, field consensus**, or whether the *full* paper
+  supports a broader statement.
+
+The agent skill's manual Full Audit protocol goes beyond the optional CLI for
+mechanism, implementation, and procedural claims. It requires a fetched
+full-text passage at that source depth; when full text is unavailable, it
+returns `WARN (ABSTRACT-ONLY)` instead of upgrading an abstract topic match to
+`ACCEPT`.
+
+**Reading a CLI verdict**
+
+| Verdict | Meaning |
+|---|---|
+| `ACCEPT` | The fetched abstract explicitly supports the claim. High-confidence pass. |
+| `WARN` / `PARTIAL` | An abstract was read but does not explicitly support the exact claim. Check the source. |
+| `UNVERIFIABLE` | No abstract was reachable to check against. Not a judgment on the claim. |
+| `REJECT` | DOI is dead, resolves to a different paper, contradicted, or retracted. |
+
+---
+
 ## Modes
 
 **Quick Screen** is for DOIs you already have. It uses CrossRef to compare the
@@ -182,9 +238,10 @@ ref-verify verify-doi <doi> --title "<title>" --first-author <last-name> --year
 exit code, so weak or mismatched metadata cannot silently pass automation gates.
 
 **Full Audit** is for literature search and final pre-submission review. The
-skill fetches abstracts through CrossRef, Semantic Scholar, Unpaywall, arXiv,
-and PubMed where needed, then checks whether the paper supports the specific
-claim being cited.
+skill fetches abstracts through CrossRef, OpenAlex, Semantic Scholar, Unpaywall,
+arXiv, and PubMed where needed. For a topline claim, it checks the abstract; for
+a mechanism, implementation, or procedural claim, it continues to a fetched
+full-text passage before assigning support.
 
 For a single DOI-backed claim, the CLI can run the abstract check:
 
@@ -197,19 +254,43 @@ ref-verify check-claim <doi> --claim "<specific claim>" --json
 `abstract_source`, `source_attempts`, and `error_code` so agents can distinguish
 missing abstracts, source failures, DOI mismatches, and ambiguous evidence.
 
+Use `check-file` when a draft, literature note, or AI-agent output has many
+DOI/claim pairs.
+
+JSONL:
+
+```bash
+ref-verify check-file claims.jsonl
+ref-verify check-file claims.jsonl --json
+```
+
+CSV:
+
+```bash
+ref-verify check-file claims.csv
+```
+
+Each row must include `doi` and `claim`. Optional fields are `id`, `source`,
+and `note`. Batch mode reuses the same conservative `check-claim` engine:
+`ACCEPT` means the abstract explicitly supports the numeric claim. `WARN`,
+`PARTIAL`, `REJECT`, or `UNVERIFIABLE` means the claim should not be treated as
+verified.
+
 Current `check-claim` error codes:
 
 - `CLAIM_SUPPORTED`: explicit abstract support found.
 - `CLAIM_NOT_EXPLICIT`: an abstract was available, but the claim was not explicitly supported.
 - `CLAIM_AMBIGUOUS`: numeric evidence or context exists, but binding is ambiguous.
 - `NO_ABSTRACT`: attempted DOI-bound sources did not provide abstract text.
-- `DOI_NOT_FOUND`: selected source did not find a DOI-bound record.
+- `DOI_NOT_FOUND`: CrossRef has no record for the DOI (HTTP 404), or the selected source did not find a DOI-bound record. The JSON still carries a `verdict` of `REJECT`.
+- `PAPER_RETRACTED`: CrossRef lists a retraction notice for the DOI; the claim is rejected before any abstract is read.
 - `DOI_MISMATCH`: the primary or explicitly selected DOI-bound record did not match the requested DOI.
-- `SOURCE_API_ERROR`, `SOURCE_TIMEOUT`, `SOURCE_UNSUPPORTED`: source lookup failed or could not be used.
+- `SOURCE_API_ERROR`, `SOURCE_TIMEOUT`, `SOURCE_RATE_LIMITED`, `SOURCE_UNSUPPORTED`: source lookup failed, timed out, was rate-limited, or could not be used.
 
 > Core rule: every content statement about a paper must come from a live-fetched
-> abstract. If the abstract is inaccessible after fallback checks, say
-> `UNVERIFIABLE`. Do not fill the gap from memory.
+> source at the depth the claim requires — abstract for topline claims, full
+> text for mechanism, implementation, or procedural claims. If the required
+> source is inaccessible, say so. Do not fill the gap from memory.
 
 ---
 
@@ -246,5 +327,4 @@ that as `WARN (PARTIAL)` instead of accepting the citation.
 
 ## Related
 
-- [anneal-skill](https://github.com/Moonweave-Systems/anneal-skill) - measure-first decision discipline for AI agents
-- [decide-skill](https://github.com/Moonweave-Systems/decide-skill) - decision automation for non-expert domains
+- [decision-kernel](https://github.com/Moonweave-Systems/decision-kernel) - evidence-gated decisions and drift/done checks for coding agents

{ref_verify-1.1.2 → ref_verify-1.2.2}/README.md

@@ -34,6 +34,10 @@ Works with **Claude Code, Cursor, Codex**, and any agent that supports the
 
 After installation, use it like a normal agent skill. You do not start a server and you do not configure MCP for this workflow. No MCP server is required for this workflow.
 
+The skill includes its own copy of the CLI engine, and the agent runs it from the skill folder, so nothing else needs to be installed. Python 3.10 or newer must be available as `python3`.
+
+For explicit agent tool-calling rules, see [AGENT_USAGE.md](https://github.com/Moonweave-Research/ref-verify/blob/main/AGENT_USAGE.md).
+
 ---
 
 ## Use it
@@ -64,20 +68,28 @@ checks that are currently safe to automate directly:
 
 - CrossRef metadata check: `ref-verify verify-doi`
 - DOI-bound abstract claim check: `ref-verify check-claim`
+- Batch DOI-bound claim checks: `ref-verify check-file`
   - literal text claims
   - subject-matched percentage claims such as efficiency, response rate, or actuation strain
   - simple unit/count claims such as cycles, patients, voltage, temperature, and concentration
-  - CrossRef first, then DOI-bound Semantic Scholar and PubMed fallback when CrossRef has no abstract
+  - CrossRef first, then DOI-bound OpenAlex, Semantic Scholar, and PubMed fallback when CrossRef has no abstract
 - JSON output for agent-readable routing
 - Non-zero exit codes for `WARN`, `REJECT`, and `UNVERIFIABLE` results
 
-Statistical metrics such as p-values, AUC/AUROC, F1 score, hazard ratio, odds ratio, and confidence intervals still use the manual skill protocol. DOI landing-page checks still use the skill protocol. Still handled by the skill protocol: Unpaywall, arXiv, two-source existence checks, and retraction checks remain in `SKILL.md`.
+Statistical metrics such as p-values, AUC/AUROC, F1 score, hazard ratio, odds ratio, and confidence intervals still use the manual skill protocol. DOI landing-page checks still use the skill protocol. The CLI rejects a DOI that CrossRef records as retracted (via its retraction notice); retraction banners CrossRef does not know about, Unpaywall, arXiv, and two-source existence checks remain in the `SKILL.md` protocol.
 
 The CLI has zero third-party Python runtime dependencies, but it is not an
 offline verifier. Functional checks require outbound HTTPS access to public
-academic APIs such as CrossRef, Semantic Scholar, and PubMed.
+academic APIs such as CrossRef, OpenAlex, Semantic Scholar, and PubMed.
 
-Install the CLI from a local checkout:
+To run the CLI yourself, install it from PyPI:
+
+```bash
+uvx ref-verify --help            # run without installing (uv)
+pipx install ref-verify          # or install the `ref-verify` command
+```
+
+Or install it from a local checkout:
 
 ```bash
 git clone https://github.com/Moonweave-Research/ref-verify.git
@@ -116,7 +128,7 @@ ref-verify check-claim 10.1126/science.287.5454.836 \
   --json
 ```
 
-By default, `check-claim` uses CrossRef first. If CrossRef has no abstract, it tries DOI-bound Semantic Scholar and PubMed fallback sources. Use `--source crossref`, `--source semantic-scholar`, or `--source pubmed` for source-specific debugging; explicit non-CrossRef source selection bypasses CrossRef.
+By default, `check-claim` uses CrossRef first. If CrossRef has no abstract, it tries DOI-bound OpenAlex, Semantic Scholar, and PubMed fallback sources. Use `--source crossref`, `--source openalex`, `--source semantic-scholar`, or `--source pubmed` for source-specific debugging; explicit non-CrossRef source selection bypasses CrossRef.
 
 Source-checkout equivalents:
 
@@ -158,6 +170,50 @@ normal CI does not fail because an upstream API is temporarily unavailable.
 
 ---
 
+## Scope — optional CLI versus manual audit
+
+`ref-verify` is a conservative guard, not an oracle. It errs toward flagging: an
+`ACCEPT` is high-confidence, and **anything else means "not auto-verifiable —
+check it yourself", not "the citation is wrong."**
+
+**The optional CLI verifies**
+
+- DOI metadata: title, first-author surname, and year against CrossRef.
+- Whether a DOI-bound **abstract** explicitly supports a specific numeric or
+  literal claim, quoted verbatim. If no abstract is reachable, it returns
+  `UNVERIFIABLE` rather than guessing.
+
+**The optional CLI does not verify** (out of scope by design, not bugs)
+
+- **Full-text, figure, table, or supplementary values** — abstract-only. A number
+  that appears only in the body stays `UNVERIFIABLE`.
+- **Relational or qualitative claims** — proportionalities, mechanisms,
+  "broader/stronger than". Only value+unit and literal claims are checked.
+- **Papers whose publisher withholds the abstract** — some titles expose no
+  abstract to CrossRef or OpenAlex. No abstract → `UNVERIFIABLE`, which reflects
+  reachability, not the claim.
+- **Statistical metrics** (p-value, AUC/AUROC, F1, hazard/odds ratio, confidence
+  intervals) — handled by the manual skill protocol, not the CLI.
+- **Paper quality, novelty, field consensus**, or whether the *full* paper
+  supports a broader statement.
+
+The agent skill's manual Full Audit protocol goes beyond the optional CLI for
+mechanism, implementation, and procedural claims. It requires a fetched
+full-text passage at that source depth; when full text is unavailable, it
+returns `WARN (ABSTRACT-ONLY)` instead of upgrading an abstract topic match to
+`ACCEPT`.
+
+**Reading a CLI verdict**
+
+| Verdict | Meaning |
+|---|---|
+| `ACCEPT` | The fetched abstract explicitly supports the claim. High-confidence pass. |
+| `WARN` / `PARTIAL` | An abstract was read but does not explicitly support the exact claim. Check the source. |
+| `UNVERIFIABLE` | No abstract was reachable to check against. Not a judgment on the claim. |
+| `REJECT` | DOI is dead, resolves to a different paper, contradicted, or retracted. |
+
+---
+
 ## Modes
 
 **Quick Screen** is for DOIs you already have. It uses CrossRef to compare the
@@ -171,9 +227,10 @@ ref-verify verify-doi <doi> --title "<title>" --first-author <last-name> --year
 exit code, so weak or mismatched metadata cannot silently pass automation gates.
 
 **Full Audit** is for literature search and final pre-submission review. The
-skill fetches abstracts through CrossRef, Semantic Scholar, Unpaywall, arXiv,
-and PubMed where needed, then checks whether the paper supports the specific
-claim being cited.
+skill fetches abstracts through CrossRef, OpenAlex, Semantic Scholar, Unpaywall,
+arXiv, and PubMed where needed. For a topline claim, it checks the abstract; for
+a mechanism, implementation, or procedural claim, it continues to a fetched
+full-text passage before assigning support.
 
 For a single DOI-backed claim, the CLI can run the abstract check:
 
@@ -186,19 +243,43 @@ ref-verify check-claim <doi> --claim "<specific claim>" --json
 `abstract_source`, `source_attempts`, and `error_code` so agents can distinguish
 missing abstracts, source failures, DOI mismatches, and ambiguous evidence.
 
+Use `check-file` when a draft, literature note, or AI-agent output has many
+DOI/claim pairs.
+
+JSONL:
+
+```bash
+ref-verify check-file claims.jsonl
+ref-verify check-file claims.jsonl --json
+```
+
+CSV:
+
+```bash
+ref-verify check-file claims.csv
+```
+
+Each row must include `doi` and `claim`. Optional fields are `id`, `source`,
+and `note`. Batch mode reuses the same conservative `check-claim` engine:
+`ACCEPT` means the abstract explicitly supports the numeric claim. `WARN`,
+`PARTIAL`, `REJECT`, or `UNVERIFIABLE` means the claim should not be treated as
+verified.
+
 Current `check-claim` error codes:
 
 - `CLAIM_SUPPORTED`: explicit abstract support found.
 - `CLAIM_NOT_EXPLICIT`: an abstract was available, but the claim was not explicitly supported.
 - `CLAIM_AMBIGUOUS`: numeric evidence or context exists, but binding is ambiguous.
 - `NO_ABSTRACT`: attempted DOI-bound sources did not provide abstract text.
-- `DOI_NOT_FOUND`: selected source did not find a DOI-bound record.
+- `DOI_NOT_FOUND`: CrossRef has no record for the DOI (HTTP 404), or the selected source did not find a DOI-bound record. The JSON still carries a `verdict` of `REJECT`.
+- `PAPER_RETRACTED`: CrossRef lists a retraction notice for the DOI; the claim is rejected before any abstract is read.
 - `DOI_MISMATCH`: the primary or explicitly selected DOI-bound record did not match the requested DOI.
-- `SOURCE_API_ERROR`, `SOURCE_TIMEOUT`, `SOURCE_UNSUPPORTED`: source lookup failed or could not be used.
+- `SOURCE_API_ERROR`, `SOURCE_TIMEOUT`, `SOURCE_RATE_LIMITED`, `SOURCE_UNSUPPORTED`: source lookup failed, timed out, was rate-limited, or could not be used.
 
 > Core rule: every content statement about a paper must come from a live-fetched
-> abstract. If the abstract is inaccessible after fallback checks, say
-> `UNVERIFIABLE`. Do not fill the gap from memory.
+> source at the depth the claim requires — abstract for topline claims, full
+> text for mechanism, implementation, or procedural claims. If the required
+> source is inaccessible, say so. Do not fill the gap from memory.
 
 ---
 
@@ -235,5 +316,4 @@ that as `WARN (PARTIAL)` instead of accepting the citation.
 
 ## Related
 
-- [anneal-skill](https://github.com/Moonweave-Systems/anneal-skill) - measure-first decision discipline for AI agents
-- [decide-skill](https://github.com/Moonweave-Systems/decide-skill) - decision automation for non-expert domains
+- [decision-kernel](https://github.com/Moonweave-Systems/decision-kernel) - evidence-gated decisions and drift/done checks for coding agents

{ref_verify-1.1.2 → ref_verify-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ref-verify"
-version = "1.1.2"
+version = "1.2.2"
 description = "Executable DOI and claim verification helpers for academic citations"
 readme = "README.md"
 requires-python = ">=3.10"

{ref_verify-1.1.2 → ref_verify-1.2.2}/src/ref_verify/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "1.1.2"
+__version__ = "1.2.2"

{ref_verify-1.1.2 → ref_verify-1.2.2}/src/ref_verify/abstract_lookup.py

@@ -202,6 +202,8 @@ def _final_error_code(
         return "SOURCE_API_ERROR"
     if "TIMEOUT" in statuses:
         return "SOURCE_TIMEOUT"
+    if "RATE_LIMITED" in statuses:
+        return "SOURCE_RATE_LIMITED"
     if "UNSUPPORTED" in statuses and "NO_ABSTRACT" not in statuses:
         return "SOURCE_UNSUPPORTED"
     if statuses and all(status == "NOT_FOUND" for status in statuses):

ref_verify-1.2.2/src/ref_verify/batch.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import csv
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Literal
+
+BatchFormat = Literal["jsonl", "csv"]
+_VALID_SOURCES = {"auto", "crossref", "openalex", "semantic-scholar", "pubmed"}
+_FAILED_ERROR_CODES = {
+    "ROW_CHECK_ERROR",
+    "SOURCE_API_ERROR",
+    "SOURCE_TIMEOUT",
+    "SOURCE_RATE_LIMITED",
+    "SOURCE_UNSUPPORTED",
+}
+
+
+class BatchInputError(ValueError):
+    pass
+
+
+@dataclass(frozen=True)
+class ClaimInputRow:
+    row_number: int
+    id: str | None
+    doi: str
+    claim: str
+    source: str = "auto"
+    note: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class BatchRowResult:
+    row: ClaimInputRow
+    payload: dict[str, Any]
+
+    def to_dict(self) -> dict[str, Any]:
+        result = {
+            "row_number": self.row.row_number,
+            "id": self.row.id,
+            "doi": self.row.doi,
+            "claim": self.row.claim,
+        }
+        if self.row.note is not None:
+            result["note"] = self.row.note
+        result.update(self.payload)
+        return result
+
+
+@dataclass(frozen=True)
+class BatchSummary:
+    total: int
+    accept: int
+    warn: int
+    reject: int
+    partial: int
+    unverifiable: int
+    failed: int
+
+    def to_dict(self) -> dict[str, int]:
+        return asdict(self)
+
+
+def detect_format(path: Path, explicit_format: str | None) -> BatchFormat:
+    if explicit_format in ("jsonl", "csv"):
+        return explicit_format
+    if explicit_format is not None:
+        raise BatchInputError(f"Unsupported input format: {explicit_format}")
+    suffix = path.suffix.lower()
+    if suffix == ".jsonl":
+        return "jsonl"
+    if suffix == ".csv":
+        return "csv"
+    raise BatchInputError("Unsupported input format; use .jsonl, .csv, or --format")
+
+
+def parse_claim_file(path: Path, explicit_format: str | None) -> list[ClaimInputRow]:
+    batch_format = detect_format(path, explicit_format)
+    try:
+        if batch_format == "jsonl":
+            rows = _parse_jsonl(path)
+        else:
+            rows = _parse_csv(path)
+    except OSError as exc:
+        raise BatchInputError(f"Could not read input file: {exc}") from exc
+    if not rows:
+        raise BatchInputError("Input file does not contain any claim rows")
+    return rows
+
+
+def summarize_results(results: list[BatchRowResult]) -> BatchSummary:
+    accept = warn = reject = partial = unverifiable = failed = 0
+    for result in results:
+        verdict = str(result.payload.get("verdict", ""))
+        status = str(result.payload.get("status", ""))
+        if verdict == "ACCEPT":
+            accept += 1
+        if verdict == "WARN":
+            warn += 1
+        if verdict == "REJECT":
+            reject += 1
+        if status == "PARTIAL":
+            partial += 1
+        if status == "UNVERIFIABLE":
+            unverifiable += 1
+        if verdict == "ERROR" or str(result.payload.get("error_code", "")) in _FAILED_ERROR_CODES:
+            failed += 1
+    return BatchSummary(
+        total=len(results),
+        accept=accept,
+        warn=warn,
+        reject=reject,
+        partial=partial,
+        unverifiable=unverifiable,
+        failed=failed,
+    )
+
+
+def batch_payload(results: list[BatchRowResult]) -> dict[str, Any]:
+    return {
+        "summary": summarize_results(results).to_dict(),
+        "results": [result.to_dict() for result in results],
+    }
+
+
+def render_batch_text(results: list[BatchRowResult]) -> str:
+    summary = summarize_results(results)
+    lines = [
+        (
+            f"Summary: total={summary.total} accept={summary.accept} "
+            f"warn={summary.warn} reject={summary.reject} "
+            f"partial={summary.partial} unverifiable={summary.unverifiable} "
+            f"failed={summary.failed}"
+        )
+    ]
+    for result in results:
+        payload = result.payload
+        label = str(payload.get("verdict", "WARN"))
+        row_id = result.row.id or f"row-{result.row.row_number}"
+        lines.extend(
+            [
+                "",
+                f"{label}  {row_id}  {result.row.doi}",
+                f"Claim: {result.row.claim}",
+                f"Reason: {payload.get('reason', '')}",
+            ]
+        )
+        evidence = payload.get("evidence")
+        if evidence:
+            lines.append(f"Evidence: {evidence}")
+        error_code = payload.get("error_code")
+        if error_code:
+            lines.append(f"Error code: {error_code}")
+    return "\n".join(lines)
+
+
+def _parse_jsonl(path: Path) -> list[ClaimInputRow]:
+    rows: list[ClaimInputRow] = []
+    with path.open("r", encoding="utf-8") as handle:
+        for line_number, line in enumerate(handle, start=1):
+            stripped = line.strip()
+            if not stripped:
+                continue
+            try:
+                raw = json.loads(stripped)
+            except json.JSONDecodeError as exc:
+                raise BatchInputError(f"Invalid JSON on line {line_number}: {exc.msg}") from exc
+            if not isinstance(raw, dict):
+                raise BatchInputError(f"Invalid row on line {line_number}: expected object")
+            rows.append(_row_from_mapping(raw, line_number=line_number, row_label="line"))
+    return rows
+
+
+def _parse_csv(path: Path) -> list[ClaimInputRow]:
+    rows: list[ClaimInputRow] = []
+    with path.open("r", encoding="utf-8-sig", newline="") as handle:
+        reader = csv.DictReader(handle, skipinitialspace=True)
+        if reader.fieldnames is None:
+            raise BatchInputError("CSV input is missing a header row")
+        fieldnames = {_normalize_csv_fieldname(field) for field in reader.fieldnames if field}
+        missing = {"doi", "claim"} - fieldnames
+        if missing:
+            missing_fields = ", ".join(sorted(missing))
+            raise BatchInputError(f"CSV header must include doi and claim fields; missing: {missing_fields}")
+        for row_number, raw in enumerate(reader, start=2):
+            rows.append(
+                _row_from_mapping(
+                    _normalize_csv_row(raw),
+                    line_number=row_number,
+                    row_label="line",
+                )
+            )
+    return rows
+
+
+def _row_from_mapping(raw: dict[str, Any], *, line_number: int, row_label: str) -> ClaimInputRow:
+    doi = _required_string(raw, "doi", line_number, row_label)
+    claim = _required_string(raw, "claim", line_number, row_label)
+    source = _optional_string(raw, "source") or "auto"
+    if source not in _VALID_SOURCES:
+        raise BatchInputError(f"Invalid field on {row_label} {line_number}: source={source}")
+    return ClaimInputRow(
+        row_number=line_number,
+        id=_optional_string(raw, "id"),
+        doi=doi,
+        claim=claim,
+        source=source,
+        note=_optional_string(raw, "note"),
+    )
+
+
+def _required_string(raw: dict[str, Any], field: str, line_number: int, row_label: str) -> str:
+    value = raw.get(field)
+    if not isinstance(value, str) or not value.strip():
+        raise BatchInputError(f"Missing required field on {row_label} {line_number}: {field}")
+    return value.strip()
+
+
+def _optional_string(raw: dict[str, Any], field: str) -> str | None:
+    value = raw.get(field)
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        return str(value)
+    stripped = value.strip()
+    return stripped or None
+
+
+def _normalize_csv_fieldname(field: str) -> str:
+    return field.lstrip("\ufeff").strip()
+
+
+def _normalize_csv_row(raw: dict[str, Any]) -> dict[str, Any]:
+    return {_normalize_csv_fieldname(key): value for key, value in raw.items() if key is not None}

{ref_verify-1.1.2 → ref_verify-1.2.2}/src/ref_verify/claim_check.py

@@ -209,13 +209,29 @@ _UNSUPPORTED_CLAIM_FRAME_PATTERNS = (
     r"\bsaid to\b",
     r"\b(?:expect|expects|expected|expecting) to\b",
     r"\b(?:project|projects|projected|projecting) to\b",
-    r"\b(?:estimate|estimates|estimated|estimating) to\b",
+    r"\b(?:estimate|estimates|estimated|estimating) to (?!be\b|equal\b|at\b|about\b)",
     r"\bachievable\b",
     r"\bpossible\b",
 )
 
 
+def retracted_claim_result(record: PaperRecord, claim: str) -> ClaimSupportResult:
+    return ClaimSupportResult(
+        status="RETRACTED",
+        verdict="REJECT",
+        reason=(
+            "CrossRef records this paper as retracted "
+            f"(notice DOI {record.retraction_doi}); its abstract cannot support the claim."
+        ),
+        evidence="",
+        paper=record,
+        claim=claim,
+    )
+
+
 def check_claim_support(record: PaperRecord, claim: str) -> ClaimSupportResult:
+    if record.retraction_doi:
+        return retracted_claim_result(record, claim)
     if not record.abstract:
         return ClaimSupportResult(
             status="UNVERIFIABLE",
@@ -338,6 +354,8 @@ def _claim_percentage_comparator(claim: str) -> str:
         return "gte"
     if re.search(r"\b(at most|no more than)\b", normalized):
         return "lte"
+    if re.search(r"\bup to\b", normalized):
+        return "up_to"
     if re.search(r"\b(below|under|less than)\b", normalized):
         return "lt"
     if re.search(
@@ -414,6 +432,8 @@ def _evidence_entails_claim(
     claim_comparator: str,
 ) -> bool:
     if evidence_comparator == "up_to":
+        if claim_comparator == "up_to":
+            return value == threshold
         if claim_comparator == "exact":
             return False
         return _compare_percentage(value, threshold, claim_comparator)