Data layer at release v1.0.2: the card cites the reference list and names each archived version identifier
bfe0063 verified | #!/usr/bin/env python3 | |
| """analyze.py — recompute every number the report quotes, from evidence/ only. | |
| Reads the anonymized evidence tree, derives the statistics cited in | |
| report_qwenAliServiceQuality.md, writes analysis/summary_tables.md, and | |
| asserts each expected value. Exit code 1 = a report number no longer | |
| matches the evidence. | |
| Usage: python3 analyze.py (run from scripts/) | |
| """ | |
| from __future__ import annotations | |
| import hashlib | |
| import json | |
| import re | |
| import subprocess | |
| import sys | |
| from collections import Counter, defaultdict | |
| from datetime import datetime | |
| from pathlib import Path | |
| from statistics import median as statistics_median | |
| EV = Path(__file__).resolve().parents[1] / "evidence" | |
| OUT = Path(__file__).resolve().parents[1] / "analysis" / "summary_tables.md" | |
| TS = "%Y-%m-%d %H:%M:%S" | |
| fails: list[str] = [] | |
| checks_done = 0 # how many checks this run performed, i.e. the number prose may quote | |
| def check(name: str, got, want) -> None: | |
| global checks_done | |
| checks_done += 1 | |
| ok = got == want | |
| print(f" {'PASS' if ok else 'FAIL'} {name}: {got}" + ("" if ok else f" (report says {want})")) | |
| if not ok: | |
| fails.append(name) | |
| def ts_of(line: str) -> datetime: | |
| return datetime.strptime(line[:19], TS) | |
| # ---- timeout events --------------------------------------------------------- | |
| rows = (EV / "logs/timeout_resume_events.csv").read_text().splitlines()[1:] | |
| codes = Counter(r.split(",")[2] for r in rows) | |
| per_day = Counter(r[:10] for r in rows) | |
| times = sorted(ts_of(r) for r in rows) | |
| # densest 75-minute block | |
| best = max(range(len(times)), key=lambda i: sum(1 for t in times if 0 <= (t - times[i]).total_seconds() <= 75 * 60)) | |
| block_n = sum(1 for t in times if 0 <= (t - times[best]).total_seconds() <= 75 * 60) | |
| # ---- quota events (cluster lines within 2 s) -------------------------------- | |
| qtimes = [ts_of(ln) for ln in (EV / "logs/quota_error_lines.txt").read_text().splitlines() | |
| if re.match(r"^\d{4}-\d\d-\d\d \d\d:\d\d:\d\d", ln)] | |
| events: list[list[datetime]] = [] | |
| for t in sorted(qtimes): | |
| if events and (t - events[-1][-1]).total_seconds() <= 2: | |
| events[-1].append(t) | |
| else: | |
| events.append([t]) | |
| payloads = sorted(set(re.findall(r'"message":"([^"]{20,140})', | |
| (EV / "logs/quota_error_lines.txt").read_text()))) | |
| codes_seen = sorted(set(re.findall(r'"code":"?(-?\d+)"?', | |
| (EV / "logs/quota_error_lines.txt").read_text()))) | |
| # ---- chat_finish census ------------------------------------------------------ | |
| census = (EV / "logs/chat_finish_census.txt").read_text().splitlines() | |
| c_total = c_success = 0 | |
| for ln in census: | |
| m = re.match(r"\s*(\d+) (.*)", ln) | |
| if not m or '"command"' in ln: | |
| continue | |
| c_total += int(m.group(1)) | |
| if "success:200" in m.group(2): | |
| c_success += int(m.group(1)) | |
| # ---- sessions ---------------------------------------------------------------- | |
| sess = [ln.split(",") for ln in (EV / "stats/session_size_stats.csv").read_text().splitlines()[1:]] | |
| big = sorted(sess, key=lambda r: -int(r[3]))[:3] | |
| # ---- request lifecycle (frozen from a log snapshot via scripts/latency_from_logs.py) -- | |
| lc = [ln.split(",") for ln in (EV / "stats/request_lifecycle.csv").read_text().splitlines()[1:]] | |
| _fl = lambda x: float(x) if x else None | |
| _p50 = lambda v: (round(sorted(v)[min(len(v) - 1, int(0.5 * (len(v) - 1)))], 1) if v else None) | |
| _succ = [r for r in lc if r[2] == "S"] | |
| _stall = [r for r in lc if r[2] == "T"] | |
| _tto = [r for r in lc if r[2] == "T" and len(r) > 7 and r[7] == "resume_tool_call"] | |
| _tdi = [r for r in lc if r[2] == "T" and len(r) > 7 and r[7] == "permission_request"] | |
| _ttft = [x for x in map(lambda r: _fl(r[3]), lc) if x is not None] | |
| _tot = [_fl(r[4]) for r in _succ if _fl(r[4]) is not None and int(r[6] or 0) == 0] | |
| _stv = [_fl(r[5]) for r in _stall if _fl(r[5]) is not None] | |
| _fau = sum(1 for r in _succ if int(r[6] or 0) == 0) | |
| # ---- task lifecycle (quest.log; one master-mode task per conversation) -------- | |
| # The client's task object carries the conversation's own id (the log line names | |
| # it twice: "taskId" and "executionSessionId"). Every open IDE window writes the | |
| # same event into its own quest.log, so (session, status) repeats are clustered at | |
| # ≤2 s — the same rule used above for the quota markers. | |
| TLINE = re.compile(r"^\[(window\d+)\] (\d{4}-\d\d-\d\d \d\d:\d\d:\d\d\.\d{3}) \[\w+\] " | |
| r"task\.status\.update(\.skipNonQuestTask)? " | |
| r'\{"taskId":"(sess-\d+)","status":"(\w+)"') | |
| tl = [] | |
| for ln in (EV / "logs/task_status_lines.txt").read_text().splitlines(): | |
| m = TLINE.match(ln) | |
| if m: | |
| tl.append(m.groups()) | |
| tl_dupes = sum(1 for g in tl if g[2]) # .skipNonQuestTask twins | |
| tl_main = sorted((g for g in tl if not g[2]), key=lambda g: g[1]) | |
| task_ev: list[list] = [] # de-duplicated events | |
| for win, ts, _s, sid, st in tl_main: | |
| t = datetime.strptime(ts, TS + ".%f") | |
| if (task_ev and task_ev[-1][1] == sid and task_ev[-1][2] == st | |
| and (t - task_ev[-1][0]).total_seconds() <= 2): | |
| task_ev[-1][3].add(win) | |
| continue | |
| task_ev.append([t, sid, st, {win}]) | |
| task_status = Counter(e[2] for e in task_ev) | |
| task_windows = sum(1 for e in task_ev if len(e[3]) > 1) | |
| run_state: dict[str, datetime] = {} | |
| run_iv: list[tuple] = [] | |
| for t, sid, st, _w in task_ev: | |
| if st == "Running": | |
| if sid not in run_state: | |
| run_state[sid] = t | |
| else: | |
| if sid in run_state: | |
| run_iv.append((run_state.pop(sid), t, sid)) | |
| run_dur = sorted((b - a).total_seconds() for a, b, _ in run_iv) | |
| conc = sorted([(a, 1) for a, _, _ in run_iv] + [(b, -1) for a, b, _ in run_iv], | |
| key=lambda x: (x[0], x[1])) | |
| conc_now = conc_max = 0 | |
| for _t, d in conc: | |
| conc_now += d | |
| conc_max = max(conc_max, conc_now) | |
| # unordered pairs of conversations whose Running spans overlap in time | |
| conc_pairs = sum(1 for i, (s1, e1, _n1) in enumerate(run_iv) | |
| for s2, e2, _n2 in run_iv[i + 1:] if s2 < e1 and e2 > s1) | |
| # transition spans: Running -> ActionRequired is "sent, then went silent"; the | |
| # duration distribution of successful runs says whether the watchdog caps total | |
| # duration or only the silence between chunks. | |
| wd_span, ok_span = [], [] | |
| for (t1, s1, st1, _w1), (t2, s2, st2, _w2) in zip(task_ev, task_ev[1:]): | |
| if s1 != s2: | |
| continue | |
| gap = (t2 - t1).total_seconds() | |
| if st1 == 'Running' and st2 == 'ActionRequired': | |
| wd_span.append(gap) | |
| elif st1 == 'Running' and st2 == 'Completed': | |
| ok_span.append(gap) | |
| wd_mode, wd_mode_n = Counter(round(g) for g in wd_span).most_common(1)[0] | |
| ok_over = sum(1 for g in ok_span if g > wd_mode) | |
| # ActionRequired = "the banner is up, nothing is generating": pair it with the | |
| # 80408 resume-button events independently captured from the agent logs. Those | |
| # are read at full millisecond precision (`times` above is second-truncated). | |
| ar = [(t, sid) for t, sid, st, _w in task_ev if st == "ActionRequired"] | |
| resume_ms = [datetime.strptime(r.split(",")[0], TS + ".%f") for r in rows] | |
| ar_offsets = [min((abs((t - a).total_seconds()) for a, _ in ar), default=9e9) for t in resume_ms] | |
| ar_paired = sum(1 for g in ar_offsets if g <= 0.5) | |
| ar_max_off = max(ar_offsets, default=0.0) | |
| ar_per_sess = Counter(sid for t, sid in ar) | |
| # ---- per-interaction phase timing (the client's own state machine) ----------- | |
| # One line per phase boundary of a turn: `State transition: A -> B, trigger: T`. | |
| # The interval spent in state B runs from that line to the conversation's next | |
| # one, so `prompting` = send pressed → first streamed chunk, `streaming` = the | |
| # generation itself, `suspended` = a dialog or the timeout banner is up. | |
| PLINE = re.compile(r"^\[(window\d+)\] (\d{4}-\d\d-\d\d \d\d:\d\d:\d\d\.\d{3}) \[\w+\] " | |
| r"\[ACPProgressStateMachine\] State transition: (\w+) -> (\w+), " | |
| r"trigger: (.+), sessionId: (sess-\d+)") | |
| ph_raw = [] | |
| for ln in (EV / "logs/phase_transitions.txt").read_text().splitlines(): | |
| m = PLINE.match(ln) | |
| if m: | |
| ph_raw.append((datetime.strptime(m.group(2), TS + ".%f"), m.group(3), m.group(4), | |
| m.group(5), m.group(6))) | |
| ph_by_sess: dict[str, list] = defaultdict(list) | |
| for t, _frm, to, trig, sid in sorted(ph_raw): | |
| ph_by_sess[sid].append((t, to, trig.split(":")[0], trig)) | |
| wait_first, fastfail, gen_ok, hold_banner, hold_perm = [], [], [], [], [] | |
| suspend_cause = Counter() | |
| prompts = 0 | |
| for sid, seq in ph_by_sess.items(): | |
| for _t, to, fam, _trig in seq: | |
| if to == "suspended": | |
| suspend_cause[fam] += 1 | |
| for (t1, state1, fam1, _tr1), (t2, state2, fam2, _tr2) in zip(seq, seq[1:]): | |
| secs = (t2 - t1).total_seconds() | |
| if fam1 == "user_message_chunk": | |
| prompts += 1 | |
| if state2 == "streaming": | |
| wait_first.append(secs) | |
| elif state2 == "error": | |
| fastfail.append(secs) | |
| if state1 == "streaming" and state2 == "completed" and fam2 == "chat_finish": | |
| gen_ok.append(secs) | |
| if state1 == "suspended": | |
| (hold_banner if fam1 == "resume_tool_call" else hold_perm).append(secs) | |
| # ---- report assertions ------------------------------------------------------- | |
| print("assertions against the report:") | |
| check("timeout events", len(rows), 33) | |
| check("all timeouts code 80408", dict(codes), {"80408": 33}) | |
| check("timeouts Sep 7/8/9", dict(per_day), {"2026-09-07": 1, "2026-09-08": 4, "2026-09-09": 28}) | |
| check("densest 75-min block", block_n, 20) | |
| check("quota events clustered", len(events), 18) | |
| check("quota payload variants", len(payloads), 3) | |
| check("80411 never fired (absent from every log extract)", | |
| sum("80411" in p.read_text(errors="replace") for p in (EV / "logs").rglob("*")), 0, | |
| ) # the code exists only in the dictionary (config/), never on an event line | |
| check("chat_finish lines", c_total, 245) # echo-artifact line removed by anonymize.py | |
| check("chat_finish successes", c_success, 225) | |
| check("largest session entries", big[0][3], "626") | |
| check("lifecycle requests", len(lc), 308) | |
| check("lifecycle sessions", len({r[0] for r in lc}), 10) | |
| check("lifecycle successes (S)", len(_succ), 211) | |
| check("lifecycle stalls (T)", len(_stall), 71) | |
| check("lifecycle timeout parks (trigger resume_tool_call)", len(_tto), 33) | |
| check("lifecycle dialog parks (trigger permission_request)", len(_tdi), 38) | |
| check("lifecycle first-attempt usable", _fau, 179) | |
| check("lifecycle first-chunk median seconds", _p50(_ttft), 11.3) | |
| check("lifecycle clean-success total median seconds", _p50(_tot), 120.0) | |
| check("lifecycle time-to-stall median seconds", _p50(_stv), 305.4) | |
| # ---- incident 2 (2026-09-10 collection round; evidence/incident_20260910/) ---- | |
| # Regenerate: python3 scripts/latency_from_logs.py raw_snapshots/20260910T155718/logs \ | |
| # --since 2026-09-10T00:00 --emit-csv evidence/incident_20260910/request_lifecycle.csv | |
| i2 = [ln.split(",") for ln in | |
| (EV / "incident_20260910/request_lifecycle.csv").read_text().splitlines()[1:]] | |
| i2_to = [r for r in i2 if len(r) > 7 and r[7] == "resume_tool_call"] | |
| i2_dlg = [r for r in i2 if len(r) > 7 and r[7] == "permission_request"] | |
| i2_s_ok = [int(r[9]) for r in i2 if r[2] == "S" and len(r) > 9 and r[9]] | |
| i2_to_ctx = [int(r[9]) for r in i2_to if len(r) > 9 and r[9]] | |
| check("incident-2 requests", len(i2), 62) | |
| check("incident-2 timeout parks (80408 banner)", len(i2_to), 5) | |
| check("incident-2 permission-dialog parks", len(i2_dlg), 2) | |
| check("incident-2 smallest context that timed out (tokens)", min(i2_to_ctx), 490789) | |
| check("incident-2 largest context that completed (tokens)", max(i2_s_ok), 452447) | |
| check("incident-2 timeout send-to-stall, min/max seconds", | |
| (round(min(float(r[5]) for r in i2_to), 1), round(max(float(r[5]) for r in i2_to), 1)), | |
| (125.3, 4860.7)) | |
| check("task-status lines (incl. .skipNonQuestTask twins)", len(tl), 1252) | |
| check("conversations with task lifecycle events", len({e[1] for e in task_ev}), 9) | |
| check("task lifecycle events after ≤2 s de-dup", len(task_ev), 524) | |
| check("task lifecycle statuses seen", dict(task_status), | |
| {"Running": 258, "Completed": 208, "ActionRequired": 33, "Error": 18, "Stopped": 7}) | |
| check("ActionRequired count == timeout resume count", len(ar), len(rows)) | |
| check("every timeout has an ActionRequired ≤0.5 s away", ar_paired, len(rows)) | |
| check("per-conversation timeout split (session-level, was window-level)", | |
| dict(ar_per_sess), {"sess-16": 1, "sess-11": 5, "sess-03": 23, "sess-04": 4}) | |
| check("closed Running intervals", len(run_iv), 257) | |
| check("Running spans still open at the extract horizon (log ends mid-run)", | |
| len(run_state), 1) | |
| check("max simultaneous Running tasks", conc_max, 2) | |
| check("overlapping Running pairs (two tasks at once)", conc_pairs, 10) | |
| check("watchdog: modal Running→ActionRequired span (s)", wd_mode, 61) | |
| check("banners at that modal span", wd_mode_n, 16) | |
| check("successful runs longer than the watchdog span", (ok_over, len(ok_span)), (155, 194)) | |
| check("phase transition lines", len(ph_raw), 885) | |
| check("conversations with phase data", len(ph_by_sess), 9) | |
| check("prompts sent (user_message_chunk)", prompts, 252) | |
| check("what suspended a turn", dict(suspend_cause), | |
| {"resume_tool_call": 33, "permission_request": 37}) | |
| check("banner holds that were resumed (sess-03's last never was)", len(hold_banner), 32) | |
| check("median wait for the first streamed chunk (s)", | |
| round(statistics_median(sorted(wait_first)), 1), 9.6) | |
| check("prompts answered with an error before any chunk", len(fastfail), 4) | |
| check("successful generations longer than the watchdog span", | |
| (sum(1 for g in gen_ok if g > wd_mode), len(gen_ok)), (149, 208)) | |
| check("total operator hold on banners (min)", round(sum(hold_banner) / 60, 1), 90.5) | |
| check("total operator hold on permission dialogs (min)", round(sum(hold_perm) / 60, 1), 122.0) | |
| # ---- cross-document consistency (the paper and the case report must not drift) -- | |
| # Both were corrected during the second collection round; a fix applied to one and | |
| # not the other is exactly the failure mode this guards, so the retired wordings are | |
| # forbidden outright and the shared figures must appear in both narratives. | |
| DOCS = [doc for doc in (EV.parent / n for n in ("report_qwenAliServiceQuality.md", | |
| "paper_ai_QoS.md", "methodology.md", "README.md", "abstract.md")) if doc.exists()] | |
| # The dataset repository ships the data layer only, so the narratives may be absent; | |
| # their absence is reported as a skip, never as a silent pass. | |
| NARRATIVES = [doc for doc in DOCS if doc.name in | |
| ("report_qwenAliServiceQuality.md", "paper_ai_QoS.md")] | |
| RETIRED = ["no per-request token usage is logged", "No per-request token usage exists client-side", | |
| "checked — zero hits", | |
| "same window3 session", "Deepest session in window", | |
| "62 requests across three", "requests, three conversations, columns", | |
| "largest *active* contexts", "is not documented and was not measured"] | |
| SHARED = ["490,789", "494,193", "452,447", "117,153", "episode"] | |
| drift = [] | |
| for doc in DOCS: | |
| body = doc.read_text(errors="replace") | |
| drift += [f"{doc.name}: retired wording still present: {phrase!r}" | |
| for phrase in RETIRED if phrase in body] | |
| for doc in NARRATIVES: | |
| body = doc.read_text(errors="replace") | |
| drift += [f"{doc.name}: shared figure missing: {figure!r}" | |
| for figure in SHARED if figure not in body] | |
| if NARRATIVES: | |
| check("no drift between the paper and the case report", drift, []) | |
| else: | |
| print(" SKIP no drift check: the paper and the case report are not in this " | |
| "checkout (data-layer repository)") | |
| # ---- release notice: one text, one version, present everywhere ---- | |
| NOTICE_DATE = "2026-09-11" | |
| RELEASED = "1.0.2" # the released version; CITATION.cff must carry this same string | |
| NOTICE_MARK = f"**Released {NOTICE_DATE} as v{RELEASED}**" | |
| PUBLISHED_NAMES = ("paper_ai_QoS.md", "report_qwenAliServiceQuality.md", "README.md", | |
| "abstract.md", "methodology.md", "anonymization.md", "ask_vendor.md", | |
| "DATA_REQUEST.md", "DATASET_CARD.md") | |
| def tracked_here() -> set[str] | None: | |
| """Paths git tracks, but only at the top level of a repository: `git ls-files` lists what is | |
| tracked *under* the current directory, so asking it from a staging directory would return an | |
| empty set and make every published file look unpublished.""" | |
| try: | |
| prefix = subprocess.run(["git", "-C", str(EV.parent), "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(EV.parent), "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_here() | |
| # "Published document" means a document in the published set, not merely a file on this disk: | |
| # zenodo/README.md moved to the private workshop repository and is no longer a reader's file. | |
| PUB_DOCS = [doc for doc in (EV.parent / n for n in PUBLISHED_NAMES) | |
| if doc.exists() and (TRACKED is None or doc.relative_to(EV.parent).as_posix() in TRACKED)] | |
| def where(doc) -> str: | |
| """Relative path, never a bare name: zenodo/README.md and README.md share a name, and a | |
| failure that names only "README.md" sends the reader to the wrong file.""" | |
| return doc.relative_to(EV.parent).as_posix() | |
| notice_problems = [where(doc) for doc in PUB_DOCS | |
| if NOTICE_MARK not in doc.read_text(errors="replace")] | |
| if PUB_DOCS: | |
| check(f"release notice {NOTICE_MARK} present in every published document", | |
| notice_problems, []) | |
| # The version lives in two places, so one is checked against the other: a notice that names a | |
| # version CITATION.cff does not would send a citation to a snapshot that is not this one. | |
| cff = EV.parent / "CITATION.cff" | |
| cff_found = re.search(r'^version: "([^"]+)"', cff.read_text(errors="replace"), re.M) if cff.exists() else None | |
| if cff.exists(): | |
| check("CITATION.cff and the release notices carry the same version", | |
| cff_found.group(1) if cff_found else "unreadable", RELEASED) | |
| late = [doc.name for doc in PUB_DOCS | |
| if datetime.fromtimestamp(doc.stat().st_mtime).date() > datetime.strptime(NOTICE_DATE, "%Y-%m-%d").date()] | |
| if late: | |
| print(" ADVISORY: edited after the release date — a released snapshot is frozen, so " | |
| "these edits belong in the next version: " + ", ".join(sorted(late))) | |
| else: | |
| print(" SKIP release notice check: no published documents in this checkout (data layer)") | |
| # ---- authorship: one handle, no institution, anywhere in the public set ---- | |
| BYLINE = "independent, unaffiliated" | |
| # By relative path, not by name: zenodo/README.md and the root README.md share a name. | |
| BYLINE_DOCS = ("paper_ai_QoS.md", "DATASET_CARD.md", "abstract.md", "README.md") | |
| byline_docs = [doc for doc in PUB_DOCS | |
| if doc.parent == EV.parent and doc.name in BYLINE_DOCS] | |
| if byline_docs: | |
| check("authorship stated as independent and unaffiliated in every document that carries a byline", | |
| [where(doc) for doc in byline_docs if BYLINE not in doc.read_text(errors="replace")], []) | |
| zen = [p for p in (EV.parent / "zenodo" / "deposit-dataset.json", EV.parent / ".zenodo.json") | |
| if p.exists()] | |
| bad = [] | |
| for p in zen: | |
| creators = json.loads(p.read_text()).get("creators") or [] | |
| if len(creators) != 1 or creators[0].get("name") != "2makeitwork" \ | |
| or creators[0].get("affiliation", ""): | |
| bad.append(p.name) | |
| if zen: | |
| check("archive metadata carries the pseudonym with an empty affiliation", bad, []) | |
| # ---- published documents must not send a reader to a file that is not published ---- | |
| PRIVATE = ["PUBLICATION.md", "prior-works.md", "methodology_guidance"] | |
| DISCLOSED = ["not published", "not part of", "deliberately", "private", "ignored", | |
| "working notes", "kept local", "no reading obligation"] | |
| private_problems = [] | |
| for doc in [d for d in PUB_DOCS if d.name != "PUBLICATION.md"]: | |
| body = doc.read_text(errors="replace") | |
| for n, line in enumerate(body.splitlines(), 1): | |
| named = [p for p in PRIVATE if p in line] | |
| if named and not any(w in line.lower() for w in DISCLOSED): | |
| private_problems.append(f"{where(doc)}:{n} names {named[0]} without saying it is unpublished") | |
| if PUB_DOCS: | |
| check("no published document points a reader at a private file without saying so", | |
| private_problems, []) | |
| # ---- counts belong to the script's output, not to prose ---- | |
| # scripts/analyze.py prints one line per check, so the total is whatever a run reports. Quoting | |
| # it in a document is a claim with a shelf life: the dataset card said "50", then "52", while the | |
| # script was already at 56, and no gate failed. A count is therefore allowed only where the | |
| # passage says it was measured and on which date - the same date the notices carry, so bumping | |
| # the revision date forces the counts to be re-measured rather than left behind. | |
| COUNT_RE = re.compile(r"\b(\d{2,3})\s+(?:assertions?\b|published figures?\b|checks\b)") | |
| DATE_RE = re.compile(r"measured|re-runs|attempt", re.I) | |
| def section_of(lines: list[str], at: int) -> str: | |
| """The markdown section a line belongs to, by heading boundaries.""" | |
| start = 0 | |
| for i in range(at - 1, -1, -1): | |
| if lines[i].startswith("#"): | |
| start = i | |
| break | |
| end = len(lines) | |
| for i in range(at, len(lines)): | |
| if lines[i].startswith("#"): | |
| end = i | |
| break | |
| return "\n".join(lines[start:end]) | |
| count_problems = [] | |
| for doc in PUB_DOCS: | |
| body_lines = doc.read_text(errors="replace").splitlines() | |
| for n, line in enumerate(body_lines, 1): | |
| found = COUNT_RE.search(line) | |
| if not found: | |
| continue | |
| section = section_of(body_lines, n - 1) | |
| if NOTICE_DATE not in section or not DATE_RE.search(section): | |
| count_problems.append(f"{where(doc)}:{n}: {found.group(0)!r} quoted in a section that " | |
| f"does not date the measurement (need {NOTICE_DATE} + 'measured')") | |
| 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"{where(doc)}:{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 if TRACKED is not None else 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 | |
| # running the release, and once published it sits on a public page. So the note is authored | |
| # in RELEASE_NOTES.md, scanned here, and pushed with | |
| # gh release edit <tag> --notes-file RELEASE_NOTES.md | |
| # The list was narrowed on 2026-09-11. It used to forbid the words "zenodo", "integration" and | |
| # "archived" outright, which was right when the only such sentence was pipeline instruction and is | |
| # wrong now that a published archive with an identifier exists: naming the archive and its | |
| # identifier is what a reader of a release needs. What stays forbidden is the mechanics - what has | |
| # to be enabled, what a draft does not trigger, which page to click, which token to revoke. | |
| MACHINERY = ["must be enabled", "never archived", "binary asset", "draft release", "edit page", | |
| "access token", "revoke", "integration watches", "sync_draft", "deposit.sh", | |
| "before the release is published", "not published as a"] | |
| release_notes = EV.parent / "RELEASE_NOTES.md" | |
| if release_notes.exists(): | |
| note_hits = [w for w in MACHINERY if w in release_notes.read_text(errors="replace").lower()] | |
| check("RELEASE_NOTES.md describes the release, not the publishing machinery", note_hits, []) | |
| # ---- CITATION.cff must be a citation file the format can read ---- | |
| # The file invented a `versions:` key and declared cff-version 1.3.0, neither of which exists: | |
| # checked against the official schema (github.com/citation-file-format, fetched 2026-09-11), whose | |
| # additionalProperties is false, so an invented key is a validation error and the invented history | |
| # block would be dropped by every converter. Keys are now prose comments, and the check fails on | |
| # any top-level key outside the schema's list. | |
| CFF_KEYS = {"abstract", "authors", "cff-version", "commit", "contact", "date-released", "doi", | |
| "identifiers", "keywords", "license", "license-url", "message", "preferred-citation", | |
| "references", "repository", "repository-artifact", "repository-code", "title", "type", | |
| "url", "version"} | |
| cff_file = EV.parent / "CITATION.cff" | |
| if cff_file.exists(): | |
| cff_text = cff_file.read_text(errors="replace") | |
| cff_top = [m.group(1) for m in re.finditer(r"^([A-Za-z][A-Za-z-]*):", cff_text, re.M)] | |
| check("CITATION.cff uses only keys the Citation File Format defines", | |
| sorted({k for k in cff_top if k not in CFF_KEYS}), []) | |
| check("CITATION.cff declares a cff-version the schema accepts", | |
| re.findall(r"^cff-version: (\S+)", cff_text, re.M), ["1.2.0"]) | |
| # ---- summary tables ---------------------------------------------------------- | |
| out = ["# Analysis summary (generated by scripts/analyze.py from evidence/)", "", | |
| "## Timeout (80408) events", "", | |
| f"- total: **{len(rows)}**, all `reasonForCode: 80408`", | |
| f"- per day: " + ", ".join(f"{d}: {n}" for d, n in sorted(per_day.items())), | |
| f"- densest 75-minute block: **{block_n} events** (the resume-button loop)", ""] | |
| out += ["## Quota/account events", "", | |
| f"- log lines: {len(qtimes)} → clustered (≤2 s apart): **{len(events)} events**", | |
| f"- distinct codes seen: {', '.join(codes_seen)}", | |
| f"- distinct message wordings: {len(payloads)}", ""] | |
| for p in payloads: | |
| out.append(f" - `{p[:100]}`") | |
| out += ["", "## chat_finish census", "", | |
| f"- {c_total} lines total: {c_success} `success:200`, {c_total - c_success} error payloads,", | |
| f" **zero attributable to the {len(rows)} timeout events** (no chat_finish line exists for them)", ""] | |
| out += ["## Three largest sessions (transcript entries)", "", | |
| "| session | entries | jsonl bytes |", "|---|---|---|"] | |
| for r in big: | |
| out.append(f"| `{r[1]}` | {r[3]} | {r[2]} |") | |
| out += ["", "## Task lifecycle (`quest.log` — the client's `task` = one conversation)", "", | |
| f"- {len(tl)} log lines → **{len(task_ev)} events** after ≤2 s de-dup " | |
| f"({task_windows} events replicated into ≥2 IDE windows, " | |
| f"{tl_dupes} `.skipNonQuestTask` twins dropped)", | |
| "- statuses: " + ", ".join(f"{k} {v}" for k, v in sorted(task_status.items())), | |
| f"- `Running` spans: {len(run_iv)} closed" + | |
| (f", {len(run_state)} still open at the extract horizon" if run_state else "") + | |
| f"; median {statistics_median(run_dur):.0f} s, " | |
| f"90th percentile {run_dur[int(0.9 * len(run_dur))]:.0f} s, max {max(run_dur):.0f} s", | |
| f"- **max simultaneous `Running` tasks: {conc_max}** (never 3+; " | |
| f"{conc_pairs} overlapping pairs of conversations), " | |
| "`error.code.task.running.quota.exceeded` fired 0 times, so that ceiling is " | |
| "only bounded ≥2", | |
| f"- `ActionRequired` (banner up, nothing generating): {len(ar)} events, 1:1 with " | |
| f"the {len(rows)} timeout resume lines (largest offset {ar_max_off * 1000:.0f} ms)", | |
| "- conversation-level split of those timeouts, which supersedes the " | |
| "window-level correlation in report §4.2: " | |
| + ", ".join(f"`{s}` {n}" for s, n in sorted(ar_per_sess.items())), | |
| f"- watchdog measured off the state machine: **{wd_mode} s of silence** before the " | |
| f"banner ({wd_mode_n} of {len(wd_span)} banners at exactly that span; the rest are " | |
| "mid-run stalls after some output), and " | |
| f"{ok_over} of {len(ok_span)} *successful* runs ran longer than that span — so it " | |
| "caps inactivity, not total duration", ""] | |
| out += ["", "## Per-interaction phase timing (`[ACPProgressStateMachine]`)", "", | |
| f"- {len(ph_raw)} transitions over {len(ph_by_sess)} conversations: " | |
| f"{prompts} prompts sent, {len(wait_first)} answered with a first streamed chunk, " | |
| f"{len(fastfail)} rejected before any chunk, {len(gen_ok)} generations finished", | |
| f"- **wait for the first chunk** (`prompting` → `streaming`, the UI's " | |
| f"'Thinking…'): median **{statistics_median(sorted(wait_first)):.1f} s**, " | |
| f"90th percentile {sorted(wait_first)[int(0.9 * len(wait_first))]:.0f} s, " | |
| f"max {max(wait_first):.0f} s, min {min(wait_first):.1f} s", | |
| f"- generation time (`streaming` → `chat_finish:success`): median " | |
| f"{statistics_median(sorted(gen_ok)):.0f} s, " | |
| f"90th percentile {sorted(gen_ok)[int(0.9 * len(gen_ok))]:.0f} s, max {max(gen_ok):.0f} s; " | |
| f"{sum(1 for g in gen_ok if g > wd_mode)} of {len(gen_ok)} exceed the " | |
| f"{wd_mode} s watchdog span", | |
| "- what suspended a turn: " + ", ".join(f"{k} {v}" for k, v in sorted(suspend_cause.items())) | |
| + " (`resume_tool_call` = the 80408 banner, a third stream confirming 33)", | |
| f"- operator hold: banners {len(hold_banner)} resumed, median " | |
| f"{statistics_median(sorted(hold_banner)):.0f} s, total {sum(hold_banner) / 60:.1f} min; " | |
| f"permission dialogs {len(hold_perm)}, median " | |
| f"{statistics_median(sorted(hold_perm)):.0f} s, total {sum(hold_perm) / 60:.1f} min", ""] | |
| # The footer carries both: a content hash that machines compare, and a second-precision | |
| # timestamp a person reads. It is appended at the very end so the hash covers the whole | |
| # document; scripts/check_release_sync.py compares that hash and ignores the time, so a | |
| # rebuild with the same statistics is recognised as identical rather than reported as drift. | |
| out += ["", "## Request lifecycle (frozen log snapshot; scripts/latency_from_logs.py)", "", | |
| f"- {len(lc)} requests across {len({r[0] for r in lc})} sessions — S {len(_succ)}, T {len(_stall)} (timeout {len(_tto)} / dialog {len(_tdi)}), F/U {len(lc) - len(_succ) - len(_stall)}", | |
| f"- first-attempt usable (0-retry S) **{_fau}/{len(_succ)} ({100*_fau//len(_succ)}%)**", | |
| f"- first-chunk wait median {_p50(_ttft)}s (n={len(_ttft)}); clean-success turn total " | |
| f"median {_p50(_tot)}s (n={len(_tot)}); send-to-stall median {_p50(_stv)}s (n={len(_stv)})", ""] | |
| out += ["", "## Incident 2 — collection round of 2026-09-10 (`evidence/incident_20260910/`)", "", | |
| f"- {len(i2)} request episodes (55 distinct submitted prompts) in 3 conversations on the observation day: " | |
| f"{sum(1 for r in i2 if r[2] == 'S')} completed, {len(i2_to)} timeout parks, " | |
| f"{len(i2_dlg)} dialog parks, {sum(1 for r in i2 if r[2] in ('F', 'U'))} failed/cancelled", | |
| f"- the five timeouts all sit in one conversation at **{min(i2_to_ctx):,} tokens**; " | |
| f"the largest context that still completed that day is **{max(i2_s_ok):,} tokens** — " | |
| f"a {max(i2_s_ok):,}-versus-{min(i2_to_ctx):,} separation on the day " | |
| "(round 1 pooled data does NOT separate cleanly; see report §4.2)", | |
| f"- send-to-stall spanned {min(float(r[5]) for r in i2_to):.0f}s to " | |
| f"{max(float(r[5]) for r in i2_to):.0f}s (the upper value is a banner left parked " | |
| "for 81 minutes)", | |
| "- paired experiment: the same conversation stalled five times at 494,193 tokens, then " | |
| "after the client's context-compaction control reported 117,153 tokens " | |
| "(`Compression API call completed for session compact`) a request carrying 85,115 " | |
| "tokens completed in 10.1 s — report §9", | |
| "- three negative results from this round: tab visibility (a hidden conversation " | |
| "completed in 2.58 s), server-side cache residency across a 27.7-minute idle gap " | |
| "(17.11 s versus 17.58 s at the same size), and inflating an agent's context by " | |
| "asking it to read files (one such turn added 851 tokens)", ""] | |
| OUT.parent.mkdir(parents=True, exist_ok=True) | |
| # The stamp records when the content last changed, not when the script last ran: a verification | |
| # run must not make the working tree dirty, which is what preflight.sh's clean-tree check relies | |
| # on. The hash covers the whole document, footer excluded, so two copies with the same hash hold | |
| # the same statistics whatever their stamps say. | |
| body = "\n".join(out).rstrip("\n") # canonical: trailing newlines are not part of the content | |
| content_sha = hashlib.sha256(body.encode()).hexdigest() | |
| previous = OUT.read_text(errors="replace") if OUT.exists() else "" | |
| MARKER = "\nContent hash `sha256:" | |
| idx = previous.rfind(MARKER) | |
| previous_body = previous[:idx].rstrip("\n") if idx != -1 else None | |
| keep_stamp = previous_body is not None and hashlib.sha256(previous_body.encode()).hexdigest() == content_sha | |
| if not keep_stamp: | |
| OUT.write_text(body + f"\n\nContent hash `sha256:{content_sha}` - generated " | |
| f"{datetime.now():%Y-%m-%d %H:%M:%S} - rerun: " | |
| "`python3 scripts/analyze.py`\n") | |
| print(f"\nwrote {OUT.relative_to(EV.parent)}" if not keep_stamp else | |
| f"{OUT.relative_to(EV.parent)} unchanged (content hash matches, stamp kept)") | |
| # ---- a count quoted in the documents must equal this run's count ---- | |
| # The dated-measurement rule above keeps a quoted number from going stale silently; this keeps | |
| # it from being wrong. Deliberately only in the source repository: a data-layer checkout skips | |
| # the checks that read the paper and the case report, so its smaller total is correct behaviour, | |
| # not drift. Printed as a note rather than a PASS line, so "how many assertions passed" keeps | |
| # meaning "how many check() calls succeeded" and nothing else. | |
| if NARRATIVES: | |
| quoted = {doc.name: [int(m.group(1)) for m in | |
| re.finditer(r"\b(\d+) assertions pass", doc.read_text(errors="replace"))] | |
| for doc in PUB_DOCS} | |
| wrong = {name: nums for name, nums in quoted.items() | |
| if any(n != checks_done for n in nums)} | |
| if wrong: | |
| fails.append("documented assertion count") | |
| print(f" FAIL {wrong} quoted in the documents, but this run performed {checks_done} " | |
| f"checks - update the number where it is quoted", file=sys.stderr) | |
| elif any(quoted.values()): | |
| print(f" note: the assertion count quoted in the documents equals this run " | |
| f"({checks_done} checks)") | |
| if fails: | |
| print(f"FAILED: {fails}", file=sys.stderr) | |
| sys.exit(1) | |
| print("all report numbers verified against evidence") | |