ref-verify 1.3.0__tar.gz → 1.3.1__tar.gz

{ref_verify-1.3.0/src/ref_verify.egg-info → ref_verify-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ref-verify
-Version: 1.3.0
+Version: 1.3.1
 Summary: Executable DOI and claim verification helpers for academic citations
 Author: Moonweave Research
 License-Expression: MIT
@@ -392,7 +392,8 @@ Current `check-claim` error codes:
 - `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`: 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`.
+- `DOI_NOT_FOUND`: neither CrossRef nor doi.org knows the DOI, or the selected source did not find a DOI-bound record. The JSON still carries a `verdict` of `REJECT`.
+- `DOI_NOT_IN_CROSSREF`: CrossRef has no record, but doi.org lists the DOI with another agency (DataCite for arXiv and Zenodo, KISTI, JaLC, ...). `verify-doi` returns `verdict: WARN`, `status: UNVERIFIED` without comparing metadata; `check-claim` tries OpenAlex, Semantic Scholar (arXiv DOIs by arXiv identifier), and PubMed for the abstract and judges the claim if one has it, otherwise returns `status: UNVERIFIABLE`, `verdict: WARN` with this code. Not a dead DOI.
 - `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_RATE_LIMITED`, `SOURCE_UNSUPPORTED`: source lookup failed, timed out, was rate-limited, or could not be used.
@@ -419,7 +420,18 @@ romanized ones (윤 → Yoon/Yun). When a DOI is unknown to CrossRef, doi.org is
 asked which agency registered it, so arXiv, Zenodo, or KISTI DOIs are not
 reported as dead. Search results that are about the paper rather than the
 paper itself (peer-review reports, Faculty Opinions recommendations,
-addenda and corrections) are skipped. The terminal output starts with a count line
+addenda and corrections) are skipped. A citation in a style that omits the
+article title (`J. Bardeen, L. N. Cooper, and J. R. Schrieffer, Phys. Rev. 108,
+1175 (1957)`) is compared on journal (full name or abbreviation), volume, first
+page or article number, year, and first author; it passes when all of them
+agree, and otherwise the reason names each field that differs. Without a DOI,
+when the plain search finds nothing and the citation looks title-less, a second
+CrossRef search by first author,
+the rest of the citation, and the cited year finds short citations such as
+`A. G. Riess et al., Astron. J. 116, 1009 (1998).`; the same full agreement is
+required. The first author
+is read only from the first name in the list, so a reference that puts a
+co-author first does not pass. The terminal output starts with a count line
 (`19 references: 11 PASS, 2 WARN, 5 REJECT, 1 UNVERIFIED`), lists one row per
 reference (citation key, or the start of the reference for a pasted list), puts
 the reason under every row that is not `PASS`, and ends with a one-paragraph

{ref_verify-1.3.0 → ref_verify-1.3.1}/README.md

@@ -381,7 +381,8 @@ Current `check-claim` error codes:
 - `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`: 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`.
+- `DOI_NOT_FOUND`: neither CrossRef nor doi.org knows the DOI, or the selected source did not find a DOI-bound record. The JSON still carries a `verdict` of `REJECT`.
+- `DOI_NOT_IN_CROSSREF`: CrossRef has no record, but doi.org lists the DOI with another agency (DataCite for arXiv and Zenodo, KISTI, JaLC, ...). `verify-doi` returns `verdict: WARN`, `status: UNVERIFIED` without comparing metadata; `check-claim` tries OpenAlex, Semantic Scholar (arXiv DOIs by arXiv identifier), and PubMed for the abstract and judges the claim if one has it, otherwise returns `status: UNVERIFIABLE`, `verdict: WARN` with this code. Not a dead DOI.
 - `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_RATE_LIMITED`, `SOURCE_UNSUPPORTED`: source lookup failed, timed out, was rate-limited, or could not be used.
@@ -408,7 +409,18 @@ romanized ones (윤 → Yoon/Yun). When a DOI is unknown to CrossRef, doi.org is
 asked which agency registered it, so arXiv, Zenodo, or KISTI DOIs are not
 reported as dead. Search results that are about the paper rather than the
 paper itself (peer-review reports, Faculty Opinions recommendations,
-addenda and corrections) are skipped. The terminal output starts with a count line
+addenda and corrections) are skipped. A citation in a style that omits the
+article title (`J. Bardeen, L. N. Cooper, and J. R. Schrieffer, Phys. Rev. 108,
+1175 (1957)`) is compared on journal (full name or abbreviation), volume, first
+page or article number, year, and first author; it passes when all of them
+agree, and otherwise the reason names each field that differs. Without a DOI,
+when the plain search finds nothing and the citation looks title-less, a second
+CrossRef search by first author,
+the rest of the citation, and the cited year finds short citations such as
+`A. G. Riess et al., Astron. J. 116, 1009 (1998).`; the same full agreement is
+required. The first author
+is read only from the first name in the list, so a reference that puts a
+co-author first does not pass. The terminal output starts with a count line
 (`19 references: 11 PASS, 2 WARN, 5 REJECT, 1 UNVERIFIED`), lists one row per
 reference (citation key, or the start of the reference for a pasted list), puts
 the reason under every row that is not `PASS`, and ends with a one-paragraph

{ref_verify-1.3.0 → ref_verify-1.3.1}/pyproject.toml

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

{ref_verify-1.3.0 → ref_verify-1.3.1}/src/ref_verify/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "1.3.0"
+__version__ = "1.3.1"

{ref_verify-1.3.0 → ref_verify-1.3.1}/src/ref_verify/cli.py

@@ -24,7 +24,7 @@ from ref_verify.batch import (
 )
 from ref_verify.cache import ResponseCache, default_cache
 from ref_verify.claim_check import check_claim_support, retracted_claim_result
-from ref_verify.crossref import CrossrefClient
+from ref_verify.crossref import CrossrefClient, not_in_crossref_reason, other_registration_agency
 from ref_verify.doi_check import normalize_doi, verify_doi_metadata
 from ref_verify.models import CitationInput, ClaimSupportResult
 from ref_verify.openalex import OpenAlexClient
@@ -185,6 +185,21 @@ def _verify_doi(args: argparse.Namespace, client: CrossrefClient) -> int:
     except HTTPError as exc:
         if not _is_not_found(exc):
             raise
+        agency = other_registration_agency(client, lookup_doi)
+        if agency:
+            _emit(
+                {
+                    "status": "UNVERIFIED",
+                    "verdict": "WARN",
+                    "mismatches": [],
+                    "reason": not_in_crossref_reason(agency, lookup_doi),
+                    "provided": provided.to_dict(),
+                    "fetched": None,
+                    "error_code": "DOI_NOT_IN_CROSSREF",
+                },
+                as_json=args.json,
+            )
+            return 2
         # A dead DOI is a verdict, not a tool failure; keep the `verdict` key so
         # callers that parse JSON do not have to special-case the error shape.
         _emit(
@@ -365,7 +380,10 @@ def _run_claim_check(
         except HTTPError as exc:
             if not _is_not_found(exc):
                 raise
-            return _doi_not_found_payload(claim)
+            agency = other_registration_agency(client, lookup_doi)
+            if not agency:
+                return _doi_not_found_payload(claim)
+            return _not_in_crossref_claim(lookup_doi, claim, agency, selected_clients)
         if fetched.retraction_doi:
             # Fallback abstract sources would drop the retraction flag, so decide here.
             result = retracted_claim_result(fetched, claim)
@@ -410,6 +428,34 @@ def _doi_not_found_payload(claim: str) -> dict:
     }
 
 
+def _not_in_crossref_claim(
+    doi: str,
+    claim: str,
+    agency: str,
+    fallback_clients: Sequence[AbstractSourceClient],
+) -> dict:
+    # CrossRef has no record, but OpenAlex or Semantic Scholar often index arXiv and other
+    # DataCite works with their abstracts.
+    lookup_result = lookup_selected_abstract(doi, fallback_clients)
+    if lookup_result.record.abstract:
+        return _claim_payload(check_claim_support(lookup_result.record, claim), lookup_result)
+    sources = ", ".join(client.source_name for client in fallback_clients) or "no other source"
+    return {
+        "status": "UNVERIFIABLE",
+        "verdict": "WARN",
+        "reason": (
+            f"This DOI is registered with {agency}, not CrossRef, and no DOI-bound abstract was "
+            f"found ({sources} tried), so the claim was not judged; open https://doi.org/{doi}."
+        ),
+        "evidence": "",
+        "paper": None,
+        "claim": claim,
+        "abstract_source": None,
+        "source_attempts": [attempt.to_dict() for attempt in lookup_result.attempts],
+        "error_code": "DOI_NOT_IN_CROSSREF",
+    }
+
+
 def _row_error_payload(claim: str, exc: Exception) -> dict:
     return {
         "status": "UNVERIFIABLE",

{ref_verify-1.3.0 → ref_verify-1.3.1}/src/ref_verify/crossref.py

@@ -46,8 +46,19 @@ class CrossrefClient:
             )
         return parse_crossref_work(payload["message"])
 
-    def search_bibliographic(self, query: str, rows: int = 3) -> list[PaperRecord]:
+    def search_bibliographic(
+        self,
+        query: str,
+        rows: int = 3,
+        *,
+        author: str | None = None,
+        year_range: tuple[int, int] | None = None,
+    ) -> list[PaperRecord]:
         params = {"query.bibliographic": query, "rows": str(rows)}
+        if author:
+            params["query.author"] = author
+        if year_range:
+            params["filter"] = f"from-pub-date:{year_range[0]},until-pub-date:{year_range[1]}"
         mailto = os.environ.get("REF_VERIFY_MAILTO")
         if mailto:
             params["mailto"] = mailto
@@ -87,6 +98,26 @@ def _pace_search(interval: float) -> None:
         _last_search_started[0] = time.monotonic()
 
 
+def other_registration_agency(client: Any, doi: str) -> str | None:
+    # arXiv and Zenodo (DataCite), many Korean (KISTI) and Japanese (JaLC) DOIs are registered
+    # outside CrossRef, so a CrossRef 404 alone does not make them dead. Returns that agency,
+    # or None when doi.org names CrossRef, says the DOI does not exist, or cannot be reached.
+    try:
+        agency = client.registration_agency(doi)
+    except Exception:
+        return None
+    if agency and agency.casefold() != "crossref":
+        return agency
+    return None
+
+
+def not_in_crossref_reason(agency: str, doi: str) -> str:
+    return (
+        f"This DOI is registered with {agency}, not CrossRef, so its title and authors were not "
+        f"compared; open https://doi.org/{doi} to confirm it is this work."
+    )
+
+
 def parse_crossref_work(message: dict[str, Any]) -> PaperRecord:
     doi = str(message.get("DOI") or "")
     title = _clean_title(_first_string(message.get("title"))) or "[title missing]"
@@ -124,6 +155,11 @@ def parse_crossref_work(message: dict[str, Any]) -> PaperRecord:
         alt_years=years[1:],
         work_type=str(message["type"]) if message.get("type") else None,
         is_about_other_work=_is_about_other_work(message, title),
+        journal_abbreviations=[
+            str(value).strip() for value in message.get("short-container-title") or [] if str(value).strip()
+        ],
+        volume=_first_string(message.get("volume")),
+        first_page=_first_page(message),
     )
 
 
@@ -172,6 +208,16 @@ def _is_about_other_work(message: dict[str, Any], title: str) -> bool:
     return bool(_ABOUT_OTHER_WORK_TITLE.match(title))
 
 
+def _first_page(message: dict[str, Any]) -> str | None:
+    article_number = _first_string(message.get("article-number"))
+    if article_number:
+        return article_number
+    page = _first_string(message.get("page"))
+    if not page:
+        return None
+    return re.split(r"\s*[-\u2013\u2014,]\s*", page)[0] or None
+
+
 def _first_string(value: Any) -> str | None:
     if isinstance(value, list) and value:
         return str(value[0]).strip()

{ref_verify-1.3.0 → ref_verify-1.3.1}/src/ref_verify/doi_check.py

@@ -274,6 +274,7 @@ def _transliterate_greek_letters(value: str) -> str:
 titles_match = _titles_match
 author_matches = _author_matches
 author_tokens = _author_tokens
+looks_like_group_author = _looks_like_group_author
 
 
 def title_in_text(title: str, text: str) -> bool:

{ref_verify-1.3.0 → ref_verify-1.3.1}/src/ref_verify/http.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import json
 import time
 from email.message import Message
-from typing import Any, Callable
+from typing import Any, Callable, Protocol
 from urllib.error import HTTPError
 from urllib.request import Request, urlopen
 
@@ -15,6 +15,29 @@ RETRY_STATUSES = frozenset({429, 500, 502, 503, 504})
 MAX_BACKOFF_SECONDS = 10.0
 
 
+class HttpBackend(Protocol):
+    # Returns the decoded body of a 2xx response. An HTTP error status raises
+    # urllib.error.HTTPError (with `code` and `headers`) so retries, Retry-After, and the
+    # 404 cache work the same for every backend; a network failure raises URLError.
+    def get(self, url: str, headers: dict[str, str], timeout: float) -> str:
+        ...
+
+
+class UrllibBackend:
+    def get(self, url: str, headers: dict[str, str], timeout: float) -> str:
+        with urlopen(Request(url, headers=headers), timeout=timeout) as response:
+            return response.read().decode("utf-8")
+
+
+_backend: HttpBackend = UrllibBackend()
+
+
+def set_backend(backend: HttpBackend | None) -> None:
+    # The browser build swaps in a transport that runs inside the page; None restores urllib.
+    global _backend
+    _backend = backend if backend is not None else UrllibBackend()
+
+
 def fetch_json(
     url: str,
     *,
@@ -54,8 +77,7 @@ def fetch_text(
     attempt = 0
     while True:
         try:
-            with urlopen(Request(url, headers=headers), timeout=timeout) as response:
-                body = response.read().decode("utf-8")
+            body = _backend.get(url, headers, timeout)
         except HTTPError as exc:
             if exc.code == 404 and cache is not None:
                 cache.put(url, 404, "")

{ref_verify-1.3.0 → ref_verify-1.3.1}/src/ref_verify/models.py

@@ -34,6 +34,11 @@ class PaperRecord:
     # review, recommendation, or notice about another work rather than the work itself.
     work_type: str | None = None
     is_about_other_work: bool = False
+    # Where the paper sits in its journal, for citation styles that omit the article title
+    # ("Phys. Rev. 108, 1175 (1957)"); `first_page` is the article number when there is one.
+    journal_abbreviations: list[str] = field(default_factory=list)
+    volume: str | None = None
+    first_page: str | None = None
 
     def to_dict(self) -> dict[str, Any]:
         return asdict(self)

{ref_verify-1.3.0 → ref_verify-1.3.1}/src/ref_verify/reference_parse.py

@@ -21,6 +21,7 @@ _SUFFIX_FORMATS: dict[str, ReferenceFormat] = {
 # Old Wiley DOIs are SICIs with an angle-bracketed part ("...40:11<2004::aid-anie2004>3.0.co;2-5");
 # a bracketed run without spaces stays in the DOI, while a DOI wrapped as <...> ends at ">".
 _DOI_PATTERN = re.compile(r"10\.\d{4,9}/(?:[^\s\"<>{}]|<[^\s\"<>{}]*>)+", re.IGNORECASE)
+DOI_PATTERN = _DOI_PATTERN
 _YEAR_PATTERN = re.compile(r"\b(?:1[89]|20)\d{2}\b")
 _PARENTHESISED_YEAR_PATTERN = re.compile(r"\(((?:1[89]|20)\d{2})[a-z]?\)")
 # A publication year is followed by punctuation or the end ("2020;395", "2020.", "2020)"),

{ref_verify-1.3.0 → ref_verify-1.3.1}/src/ref_verify/reference_resolve.py

@@ -13,6 +13,7 @@ from ref_verify.doi_check import (
     author_matches,
     author_tokens,
     hangul_surname_matches,
+    looks_like_group_author,
     record_titles,
     record_years,
     title_in_text,
@@ -20,9 +21,10 @@ from ref_verify.doi_check import (
     titles_match,
     verify_doi_metadata,
 )
+from ref_verify.crossref import not_in_crossref_reason, other_registration_agency
 from ref_verify.http import retry_after_seconds as _retry_after_seconds
 from ref_verify.models import CitationInput, PaperRecord
-from ref_verify.reference_parse import ReferenceEntry
+from ref_verify.reference_parse import DOI_PATTERN, ReferenceEntry
 
 UNMATCHED_REASON = "No matching CrossRef record was found; verify this reference manually."
 _INSUFFICIENT_REASON = (
@@ -32,9 +34,21 @@ _INSUFFICIENT_REASON = (
 _MIN_TEXT_TITLE_OVERLAP = 0.8
 # Below this share of the CrossRef title's words, plain reference text is about another paper.
 _MAX_SWAPPED_TITLE_OVERLAP = 0.5
-# Reference strings start with the author list, so the first author's family name should
-# appear among the first few name tokens ("Pelrine R", "R. Pelrine", "Ronald E. Pelrine").
-_FIRST_AUTHOR_TOKEN_WINDOW = 4
+# Reference strings start with the author list. The first author is the text before the
+# first separator ("Pelrine R, ...", "R. Pelrine, ...", "Pelrine, R., ...", "A. G. Riess et
+# al.", "Ronald E. Pelrine and ..."), and the family name sits within its first few words
+# ("J. D. van der Waals").
+_FIRST_AUTHOR_END = re.compile(r",|;|\(|\s(?:and|&)\s|\set\.?\s*al\b", re.IGNORECASE)
+_FIRST_AUTHOR_TOKEN_WINDOW = 6
+# Words that are neither title nor author in a citation such as
+# "J. Bardeen, L. N. Cooper, and J. R. Schrieffer, Phys. Rev. 108, 1175 (1957)".
+_CITATION_FILLER = {
+    "al", "and", "et", "vol", "no", "pp", "doi", "https", "http", "org", "dx", "art", "article",
+    "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "sept", "oct", "nov", "dec",
+}
+# More words than this before the volume number are a title plus journal, not a journal alone.
+_MAX_TITLELESS_JOURNAL_WORDS = 5
+_JOURNAL_STOPWORDS = {"a", "an", "and", "de", "der", "des", "for", "in", "of", "on", "the", "und"}
 _DEFAULT_RATE_LIMIT_PAUSE_SECONDS = 15.0
 _MAX_RATE_LIMIT_PAUSE_SECONDS = 60.0
 _sleep = time.sleep
@@ -45,7 +59,14 @@ class ReferenceClient(Protocol):
     def fetch_work(self, doi: str) -> PaperRecord:
         ...
 
-    def search_bibliographic(self, query: str, rows: int = 3) -> list[PaperRecord]:
+    def search_bibliographic(
+        self,
+        query: str,
+        rows: int = 3,
+        *,
+        author: str | None = None,
+        year_range: tuple[int, int] | None = None,
+    ) -> list[PaperRecord]:
         ...
 
     def registration_agency(self, doi: str) -> str | None:
@@ -147,7 +168,25 @@ def _check_doi_reference(entry: ReferenceEntry, doi: str, client: ReferenceClien
     if metadata.verdict == "PASS":
         status, reason = "VERIFIED", metadata.reason
     elif metadata.verdict == "WARN" and "metadata" in metadata.mismatches:
-        if not entry.title and not text_title and _text_names_another_paper(entry.raw, fetched):
+        titleless = None if text_title else _titleless_differences(entry, fetched)
+        if titleless == []:
+            return ReferenceResult(
+                entry=entry,
+                status="VERIFIED",
+                verdict="PASS",
+                reason=(
+                    "The reference has no article title; it matches CrossRef's record for this DOI on "
+                    f"{_titleless_fields(fetched)}."
+                ),
+                fetched=fetched,
+            )
+        if titleless:
+            status = "MISMATCH"
+            reason = (
+                "The reference has no article title, and CrossRef's record for this DOI differs in "
+                f"{'; '.join(titleless)}."
+            )
+        elif not entry.title and not text_title and _text_names_another_paper(entry.raw, fetched):
             status = "MISMATCH"
             reason = (
                 f"This DOI belongs to {_describe(fetched)}, which this reference does not mention; "
@@ -176,21 +215,13 @@ def _check_doi_reference(entry: ReferenceEntry, doi: str, client: ReferenceClien
 
 
 def _missing_from_crossref(entry: ReferenceEntry, doi: str, client: ReferenceClient) -> ReferenceResult:
-    try:
-        agency = client.registration_agency(doi)
-    except Exception:
-        agency = None
-    # arXiv, Zenodo, and many Korean (KISTI) or Japanese (JaLC) DOIs are registered with
-    # another agency, so a CrossRef 404 alone does not make them dead.
-    if agency and agency.casefold() != "crossref":
+    agency = other_registration_agency(client, doi)
+    if agency:
         return ReferenceResult(
             entry=entry,
             status="UNVERIFIED",
             verdict="WARN",
-            reason=(
-                f"This DOI is registered with {agency}, not CrossRef, so its title and authors "
-                f"were not compared; open https://doi.org/{doi} to confirm it is this work."
-            ),
+            reason=not_in_crossref_reason(agency, doi),
             error_code="DOI_NOT_IN_CROSSREF",
         )
     return ReferenceResult(
@@ -216,7 +247,7 @@ def _insufficient_reason(provided: CitationInput, fetched: PaperRecord) -> str:
     if provided.title and not provided.first_author and fetched.authors:
         return (
             f"The DOI and title match CrossRef, but its first author ({fetched.authors[0]}) was not "
-            "found in the reference; check the author names manually."
+            "found in the reference's first-author position; check the author names manually."
         )
     if provided.first_author and not provided.title:
         return (
@@ -258,7 +289,11 @@ def _resolve_reference(entry: ReferenceEntry, client: ReferenceClient) -> Refere
     # top three results ahead of the paper itself.
     candidates = client.search_bibliographic(query, rows=5) if query else []
     for candidate in candidates:
-        if candidate.is_about_other_work or not _candidate_matches(entry, candidate):
+        if candidate.is_about_other_work:
+            continue
+        if not _candidate_matches(entry, candidate):
+            if _titleless_differences(entry, candidate) == []:
+                return _titleless_resolved(entry, candidate)
             continue
         if candidate.retraction_doi:
             return _retracted(entry, candidate, resolved_doi=candidate.doi)
@@ -282,6 +317,16 @@ def _resolve_reference(entry: ReferenceEntry, client: ReferenceClient) -> Refere
             resolved_doi=candidate.doi,
             fetched=candidate,
         )
+    structured = _structured_query(entry)
+    if structured:
+        # A short title-less citation ("A. G. Riess et al., Astron. J. 116, 1009 (1998).") can
+        # rank below unrelated records with similar numbers; a second search by first author,
+        # journal, volume, and page within the cited year finds it. Only full field agreement
+        # is accepted from it.
+        query, author, year_range = structured
+        for candidate in client.search_bibliographic(query, rows=5, author=author, year_range=year_range):
+            if not candidate.is_about_other_work and _titleless_differences(entry, candidate) == []:
+                return _titleless_resolved(entry, candidate)
     return ReferenceResult(
         entry=entry,
         status="UNVERIFIED",
@@ -291,6 +336,66 @@ def _resolve_reference(entry: ReferenceEntry, client: ReferenceClient) -> Refere
     )
 
 
+def _titleless_resolved(entry: ReferenceEntry, candidate: PaperRecord) -> ReferenceResult:
+    if candidate.retraction_doi:
+        return _retracted(entry, candidate, resolved_doi=candidate.doi)
+    return ReferenceResult(
+        entry=entry,
+        status="RESOLVED",
+        verdict="PASS",
+        reason=(
+            f"Matched CrossRef record {candidate.doi} by bibliographic search; the reference has "
+            f"no article title, so it was matched on {_titleless_fields(candidate)}."
+        ),
+        error_code="REFERENCE_RESOLVED",
+        resolved_doi=candidate.doi,
+        fetched=candidate,
+    )
+
+
+def _structured_query(entry: ReferenceEntry) -> tuple[str, str, tuple[int, int]] | None:
+    # The first author goes to `query.author`, the rest of the citation without the year (a
+    # bare year matches far too many records) to `query.bibliographic`, and the year (or the
+    # year before, for online-first papers) to a publication-date filter.
+    if entry.title or entry.year is None or not _looks_titleless(entry.raw):
+        return None
+    parts = _FIRST_AUTHOR_END.split(DOI_PATTERN.sub(" ", entry.raw), maxsplit=1)
+    names = re.findall(r"[^\W\d_]{2,}", parts[0])
+    if len(parts) < 2 or not names:
+        return None
+    rest = re.sub(r"\bet\.?\s*al\b\.?|\(?\b(?:1[89]|20)\d{2}[a-z]?\b\)?", " ", parts[1])
+    rest = " ".join(rest.split()).strip(" .,;")
+    if not rest:
+        return None
+    return rest, names[-1], (entry.year - 1, entry.year)
+
+
+def _looks_titleless(text: str) -> bool:
+    # Without a record to compare against: the words before the volume number, once the
+    # authors are set aside, are only a journal name ("A. G. Riess et al., Astron. J. 116,
+    # 1009"), not a title plus journal. Authors are the first word and any word next to an
+    # initial ("Riess" in "A. G. Riess", "Cooper" in "L. N. Cooper", "Tang" in "Tang, C. W.").
+    text = re.sub(r"\bet\.?\s*al\b|\(?\b(?:1[89]|20)\d{2}[a-z]?\b\)?", " ", DOI_PATTERN.sub(" ", text))
+    tokens = re.findall(r"[^\W_]+", text)
+    numbers = [index for index, token in enumerate(tokens) if token.isdigit()]
+    # Volume and page (or article number) must both follow the journal.
+    if len(numbers) < 2:
+        return False
+    before = tokens[: numbers[0]]
+    initials = {index for index, token in enumerate(before) if token.isalpha() and token.isupper() and len(token) <= 2}
+    words = [
+        token
+        for index, token in enumerate(before)
+        if index not in initials
+        and index != 0
+        and not ({index - 1, index + 1} & initials)
+        and len(token) >= 3
+        and token.isalpha()
+        and token.casefold() not in _JOURNAL_STOPWORDS | _CITATION_FILLER
+    ]
+    return len(words) <= _MAX_TITLELESS_JOURNAL_WORDS
+
+
 def _bibliographic_query(entry: ReferenceEntry) -> str:
     if entry.title:
         parts = (entry.title, entry.first_author, entry.year, entry.journal)
@@ -326,11 +431,98 @@ def _first_author_matches(entry: ReferenceEntry, candidate: PaperRecord) -> bool
 def _first_author_in_text(text: str, record: PaperRecord) -> str | None:
     if not text or not record.authors:
         return None
-    if hangul_surname_matches(text, record.authors[0]):
-        return record.authors[0]
-    family = author_tokens(record.authors[0])
-    if family and family[-1] in author_tokens(text)[:_FIRST_AUTHOR_TOKEN_WINDOW]:
-        return record.authors[0]
+    first_author = record.authors[0]
+    if hangul_surname_matches(text, first_author):
+        return first_author
+    family = author_tokens(first_author)
+    if not family:
+        return None
+    if looks_like_group_author(family):
+        # A group author ("Writing Group for the ... Investigators") opens the reference whole.
+        group = [token for token in family if token != "the"]
+        opening = [token for token in author_tokens(text) if token != "the"][: len(group)]
+        return first_author if opening == group else None
+    # Only the first author's own name counts, so "Perlmutter S, Riess AG" does not pass for
+    # a paper whose first author is Riess.
+    first_name = _FIRST_AUTHOR_END.split(text, maxsplit=1)[0]
+    if family[-1] in author_tokens(first_name)[:_FIRST_AUTHOR_TOKEN_WINDOW]:
+        return first_author
+    return None
+
+
+def _titleless_differences(entry: ReferenceEntry, record: PaperRecord) -> list[str] | None:
+    # A citation without an article title ("Phys. Rev. 108, 1175 (1957)") is compared on the
+    # fields it does carry. None means it carries a title (words that are not authors,
+    # journal, or numbers) or the record has no volume or page to compare; otherwise the list
+    # names the fields that disagree, and an empty list means every field agrees.
+    if entry.title or not (record.volume or record.first_page):
+        return None
+    tokens = _plain_tokens(DOI_PATTERN.sub(" ", entry.raw))
+    journal_run = next(
+        (
+            run
+            for journal in (record.journal, *record.journal_abbreviations)
+            if journal and (run := _journal_run(journal, tokens))
+        ),
+        None,
+    )
+    author_words = {token for author in record.authors for token in author_tokens(author)}
+    leftover = [
+        token
+        for index, token in enumerate(tokens)
+        if not (journal_run and index in journal_run)
+        and token not in author_words
+        and token not in _CITATION_FILLER
+        and not token.isdigit()
+        and len(token) >= 3
+    ]
+    if len(leftover) >= 3:
+        return None
+    differences = []
+    if not journal_run:
+        differences.append(f"journal (CrossRef: {record.journal or 'none listed'})")
+    if record.volume and record.volume.casefold() not in tokens:
+        differences.append(f"volume (CrossRef: {record.volume})")
+    if record.first_page and record.first_page.casefold() not in tokens:
+        differences.append(f"first page (CrossRef: {record.first_page})")
+    years = record_years(record)
+    if entry.year is None or entry.year not in years:
+        reference = f"reference: {entry.year}; " if entry.year is not None else ""
+        crossref_years = "/".join(str(year) for year in years) or "none listed"
+        differences.append(f"year ({reference}CrossRef: {crossref_years})")
+    if _first_author_in_text(entry.raw, record) is None:
+        differences.append(f"first author (CrossRef: {record.authors[0] if record.authors else 'none listed'})")
+    return differences
+
+
+def _titleless_fields(record: PaperRecord) -> str:
+    fields = ["journal"]
+    if record.volume:
+        fields.append("volume")
+    if record.first_page:
+        fields.append("first page")
+    fields.extend(["year", "first author"])
+    return ", ".join(fields[:-1]) + f", and {fields[-1]}"
+
+
+def _plain_tokens(text: str) -> list[str]:
+    folded = "".join(
+        char for char in unicodedata.normalize("NFKD", text.casefold()) if not unicodedata.combining(char)
+    )
+    return re.findall(r"[a-z0-9]+", folded)
+
+
+def _journal_run(journal: str, tokens: list[str]) -> set[int] | None:
+    # Full name or a standard abbreviation: "Phys. Rev. Lett." matches "Physical Review
+    # Letters" word by word, each abbreviated word being the start of the full one.
+    words = [word for word in _plain_tokens(journal) if word not in _JOURNAL_STOPWORDS]
+    if not words:
+        return None
+    positions = [index for index, token in enumerate(tokens) if token not in _JOURNAL_STOPWORDS]
+    for start in range(len(positions) - len(words) + 1):
+        window = positions[start : start + len(words)]
+        if all(words[offset].startswith(tokens[index]) for offset, index in enumerate(window)):
+            return set(range(window[0], window[-1] + 1))
     return None