Audit 2026-09-28 (evening): a late author response is never overwritten by the window check, an accept waits for a panel report, a review of a paper that studies models passes the redaction gate, a data sentence does not take back a code claim, the stats snapshot never shrinks

code_availability.py

@@ -38,6 +38,9 @@ _CLAIM_PATTERNS = [
     r"\b(?:archive|repository)\s+(?:contains|includes|provides)\b",
 ]
 _CLAIM_RE = re.compile("|".join(f"(?:{p})" for p in _CLAIM_PATTERNS), re.I)
+# The first pattern is a heading ("Data availability"); its answer follows it.
+_HEADING_RE = re.compile(_CLAIM_PATTERNS[0], re.I)
+_SENTENCE_END = re.compile(r"[.!?](?:\s|$)")
 
 # Said right after an availability heading, these mean there is nothing to link.
 _NOTHING_TO_SHARE = re.compile(
@@ -81,7 +84,14 @@ def find_claims(text: str) -> list[str]:
     """Availability statements in `text`, one quoted sentence each."""
     out: list[str] = []
     for m in _CLAIM_RE.finditer(text):
-        if _NOTHING_TO_SHARE.search(text[m.end(): m.end() + 120]):
+        after = text[m.end(): m.end() + 120]
+        if not _HEADING_RE.fullmatch(m.group(0)):
+            # "Code is available. No new data were generated." The second
+            # sentence is about data; it does not take back the code claim.
+            end = _SENTENCE_END.search(after)
+            if end:
+                after = after[: end.start()]
+        if _NOTHING_TO_SHARE.search(after):
             continue
         quote = _sentence(text, m.start(), m.end())
         if quote not in out:

crossref_deposit.py

@@ -905,12 +905,24 @@ def _push_publications(sub_dir: Path, submission: dict, doi: str, *, log) -> dic
             f"the landing page will show none")
     # The public stats snapshot rode only the legacy Zenodo path and had stood
     # still since May (audit 2026-09-28 pass D); refresh it with every publication.
+    # The review files behind the May snapshot left reviews/ at the public flip,
+    # so a fresh count can be LOWER than the published one; a snapshot that
+    # would shrink the total is never written (audit 2026-09-28, evening).
     try:
         import stats as _stats
-        stats_path = _stats.write_stats(config.REVIEWS_DIR,
-                                        os.path.join(publications.WEBSITE_REPO, "src", "data", "stats.json"))
-        if stats_path:
-            extra.append(stats_path)
+        out = os.path.join(publications.WEBSITE_REPO, "src", "data", "stats.json")
+        fresh = _stats.compute_stats(config.REVIEWS_DIR)
+        try:
+            published = json.loads(Path(out).read_text()).get("total_reviewed") or 0
+        except Exception:
+            published = 0
+        if (fresh.get("total_reviewed") or 0) < published:
+            log(f"  crossref: stats snapshot kept: a fresh count of {fresh.get(total_reviewed)} "
+                f"would replace the published {published}")
+        else:
+            stats_path = _stats.write_stats(config.REVIEWS_DIR, out)
+            if stats_path:
+                extra.append(stats_path)
     except Exception as exc:   # the stats page must never block a registration
         log(f"  crossref: stats snapshot not refreshed ({exc})")
     publications.commit_and_push(message=f"publications: {entry['title']} ({entry['slug']}) — {doi}",

intake/apply_decision.py

@@ -168,6 +168,14 @@ def main(argv: list[str]) -> int:
             code_link_claims = []
 
     panel_md, rqc_md = worker._scrubbed_report_pair(sub_id, title, tier=tier)
+    # The acceptance email attaches the panel report and the record publishes it:
+    # an accept with none (the panel never ran, e.g. right after a code-check
+    # override, or the redaction gate dropped it) waits (audit 2026-09-28).
+    if verdict == "accept" and not panel_md.strip() and not force:
+        print(f"{sub_id} has no publishable panel report (not reviewed yet, or the redaction "
+              f"gate dropped it: see the curator alert). Nothing done. Decide after the panel, "
+              f"or run with ICSAC_DECISION_FORCE=1 to accept without the report.", file=sys.stderr)
+        return 3
     deposit_doi = state_pre.get("deposit_doi")
     deposit_url = state_pre.get("deposit_url")
 

intake/author_approval.py

@@ -23,7 +23,10 @@ author_hold_note.
 """
 from __future__ import annotations
 
+import contextlib
 import datetime as _dt
+import fcntl
+import os
 import hashlib
 import json
 import re
@@ -107,7 +110,24 @@ def _load(sub_dir: Path) -> Optional[dict]:
 
 
 def _save(sub_dir: Path, rec: dict) -> None:
-    (Path(sub_dir) / FILE).write_text(json.dumps(rec, indent=2) + "\n")
+    p = Path(sub_dir) / FILE
+    tmp = p.with_name(p.name + ".tmp")
+    tmp.write_text(json.dumps(rec, indent=2) + "\n")
+    os.replace(tmp, p)
+
+
+@contextlib.contextmanager
+def _locked(sub_dir: Path):
+    """One writer at a time per paper: the intake server records responses while
+    the batch tick marks closed windows, and a stale read in either would overwrite
+    the other's write (audit 2026-09-28)."""
+    fd = os.open(str(Path(sub_dir) / (FILE + ".lock")), os.O_CREAT | os.O_RDWR, 0o600)
+    try:
+        fcntl.flock(fd, fcntl.LOCK_EX)
+        yield
+    finally:
+        fcntl.flock(fd, fcntl.LOCK_UN)
+        os.close(fd)
 
 
 def is_test(sub_id: str) -> bool:
@@ -227,31 +247,39 @@ def record(sub_dir: Path, rec: dict, choice: str, note: str = "",
         raise ValueError(f"unknown exclusion(s): {bad}")
     if choice != "approve" and excl:
         excl = []  # exclusions only mean something on an approval
-    st = _state(sub_dir)
-    if st.get("crossref_registered_at"):
-        raise Locked("the DOI is already registered; write to help@icsacinstitute.org for a correction")
-    if rec.get("status", "pending") != "pending" or rec.get("responses"):
-        # One response per paper (policy since 2026-09-28): the first click is the
-        # instruction of record; anything after it goes through help@.
-        raise Locked("your response is already on record; for any change write to "
-                     "help@icsacinstitute.org with your submission ID in the subject line")
-    entry = {"at": _iso(_now()), "choice": choice, "exclusions": excl, "note": note,
-             "quote_ok": bool(quote_ok) and choice == "approve",
-             "orcid": (orcid or "").strip()}   # the iD that signed this response (2026-09-28)
-    rec.setdefault("responses", []).append(entry)
-    rec["status"] = CHOICES[choice]
-    _save(sub_dir, rec)
-    fields = {
-        "author_approval_status": rec["status"],
-        "author_exclusions": excl,
-        "promotion_opt_out": bool(set(excl) & PROMOTION_IDS),
-        "persistence_opt_out": "persistence" in excl,
-        "withdrawn_by_author": choice == "withdraw",
-        "author_quote_ok": entry["quote_ok"],
-    }
-    if choice in ("hold", "withdraw"):
-        fields["author_hold_note"] = note
-    _update_state(sub_dir, **fields)
+    with _locked(sub_dir):
+        cur = _load(sub_dir)
+        if cur is not None:
+            if cur.get("token_sha256") != rec.get("token_sha256"):
+                raise Locked("this link is no longer valid; write to help@icsacinstitute.org "
+                             "with your submission ID in the subject line")
+            rec.clear()
+            rec.update(cur)
+        st = _state(sub_dir)
+        if st.get("crossref_registered_at"):
+            raise Locked("the DOI is already registered; write to help@icsacinstitute.org for a correction")
+        if rec.get("status", "pending") != "pending" or rec.get("responses"):
+            # One response per paper (policy since 2026-09-28): the first click is the
+            # instruction of record; anything after it goes through help@.
+            raise Locked("your response is already on record; for any change write to "
+                         "help@icsacinstitute.org with your submission ID in the subject line")
+        entry = {"at": _iso(_now()), "choice": choice, "exclusions": excl, "note": note,
+                 "quote_ok": bool(quote_ok) and choice == "approve",
+                 "orcid": (orcid or "").strip()}   # the iD that signed this response (2026-09-28)
+        rec.setdefault("responses", []).append(entry)
+        rec["status"] = CHOICES[choice]
+        _save(sub_dir, rec)
+        fields = {
+            "author_approval_status": rec["status"],
+            "author_exclusions": excl,
+            "promotion_opt_out": bool(set(excl) & PROMOTION_IDS),
+            "persistence_opt_out": "persistence" in excl,
+            "withdrawn_by_author": choice == "withdraw",
+            "author_quote_ok": entry["quote_ok"],
+        }
+        if choice in ("hold", "withdraw"):
+            fields["author_hold_note"] = note
+        _update_state(sub_dir, **fields)
     if audit:
         try:
             audit({"sub_id": sub_id, "event": "author_response", "choice": choice,
@@ -324,9 +352,13 @@ def check_windows(*, now: Optional[_dt.datetime] = None) -> int:
                      f"Accepted {str(st.get('completed_at', '?'))[:10]}; the author has not responded by "
                      f"{rec['deadline'][:10]}. Your call: intake/register-doi.sh {sub_dir.name} --live"):
             continue
-        rec["window_closed_pinged"] = True
-        rec["window_closed_pinged_at"] = _iso(now)
-        _save(sub_dir, rec)
+        with _locked(sub_dir):
+            # Re-read: the author may have answered while the ping was in flight.
+            cur = _load(sub_dir)
+            if cur and cur.get("status") == "pending" and not cur.get("window_closed_pinged"):
+                cur["window_closed_pinged"] = True
+                cur["window_closed_pinged_at"] = _iso(now)
+                _save(sub_dir, cur)
         pinged += 1
     return pinged
 

intake/scripts/test_audit_20260928b.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""Regression checks for the second audit of 2026-09-28 (the evening sweep).
+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:
+    .venv/bin/python intake/scripts/test_audit_20260928b.py
+
+Covers: a late author response is never overwritten by the window check; a
+second response still refuses; the code claim is not taken back by a data
+sentence; the redaction gate passes a review of a paper that studies models and
+still stops seat talk; accept waits for a panel report.
+"""
+from __future__ import annotations
+
+import json
+import shutil
+import sys
+import tempfile
+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)
+
+
+tmp = Path(tempfile.mkdtemp(prefix="icsac-audit-b-"))
+try:
+    # ── author approval: the window check and a late response ──────────────
+    from intake import author_approval as aa
+    aa.SUBMISSIONS_ROOT = tmp
+    sub = tmp / "ICSAC-SUB-00099"
+    sub.mkdir()
+    (sub / "state.json").write_text(json.dumps({"state": "completed", "decision": "accept",
+                                                "completed_at": "2026-09-01T00:00:00Z"}))
+    rec = {"token_sha256": "abc", "issued_at": "2026-09-01T00:00:00Z",
+           "deadline": "2026-09-08T00:00:00Z", "status": "pending", "responses": [],
+           "window_closed_pinged": False}
+    aa._save(sub, rec)
+    sent = []
+
+    def ping_while_author_answers(msg: str) -> bool:
+        # The author's late approval lands while the curator ping is in flight.
+        sent.append(msg)
+        if len(sent) == 1:   # record() pings the curator too; answer only once
+            aa.record(sub, aa._load(sub), "approve", "", [], orcid="0000-0000-0000-0001")
+        return True
+
+    real_ping = aa._ping
+    aa._ping = ping_while_author_answers
+    try:
+        aa.check_windows()
+    finally:
+        aa._ping = real_ping
+    final = aa._load(sub)
+    check(final["status"] == "approved" and len(final["responses"]) == 1,
+          "a response recorded during the window ping survives the tick")
+    check(not final.get("window_closed_pinged"), "the tick does not mark an answered paper as closed in silence")
+    try:
+        aa.record(sub, aa._load(sub), "withdraw", "x" * 40, [], orcid="0000-0000-0000-0001")
+        check(False, "a second response is refused")
+    except aa.Locked:
+        check(True, "a second response is refused")
+    stale = dict(final, token_sha256="other")
+    (sub / aa.FILE).write_text(json.dumps(dict(final, status="pending", responses=[])))
+    try:
+        aa.record(sub, stale, "approve", "", [], orcid="0000-0000-0000-0001")
+        check(False, "a response through a re-issued link's old token is refused")
+    except aa.Locked:
+        check(True, "a response through a re-issued link's old token is refused")
+    check(not list(sub.glob("*.tmp")), "no temporary file is left beside the record")
+
+    # ── code claims ─────────────────────────────────────────────────────────
+    import code_availability as ca
+    check(len(ca.find_claims("The code is available on request. No new data were generated.")) == 1,
+          "a data sentence after a code claim does not take the claim back")
+    check(ca.find_claims("Data availability\nNot applicable.\n") == [],
+          "a heading answered 'Not applicable' is still no claim")
+    check(ca.find_claims("Data availability: no new data were generated in this study.") == [],
+          "a heading answered 'no new data' is still no claim")
+    check(len(ca.find_claims("Code availability: the scripts are available on request.")) >= 1,
+          "a heading followed by a real statement is a claim")
+
+    # ── redaction: models studied vs seats named ────────────────────────────
+    import redaction
+    try:
+        redaction.assert_clean("The authors compare the GPT model with two Llama models and a Gemini model.")
+        check(True, "a review of a paper that studies models passes the gate")
+    except redaction.RedactionLeak:
+        check(False, "a review of a paper that studies models passes the gate")
+    for leak in ("The Claude-position reviewers agree.", "the Qwen slot scored it lower", "a GPT reviewer"):
+        try:
+            redaction.assert_clean(leak)
+            check(False, f"seat talk is fatal: {leak!r}")
+        except redaction.RedactionLeak:
+            check(True, f"seat talk is fatal: {leak!r}")
+
+    # ── accept waits for a panel report ─────────────────────────────────────
+    src = (ROOT / "intake" / "apply_decision.py").read_text()
+    i = src.find("panel_md, rqc_md = worker._scrubbed_report_pair(")
+    j = src.find('if verdict == "accept" and not panel_md.strip() and not force:')
+    k = src.find("publications_url_str: str | None = None")
+    check(0 < i < j < k, "the no-report guard sits before the first side effect of an accept")
+
+    # ── the stats snapshot never shrinks ────────────────────────────────────
+    import stats
+    rdir = tmp / "reviews"; rdir.mkdir()
+    check(stats.compute_stats(str(rdir)).get("total_reviewed") == 0, "an empty reviews dir counts zero")
+    cd = (ROOT / "crossref_deposit.py").read_text()
+    g = cd.find("if (fresh.get(\"total_reviewed\") or 0) < published:")
+    w = cd.find("stats_path = _stats.write_stats(config.REVIEWS_DIR, out)")
+    check(0 < g < w, "a fresh count below the published total is never written")
+finally:
+    shutil.rmtree(tmp, ignore_errors=True)
+
+print(f"\n{'ALL GREEN' if not failures else f'{len(failures)} FAILURE(S)'}")
+sys.exit(1 if failures else 0)

redaction.py

@@ -92,9 +92,10 @@ SOFT_WARN_TOKENS: tuple[str, ...] = (
 # Panel-composition talk in reviewer or RQC prose: a vendor or model name tied
 # to a seat ("Claude-position reviewers", "the GPT slot"). A paper's own AI-use
 # disclosure never takes this shape, so it is fatal wherever it appears, prose
-# included (audit 2026-09-28 item 4).
+# included (audit 2026-09-28 item 4). "Model" is not a seat word: a review of a
+# paper that studies "the GPT model" or "Llama models" must not trip the gate.
 FORBIDDEN_PANEL_PATTERNS: tuple[str, ...] = (
-    r"(?i)\b(?:claude|anthropic|gpt|chatgpt|openai|gemini|gemma|qwen|deepseek|llama|mistral|nemotron|sonnet|opus)[- ](?:position|seat|slot|reviewer|model)s?\b",
+    r"(?i)\b(?:claude|anthropic|gpt|chatgpt|openai|gemini|gemma|qwen|deepseek|llama|mistral|nemotron|sonnet|opus)[- ](?:position|seat|slot|reviewer)s?\b",
 )
 
 FORBIDDEN_EXFIL_PATTERNS: tuple[str, ...] = (
@@ -756,7 +757,7 @@ def build_public_rqc_markdown(parsed: ParsedRQC) -> str:
     enforces this before the redaction writes anything to the site.
     """
     status_line = (
-        "Review Quality Control: flagged — reviewed by human curators before acceptance."
+        "Review Quality Control: flagged — reviewed by the curation team before acceptance."
         if parsed.flag
         else "Review Quality Control: passed."
     )