Data layer at the amended release v1.0.0: card no longer names local-only tooling, frozen-snapshot notice

README.md

@@ -201,11 +201,10 @@ The first two run offline and exit 0 in either repository — the source reposit
 data layer — against the files shipped here. The third reaches the hub (and Zenodo, given a
 record identifier) and is the release-time check that the copy you are reading is byte-for-byte
 the copy in the other places: it reports drift rather than asserting agreement, because the
-three locations are updated by different commands and nothing synchronises them. The self-audit
-of the anonymiser itself (`scripts/anonymize.py --input raw_evidence`) needs the raw logs, which
-are not published, and the document gate over links, personal data and ignore rules (`tools/`) is
-local-only tooling that is deliberately not part of either repository: the commands above are what
-a reader can actually run, so they are what this card asks a reader to run.
+three locations are updated by different commands and nothing synchronises them. Anything not
+listed above is author-side tooling, or needs material deliberately not published here — the raw
+client logs, which carry local paths and real conversation identifiers. The commands above are
+what a reader can actually run, so they are what this card asks a reader to run.
 
 Pseudonyms (`sess-NN` in round 1, `S1`… in round 2) are numbered by the data's own
 order; the mapping to real conversation identifiers is not published and cannot be

methodology.md

@@ -31,7 +31,7 @@ and real conversation identifiers):
 
 | Step | Command | Result of the attempt |
 |---|---|---|
-| Derived statistics from the published evidence | `python3 scripts/analyze.py` | **reproduces exactly.** 58 assertions pass. The output file ends with a content hash plus a second-precision timestamp, and when the hash is unchanged the file is not rewritten at all — so running the checks cannot dirty the tree, and two copies with the same hash hold the same statistics whatever their stamps say |
+| Derived statistics from the published evidence | `python3 scripts/analyze.py` | **reproduces exactly.** 60 assertions pass. The output file ends with a content hash plus a second-precision timestamp, and when the hash is unchanged the file is not rewritten at all — so running the checks cannot dirty the tree, and two copies with the same hash hold the same statistics whatever their stamps say |
 | Card against files | `python3 scripts/verify_dataset_card.py` | **reproduces exactly**, eight checks, in either repository |
 | Log extracts from the pinned snapshot | `LOGSRC=<snapshot>/logs scripts/collect_evidence.sh` then `scripts/anonymize.py` | **does not reproduce the frozen bundle.** Of 24 published items, 4 matched byte for byte, 11 differed, and 9 were not produced at all (`evidence/screenshots/`, `evidence/user_statements.md`, four extracts, two statistics files, the round-2 directory) |
 

scripts/analyze.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 import hashlib
 import json
 import re
+import subprocess
 import sys
 from collections import Counter, defaultdict
 from datetime import datetime
@@ -405,6 +406,80 @@ if PUB_DOCS:
     check("no published document quotes a check or figure count unless its section dates the measurement",
           count_problems, [])
 
+# ---- a published heading must not route text to a venue ----
+# The released v1.0.0 tag carried "## One-line entry (repository subtitle, listing, tweet)" and
+# "## Short entry (about 300 characters: post summary field, search result, card lead)" in
+# abstract.md: notes for whoever posts the text, sitting in a file a stranger downloads. Venue
+# routing in a heading is the signature, so the heading is what is checked - prose may name a
+# medium freely.
+VENUE_WORDS = ("subtitle", "listing", "tweet", "summary field", "post summary", "search result",
+               "card lead", "post body", "collection note", "use everywhere", "use verbatim",
+               "for listings", "to paste", "paste this", "headline to use")
+editorial_problems = []
+for doc in PUB_DOCS:
+    for n, line in enumerate(doc.read_text(errors="replace").splitlines(), 1):
+        low = line.lower()
+        if line.startswith("#") and "(" in line and any(w in low for w in VENUE_WORDS):
+            editorial_problems.append(f"{doc.name}:{n}: heading routes text to a venue: "
+                                      f"{line.strip()[:64]}")
+if PUB_DOCS:
+    check("no published heading carries editorial routing instructions", editorial_problems, [])
+
+# ---- a published script may only tell someone to run something that exists ----
+# scripts/preflight.sh invoked `python3 tools/verify_docs.py` unconditionally. tools/ is local-only,
+# so a clean clone of the release tag finished with NOT READY TO PUBLISH — a red light caused by
+# tooling nobody published. Same defect as the dataset card's un-runnable command, one layer down,
+# which is why this checks scripts too and asks git rather than the disk: the author's disk has
+# everything, so presence proves nothing about what was shipped.
+CALL_RE = re.compile(r"(?:python3|bash)\s+((?:scripts|tools|zenodo|analysis)/[\w./-]+)")
+
+
+def tracked_at_root() -> set[str] | None:
+    """What git tracks, but only when this checkout is the top level of its own repository."""
+    root = EV.parent
+    try:
+        prefix = subprocess.run(["git", "-C", str(root), "rev-parse", "--show-prefix"],
+                                capture_output=True, text=True, timeout=30)
+        if prefix.returncode != 0 or prefix.stdout.strip():
+            return None
+        listing = subprocess.run(["git", "-C", str(root), "ls-files"],
+                                 capture_output=True, text=True, timeout=30)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return set(listing.stdout.split()) if listing.returncode == 0 else None
+
+
+TRACKED = tracked_at_root()
+LOCAL_WORDS = ("local-only", "not published", "not in this repository", "never published")
+script_problems = []
+scripts_dir = EV.parent / "scripts"
+if scripts_dir.is_dir():
+    # Iterate what is *published*, not what is on this disk: the first version of this check walked
+    # scripts/ and reported an untracked local helper that no reader has, which is precisely the
+    # mistake the check exists to catch.
+    if TRACKED is not None:
+        candidates = sorted(EV.parent / rel for rel in TRACKED
+                            if rel.startswith(("scripts/", "zenodo/"))
+                            and rel.endswith((".sh", ".py")))
+    else:
+        candidates = sorted(list(scripts_dir.glob("*.sh")) + list(scripts_dir.glob("*.py"))
+                            + list((EV.parent / "zenodo").glob("*.sh")))
+    for script in candidates:
+        if not script.is_file() or script.name == "analyze.py":
+            continue                      # this file's own strings are not instructions
+        lines = script.read_text(errors="replace").splitlines()
+        for n, line in enumerate(lines, 1):
+            for found in CALL_RE.finditer(line):
+                target = found.group(1)
+                shipped = (target in TRACKED) if TRACKED is not None else (EV.parent / target).exists()
+                window = " ".join(lines[max(0, n - 4):n + 3]).lower()
+                if not shipped and not any(w in window for w in LOCAL_WORDS):
+                    script_problems.append(f"{script.name}:{n} runs {target}, which is not shipped "
+                                           f"and is not marked local-only here")
+if TRACKED is not None or scripts_dir.is_dir():
+    check("no published script tells a reader to run something that is not published",
+          script_problems, [])
+
 # ---- the release note describes the artifact, not the machinery that publishes it ----
 # A GitHub release body is reader-facing text. Workflow commentary in it - what we chose not
 # to attach and why, which integration has to be enabled first - is addressed to the person