evals-lab 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -5,6 +5,35 @@ Newest first. Read a release's **Upgrade notes** before installing it: an
 upgrade can rewrite what the lab keeps in your data directory, and an older
 version cannot always read it back.
 
+## 0.4.0
+
+### Upgrade notes
+
+- **Copy your data directory before upgrading** (see "Where your data is
+  kept" in the README). A dataset 0.4.0 saves is dataset version 7, which
+  0.3.x cannot read. To go back, reinstall 0.3.0 and restore the copy.
+- Stored datasets are not rewritten on upgrade: 0.4.0 reads a version-6
+  dataset as version 7, and writes version 7 the next time it is saved.
+- Export JSON writes dataset version 7, which 0.3.x refuses to import.
+  Import reads versions 1 to 7.
+
+### Added
+
+- Re-run, in a History row's menu and in Results' run menu: a new run of the
+  same pipeline over the same file revisions and the same dataset version.
+  It is refused while the run is still going, or when one of the files it
+  read is gone. The new run says which run it re-ran, and links back to it
+  in Results. Undo cancels it while it is still queued.
+- A dataset carries four new sections, `scoring`, `grader`, `every` and
+  `run`: how it scores, which model grades it, and metrics for every item
+  and for the whole run. Edit raw… shows them. Runs do not read them yet.
+  A dataset from 0.3.x has them as scored All, by the lab's grader, with no
+  metrics of its own.
+
+### Changed
+
+- Resume is in a History row's menu, beside Re-run.
+
 ## 0.3.0
 
 ### Upgrade notes

package/lab/VERSION

@@ -1 +1 @@
-0.3.0 (2026.10.02-355)
+0.4.0 (2026.10.02-361)

package/lab/evals-core.mjs

@@ -983,22 +983,37 @@ const SLOTS                      = ["content", "target", "responses"];
                             
                                        
                                                                           
-                      
+                                                                              
                      
-                          
+                                                                     
+                                                                   
+                        
+                                                                              
+                     
+                                                       
+                  
+                                                                
+                
+                                                                           
                 
  
 
-/** The dataset body's version: 6 marks itself; 5 named its Source; 4 and
-    earlier, neither. */
-const DATASET_BODY_VERSION = 6         ;
+/** An eval group's scoring (docs/pipeline-model.md §17). */
+                               
+                           
+                           
+ 
+
+/** The dataset body's version: 7 is an eval group (§17); 6 marks itself; 5
+    named its Source; 4 and earlier, neither. */
+const DATASET_BODY_VERSION = 7         ;
 
 /** The metrics whose Ignore case version 6 made mean what it says for a
     reply read as a list, as well as one read as text. */
 const CASE_FOLDING = ["contains", "contains-all", "contains-any"];
 
 /**
- * [body] as this version of a dataset (6), from any earlier one. Version 1
+ * [body] as this version of a dataset (7), from any earlier one. Version 1
  * held `imageCases`, each with `minTags`/`maxTags`, and the parser's
  * `replays` and `conformance` (now fixtures/replays.json beside the checks).
  * Version 2 held `rules`, which clean a job's answer and so belong to the
@@ -1010,7 +1025,9 @@ const CASE_FOLDING = ["contains", "contains-all", "contains-any"];
  * `note`, `traits` go, and the body names no Source yet. Version 5 matched
  * a list's items ignoring case whatever a Contains metric's Ignore case
  * said, so each of its Contains metrics says Ignore case (`caseOfV5`), and
- * the body says its version. Every reader of a
+ * the body says its version. Version 6 is a group's cases alone: version 7
+ * adds its scoring, grader, Every item and Whole run (`groupOfV6`), and a
+ * stored row is read that way rather than rewritten. Every reader of a
  * body calls this: the runner, the page, a run's kept copy. A reader that
  * needs a version-2 body's rules -- to upgrade a pipeline graded against
  * it -- takes them first (`datasetRules`). Pure: the same body gives the
@@ -1021,14 +1038,26 @@ function upgradeDatasetBody   (body   )                  {
   if (!isObj(body)) return body;
   if (body.version === DATASET_BODY_VERSION) return body;
   const b = body             ;
+  // A body saying any other version is one this lab does not read.
+  if ("version" in b) return b.version === 6 ? groupOfV6(b) : body;
   // A body that names its Source, even as null, is version 5.
   if ("source" in b) {
-    return { version: DATASET_BODY_VERSION, ...b, ...(Array.isArray(b.cases) ? { cases: b.cases.map(caseOfV5) } : {}) };
+    return groupOfV6({ ...b, ...(Array.isArray(b.cases) ? { cases: b.cases.map(caseOfV5) } : {}) });
   }
   const raw = Array.isArray(b.cases) ? b.cases : Array.isArray(b.imageCases) ? b.imageCases : null;
   // Not a body of any version -- a copy kept while a dataset was an overlay.
   if (!raw) return body;
-  return { version: DATASET_BODY_VERSION, source: null, cases: raw.map(caseOfV4).map(caseOfV5) };
+  return groupOfV6({ source: null, cases: raw.map(caseOfV4).map(caseOfV5) });
+}
+
+/** A version-6 body as a version-7 eval group: scored All, the lab's
+    grader, and no metrics of its own for every item or the whole run --
+    what a Metrics eval naming the dataset with none of its own graded, which
+    is what every Graded set converted to. */
+function groupOfV6(b           )              {
+  const { version: _v, ...rest } = b;
+  return { version: DATASET_BODY_VERSION, source: null, scoring: { mode: "all", threshold: null }, grader: null, every: [], run: [],
+           ...rest }               ;
 }
 
 /** A version-5 case as a version-6 one: each Contains metric says Ignore
@@ -3187,15 +3216,7 @@ EVAL_TYPES.metrics = {
     ? { ...t, grader: { id: ctx.grader.id, name: ctx.grader.name } } : t),
   wholeRun: t => t.over === "run",
   // Over the whole run: every metric over the replies together, or each alone.
-  verdict(t, ress, kind){
-    const run = runInput(ress, !(kind != null && OUTPUT_KINDS[kind]?.terms));
-    const metrics = readRun(t.metrics || [], run);
-    const s = scoreOf(metrics, t.mode, t.threshold);
-    const off = metrics.filter(r => !r.pass);
-    return { pass: s ? s.pass : true, detail: off.length ? off.map(r => `${r.label}: ${r.reason}`).join(" · ") : "all matched",
-             ran: run.replies.length,
-             checks: metrics.map((r, x) => ({ key: `m${x}`, label: r.label, want: "", pass: r.pass, ...(r.pass ? {} : { note: r.reason }) })) };
-  },
+  verdict: (t, ress, kind) => wholeRunVerdict(t.metrics || [], ress, kind, t.mode, t.threshold),
   // Rule m{x} is the eval's own metric x, read in that place on every item.
   // A score stored before Metrics -- a Graded set's, read as its conversion --
   // has no readings of its own: its one metric's reading is the score's.
@@ -3296,6 +3317,38 @@ LEGACY_TESTS.single .toMetrics = t => {
   return { ...common(t), type: "metrics", mode: "all", threshold: null, grader: null, dataset: null, over: "run", metrics };
 };
 
+/** [list] read over a whole run's replies so far, scored the way [mode]
+    says: a Metrics eval's verdict over the run, and an eval group's Whole run. */
+function wholeRunVerdict(list                   , ress                                       , kind               ,
+                         mode = "all", threshold                = null)                  {
+  const run = runInput(ress, !(kind != null && OUTPUT_KINDS[kind]?.terms));
+  const metrics = readRun(list, run);
+  const s = scoreOf(metrics, mode, threshold);
+  const off = metrics.filter(r => !r.pass);
+  return { pass: s ? s.pass : true, detail: off.length ? off.map(r => `${r.label}: ${r.reason}`).join(" · ") : "all matched",
+           ran: run.replies.length,
+           checks: metrics.map((r, x) => ({ key: `m${x}`, label: r.label, want: "", pass: r.pass, ...(r.pass ? {} : { note: r.reason }) })) };
+}
+
+/**
+ * An eval group's verdict on one item (docs/pipeline-model.md §17): its
+ * Every item metrics and [kase]'s own -- the item's case in the group, or
+ * null where it has none -- read of the reply under the group's scoring.
+ * The reading a Metrics eval naming the group as its dataset gives, which
+ * groups-check.js holds it to. Null where no metric had anything to read.
+ */
+function readGroup(group             , kase             , res                    , more           = {})                              {
+  return readMetrics([...group.every, ...(kase?.metrics ?? [])], metricInput(res, kase, more), graderCtx(group, more),
+                     group.scoring.mode, group.scoring.threshold);
+}
+
+/** An eval group's Whole run verdict, from the replies so far: its `run`
+    metrics under its scoring. Null for a group with no Whole run metrics,
+    which has nothing to say of a run. */
+function readGroupRun(group             , ress                                       , kind                = null)                         {
+  return group.run.length ? wholeRunVerdict(group.run, ress, kind, group.scoring.mode, group.scoring.threshold) : null;
+}
+
 /** The grader a Metrics eval names, reached through what the runner hands it. */
 function graderCtx(t           , more          )            {
   const ask = isRef(t.grader) ? more.grader?.(t.grader) : undefined;
@@ -4768,6 +4821,24 @@ function validateEvals(ev           , files
   }
   if (ev.cases != null && !Array.isArray(ev.cases)) bad.push("cases has to be a list");
   if (ev.source != null && !isRef(ev.source)) bad.push("a dataset names its Source as { id, name }, or null");
+  // An eval group's own sections (version 7): what a Metrics eval held.
+  if (ev.scoring != null) {
+    const sc = ev.scoring;
+    if (!isObj(sc) || !SCORING_MODES.includes(sc.mode)) bad.push(`a group is scored ${SCORING_MODES.join(" or ")}`);
+    else if (sc.mode === "weighted" && typeof sc.threshold !== "number") bad.push("a group scored in points needs Pass at: the points an item has to reach");
+    else if (sc.threshold != null && typeof sc.threshold !== "number") bad.push("a group's Pass at has to be a number");
+  }
+  if (ev.grader != null && !isRef(ev.grader)) bad.push("a group names its grader as { id, name }, or null");
+  if (ev.every != null) metricsProblems(ev.every, "Every item", bad);
+  if (ev.run != null) {
+    metricsProblems(ev.run, "Whole run", bad);
+    // Read once over every reply: nothing that reads one item, or asks a grader.
+    for (const m of Array.isArray(ev.run) ? ev.run : []) {
+      const entry = isObj(m) ? METRICS[m.type] : undefined;
+      if (entry?.graded) bad.push(`Whole run: ${entry.label} is model-graded, so it cannot read a whole run`);
+      else if (entry?.perItem) bad.push(`Whole run: ${entry.label} reads one item at a time, so it cannot read a whole run`);
+    }
+  }
   if (bad.length) return bad;
 
   const graded              = ev.cases || [];
@@ -4915,7 +4986,7 @@ registerMetrics({ registerKinds });
 export {
     TOKEN_DEFAULTS, TOKEN_TYPES, tokenMapping, tokenNames, resolvePrompt, tokenSet, textPrompt, words,
     loopReplyError, preparedSize,
-    termIn, forbiddenIn, readCase, gradedSetFrom, caseItem, caseMetrics, metricLines, upgradeDatasetBody, datasetRules, upgradeResults, emptyTally, addToTally, isHostedUrl,
+    termIn, forbiddenIn, readCase, gradedSetFrom, caseItem, caseMetrics, metricLines, upgradeDatasetBody, readGroup, readGroupRun, datasetRules, upgradeResults, emptyTally, addToTally, isHostedUrl,
     SEED, REPLY_TOKENS_BEFORE, ANTHROPIC_MAX_TOKENS, asNumber, pinReplyTokens, mappingsFor,
     CONNECTION_TYPES, HTTP_APIS, httpApiFor, httpRequestOf, httpReplyOf, readFlowReply, WdlError, localAnswer, typeOf, profileType, convertProfile, splitOllama, DECODING_KEYS, apiBase,
     EDGE_448, budgetLabel, IMAGE_FORMATS, encoderQuality,

package/lab/run-evals.js

@@ -296,8 +296,8 @@ function readDataset(file) {
     broken(`${file}: ${e.message}`);
   }
   if (isObject(doc) && doc.format === "evals-lab/dataset") {
-    if (![1, 2, 3, 4, 5].includes(doc.version)) {
-      broken(`${file} is version ${JSON.stringify(doc.version)}, and this reads versions 1 to 5`);
+    if (![1, 2, 3, 4, 5, 6, 7].includes(doc.version)) {
+      broken(`${file} is version ${JSON.stringify(doc.version)}, and this reads versions 1 to 7`);
     }
     doc = isObject(doc.dataset) ? doc.dataset.body : null;
   }

package/lab/server.py

@@ -1356,23 +1356,25 @@ class Sources:
 # A lab from before this held a one-time import's `meta` row saying it ran;
 # it is left where it is, and nothing reads it.
 
-DATASET_FIELDS = ("version", "source", "cases")
-# A body's own version: evals-core.ts's DATASET_BODY_VERSION. Version 5 was
-# told by its `source` alone, and earlier ones by neither.
-DATASET_BODY_VERSION = 6
+DATASET_FIELDS = ("version", "source", "scoring", "grader", "every", "run", "cases")
+# A body's own version: evals-core.ts's DATASET_BODY_VERSION. Version 7 is an
+# eval group (docs/pipeline-model.md §17), version 6 its cases alone; version
+# 5 was told by its `source` alone, and earlier ones by neither.
+DATASET_BODY_VERSION = 7
 DATASET_NAME_MAX = 80
-# The file forms Export writes and Import reads. Export writes version 6;
-# Import reads it and versions 1 to 5, upgraded, and refuses anything else,
+# The file forms Export writes and Import reads. Export writes version 7;
+# Import reads it and versions 1 to 6, upgraded, and refuses anything else,
 # as a pipeline of another version is refused. Versions 1 to 3 carried a
 # prompt, which an import gives to the Prompt library.
 EXPORT_ONE = "evals-lab/dataset"
 EXPORT_ALL = "evals-lab/datasets"
-EXPORT_VERSION = 6
-IMPORT_VERSIONS = (1, 2, 3, 4, 5, 6)
+EXPORT_VERSION = 7
+IMPORT_VERSIONS = (1, 2, 3, 4, 5, 6, 7)
+SCORING_MODES = ("all", "weighted")
 
 
 def blank_dataset() -> dict:
-    return {"version": DATASET_BODY_VERSION, "source": None, "cases": []}
+    return group_of_v6({"source": None, "cases": []})
 
 
 # vocab: the names older versions gave a case's fields
@@ -1400,7 +1402,7 @@ def _term_in(items, term) -> bool:
 def case_metrics(c: dict) -> list:
     """A version-4 case's expectations as the metrics that say the same:
     evals-core.ts's caseMetrics, in Python, and held to it by proxy-check.py
-    through fixtures/dataset-v6.json."""
+    through fixtures/dataset-v7.json."""
     def strs(v):
         return [x for x in v if isinstance(x, str)] if isinstance(v, list) else []
     if c.get("discarded") is True:
@@ -1466,8 +1468,18 @@ def case_of_v5(c):
                              else m for m in c["metrics"]]}
 
 
+def group_of_v6(body: dict) -> dict:
+    """A version-6 body as a version-7 eval group: evals-core.ts's
+    groupOfV6. Scored All, the lab's grader, and no metrics of its own for
+    every item or the whole run -- what a Metrics eval naming the dataset with
+    none of its own graded."""
+    rest = {k: v for k, v in body.items() if k != "version"}
+    return {"version": DATASET_BODY_VERSION, "source": None, "scoring": {"mode": "all", "threshold": None},
+            "grader": None, "every": [], "run": [], **rest}
+
+
 def upgrade_body(body):
-    """An earlier body as today's (version 6): evals-core.ts's
+    """An earlier body as today's (version 7): evals-core.ts's
     upgradeDatasetBody, in Python. Version 1's `imageCases` are `cases`, and
     its `replays` and `conformance` go (fixtures/replays.json holds the
     parser's tests). Version 2's `rules` go -- they clean a job's answer, so
@@ -1477,19 +1489,25 @@ def upgrade_body(body):
     `note`, `traits` go, and the body names no Source yet. A caller that
     needs the rules or the prompt takes them first (`body_rules`,
     `body_prompt`). A body naming its Source is version 5, whose Contains
-    metrics each come to say Ignore case (`case_of_v5`). A body saying it is
-    version 6 comes back as it was; so does anything that is not a body."""
+    metrics each come to say Ignore case (`case_of_v5`). Version 6 gains a
+    group's scoring, grader, Every item and Whole run (`group_of_v6`). A body
+    saying it is version 7 comes back as it was; so does anything that is
+    not a body."""
     if not isinstance(body, dict) or body.get("version") == DATASET_BODY_VERSION:
         return body
+    # A body saying any other version is one this lab does not read, and is
+    # left for dataset_problem to refuse.
+    if "version" in body:
+        return group_of_v6(body) if body["version"] == 6 else body
     if "source" in body:
-        up = {"version": DATASET_BODY_VERSION, **body}
+        up = dict(body)
         if isinstance(body.get("cases"), list):
             up["cases"] = [case_of_v5(c) for c in body["cases"]]
-        return up
+        return group_of_v6(up)
     cases = body.get("cases") if isinstance(body.get("cases"), list) else body.get("imageCases")
     if not isinstance(cases, list):
         return body
-    return {"version": DATASET_BODY_VERSION, "source": None, "cases": [case_of_v5(case_of_v4(c)) for c in cases]}
+    return group_of_v6({"source": None, "cases": [case_of_v5(case_of_v4(c)) for c in cases]})
 
 
 def body_prompt(body):
@@ -1518,10 +1536,25 @@ def dataset_problem(body) -> str:
         return f"a dataset's body is version {DATASET_BODY_VERSION}"
     if not isinstance(body["cases"], list) or not all(isinstance(c, dict) for c in body["cases"]):
         return "cases has to be a list of cases"
-    src = body["source"]
-    if src is not None and not (isinstance(src, dict) and isinstance(src.get("id"), str)
-                                and isinstance(src.get("name"), str)):
+    def is_ref(v):
+        return isinstance(v, dict) and isinstance(v.get("id"), str) and isinstance(v.get("name"), str)
+    if body["source"] is not None and not is_ref(body["source"]):
         return "a dataset names its Source as { id, name }, or null"
+    # A group's own sections: their metrics are evals-core.ts's validateEvals'
+    # to judge, as a case's are; the shape is the server's.
+    sc = body["scoring"]
+    if not isinstance(sc, dict) or sc.get("mode") not in SCORING_MODES:
+        return "a group is scored all or weighted"
+    number = lambda v: type(v) in (int, float)
+    if sc["mode"] == "weighted" and not number(sc.get("threshold")):
+        return "a group scored in points needs Pass at: the points an item has to reach"
+    if sc.get("threshold") is not None and not number(sc.get("threshold")):
+        return "a group's Pass at has to be a number"
+    if body["grader"] is not None and not is_ref(body["grader"]):
+        return "a group names its grader as { id, name }, or null"
+    for k, label in (("every", "Every item"), ("run", "Whole run")):
+        if not isinstance(body[k], list) or not all(isinstance(m, dict) for m in body[k]):
+            return f"{label} has to be a list of metrics"
     return ""
 
 
@@ -1926,6 +1959,10 @@ class Datasets:
             given = False
             for did, name, version, raw in rows:
                 body = json.loads(raw)
+                # A version-6 body is read as version 7 (`_doc`) and saved as
+                # one at its next edit, never rewritten here (§17).
+                if isinstance(body, dict) and body.get("version") == 6:
+                    continue
                 up = upgrade_body(body)
                 if up is not body:
                     self._archive(db, did, body)
@@ -1956,8 +1993,9 @@ class Datasets:
 
     @staticmethod
     def _doc(r, body=True):
-        """A row as the API answers it: a DatasetSummary, and its body with it."""
-        parsed = json.loads(r["body"])
+        """A row as the API answers it: a DatasetSummary, and its body with it,
+        read as today's version."""
+        parsed = upgrade_body(json.loads(r["body"]))
         out = {"id": r["id"], "name": r["name"], "cases": len(parsed.get("cases") or []),
                "version": r["version"], "updated": r["updated_at"]}
         if body:
@@ -2101,7 +2139,7 @@ class Datasets:
             rows = db.execute("SELECT * FROM datasets WHERE trash IS NULL "
                               "ORDER BY name COLLATE NOCASE, id").fetchall()
         return {"format": EXPORT_ALL, "version": EXPORT_VERSION,
-                "datasets": [{"name": r["name"], "body": json.loads(r["body"])} for r in rows]}
+                "datasets": [{"name": r["name"], "body": upgrade_body(json.loads(r["body"]))} for r in rows]}
 
     def import_file(self, doc):
         """Either export's file, as new datasets: import always creates, ids
@@ -3323,11 +3361,22 @@ class Queue:
                        "dataset TEXT)")
             # A store from before runs kept their dataset gains the column;
             # its rows have none, and are pinned when first they need one.
-            if "dataset" not in [c[1] for c in db.execute("PRAGMA table_info(queue)")]:
+            cols = [c[1] for c in db.execute("PRAGMA table_info(queue)")]
+            if "dataset" not in cols:
                 db.execute("ALTER TABLE queue ADD COLUMN dataset TEXT")
+            # The run a re-run was queued from (#245); every earlier row is
+            # one of its own.
+            if "rerun_of" not in cols:
+                db.execute("ALTER TABLE queue ADD COLUMN rerun_of TEXT")
 
     # ---- rows -----------------------------------------------------------
 
+    # A row read with the submit time of the run it re-runs, if any: the
+    # page names a run by that time (History's Run ID), so a "Re-run of"
+    # note reads without fetching the original.
+    SELECT = ("SELECT q.*, o.submitted_at FROM queue q "
+              "LEFT JOIN queue o ON o.id = q.rerun_of")
+
     @staticmethod
     def _row(r):
         if r is None:
@@ -3338,6 +3387,8 @@ class Queue:
             "snapshot": json.loads(r[6]), "results": json.loads(r[7]),
             "progress": json.loads(r[8]), "totals": json.loads(r[9]),
             "error": r[10],
+            "rerunOf": r[12] if len(r) > 12 else None,
+            "rerunOfAt": r[13] if len(r) > 13 else None,
         }
 
     # A row from before run documents has no version, and nothing here can
@@ -3351,12 +3402,12 @@ class Queue:
         return row is not None and (row["snapshot"] or {}).get("version") in READABLE_VERSIONS
 
     def _all(self, db):
-        return [row for row in (self._row(r) for r in db.execute("SELECT * FROM queue"))
+        return [row for row in (self._row(r) for r in db.execute(self.SELECT))
                 if self._readable(row)]
 
     def get(self, rid):
         with self.lock, closing(sqlite3.connect(self.store.path)) as db:
-            row = self._row(db.execute("SELECT * FROM queue WHERE id = ?",
+            row = self._row(db.execute(self.SELECT + " WHERE q.id = ?",
                                        (rid,)).fetchone())
         return row if self._readable(row) else None
 
@@ -3379,13 +3430,13 @@ class Queue:
 
     # ---- submit ---------------------------------------------------------
 
-    def submit(self, run: dict, dataset=None):
+    def submit(self, run: dict, dataset=None, rerun_of=None):
         """
         A new queued run. `run` is the run document (docs/pipeline-model.md
         §5): the pipeline, the profiles it resolved to without their keys, its
         content's file list in order and with its repeats, and the dataset's
-        version; `dataset` is that version's body, for a graded run. Returns
-        the row. Its items are that list, or the one inline text, each through
+        version; `dataset` is that version's body, for a graded run;
+        `rerun_of` is the run a re-run was queued from. Returns the row. Its items are that list, or the one inline text, each through
         every scenario -- so the total is the list's length, repeats and all,
         the same count the runner and the page make.
         """
@@ -3394,11 +3445,12 @@ class Queue:
         total = len(run_items(run))
         with self.lock, closing(sqlite3.connect(self.store.path)) as db, db:
             db.execute("INSERT INTO queue (id, status, cancel, submitted_at, "
-                       "snapshot, results, progress, totals, dataset) VALUES (?, ?, 0, ?, ?, ?, ?, ?, ?)",
+                       "snapshot, results, progress, totals, dataset, rerun_of) "
+                       "VALUES (?, ?, 0, ?, ?, ?, ?, ?, ?, ?)",
                        (rid, "queued", now, json.dumps(run), "[]",
                         json.dumps({"current": None, "n": 0, "total": total}),
                         json.dumps({"ran": 0, "passed": 0, "found": 0, "of": 0}),
-                        None if dataset is None else json.dumps(dataset)))
+                        None if dataset is None else json.dumps(dataset), rerun_of))
             # Its prompts' uses, in the same transaction: a run is in the
             # library the moment it is queued, or not queued at all.
             if self.prompts is not None:
@@ -3406,7 +3458,7 @@ class Queue:
             # Read back under the lock the worker dequeues under, so the
             # answer is the run as it was queued: an idle worker can take it
             # the moment the lock is let go.
-            return self._row(db.execute("SELECT * FROM queue WHERE id = ?", (rid,)).fetchone())
+            return self._row(db.execute(self.SELECT + " WHERE q.id = ?", (rid,)).fetchone())
 
     def dataset(self, rid, raw=False):
         """The dataset body a readable run was submitted against, or None --
@@ -3525,6 +3577,46 @@ class Queue:
                 shutil.rmtree(d, ignore_errors=True)
         return n
 
+    def rerun(self, rid):
+        """
+        A new run from a finished one's document (#245): a new id and submit
+        time, the same document -- the file revisions and the plugins it
+        pinned -- and the dataset body it was graded by, so a re-run measures
+        the model again rather than changed data. The original is left as it
+        was; the new row names it in `rerunOf`. Refused, naming what is
+        missing, when a pinned file or dataset version is no longer kept. A
+        Target's key is read from its profile now, at dequeue, as for any
+        run: none is ever stored in one.
+        """
+        run = self.get(rid)
+        if run is None:
+            return None, (404, "no such run")
+        if run["status"] in ("queued", "running"):
+            return None, (409, "a run still in progress cannot be re-run")
+        snap = run["snapshot"]
+        _, err = self._pinned_files(snap)
+        if err:
+            return None, (409, err)
+        ref = evals_dataset(snap)
+        body = None
+        if ref is not None:
+            body = self.dataset(rid, raw=True)
+            if body is None:
+                # A run that never started kept no body: the dataset's, if it
+                # still reads as the version the run was submitted against.
+                now = DATASETS.snapshot(ref.get("id")) if DATASETS is not None else None
+                if now is None or not ref.get("version") or now[1] != ref.get("version"):
+                    return None, (409, f"the version of the dataset {ref.get('name') or ref.get('id')!r} "
+                                       "this run was submitted against is no longer kept")
+                body = now[0]
+        _, err = self._plugin_args(run)
+        if err:
+            return None, (409, err)
+        _, err = worker_destinations(snap)
+        if err:
+            return None, (403, err)
+        return self.submit(snap, body, rerun_of=rid), None
+
     def rerun_item(self, rid, index):
         """
         One item against the run's snapshot, by its index, updating the row in
@@ -3671,34 +3763,48 @@ class Queue:
         has gone fails the run with the reason stated. Returns the run dir,
         or (None, error)."""
         snap = run["snapshot"]
-        content = content_of(snap) or {}
+        files, err = self._pinned_files(snap)
+        if err:
+            return None, err
         rundir = self.dir / run["id"]
         files_dir = rundir / "files"
         shutil.rmtree(rundir, ignore_errors=True)
         files_dir.mkdir(parents=True)
-        if content.get("type") == "source":
-            ref = content.get("ref") or {}
-            label = ref.get("name") or ref.get("id")
-            if SOURCES.get(ref.get("id")) is None:
-                return None, f"the source {label!r} is gone"
-            revs = content.get("revs") if isinstance(content.get("revs"), dict) else None
-            changed = []
-            for name in dict.fromkeys(content.get("files") or []):
-                path = SOURCES.file_path(ref["id"], name)
-                if path is None or not path.is_file():
-                    return None, f"{name!r} is gone from the source {label!r}"
-                if revs is not None:
-                    path = SOURCES.rev_path(ref["id"], name, revs.get(name))
-                    if path is None:
-                        changed.append(repr(name))
-                        continue
-                shutil.copy2(path, files_dir / name)
-            if changed:
-                return None, (f"{', '.join(changed)} {'has' if len(changed) == 1 else 'have'} "
-                              f"changed in the source {label!r} since this run was queued")
+        for name, path in files:
+            shutil.copy2(path, files_dir / name)
         (rundir / "run.json").write_text(json.dumps(snap))
         return rundir, None
 
+    @staticmethod
+    def _pinned_files(snap):
+        """Each file a run document reads, by name, and the path holding the
+        bytes it pinned at submit -- or (None, why), naming the Source that
+        has gone, or the files gone from it or changed since. A document
+        with no Source reads no files."""
+        content = content_of(snap) or {}
+        if content.get("type") != "source":
+            return [], None
+        ref = content.get("ref") or {}
+        label = ref.get("name") or ref.get("id")
+        if SOURCES.get(ref.get("id")) is None:
+            return None, f"the source {label!r} is gone"
+        revs = content.get("revs") if isinstance(content.get("revs"), dict) else None
+        files, changed = [], []
+        for name in dict.fromkeys(content.get("files") or []):
+            path = SOURCES.file_path(ref["id"], name)
+            if path is None or not path.is_file():
+                return None, f"{name!r} is gone from the source {label!r}"
+            if revs is not None:
+                path = SOURCES.rev_path(ref["id"], name, revs.get(name))
+                if path is None:
+                    changed.append(repr(name))
+                    continue
+            files.append((name, path))
+        if changed:
+            return None, (f"{', '.join(changed)} {'has' if len(changed) == 1 else 'have'} "
+                          f"changed in the source {label!r} since this run was queued")
+        return files, None
+
     def _execute(self, run):
         """One run, FIFO. Never more than one of these at a time: the worker
         is a single thread, so the queue is single-flight by construction."""
@@ -5199,6 +5305,9 @@ class Handler(BaseHTTPRequestHandler):
         return self._send(404, b"not found", "text/plain")
 
     def _queue_action(self, path):
+        # Drained, so a keep-alive connection is not left holding the
+        # page's `{}` in front of its next request.
+        self._payload()
         parts = path.split("/")
         rid = parts[3]
         action = parts[4] if len(parts) > 4 else ""
@@ -5206,6 +5315,10 @@ class Handler(BaseHTTPRequestHandler):
             run, err = QUEUE.cancel(rid)
         elif action == "resume":
             run, err = QUEUE.resume(rid)
+        elif action == "rerun" and len(parts) == 5:
+            run, err = QUEUE.rerun(rid)
+            if not err:
+                return self._json(201, {"run": run})
         elif action == "items" and len(parts) == 6:
             run, err = QUEUE.rerun_item(rid, urllib.parse.unquote(parts[5]))
         elif action == "rescore" and len(parts) == 6: