Add the measurement corpus: 8,199 runs, 110,711 ledger events, 14,008 refusals, with scorer and verifier

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+events.jsonl filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,245 @@
 ---
 license: mit
+language:
+  - en
+pretty_name: "Database agent runs: 8,199 tool-calling runs across 40 language models"
+size_categories:
+  - 100K<n<1M
+task_categories:
+  - other
+tags:
+  - agents
+  - tool-use
+  - function-calling
+  - benchmark
+  - failure-analysis
+  - sql
+  - database
+  - small-language-models
+  - ollama
+  - local-inference
+configs:
+  - config_name: runs
+    data_files: runs.jsonl
+  - config_name: events
+    data_files: events.jsonl
+  - config_name: refusals
+    data_files: refusals.jsonl
 ---
+
+# LibreDB Agent Benchmark
+
+**8,199 agent runs · 39 open-weight models served locally, plus one hosted model as a control · 6 task surfaces · 110,711 ledger events · 14,008 refused tool calls**
+
+This is the complete measurement record behind the paper *What Stops a Small Language Model From
+Driving a Database Agent*. It is not a scored summary: it is every event the server wrote while the
+runs happened, released so that every number in the paper can be recomputed — and disagreed with —
+without re-running anything.
+
+The headline finding is that **capability is the smallest failure class**. Of 2,194 losses by a
+named model, only 17.0% are runs that never engaged a tool. The other 83% did the work and lost it
+at the interface.
+
+## What was measured
+
+LibreDB Studio ships an agent mode that performs read-only database work through a fixed tool
+contract, with a server-side verifier that decides whether each run answered its objective. Six
+**surfaces** were driven: five in agent mode (`investigation`, `query-optimization`,
+`database-assessment`, `operations`, `data-analysis`) and one in `planning` mode. Each has its own
+objective, tool set and verifier.
+
+Every claim a report makes must cite an artifact the run actually produced — the correlation id of a
+completed read, or the fingerprint of the schema snapshot it captured. Citations are checked against
+the run's own ledger and refused if they do not resolve. This anti-hallucination rule is also a
+major source of loss, and `refusals.jsonl` is where that shows.
+
+Models were served locally through **Ollama 0.33.0** on an Apple M5 Max with 64 GB of unified
+memory, against a fixed synthetic employee/department/salary SQLite schema. One hosted model
+(`gemini-3.5-flash-lite`) is included as a control. **No real or customer database was connected at
+any point.**
+
+## Files
+
+| File | Rows | One row is |
+|---|---|---|
+| `runs.jsonl` | 8,199 | one agent run: model, surface, verdict, shortfall, tool/refusal/guidance histograms, loss class |
+| `events.jsonl` | 110,711 | one ledger event, with its offset from the start of its run |
+| `refusals.jsonl` | 14,008 | one refused or declined tool call: tool, reason code, the validator's field paths |
+
+`events.jsonl` is the evidence; `runs.jsonl` and the loss taxonomy are an *interpretation of* it.
+That separation is deliberate — swap `classify()` in the exporter and the corpus reclassifies
+without the data changing.
+
+### `runs.jsonl` fields
+
+| Field | Notes |
+|---|---|
+| `run_id` | joins to `events.jsonl` and `refusals.jsonl` |
+| `worktree` | which checkout of the server the run executed against — **the code under test differed between them**, so do not pool across this field without saying so |
+| `model`, `provider`, `tuning_origin` | `tuning_origin` is `bundled` when the model carried a measured profile |
+| `mode`, `surface`, `verifier` | `surface` is derived from the verifier id |
+| `status` | process outcome. **`succeeded` is not a pass** — a run that reported nothing also exits successfully |
+| `outcome` | `answered` / `unanswered`: the verifier's judgement, and the only pass/fail label |
+| `unmet` | what was missing (`no-report`, `no-answer`, `no-plan`, …) |
+| `stop_reason` | `report-composed`, `model-stopped`, `model-timeout`, `turn-limit`, `deadline-exceeded` |
+| `loss_class` | `transport` / `clock` / `verification` / `capability`, empty when answered |
+| `tools`, `refusals`, `guidance` | histograms, e.g. `{"inspect_schema": 3}` |
+| `order` | rank of this run within its worktree. **Load-bearing:** the protocol scores five *consecutive* passes, which cannot be recovered without it |
+| `elapsed_ms`, `event_count`, `stopped_saying_chars` | |
+
+Absolute timestamps are not published — when this machine ran a sweep is not part of the finding —
+but `order` preserves sequence, which is.
+
+## The protocol, and how to score it
+
+The unit is a **cell**: one model on one surface, five consecutive runs against a fixed objective.
+Five consecutive passes locks the cell. A model is complete at **30/30** — six cells × five runs.
+Scores are reported as the pair (`27/30`), never a percentage, because the denominator is what makes
+two readings comparable.
+
+```
+python3 score.py runs.jsonl --mode row      # the protocol
+python3 score.py runs.jsonl --mode pooled   # the naive reading, for comparison
+```
+
+`score.py` has three modes and **the gap between them is the most important thing in this
+benchmark**:
+
+- **`pooled`** — any five-in-a-row anywhere in a cell's history. The obvious implementation.
+- **`session`** — the five passes must fall inside one contiguous sitting of that cell. Fixes
+  pooling *within* a cell.
+- **`row`** (default, and the protocol) — all six cells must lock inside **one sitting of the
+  model**. Fixes pooling *between* cells, which is where the error actually lives.
+
+Measured on this corpus, `pooled` and `session` both report `llama3.1:8b` and `cogito:8b` at 6/6 and
+30/30. `row` reports 23/30 for both. Re-reading those two models by hand — six surfaces, one
+sitting — returned 24/30 and 21/30. **The looser readings overstate by seven points**, and they do
+it while every underlying cell genuinely is 5/5. Six cells locked on six different days is six
+results, not one row, and a row is what a deployment gets.
+
+If you publish a number from this dataset, publish the `row` number.
+
+## Leaderboard (`--mode row`, models with ≥30 runs)
+
+`*` marks a locked cell. `inv`/`que`/`dat`/`ope`/`dat`/`pla` are investigation, query-optimization,
+database-assessment, operations, data-analysis, planning.
+
+| Model | runs | inv | que | ass | ope | ana | pla | of 30 | cells |
+|---|---|---|---|---|---|---|---|---|---|
+| `qwen3:4b` | 73 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | **30/30** | 6/6 |
+| `qwen3.6:35b` | 137 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | **30/30** | 6/6 |
+| `qwen3.5:27b` | 30 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | **30/30** | 6/6 |
+| `qwen3-coder:30b` | 71 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | **30/30** | 6/6 |
+| `gpt-oss:20b` | 272 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | **30/30** | 6/6 |
+| `granite4.2:3b` | 131 | 5/5* | 5/5* | 5/5* | 5/5* | 3/5 | 5/5* | 28/30 | 5/6 |
+| `gemini-3.5-flash-lite` (hosted) | 90 | 5/5* | 3/5 | 5/5* | 5/5* | 5/5* | 5/5* | 28/30 | 5/6 |
+| `qwq:32b` | 50 | 5/5* | 4/5 | 4/5 | 5/5* | 5/5* | 5/5* | 28/30 | 4/6 |
+| `deepseek-r1:8b` | 383 | 5/5* | 2/5 | 5/5* | 5/5* | 5/5* | 5/5* | 27/30 | 5/6 |
+| `mistral-small3.2:24b` | 548 | 5/5* | 5/5* | 5/5* | 5/5* | — | 5/5* | 25/30 | 5/6 |
+| `granite4:3b` | 85 | 5/5* | 5/5* | 5/5* | 5/5* | 0/5 | 5/5* | 25/30 | 5/6 |
+| `magistral:24b` | 49 | 3/5 | 5/5* | 5/5* | 5/5* | 2/5 | 5/5* | 25/30 | 4/6 |
+| `glm-4.7-flash` | 217 | 5/5* | 2/5 | 5/5* | 5/5* | 5/5* | 3/5 | 25/30 | 4/6 |
+| `mistral-nemo:12b` | 398 | 5/5* | 1/5 | 5/5* | 5/5* | 3/5 | 5/5* | 24/30 | 4/6 |
+| `llama3.1:8b` | 629 | 5/5* | 2/5 | 5/5* | 5/5* | 1/5 | 5/5* | 23/30 | 4/6 |
+| `granite4.1:3b` | 70 | 5/5* | 1/5 | 5/5* | 5/5* | 2/5 | 5/5* | 23/30 | 4/6 |
+| `cogito:8b` | 551 | 5/5* | 4/5 | 0/5 | 4/5 | 5/5* | 5/5* | 23/30 | 3/6 |
+| `ministral-3:3b` | 119 | 5/5* | 3/5 | 2/5 | 4/5 | 4/5 | 5/5* | 23/30 | 2/6 |
+| `phi4-mini:3.8b` | 30 | 2/5 | 5/5* | 5/5* | 5/5* | 0/5 | 5/5* | 22/30 | 4/6 |
+| `command-r7b:7b` | 115 | 5/5* | 3/5 | 0/5 | 5/5* | 2/5 | 5/5* | 20/30 | 3/6 |
+
+Full output for all 31 qualifying models: run `score.py`, or see `leaderboard-row.txt`.
+
+**This leaderboard is a property of the corpus, not of the product.** LibreDB Studio ships 35 models
+verified at 30/30 under their own measured per-model settings; most of those verification sittings
+predate the ledger fields this dataset needs, so they do not appear here at 6/6. Read this table as
+"what these 8,199 runs support", which is the only thing a released dataset can honestly claim.
+
+## The failure taxonomy
+
+Each loss is classified by what the ledger shows the run did (`classify()` in `hf-export.py`):
+
+| Class | Definition | Count | Share |
+|---|---|---|---|
+| **transport** | invoked tools, did not run out of time, never got a deliverable through | 761 | **34.7%** |
+| **clock** | `model-timeout`, `turn-limit`, or `deadline-exceeded` | 626 | 28.5% |
+| **verification** | filed a report and was still `unanswered` — citations did not resolve | 434 | 19.8% |
+| **capability** | invoked no tool at all | 373 | **17.0%** |
+
+Pass rate by surface (named-model runs):
+
+| Surface | n | answered | rate |
+|---|---|---|---|
+| `planning` | 560 | 466 | 83.2% |
+| `investigation` | 550 | 389 | 70.7% |
+| `operations` | 603 | 399 | 66.2% |
+| `database-assessment` | 614 | 342 | 55.7% |
+| `query-optimization` | 1,360 | 639 | 47.0% |
+| `data-analysis` | 1,201 | 464 | 38.6% |
+
+The ordering tracks how many schema-constrained artifacts a surface requires, not how hard its
+question is. The two hardest both demand a second structured deliverable beyond the report.
+
+Refusals concentrate hard: `compose_report` accounts for 9,669 of 14,008 — 6,205
+`INVALID_TOOL_INPUT` and 3,464 `UNVERIFIABLE_EVIDENCE`. The one tool that turns completed work into
+a delivered answer is where two thirds of all refusals happen.
+
+## Known limitations — read these before using the numbers
+
+1. **Unbounded context is a memory confound, and this corpus contains it.** With no
+   `OLLAMA_CONTEXT_LENGTH` set, Ollama admits each model at its full advertised window.
+   `mistral-nemo:12b` — 7.1 GB on disk — was resident at **51 GB with a 262,144-token context** on a
+   64 GB machine; free memory fell to 6%. Runs taken in that state are not measurements: one
+   `granite4.2:3b` `planning` cell read 0/5 with all five runs hitting the 90-second turn limit
+   having invoked no tool, and read 5/5 with the context capped at 32,768. **All figures here were
+   taken before the cap**, so treat them as a lower bound with unknown per-model bias — models with
+   larger advertised contexts were penalised more. Anyone benchmarking local models should check
+   `ollama ps` and its CONTEXT column; note that `Ollama.app` reclaims port 11434 and `launchctl
+   setenv` does not reach it, so a capped `ollama serve` can silently fail to bind while the
+   uncapped server answers.
+2. **Unequal sampling.** Runs per model range from 20 to 629 and were allocated by operational
+   interest, not by design. This is not a randomised comparison. The taxonomy shares over 2,194
+   losses are the more robust figure; per-model rates have very unequal confidence.
+3. **3,248 runs carry no model.** They predate the `driver-resolved` ledger event. They are in
+   `events.jsonl` and excluded from every per-model figure. Whole-corpus and attributed-only
+   taxonomy shares agree within 2.7 points on every class.
+4. **The `worktree` field is a code version.** Runs in different worktrees executed against
+   different builds — including builds before and after five server-side fixes this work produced.
+   Pooling across it silently mixes conditions.
+5. **One machine, one schema, one agent implementation.** The surface ordering and the taxonomy are
+   properties of *this* tool contract. A contract with fewer structured artifacts per surface should
+   show a smaller transport class — a testable prediction, not a caveat.
+6. **The 450 ms run deadline was never raised.** `deepseek-r1:8b`'s `query-optimization` cell passes
+   at 443 s and 444 s and fails at the deadline. Raising it would likely close the cell; it is part
+   of the shipped product configuration, and a model that only passes outside it has not been shown
+   to work for a user.
+7. **Models refused before the first turn are a distinct phenomenon.** `olmo-3:7b`, `phi4:14b`,
+   `command-r:35b` and `falcon3:10b` are refused by the inference server with
+   `HTTP 400 … does not support tools`; `qwen2:7b`'s capability probe disproves schema-valid tool
+   arguments. Their `planning` cells still pass 5/5, since planning needs no tools. Scoring these as
+   0/30 without distinguishing *refused at the transport* from *tried and failed* reports two
+   different things in one number.
+
+## Privacy
+
+The ledger is server-authored. The export drops any field named like a credential, and the released
+files were scanned for key patterns, bearer tokens, private-key blocks, filesystem paths and email
+addresses. The only match is `johndoe@email.com`, a row in the synthetic sample database the agent
+read during a run.
+
+## Reproducing
+
+`hf-export.py` (in the paper package) builds all three files from the raw ledgers. The ledger format
+is one framed JSON object per chunk file: byte 0 is a marker, the JSON begins at byte 1, and the
+event is under `.event`.
+
+## Citation
+
+```bibtex
+@misc{libredb2026agentruns,
+  title  = {What Stops a Small Language Model From Driving a Database Agent},
+  author = {Bozoğlan, Cevheri and Gündoğdu, Yusuf and Kaya, Abdullah and Şirin, Koray},
+  year   = {2026},
+  note   = {Dataset: 8,199 database-agent runs across 40 models, with the reference scorer
+            and a verifier that regenerates every figure in the paper}
+}
+```

events.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a5945b211dd1f61fd7066821b89d49ce83806ddf99218e0400aee7a777610245
+size 72791511

hf-export.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""Export the whole measurement corpus as a HuggingFace-ready dataset.
+
+Three files, because three different questions are asked of this corpus and one table cannot serve
+all of them:
+
+  runs.jsonl      one object per agent run - the unit a pass/fail verdict attaches to. This is the
+                  table for "which models pass what", and it carries the verdict, the shortfall, the
+                  tool histogram, the refusal histogram and the guidance histogram inline.
+
+  events.jsonl    one object per ledger event, ~127k rows. This is the raw record and the reason the
+                  dataset is worth releasing at all: it lets a reader recompute every number in the
+                  paper, and disagree with the taxonomy without re-running anything. The taxonomy in
+                  the paper is an interpretation OF this file, not a property of it.
+
+  refusals.jsonl  every refused or declined tool call, with the tool, the reason code and the
+                  validator's field paths. Split out because it is the paper's central evidence and
+                  is otherwise buried under the event stream.
+
+Redaction: the ledger is server-authored and holds no credentials by construction, but this export
+leaves the machine, so `scrub` below drops the two fields that could carry a key if a future event
+shape ever did, and every value is passed through a secret pattern check by the caller. The sample
+database is the synthetic employee/department/salary schema shipped with the product; no real data
+was ever connected during these runs.
+"""
+import glob
+import json
+import os
+import sys
+from collections import Counter, defaultdict
+
+WORKTREES = [
+    "/home/researcher/projects/libredb/lb-guncel",
+    "/home/researcher/projects/libredb/lb-yeni",
+    "/home/researcher/projects/libredb/lb-main-test",
+    "/home/researcher/projects/libredb/lb-fix",
+    "/home/researcher/projects/libredb/libredb-studio",
+]
+
+# Never exported, whatever a future event shape puts in them.
+DROP_KEYS = {"apiKey", "api_key", "authorization", "token", "password", "secret", "connectionString"}
+
+CLOCK = {"model-timeout", "turn-limit", "deadline-exceeded"}
+
+
+def scrub(value):
+    if isinstance(value, dict):
+        return {k: scrub(v) for k, v in value.items() if k not in DROP_KEYS}
+    if isinstance(value, list):
+        return [scrub(v) for v in value]
+    return value
+
+
+def read_event(path):
+    try:
+        with open(path, "rb") as handle:
+            raw = handle.read()
+        return json.loads(raw[1:].decode("utf-8", "replace")).get("event") or {}
+    except Exception:
+        return {}
+
+
+def collect(worktree):
+    runs = defaultdict(list)
+    pattern = os.path.join(worktree, ".workflow-data/streams/chunks/agent-ledger-*.bin")
+    for path in glob.glob(pattern):
+        base = os.path.basename(path)
+        run_id = base.split("agent-ledger-", 1)[1].rsplit("-chnk_", 1)[0]
+        runs[run_id].append(path)
+    return runs
+
+
+def classify(stop_reason, tools_invoked, outcome):
+    """The paper's four-class taxonomy, computed here so the dataset carries it as a column.
+
+    Stated as code rather than prose so a reader can disagree with it precisely: the column is an
+    interpretation, `events.jsonl` is the evidence, and swapping this function reclassifies the
+    corpus without touching the data.
+    """
+    if outcome != "unanswered":
+        return ""
+    if stop_reason in CLOCK:
+        return "clock"
+    if tools_invoked == 0:
+        return "capability"
+    if stop_reason == "report-composed":
+        return "verification"
+    return "transport"
+
+
+def main():
+    out_dir = sys.argv[1] if len(sys.argv) > 1 else "/home/researcher/Desktop/makale/dataset"
+    os.makedirs(out_dir, exist_ok=True)
+    runs_path = os.path.join(out_dir, "runs.jsonl")
+    events_path = os.path.join(out_dir, "events.jsonl")
+    refusals_path = os.path.join(out_dir, "refusals.jsonl")
+
+    n_runs = n_events = n_ref = 0
+    with (
+        open(runs_path, "w") as runs_out,
+        open(events_path, "w") as events_out,
+        open(refusals_path, "w") as refusals_out,
+    ):
+        for worktree in WORKTREES:
+            tree = os.path.basename(worktree)
+            grouped = collect(worktree)
+            print(f"{tree}: {len(grouped)} run", flush=True)
+            for run_id, paths in grouped.items():
+                events = [e for e in (read_event(p) for p in paths) if e]
+                if not events:
+                    continue
+                events.sort(key=lambda e: e.get("atMs") or 0)
+                base_ms = events[0].get("atMs") or 0
+
+                record = {
+                    "run_id": run_id,
+                    "worktree": tree,
+                    "model": "",
+                    "provider": "",
+                    "tuning_origin": "",
+                    "mode": "",
+                    "surface": "",
+                    "verifier": "",
+                    "status": "",
+                    "stop_reason": "",
+                    "outcome": "",
+                    "unmet": [],
+                    "elapsed_ms": (events[-1].get("atMs") or 0) - base_ms,
+                    "event_count": len(events),
+                    "tools": {},
+                    "refusals": {},
+                    "guidance": {},
+                    "stopped_saying_chars": 0,
+                    "reports_composed": 0,
+                    "answers_composed": 0,
+                    "recommendations": 0,
+                    "loss_class": "",
+                    # Rank of this run's start within its worktree, filled after the pass below.
+                    #
+                    # The wall clock is deliberately NOT exported - when this machine ran a sweep is
+                    # not part of the finding - but ORDER is load-bearing: the protocol scores a cell
+                    # as five CONSECUTIVE passes, and consecutiveness cannot be recovered from a
+                    # pooled corpus without it. A rank gives a reader the sequence and not the date.
+                    "order": -1,
+                    "started_at_ms_raw": base_ms,
+                }
+                tools, refusals, guidance = Counter(), Counter(), Counter()
+
+                for index, event in enumerate(events):
+                    kind = event.get("kind")
+                    clean = scrub(event)
+                    # Offsets rather than wall-clock: the absolute timestamps say when this machine
+                    # ran a sweep, which is not part of the finding, and an offset is what a reader
+                    # needs to see the shape of a run.
+                    clean.pop("atMs", None)
+                    events_out.write(
+                        json.dumps(
+                            {
+                                "run_id": run_id,
+                                "worktree": tree,
+                                "seq": index,
+                                "offset_ms": (event.get("atMs") or 0) - base_ms,
+                                "kind": kind,
+                                "event": clean,
+                            },
+                            ensure_ascii=False,
+                        )
+                        + "\n"
+                    )
+                    n_events += 1
+
+                    if kind == "driver-resolved":
+                        record["model"] = event.get("modelId") or ""
+                        record["provider"] = event.get("provider") or ""
+                        record["tuning_origin"] = (event.get("tuning") or {}).get("origin") or ""
+                    elif kind == "run-started":
+                        record["mode"] = event.get("mode") or ""
+                    elif kind == "run-finished":
+                        record["status"] = event.get("status") or ""
+                        record["stop_reason"] = event.get("stopReason") or ""
+                        verdict = event.get("goalVerdict") or {}
+                        record["outcome"] = verdict.get("outcome") or ""
+                        record["unmet"] = verdict.get("unmet") or []
+                        verifier = verdict.get("verifier") or ""
+                        record["verifier"] = verifier
+                        stem = verifier.rsplit(".", 1)[0]
+                        record["surface"] = stem.removeprefix("agent-") if stem else ""
+                    elif kind == "tool-invoked":
+                        tools[event.get("tool") or event.get("toolName") or "?"] += 1
+                    elif kind == "guidance-issued":
+                        guidance[event.get("notice") or "?"] += 1
+                    elif kind == "model-stopped-saying":
+                        record["stopped_saying_chars"] += len(event.get("text") or "")
+                    elif kind == "report-composed":
+                        record["reports_composed"] += 1
+                    elif kind == "answer-composed":
+                        record["answers_composed"] += 1
+                    elif kind == "recommendation":
+                        record["recommendations"] += 1
+
+                    if kind == "call-declined":
+                        key = f"{event.get('tool')}:{event.get('reasonCode')}"
+                        refusals[key] += 1
+                        refusals_out.write(
+                            json.dumps(
+                                {
+                                    "run_id": run_id,
+                                    "worktree": tree,
+                                    "offset_ms": (event.get("atMs") or 0) - base_ms,
+                                    "channel": "call-declined",
+                                    "tool": event.get("tool") or "",
+                                    "reason_code": event.get("reasonCode") or "",
+                                    "detail": event.get("detail") or "",
+                                },
+                                ensure_ascii=False,
+                            )
+                            + "\n"
+                        )
+                        n_ref += 1
+                    elif kind == "tool-refused":
+                        refusal = event.get("refusal") or {}
+                        key = f"tool:{refusal.get('class', '?')}"
+                        refusals[key] += 1
+                        refusals_out.write(
+                            json.dumps(
+                                {
+                                    "run_id": run_id,
+                                    "worktree": tree,
+                                    "offset_ms": (event.get("atMs") or 0) - base_ms,
+                                    "channel": "tool-refused",
+                                    "tool": "",
+                                    "reason_code": refusal.get("class") or "",
+                                    "detail": refusal.get("message") or "",
+                                },
+                                ensure_ascii=False,
+                            )
+                            + "\n"
+                        )
+                        n_ref += 1
+
+                record["tools"] = dict(tools)
+                record["refusals"] = dict(refusals)
+                record["guidance"] = dict(guidance)
+                record["loss_class"] = classify(
+                    record["stop_reason"], sum(tools.values()), record["outcome"]
+                )
+                runs_out.write(json.dumps(record, ensure_ascii=False) + "\n")
+                n_runs += 1
+
+    # Second pass over runs.jsonl only: rank within worktree, then drop the raw clock.
+    by_tree = defaultdict(list)
+    with open(runs_path) as handle:
+        records = [json.loads(line) for line in handle]
+    for record in records:
+        by_tree[record["worktree"]].append(record)
+    for tree_records in by_tree.values():
+        tree_records.sort(key=lambda r: r["started_at_ms_raw"])
+        for rank, record in enumerate(tree_records):
+            record["order"] = rank
+    with open(runs_path, "w") as handle:
+        for record in records:
+            record.pop("started_at_ms_raw", None)
+            handle.write(json.dumps(record, ensure_ascii=False) + "\n")
+
+    print(f"runs={n_runs} events={n_events} refusals={n_ref}", flush=True)
+    print(f"-> {runs_path}\n-> {events_path}\n-> {refusals_path}", flush=True)
+
+
+if __name__ == "__main__":
+    main()

leaderboard-pooled.txt

@@ -0,0 +1,39 @@
+mode=pooled  models=31  (* = five consecutive passes)
+model | runs | inv | que | dat | ope | dat | pla | of30 | cells
+qwq:32b | 50 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+qwen3:4b | 73 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+qwen3.6:35b | 137 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+qwen3.5:27b | 30 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+qwen3-coder:30b | 71 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+mistral-small3.2:24b | 548 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+mistral-nemo:12b | 398 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+magistral:24b | 49 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+llama3.1:8b | 629 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+granite4.2:3b | 131 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+gpt-oss:20b | 272 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+glm-4.7-flash:latest | 217 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+gemini-3.5-flash-lite | 90 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+cogito:8b | 551 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+deepseek-r1:8b | 383 | 5/5* | 4/5 | 5/5* | 5/5* | 5/5* | 5/5* | 29/30 | 5/6
+ministral-3:3b | 119 | 5/5* | 5/5* | 4/5 | 4/5 | 5/5* | 5/5* | 28/30 | 4/6
+granite4.1:3b | 70 | 5/5* | 2/5 | 5/5* | 5/5* | 4/5 | 5/5* | 26/30 | 4/6
+granite4:3b | 85 | 5/5* | 5/5* | 5/5* | 5/5* | 0/5 | 5/5* | 25/30 | 5/6
+command-r7b:7b | 115 | 5/5* | 4/5 | 2/5 | 5/5* | 3/5 | 5/5* | 24/30 | 3/6
+phi4-mini:3.8b | 30 | 3/5 | 5/5* | 5/5* | 5/5* | 0/5 | 5/5* | 23/30 | 4/6
+qwen3.5:2b | 60 | 5/5* | 2/5 | 5/5* | 5/5* | 5/5* | 0/5 | 22/30 | 4/6
+glm4:latest | 223 | 5/5* | 0/5 | 4/5 | 5/5* | 1/5 | 5/5* | 20/30 | 3/6
+lfm2:24b | 45 | 5/5* | 1/5 | 2/5 | 5/5* | 0/5 | 5/5* | 18/30 | 3/6
+hermes3:8b | 145 | 5/5* | 0/5 | 5/5* | 0/5 | 3/5 | 5/5* | 18/30 | 3/6
+qwen3-vl:8b | 81 | 5/5* | 0/5 | 3/5 | 5/5* | 4/5 | 0/5 | 17/30 | 2/6
+qwen3:1.7b | 55 | 4/5 | 0/5 | 4/5 | 1/5 | 2/5 | 5/5* | 16/30 | 1/6
+deepseek-r1:14b | 30 | 3/5 | 0/5 | 1/5 | 3/5 | 1/5 | 5/5* | 13/30 | 1/6
+mistral-small3.1:24b | 35 | 5/5* | 0/5 | 0/5 | 0/5 | 0/5 | 5/5* | 10/30 | 2/6
+qwen2:7b | 33 | 0/5 | 0/5 | 0/5 | 3/5 | 1/5 | 5/5* | 9/30 | 1/6
+mistral:7b | 30 | 0/5 | 0/5 | 0/5 | 0/5 | 0/5 | 5/5* | 5/30 | 1/6
+qwen3-1.7b | 30 | 0/5 | 0/5 | 0/5 | 0/5 | 0/5 | 0/5 | 0/30 | 0/6
+
+losses=2194
+  transport        761  34.7%
+  clock            626  28.5%
+  verification     434  19.8%
+  capability       373  17.0%

leaderboard-row.txt

@@ -0,0 +1,39 @@
+mode=row  models=31  (* = five consecutive passes)
+model | runs | inv | que | dat | ope | dat | pla | of30 | cells
+qwen3:4b | 73 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+qwen3.6:35b | 137 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+qwen3.5:27b | 30 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+qwen3-coder:30b | 71 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+gpt-oss:20b | 272 | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 5/5* | 30/30 | 6/6
+granite4.2:3b | 131 | 5/5* | 5/5* | 5/5* | 5/5* | 3/5 | 5/5* | 28/30 | 5/6
+gemini-3.5-flash-lite | 90 | 5/5* | 3/5 | 5/5* | 5/5* | 5/5* | 5/5* | 28/30 | 5/6
+qwq:32b | 50 | 5/5* | 4/5 | 4/5 | 5/5* | 5/5* | 5/5* | 28/30 | 4/6
+deepseek-r1:8b | 383 | 5/5* | 2/5 | 5/5* | 5/5* | 5/5* | 5/5* | 27/30 | 5/6
+mistral-small3.2:24b | 548 | 5/5* | 5/5* | 5/5* | 5/5* | - | 5/5* | 25/30 | 5/6
+granite4:3b | 85 | 5/5* | 5/5* | 5/5* | 5/5* | 0/5 | 5/5* | 25/30 | 5/6
+magistral:24b | 49 | 3/5 | 5/5* | 5/5* | 5/5* | 2/5 | 5/5* | 25/30 | 4/6
+glm-4.7-flash:latest | 217 | 5/5* | 2/5 | 5/5* | 5/5* | 5/5* | 3/5 | 25/30 | 4/6
+mistral-nemo:12b | 398 | 5/5* | 1/5 | 5/5* | 5/5* | 3/5 | 5/5* | 24/30 | 4/6
+llama3.1:8b | 629 | 5/5* | 2/5 | 5/5* | 5/5* | 1/5 | 5/5* | 23/30 | 4/6
+granite4.1:3b | 70 | 5/5* | 1/5 | 5/5* | 5/5* | 2/5 | 5/5* | 23/30 | 4/6
+cogito:8b | 551 | 5/5* | 4/5 | 0/5 | 4/5 | 5/5* | 5/5* | 23/30 | 3/6
+ministral-3:3b | 119 | 5/5* | 3/5 | 2/5 | 4/5 | 4/5 | 5/5* | 23/30 | 2/6
+phi4-mini:3.8b | 30 | 2/5 | 5/5* | 5/5* | 5/5* | 0/5 | 5/5* | 22/30 | 4/6
+command-r7b:7b | 115 | 5/5* | 3/5 | 0/5 | 5/5* | 2/5 | 5/5* | 20/30 | 3/6
+lfm2:24b | 45 | 5/5* | 1/5 | 1/5 | 5/5* | 0/5 | 5/5* | 17/30 | 3/6
+hermes3:8b | 145 | 5/5* | 0/5 | 5/5* | 0/5 | 2/5 | 5/5* | 17/30 | 3/6
+glm4:latest | 223 | 5/5* | - | 2/5 | 5/5* | - | 5/5* | 17/30 | 3/6
+qwen3.5:2b | 60 | 5/5* | 1/5 | 5/5* | 3/5 | 2/5 | 0/5 | 16/30 | 2/6
+qwen3-vl:8b | 81 | 5/5* | 0/5 | 1/5 | 5/5* | 3/5 | 0/5 | 14/30 | 2/6
+qwen3:1.7b | 55 | 3/5 | 0/5 | 3/5 | 0/5 | 1/5 | 5/5* | 12/30 | 1/6
+deepseek-r1:14b | 30 | 3/5 | 0/5 | 1/5 | 2/5 | 1/5 | 5/5* | 12/30 | 1/6
+mistral-small3.1:24b | 35 | 5/5* | 0/5 | 0/5 | 0/5 | 0/5 | 5/5* | 10/30 | 2/6
+qwen2:7b | 33 | 0/5 | 0/5 | 0/5 | 2/5 | 1/5 | 5/5* | 8/30 | 1/6
+mistral:7b | 30 | 0/5 | 0/5 | 0/5 | 0/5 | 0/5 | 5/5* | 5/30 | 1/6
+qwen3-1.7b | 30 | 0/5 | 0/5 | 0/5 | 0/5 | 0/5 | 0/5 | 0/30 | 0/6
+
+losses=2194
+  transport        761  34.7%
+  clock            626  28.5%
+  verification     434  19.8%
+  capability       373  17.0%

score.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""Reference scorer for the LibreDB agent benchmark.
+
+    python3 score.py runs.jsonl [--mode row|session|pooled] [--min-runs 30]
+
+Three modes, and the difference between them is the single most important thing in this benchmark.
+`row` is the protocol and the default; the other two exist to show how much a looser reading
+inflates, because both looser readings are the obvious implementation and both are wrong.
+
+Measured on this corpus: `pooled` and `session` both put `llama3.1:8b` and `cogito:8b` at 6/6 and
+30/30. `row` puts them at 23/30. Re-reading those two models by hand, six surfaces in one sitting,
+returned 24/30 and 21/30 - which is `row`, not the other two.
+
+POOLED scans a model-surface cell's entire run history for any streak of five consecutive passes.
+It is the obvious implementation and it OVERSTATES, because a pooled history is not one experiment:
+the corpus contains runs taken on different days, against different builds of the server, and under
+different per-model settings. A streak found across that boundary says a model passed five times in
+a row under *some* mixture of conditions, which is not a claim anyone can act on.
+
+The error is not hypothetical and it is not small. Two models in this corpus score 6/6 pooled and
+were re-read surface-by-surface in one sitting at 24/30 and 21/30. Their cells were each genuinely
+5/5 - thirty runs, thirty passes, all in this dataset - and the row was still wrong, because a model
+ships with A reading, never with the union of its readings.
+
+SESSION splits each cell's history into sittings and requires the five consecutive passes to fall
+inside one sitting. A sitting ends wherever the cell's runs stop being contiguous in the worktree's
+run order - i.e. wherever the harness moved on and came back later. This fixes pooling WITHIN a cell
+and leaves it BETWEEN cells, which turns out to be where the error actually lives: six cells each
+locked in one sitting, but six DIFFERENT sittings, is six results rather than one row.
+
+ROW is the protocol. It splits the model's whole history into sittings and scores each sitting on its
+own, taking the best; all six cells must lock inside one of them. A row is what a deployment gets.
+
+Report `row` if you publish a number, and report the others only to show the gap.
+"""
+import argparse
+import collections
+import json
+
+
+CLOCK = {"model-timeout", "turn-limit", "deadline-exceeded"}
+SURFACES = ("investigation", "query-optimization", "database-assessment", "operations", "data-analysis", "planning")
+RUNS_PER_CELL = 5
+
+
+def load(path):
+    with open(path) as handle:
+        return [json.loads(line) for line in handle if line.strip()]
+
+
+def sittings(runs, max_gap=2):
+    """Split one cell's runs into contiguous sittings by their position in the worktree stream.
+
+    `max_gap` of 2 tolerates the harness's own interleaving - a retry, a server restart recorded as
+    a run - without merging two sittings separated by another model's whole cell. Raise it and
+    sittings merge toward `pooled`; lower it and a single hiccup splits a real sitting in two.
+    """
+    blocks = []
+    current = []
+    previous = None
+    for run in runs:
+        if previous is not None and run["order"] - previous > max_gap:
+            blocks.append(current)
+            current = []
+        current.append(run)
+        previous = run["order"]
+    if current:
+        blocks.append(current)
+    return blocks
+
+
+def longest_streak(outcomes):
+    best = run = 0
+    for ok in outcomes:
+        run = run + 1 if ok else 0
+        best = max(best, run)
+    return best
+
+
+def locked(cell_runs, mode):
+    """Whether this cell reaches five consecutive passes under the chosen mode."""
+    if mode == "pooled":
+        return longest_streak([r["outcome"] == "answered" for r in cell_runs]) >= RUNS_PER_CELL
+    for block in sittings(cell_runs):
+        if longest_streak([r["outcome"] == "answered" for r in block]) >= RUNS_PER_CELL:
+            return True
+    return False
+
+
+def row_score(model_runs, max_gap=12):
+    """The strict metric: all six cells locked inside ONE sitting of this model.
+
+    `session` above fixes pooling WITHIN a cell and leaves it BETWEEN cells, which turns out to be
+    where the error actually lives. Both `llama3.1:8b` and `cogito:8b` have all six cells at 5/5
+    under `session` - each cell genuinely five consecutive passes inside one sitting - and read
+    24/30 and 21/30 when the six were taken together. Six cells locked on six different days is six
+    results, not one row, and a row is what a deployment gets.
+
+    So: split this model's whole run history into sittings, and score each sitting on its own. The
+    row is the best single sitting. `max_gap` of 12 keeps one pass over six cells together (the
+    harness runs them back-to-back, thirty runs) while still splitting two passes taken days apart.
+
+    Returns (best_of_30, best_cells_locked, per_surface_scores) for that best sitting.
+    """
+    blocks = sittings(model_runs, max_gap=max_gap)
+    best = (-1, -1, ["-"] * len(SURFACES))
+    for block in blocks:
+        by_surface = collections.defaultdict(list)
+        for run in block:
+            if run.get("surface") in SURFACES:
+                by_surface[run["surface"]].append(run)
+        scores = []
+        passes = 0
+        locks = 0
+        for surface in SURFACES:
+            runs = by_surface.get(surface, [])
+            if not runs:
+                scores.append("-")
+                continue
+            streak = longest_streak([r["outcome"] == "answered" for r in runs])
+            window = min(streak, RUNS_PER_CELL)
+            if streak >= RUNS_PER_CELL:
+                locks += 1
+                scores.append("5/5*")
+            else:
+                scores.append(f"{window}/5")
+            passes += window
+        if (passes, locks) > (best[0], best[1]):
+            best = (passes, locks, scores)
+    return best
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("runs", nargs="?", default="runs.jsonl")
+    parser.add_argument("--mode", choices=("row", "session", "pooled"), default="row")
+    parser.add_argument("--min-runs", type=int, default=30, help="skip models with fewer runs")
+    args = parser.parse_args()
+
+    rows = [r for r in load(args.runs) if r.get("model")]
+    per_model = collections.Counter(r["model"] for r in rows)
+
+    cells = collections.defaultdict(list)
+    for row in sorted(rows, key=lambda r: (r["worktree"], r["order"])):
+        if row.get("surface") in SURFACES:
+            cells[(row["model"], row["surface"])].append(row)
+
+    by_model = collections.defaultdict(list)
+    for row in sorted(rows, key=lambda r: (r["worktree"], r["order"])):
+        by_model[row["model"]].append(row)
+
+    table = []
+    for model, total in per_model.items():
+        if total < args.min_runs:
+            continue
+        if args.mode == "row":
+            passes, locks, cell_scores = row_score(by_model[model])
+            table.append((passes, locks, model, total, cell_scores))
+            continue
+        cell_scores = []
+        locks = 0
+        passes = 0
+        for surface in SURFACES:
+            runs = cells.get((model, surface), [])
+            if not runs:
+                cell_scores.append("-")
+                continue
+            # The cell's best five-run window, which is what /30 counts.
+            window = max(
+                (sum(1 for r in runs[i : i + RUNS_PER_CELL] if r["outcome"] == "answered")
+                 for i in range(max(1, len(runs) - RUNS_PER_CELL + 1))),
+                default=0,
+            )
+            window = min(window, RUNS_PER_CELL)
+            is_locked = locked(runs, args.mode)
+            if is_locked:
+                locks += 1
+                window = RUNS_PER_CELL
+            passes += window
+            cell_scores.append(f"{window}/5" + ("*" if is_locked else ""))
+        table.append((passes, locks, model, total, cell_scores))
+
+    table.sort(reverse=True)
+    header = ["model", "runs", *[s[:3] for s in SURFACES], "of30", "cells"]
+    print(f"mode={args.mode}  models={len(table)}  (* = five consecutive passes)")
+    print(" | ".join(header))
+    for passes, locks, model, total, cell_scores in table:
+        print(" | ".join([model, str(total), *cell_scores, f"{passes}/30", f"{locks}/6"]))
+
+    lost = [r for r in rows if r["outcome"] == "unanswered"]
+    classes = collections.Counter(r["loss_class"] for r in lost)
+    print(f"\nlosses={len(lost)}")
+    for name, count in classes.most_common():
+        print(f"  {name or '(unclassified)':14} {count:5}  {100 * count / len(lost):.1f}%")
+
+
+if __name__ == "__main__":
+    main()

verify.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Regenerate every number in the paper from the released dataset and assert it matches.
+
+Usage:  python3 verify.py runs.jsonl
+Exit 0 means every figure in the paper reproduces from the released data.
+"""
+import json, collections, io, statistics, sys
+
+CLOCK = {"model-timeout", "turn-limit", "deadline-exceeded"}
+ok = fail = 0
+
+def check(label, got, want):
+    global ok, fail
+    good = got == want
+    ok, fail = ok + good, fail + (not good)
+    print(f"  [{'OK ' if good else 'FAIL'}] {label:<50} got={got!r:>12} want={want!r}")
+
+def ntools(r): return sum((r.get("tools") or {}).values())
+
+def classify(r, clock_first=True):
+    no_tool, clock = ntools(r) == 0, r["stop_reason"] in CLOCK
+    if clock_first:
+        if clock: return "clock"
+        if no_tool: return "capability"
+    else:
+        if no_tool: return "capability"
+        if clock: return "clock"
+    return "verification" if r["stop_reason"] == "report-composed" else "transport"
+
+path = sys.argv[1] if len(sys.argv) > 1 else "runs.jsonl"
+R = [json.loads(l) for l in io.open(path, encoding="utf-8")]
+named = [r for r in R if r.get("model")]
+L = [r for r in named if r["outcome"] == "unanswered"]
+A = [r for r in R if r["outcome"] == "unanswered"]
+
+print("\nCorpus")
+check("runs", len(R), 8199)
+check("named models", len({r["model"] for r in named}), 40)
+check("model-attributed runs", len(named), 4951)
+check("unattributed runs", len(R) - len(named), 3248)
+check("answered", sum(r["outcome"] == "answered" for r in R), 4983)
+check("unanswered", len(A), 3142)
+check("no verdict", sum(not r["outcome"] for r in R), 74)
+check("refused calls", sum(v for r in R for v in (r.get("refusals") or {}).values()), 14008)
+rp = collections.Counter(r["model"] for r in named)
+check("min runs per model", min(rp.values()), 3)
+check("max runs per model", max(rp.values()), 629)
+check("models with >=20 runs", sum(v >= 20 for v in rp.values()), 35)
+
+print("\nPass rate by surface (model-attributed)")
+for s, a, n in [("planning",466,560),("investigation",389,550),("operations",404,612),
+                ("database-assessment",342,614),("query-optimization",639,1360),("data-analysis",468,1206)]:
+    sub = [r for r in named if r.get("surface") == s]
+    check(s, (sum(r["outcome"] == "answered" for r in sub), len(sub)), (a, n))
+
+print("\nTaxonomy, clock-first (adopted)")
+check("model-attributed losses", len(L), 2194)
+c = collections.Counter(classify(r) for r in L)
+for k, v in [("transport",761),("clock",626),("verification",434),("capability",373)]:
+    check(k, c[k], v)
+check("agrees with released loss_class", sum(classify(r) == r.get("loss_class") for r in L), 2194)
+
+print("\nTaxonomy, capability-first (sensitivity)")
+c2 = collections.Counter(classify(r, False) for r in L)
+for k, v in [("transport",761),("clock",395),("verification",434),("capability",604)]:
+    check(k, c2[k], v)
+amb = [r for r in L if ntools(r) == 0 and r["stop_reason"] in CLOCK]
+check("overlapping (clock AND no tool)", len(amb), 231)
+check("of those, emitted no text", sum(r["stopped_saying_chars"] == 0 for r in amb), 225)
+
+print("\nWhole corpus")
+ca = collections.Counter(classify(r) for r in A)
+for k, v in [("transport",33.3),("clock",26.5),("verification",20.6),("capability",19.7)]:
+    check(f"{k} share %", round(100*ca[k]/len(A), 1), v)
+check("max attributed-vs-whole delta pp",
+      round(max(abs(100*ca[k]/len(A) - 100*c[k]/len(L)) for k in c), 1), 2.7)
+
+print("\nTransport engagement")
+tr = [r for r in L if classify(r) == "transport"]
+check("median tools invoked", statistics.median(ntools(r) for r in tr), 2)
+check("total tool invocations", sum(ntools(r) for r in tr), 1926)
+
+print("\nRefusals")
+ref = collections.Counter()
+for r in R:
+    for k, v in (r.get("refusals") or {}).items(): ref[k] += v
+for k, v in [("compose_report:INVALID_TOOL_INPUT",6243),("compose_report:UNVERIFIABLE_EVIDENCE",3464),
+             ("tool:database-error",1110),("present_answer:INVALID_TOOL_INPUT",1032),
+             ("present_answer:ANSWER_NOT_A_DATA_READ",696),("recommend_change:INVALID_TOOL_INPUT",613),
+             ("recommend_change:RECOMMENDATION_SHAPE_MISMATCH",248),("compare_plans:INVALID_TOOL_INPUT",152),
+             ("compare_plans:UNVERIFIABLE_PLAN",139)]:
+    check(k, ref[k], v)
+cr = ref["compose_report:INVALID_TOOL_INPUT"] + ref["compose_report:UNVERIFIABLE_EVIDENCE"]
+check("compose_report refusals", cr, 9707)
+check("compose_report share %", round(100*cr/sum(ref.values()), 1), 69.3)
+
+print("\nProcess-exit inflation claim")
+ms = [r for r in R if r["stop_reason"] == "model-stopped"]
+check("model-stopped runs", len(ms), 2204)
+check("of those unanswered", sum(r["outcome"] == "unanswered" for r in ms), 1405)
+
+print(f"\n{'='*70}\n  {ok} checks passed, {fail} failed\n{'='*70}")
+sys.exit(1 if fail else 0)