Release: acceptance and publication dates kept apart in the registry and on the cover page

crossref_deposit.py

@@ -576,6 +576,18 @@ def landing_url_for(submission: dict, sub_dir: Path) -> str:
     return publications.publications_url(publications.make_slug(submission.get("title", "")))
 
 
+def _decision_date(sub_dir: Path) -> Optional[_dt.date]:
+    """The acceptance day: the UTC date of the accept decision's stamp
+    (state.json completed_at), or None when the paper has no accept stamp."""
+    try:
+        st = json.loads((Path(sub_dir) / "state.json").read_text())
+        if st.get("decision") == "accept" and st.get("completed_at"):
+            return _dt.date.fromisoformat(st["completed_at"][:10])
+    except Exception:
+        pass
+    return None
+
+
 def stage(sub_dir: Path, submission: Optional[dict] = None, *,
           doi: Optional[str] = None, out_dir: Optional[Path] = None,
           content_type: Optional[str] = None,
@@ -596,13 +608,7 @@ def stage(sub_dir: Path, submission: Optional[dict] = None, *,
     landing = landing_url_for(submission, sub_dir)
     pdf_url = _cfg("CROSSREF_PDF_URL", "https://icsacinstitute.org/papers/{sub_id}.pdf")
     pdf_url = pdf_url.format(sub_id=sub_id) if pdf_url else None
-    acc = None
-    try:
-        st = json.loads((sub_dir / "state.json").read_text())
-        if st.get("decision") == "accept" and st.get("completed_at"):
-            acc = _dt.date.fromisoformat(st["completed_at"][:10])
-    except Exception:
-        acc = None
+    acc = _decision_date(sub_dir)
     xml_bytes = build_deposit_xml(submission, doi=doi, landing_url=landing, pdf_url=pdf_url,
                                   citations=_load_citations(sub_id), content_type=content_type,
                                   acceptance_date=acc)
@@ -998,6 +1004,37 @@ def _deposited_dates(xml_path: Path) -> tuple[Optional[_dt.date], Optional[_dt.d
     return acc, pub
 
 
+def _registry_dates(sub_dir: Path, proto: dict, *, log) -> dict:
+    """accepted_date + published_date for the registry entry, so the page shows
+    the dates Crossref holds: each is read back from the deposited XML. A date
+    the deposit lacks keeps the existing entry's (a re-run changes nothing),
+    else falls back to the accept decision's stamp (accepted) or today
+    (published). The log names where each date came from."""
+    import publications
+    dep_acc, dep_pub = _deposited_dates(sub_dir / "crossref" / "deposit.xml")
+    prior = publications.find_entry(proto) or {}
+    out: dict = {}
+    said: list[str] = []
+    for key, label, deposited in (("accepted_date", "accepted", dep_acc),
+                                  ("published_date", "published", dep_pub)):
+        if deposited:
+            out[key] = deposited.isoformat()
+            said.append(f"{label} {out[key]} (from the deposit)")
+        elif prior.get(key):
+            # Left out of the proto: the upsert keeps the entry's own value.
+            said.append(f"{label} {prior[key]} (NOT in the deposit; the existing entry's, kept)")
+        elif key == "accepted_date" and _decision_date(sub_dir):
+            out[key] = _decision_date(sub_dir).isoformat()
+            said.append(f"{label} {out[key]} (NOT in the deposit; the accept decision's stamp)")
+        else:
+            out[key] = _dt.date.today().isoformat()
+            said.append(f"{label} {out[key]} (NOT in the deposit; today)")
+    if out.get("published_date") and out.get("accepted_date") and out["published_date"] < out["accepted_date"]:
+        said.append(f"published {out.pop('published_date')} DROPPED: before acceptance")
+    log(f"  crossref: registry dates: {'; '.join(said)}")
+    return out
+
+
 def _make_cover(sub_dir: Path, slug: str, *, log) -> dict:
     """Run tools/wrap-paper-pdf.py on the PDF just copied to the website tree.
     Returns {"file", "made_at", "path"} or {"error", "at"}; never raises."""
@@ -1074,6 +1111,9 @@ def _push_publications(sub_dir: Path, submission: dict, doi: str, *, log) -> dic
     pre = preprint_doi(submission)
     if pre:
         proto["preprint_doi"] = pre   # the paper page links the preprint it was submitted from
+    # Accepted and published as deposited; upsert_entry would otherwise date
+    # acceptance to registration day.
+    proto.update(_registry_dates(sub_dir, proto, log=log))
     # register --live runs only after the curator typed the confirmation: approved.
     entry = publications.upsert_entry(proto, approved=True)
     if not entry:

intake/scripts/test_registry_dates.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""Checks the two dates of a registry entry: accepted_date (the day of
+acceptance) and published_date (the day of online publication). register
+--live writes both from the deposited Crossref XML, so the page shows the
+dates Crossref holds; a date missing there falls back to the accept
+decision's stamp (accepted) or today (published), and the log says so; an
+existing entry keeps its dates on a re-run.
+Offline: no network, no mail, no pings; every write lands in one temporary
+directory that is removed at the end, pass or fail. Run from the repo root
+with the venv:
+    .venv/bin/python intake/scripts/test_registry_dates.py
+"""
+from __future__ import annotations
+
+import datetime
+import json
+import shutil
+import sys
+import tempfile
+import types
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(ROOT))
+
+failures: list[str] = []
+
+
+def check(cond: bool, name: str) -> None:
+    print(("  ok   " if cond else "  FAIL ") + name)
+    if not cond:
+        failures.append(name)
+
+
+def deposit_xml(published: str | None, accepted: str | None) -> str:
+    """A minimal deposit: the issue's year-only date, then the article's dates."""
+    def d(tag: str, iso: str | None, attrs: str = "") -> str:
+        if not iso:
+            return ""
+        y, m, dd = iso.split("-")
+        return f"<{tag}{attrs}><month>{m}</month><day>{dd}</day><year>{y}</year></{tag}>"
+    online = ' media_type="online"'
+    return ('<?xml version="1.0"?>\n<doi_batch xmlns="http://www.crossref.org/schema/5.4.0"><body><journal>'
+            '<journal_issue><publication_date media_type="online"><year>2026</year></publication_date></journal_issue>'
+            f'<journal_article>{d("publication_date", published, online)}'
+            f'{d("acceptance_date", accepted)}</journal_article></journal></body></doi_batch>')
+
+
+tmp = Path(tempfile.mkdtemp(prefix="registry-dates-"))
+try:
+    import publications as pub
+    import crossref_deposit as cd
+    from intake import author_approval
+
+    site = tmp / "site"; (site / "src" / "data").mkdir(parents=True)
+    reg = site / "src" / "data" / "accepted.json"
+    pub.WEBSITE_REPO = str(site); pub.REGISTRY_PATH = str(reg)
+    pub.READY_DIR = str(tmp / "ready-to-publish")   # held entries stay inside the temp dir
+
+    def entries() -> list[dict]:
+        return json.loads(reg.read_text())
+
+    # ── 1. the registry keeps both dates ─────────────────────────────────────
+    print("1. registry")
+    reg.write_text("[]")
+    base = {"title": "T", "authors": ["A. Author"], "doi": "10.5555/icsac.2026.980", "source": "submission-pdf"}
+    e = pub.upsert_entry(dict(base, accepted_date="2026-03-02", published_date="2026-03-03"), approved=True)
+    check((e.get("accepted_date"), e.get("published_date")) == ("2026-03-02", "2026-03-03"), "upsert writes both dates")
+    keys = list(e)
+    check(keys.index("published_date") == keys.index("accepted_date") + 1, "published_date sits right after accepted_date")
+    e = pub.upsert_entry(dict(base), approved=True)
+    check((e.get("accepted_date"), e.get("published_date")) == ("2026-03-02", "2026-03-03"),
+          "a later upsert without dates keeps both")
+    before = reg.read_text()
+    try:
+        pub.upsert_entry(dict(base, published_date="2026-03-01"), approved=True)
+        refused = False
+    except ValueError:
+        refused = True
+    check(refused and reg.read_text() == before, "published before accepted: ValueError, registry unchanged")
+    e = pub.upsert_entry(dict(base, doi="10.5555/icsac.2026.981", accepted_date="2026-03-02"), approved=True)
+    check("published_date" not in e, "an entry given no published_date gets none (the page then reads accepted_date)")
+    check(pub.find_entry({"doi": "10.5555/icsac.2026.980"}).get("published_date") == "2026-03-03"
+          and pub.find_entry({"doi": "10.5555/icsac.2026.999"}) is None, "find_entry: the entry an upsert would update, else None")
+
+    # ── 2. the acceptance day is the decision stamp's UTC date ───────────────
+    print("2. decision stamp")
+    sd = tmp / "stamp"; sd.mkdir()
+    (sd / "state.json").write_text(json.dumps({"decision": "accept", "completed_at": "2026-02-10T23:30:00Z"}))
+    check(str(cd._decision_date(sd)) == "2026-02-10", "an accept stamp gives its UTC date")
+    (sd / "state.json").write_text(json.dumps({"decision": "revise", "completed_at": "2026-02-10T23:30:00Z"}))
+    check(cd._decision_date(sd) is None, "a stamp on another decision gives none")
+    (sd / "state.json").unlink()
+    check(cd._decision_date(sd) is None, "no state.json gives none")
+
+    # ── 3. register --live writes the dates from the deposit ─────────────────
+    print("3. register --live")
+    sys.modules["stats"] = types.SimpleNamespace(
+        compute_stats=lambda *a, **k: (_ for _ in ()).throw(RuntimeError("stats stubbed")))
+    pub.stage_public_review_for_slug = lambda *a, **k: (None, None)
+    pub.commit_and_push = lambda *a, **k: None
+    cd.stage = lambda *a, **k: None
+    cd.validate_xml = lambda b: None
+    cd.deposit = lambda *a, **k: "batch-1"
+    cd.poll_result = lambda *a, **k: {"status": "completed", "success": 1, "failure": 0}
+    cd._ping = lambda *a, **k: None
+    cd._publish_zenodo_archive = lambda *a, **k: None
+    cd._notify_author = lambda *a, **k: True
+    author_approval.gate = lambda *a, **k: (True, "approved (stub)")
+
+    def make_sub(name: str, doi: str, xml: str, state: dict) -> Path:
+        sub = tmp / name
+        (sub / "crossref").mkdir(parents=True)
+        (sub / "submission.json").write_text(json.dumps({
+            "sub_id": name, "title": f"Article {name}", "abstract": "A", "license": "cc-by-4.0",
+            "creators": [{"name": "Lovelace, Ada"}], "form": {"name": "Ada Lovelace"}}))
+        (sub / "state.json").write_text(json.dumps(state))
+        (sub / "crossref" / "deposit.xml").write_text(xml)
+        (sub / "crossref" / "staged.json").write_text(json.dumps({"doi": doi, "registered": False}))
+        return sub
+
+    def entry_for(sub_id: str) -> dict:
+        return next(x for x in entries() if x.get("sub_id") == sub_id)
+
+    reg.write_text("[]")
+    accept = {"decision": "accept", "state": "completed", "completed_at": "2026-02-10T23:30:00Z"}
+    logs: list[str] = []
+    sub = make_sub("ICSAC-SUB-09980", "10.5555/icsac.2026.982", deposit_xml("2026-03-03", "2026-03-02"), accept)
+    cd.register(sub, live=True, log=logs.append)
+    e = entry_for("ICSAC-SUB-09980")
+    check((e.get("accepted_date"), e.get("published_date")) == ("2026-03-02", "2026-03-03"),
+          "both dates are the deposit's (not the stamp's, not today)")
+    said = [m for m in logs if "registry dates:" in m]
+    check(said and "accepted 2026-03-02 (from the deposit)" in said[-1]
+          and "published 2026-03-03 (from the deposit)" in said[-1], "the log names the deposit as the source of each")
+
+    # ── 4. a date missing from the deposit falls back, and the log says so ───
+    print("4. fallback")
+    today = datetime.date.today().isoformat()
+    logs.clear()
+    sub = make_sub("ICSAC-SUB-09981", "10.5555/icsac.2026.983", deposit_xml(None, None), accept)
+    cd.register(sub, live=True, log=logs.append)
+    e = entry_for("ICSAC-SUB-09981")
+    check(e.get("accepted_date") == "2026-02-10", "accepted falls back to the decision stamp's date")
+    check(e.get("published_date") in (today, datetime.date.today().isoformat()), "published falls back to today")
+    said = [m for m in logs if "registry dates:" in m]
+    check(said and "accepted 2026-02-10 (NOT in the deposit; the accept decision's stamp)" in said[-1]
+          and "(NOT in the deposit; today)" in said[-1], "the log says which date fell back, and to what")
+    logs.clear()
+    sub = make_sub("ICSAC-SUB-09982", "10.5555/icsac.2026.984", deposit_xml(None, None),
+                   {"decision": "accept", "state": "completed"})
+    cd.register(sub, live=True, log=logs.append)
+    said = [m for m in logs if "registry dates:" in m]
+    check(said and f"accepted {entry_for('ICSAC-SUB-09982').get('accepted_date')} (NOT in the deposit; today)" in said[-1],
+          "no stamp either: accepted is today, and the log says so")
+    logs.clear()
+    sub = make_sub("ICSAC-SUB-09983", "10.5555/icsac.2026.985", deposit_xml("2026-03-01", "2026-03-02"), accept)
+    cd.register(sub, live=True, log=logs.append)
+    e = entry_for("ICSAC-SUB-09983")
+    said = [m for m in logs if "registry dates:" in m]
+    check(e.get("accepted_date") == "2026-03-02" and "published_date" not in e
+          and said and "published 2026-03-01 DROPPED: before acceptance" in said[-1],
+          "a deposited publication before acceptance is dropped, loudly, and the page still publishes")
+
+    # ── 5. a re-run keeps an existing entry's dates ──────────────────────────
+    print("5. re-run")
+
+    class LaterDay(datetime.date):
+        @classmethod
+        def today(cls):
+            return datetime.date(2026, 6, 1)
+
+    def rerun(sub: Path) -> None:
+        """A crash between the page push and its checkpoint: register runs the landing step again."""
+        sp = sub / "crossref" / "staged.json"
+        st = json.loads(sp.read_text())
+        st.get("checkpoints", {}).pop("publications_pushed_at", None)
+        sp.write_text(json.dumps(st))
+        real_dt = cd._dt
+        cd._dt = types.SimpleNamespace(date=LaterDay, datetime=datetime.datetime, timezone=datetime.timezone)
+        try:
+            cd.register(sub, live=True, log=logs.append)
+        finally:
+            cd._dt = real_dt
+
+    first = entry_for("ICSAC-SUB-09981")
+    logs.clear()
+    rerun(tmp / "ICSAC-SUB-09981")
+    again = entry_for("ICSAC-SUB-09981")
+    check(any("registry dates:" in m for m in logs), "the re-run reached the landing step")
+    check((again.get("accepted_date"), again.get("published_date"))
+          == (first.get("accepted_date"), first.get("published_date")),
+          "fallback dates survive a re-run on a later day")
+    said = [m for m in logs if "registry dates:" in m]
+    check(said and "the existing entry's, kept" in said[-1], "the log says the existing dates were kept")
+    logs.clear()
+    rerun(tmp / "ICSAC-SUB-09980")
+    again = entry_for("ICSAC-SUB-09980")
+    check((again.get("accepted_date"), again.get("published_date")) == ("2026-03-02", "2026-03-03"),
+          "deposited dates are the same on a re-run")
+    check(len([x for x in entries() if x.get("sub_id") == "ICSAC-SUB-09980"]) == 1, "a re-run updates, never duplicates")
+finally:
+    shutil.rmtree(tmp, ignore_errors=True)
+
+print()
+if failures:
+    print(f"FAILED: {len(failures)}")
+    for f in failures:
+        print("  - " + f)
+    sys.exit(1)
+print("ALL GREEN")

publications.py

@@ -80,7 +80,7 @@ def _save_registry(registry: list[dict]) -> None:
 # upsert untouched (audit 2026-09-28 item 10: they were dropped, sub_id and the
 # licence with them, so a Crossref-path landing page had no PDF link).
 _OPTIONAL_KEYS = (
-    "license_url", "keywords", "canonical_url", "ssrn_id", "ssrn_url", "ssrn_doi",
+    "published_date", "license_url", "keywords", "canonical_url", "ssrn_id", "ssrn_url", "ssrn_doi",
     "promotion_opt_out", "promotion_exclusions", "persistence_opt_out",
     "code_data_url", "preprint_doi",
 )
@@ -134,6 +134,19 @@ def _match_existing(registry: list[dict], proto: dict) -> Optional[int]:
     return None
 
 
+def find_entry(proto: dict) -> Optional[dict]:
+    """The registry entry an upsert of `proto` would update, or None (also when
+    the registry is not configured or cannot be read)."""
+    if not WEBSITE_REPO:
+        return None
+    try:
+        registry = _load_registry()
+    except (OSError, ValueError):
+        return None
+    i = _match_existing(registry, proto)
+    return dict(registry[i]) if i is not None else None
+
+
 # ── The publish gate (2026-09-29) ─────────────────────────────────────────────
 # The curator's rule: nothing publishes anywhere without his approval; everything
 # else is drafted and ready to go. The writers below (registry, public review,
@@ -178,8 +191,18 @@ def upsert_entry(proto: dict, *, approved: bool = False) -> dict:
     """Insert or update a publications entry. Returns the final entry.
 
     `proto` must carry: title, authors (list[str]), doi, source. Optional:
-    abstract, source_ref, record_id, accepted_date (defaults to today),
-    slug (auto-derived from title if absent).
+    abstract, source_ref, record_id, slug (auto-derived from title if absent),
+    and two dates, YYYY-MM-DD:
+
+      accepted_date   the day the paper was accepted: the page's "Accepted"
+                      row, the journal's order and the volume. Defaults to
+                      the existing entry's, else today.
+      published_date  the day it was published online, when that is not the
+                      day of acceptance (the Crossref route registers the DOI
+                      after the decision). The publication date Google
+                      Scholar, the JSON-LD and the feed read; without it they
+                      read accepted_date. Absent, the existing entry's is kept.
+                      Never before accepted_date (ValueError, nothing written).
 
     Existing entries (matched by record_id or doi) are updated in place;
     the existing slug is preserved for URL stability. New entries get a
@@ -246,12 +269,20 @@ def upsert_entry(proto: dict, *, approved: bool = False) -> dict:
     for key in _OPTIONAL_KEYS:
         if key in proto and proto[key] not in (None, "", [], {}):
             final[key] = proto[key]
+    # The website's schema refuses this, and a refused registry fails every build.
+    if final.get("published_date") and final["published_date"] < final["accepted_date"]:
+        raise ValueError(
+            f"published_date {final['published_date']} is before accepted_date "
+            f"{final['accepted_date']} for {proto['doi']}; registry not written"
+        )
 
     # Re-key in canonical insert order so the JSON stays diff-friendly; any
-    # field not named here is kept at the end rather than dropped.
+    # field not named here is kept at the end rather than dropped. The two
+    # dates sit together (published_date keeps its first position below).
     ordered_keys = [
         "slug", "record_id", "sub_id", "title", "authors", "doi",
-        "accepted_date", "source", "source_ref", "abstract", *_OPTIONAL_KEYS,
+        "accepted_date", "published_date", "source", "source_ref", "abstract",
+        *_OPTIONAL_KEYS,
     ]
     canonical = {k: final[k] for k in ordered_keys if k in final}
     for k, v in final.items():

tools/wrap-paper-pdf.py

@@ -163,12 +163,18 @@ def doi_url(doi: str) -> str:
     return "https://doi.org/" + re.sub(r"^doi:", "", doi, flags=re.I)
 
 
+def published_on(paper: dict) -> str:
+    """The publication date the site reads (published_date, else accepted_date):
+    a citation's year and the volume follow publication, as in cite.ts."""
+    return paper.get("published_date") or paper.get("accepted_date") or ""
+
+
 def cite_as(paper: dict, j: dict) -> str:
     """The page's "The work" plain-text citation (cite.ts plainTextWork)."""
     authors = authors_apa_list(paper.get("authors") or [])
-    year = (paper.get("accepted_date") or "")[:4]
+    year = published_on(paper)[:4]
     if is_institute_doi(paper["doi"], j["prefix"]):
-        vol = volume_for(paper.get("accepted_date") or "", j["volumes"])
+        vol = volume_for(published_on(paper), j["volumes"])
         art = article_number_for(paper["doi"], j["prefix"])
         loc = j["title"] + (f", {vol['volume']}" if vol else "") + (f", Article {art}" if art else "")
         return f"{authors} ({year}). {paper['title']}. {loc}. {doi_url(paper['doi'])}"
@@ -320,7 +326,7 @@ def _page_size(page) -> str:
 def render_cover(paper: dict, rec: dict, site: Site, size: str = "Letter") -> bytes:
     j = site.journal()
     doi = bare_doi(paper["doi"])
-    vol = volume_for(paper.get("accepted_date") or "", j["volumes"])
+    vol = volume_for(published_on(paper), j["volumes"])
     art = article_number_for(doi, j["prefix"])
     issue = " · ".join(x for x in (
         f"Volume {_escape(vol['volume'])} ({_escape(vol['year'])})" if vol else "",