evals-lab 0.15.0 → 0.16.0

package/lab/evals-core.mjs

@@ -255,7 +255,9 @@ import list, { ECHO, CASE_MODES, legacyTagsOut, legacyTagsModifiers, cleaningFil
 
 /** A target (pipeline-model §16): one column through every job, compared
     side by side in Results -- what version 9 called a scenario. Its step in
-    each job says what it sends there. */
+    each job says what it sends there. From version 20 a Target is the
+    derived view of a Variant over the pipeline's Request steps (jobsOf,
+    targetsOf); the stored shape is the flat step list and its Variants (§20). */
                          
                                                                        
                                                 
@@ -270,6 +272,95 @@ import list, { ECHO, CASE_MODES, legacyTagsOut, legacyTagsModifiers, cleaningFil
                       
  
 
+// ---- the flat step list and Variants (version 20, pipeline-model §20) --------
+//
+// Version 20 reshapes a pipeline from jobs (each a stage holding every
+// Target's step) into one ordered list of steps with Variants beside it. The
+// steps are Get items, Request N, Read Response N and Filter; a Request holds
+// the settings every Variant shares, and each Variant overrides any of them
+// per Request. jobsOf / targetsOf derive the version-19 jobs and targets from
+// this shape, so every reader (the page, the runner, the server through the
+// core) keeps reading one shape; withJobs / withTargets serialise an edit
+// back. The encoding is a verbatim re-packaging of jobs and targets, so a
+// round-trip is byte-exact and stagesFor gives the same stages (#669).
+
+/** Get items: the items a run goes over, before Request 1. There can be
+    several, each adding more items (§20); the upgrade from 19 makes one from
+    job 1's Attach Content. */
+                               
+                   
+             
+                   
+ 
+
+/** A Request: the settings every Variant shares in this job -- its base cell
+    (Variant A's: what it asks and of whom, its words, and an HTTP Request's
+    template), whether the item's image goes with it, the token mappings its
+    words resolve under, and the flow step its records are calls of, for a
+    workflow Request. Each Variant overrides its cell (Variant.overrides); the
+    image and the tokens are the Request's alone. */
+                              
+                  
+             
+               
+                                                                           
+                                                      
+                   
+                                                                             
+                     
+                  
+                                                    
+                         
+                                                                           
+                                                            
+ 
+
+/** Read Response N: how Request N's response is read -- the flow's reading of
+    it (`readAs`, a workflow Request's) and the output kind it is validated as
+    (`out`, absent for plain text). Comes after its Request. */
+                                   
+                       
+             
+                                                          
+                  
+                  
+                               
+                                                                           
+                                                                          
+                                            
+                         
+ 
+
+/** Filter: the filter sets a Request's response is cleaned and gated by, in
+    run order around its Response Format (the version-19 `filters` step, now
+    its own step in the list). Comes after its Request. */
+                                
+                 
+             
+                                                           
+                  
+                              
+                  
+ 
+
+/** One step of a version-20 pipeline. */
+                                                                                         
+
+/** A Variant (version 20): a column through every Request, at most four. It
+    overrides a Request's shared settings, keyed by the Request's id -- AI
+    Connection, Model, Profile, Prompt (or Body) and a workflow Request's
+    Answered by (the cell's `type`); Send image and Tokens are the Request's.
+    An empty override inherits the Request's base; Variant A (the first)
+    inherits every one. The Variant's own `connection` / `profile` are the fallback a Request with no
+    override of its own uses, as a version-19 target's were. */
+                          
+             
+               
+                         
+                      
+                                                 
+ 
+
 /** What every eval carries whatever its type: an id minted once and never
     shown, an optional name ("Eval 2" when blank), and whether the evals after
     it still read what it failed on (docs/pipeline-model.md §3). */
@@ -410,8 +501,13 @@ export const formatReadsItems = (kind                           )          =>
                                           
              
                
-              
-                    
+                                                                       
+                                                                          
+                                                        
+                        
+                                                                        
+                                                                                  
+                      
                
                  
  
@@ -964,12 +1060,18 @@ export function kept(text        , max = KEPT_CHARS)         {
               
                  
                        
+                                                                         
+                                                                     
+                             
  
 
 /** One item of a queue row's results: a file or the pasted text. */
                              
                 
                 
+                                                                        
+                        
+                    
               
                  
                            
@@ -2134,7 +2236,7 @@ function ollamaType(id        , label        , cloud         )                 {
     description: cloud ? "Ollama's cloud at ollama.com, with a key." : "Ollama on a machine of your own; it takes no key.",
     settings: [
       { key: "seed", label: "Seed", control: "text", default: "", hint: "" },
-      { key: "nPredict", label: "Reply tokens", control: "text", default: "", hint: "" },
+      { key: "nPredict", label: "Response tokens", control: "text", default: "", hint: "" },
       { key: "temperature", label: "Temperature", control: "text", default: "", hint: "" },
       { key: "repeatPenalty", label: "Repeat penalty", control: "text", default: "", hint: "" },
     ],
@@ -2187,7 +2289,7 @@ const sendsNothing = ()        => { throw new Error("Echo answers from the item
 // stays so a stored run, or a profile made before, still reads.
 CONNECTION_TYPES.echo = {
   id: "echo", label: "Echo", settings: [], keyless: true, picker: false,
-  description: "No model: answers with each text item itself, to grade replies recorded earlier.",
+  description: "No model: answers with each text item itself, to grade responses recorded earlier.",
   local: (item, sent) => item.text ?? sent,
   request: sendsNothing, parseReply: sendsNothing, listModels: sendsNothing, parseModels: () => [],
 };
@@ -2207,7 +2309,7 @@ function recordedRaw(record         )         {
 // the flow reads a reply; `local` is the no-Read-as fallback.
 CONNECTION_TYPES.recorded = {
   id: "recorded", label: "Recorded", settings: [], keyless: true, picker: false, replays: true,
-  description: "Answers each call with the reply it got when it was recorded. Sends nothing.",
+  description: "Answers each item with the response it got when it was recorded. Sends nothing.",
   local: (_item, _sent, record) => recordedRaw(record),
   request: sendsNothing, parseReply: sendsNothing, listModels: sendsNothing, parseModels: () => [],
 };
@@ -2251,7 +2353,7 @@ CONNECTION_TYPES["openai-compatible"] = {
     // A reasoning model refuses a temperature.
     { key: "temperature", label: "Temperature", control: "text", default: "", hint: "",
       appliesTo: (conn) => !/^(gpt-5|o\d)/i.test(String(conn.model ?? "")) },
-    { key: "nPredict", label: "Reply tokens", control: "text", default: "", hint: "" },
+    { key: "nPredict", label: "Response tokens", control: "text", default: "", hint: "" },
   ],
   // /v1/chat/completions, covering OpenAI, OpenRouter, vLLM, LM Studio.
   // max_completion_tokens stays with this type, as the hosted providers
@@ -2295,7 +2397,7 @@ CONNECTION_TYPES.anthropic = {
   settings: [
     { key: "temperature", label: "Temperature", control: "text", default: "", hint: "",
       appliesTo: (conn) => !CLAUDE_FIXED_SAMPLING.test(String(conn.model ?? "")) },
-    { key: "maxTokens", label: "Reply tokens", control: "text", default: "", hint: "" },
+    { key: "maxTokens", label: "Response tokens", control: "text", default: "", hint: "" },
   ],
   // Asked words (a Prompt step, a grader) or sent a flow's whole request (an
   // HTTP Request step): one profile and one key do both.
@@ -2360,7 +2462,7 @@ CONNECTION_TYPES["llama.cpp"] = {
   settings: [
     { key: "temperature", label: "Temperature", control: "text", default: "", hint: "" },
     { key: "seed", label: "Seed", control: "text", default: "", hint: "" },
-    { key: "nPredict", label: "Reply tokens", control: "text", default: "", hint: "" },
+    { key: "nPredict", label: "Response tokens", control: "text", default: "", hint: "" },
     { key: "repeatPenalty", label: "Repeat penalty", control: "text", default: "", hint: "" },
     { key: "frequencyPenalty", label: "Frequency penalty", control: "text", default: "", hint: "" },
     { key: "presencePenalty", label: "Presence penalty", control: "text", default: "", hint: "" },
@@ -2374,7 +2476,7 @@ CONNECTION_TYPES["llama.cpp"] = {
       choices: [{ value: "on", label: "on" }, { value: "off", label: "off" }], hint: "" },
     { key: "thinking", label: "Thinking", control: "select", default: "off",
       choices: [{ value: "on", label: "on" }, { value: "off", label: "off" }], hint: "" },
-    { key: "rejectLoops", label: "Reject looping replies", control: "select", default: "off",
+    { key: "rejectLoops", label: "Reject looping responses", control: "select", default: "off",
       choices: [{ value: "on", label: "on" }, { value: "off", label: "off" }], hint: "" },
   ],
   request(conn, prompt, dataUrl, base, key) {
@@ -3104,7 +3206,7 @@ function singleRules(test                     )         {
 }
 
 /** "3 of 12 replies", or "the reply" where there was only one. */
-const ofReplies = (k        , n        )         => (n === 1 ? "the reply" : `${k} of ${n} replies`);
+const ofReplies = (k        , n        )         => (n === 1 ? "the response" : `${k} of ${n} responses`);
 const quoted = (s        )         => `"${s.trim().slice(0, 60)}"`;
 
 /**
@@ -3225,7 +3327,7 @@ function jobProblem(stages                  , call
       const kind = OUTPUT_KINDS[kinds[from] ] ;
       if (sub && !(kind.offers || []).includes(sub)) {
         return `and stage ${from + 1} answers with ${kind.noun || kinds[from]}, which has no ${sub} — `
-             + `{${m ? `stage${from + 1}` : "reply"}} is its reply`;
+             + `{${m ? `stage${from + 1}` : "reply"}} is its response`;
       }
       return null;
     };
@@ -3461,7 +3563,7 @@ function applyModifiers   (list                                 , kind        ,
 // pins one response (#596).
 // 19: a job's filters are one list, run in order around its Response Format,
 // and filters are seven verbs (#615).
-const PIPELINE_VERSION = 19         ;
+const PIPELINE_VERSION = 20         ;
 
 // Plain objects, so an entry is added by assignment and a reader never needs
 // to know which registered it.
@@ -3581,9 +3683,9 @@ const clone =    (v   )    => JSON.parse(JSON.stringify(v));
 // A reply read as itself: anything at all, handed on untouched.
 OUTPUT_KINDS.text = {
   label: "Plain text", noun: "text", offers: [],
-  description: "Keeps the reply as it came back, whole.",
+  description: "Keeps the response as it came back, whole.",
   read: reply => ({ value: String(reply ?? "") }),
-  handsOn: (value        ) => (value.trim() ? null : "empty reply"),
+  handsOn: (value        ) => (value.trim() ? null : "empty response"),
 }                                                     ;
 
 // ---- the connection a profile reference resolves to ------------------------
@@ -3694,6 +3796,28 @@ function connectionOf(p         )             {
   return out;
 }
 
+/** The settings a Prompt Request may hold of its own (#672): any connection
+    type's, but those that say how it is reached and the model, its own field. */
+const requestSettingKeys = ()           => [...new Set(Object.values(CONNECTION_TYPES)
+  .flatMap(t => t.settings.filter(s => s.scope !== "connection" && s.key !== "model").map(s => s.key)))];
+
+/** [conn] with a Request's own settings over it, as connectionOf carries
+    them: a preset kept on a Variant (#672). One left blank is not sent, so a
+    preset clears what it does not set, as Apply preset does a profile's. */
+function withOwnSettings                                                                          (conn   , own                                    )    {
+  if (!own || !Object.keys(own).length) return conn;
+  const out    = { ...conn };
+  const options                            = { ...(conn.options || {}) };
+  for (const [k, v] of Object.entries(own)) {
+    const set = String(v ?? "").trim() !== "";
+    if (k === "temperature") { if (set) out.temperature = v; else delete out.temperature; }
+    else if (set) options[k] = v;
+    else delete options[k];
+  }
+  if (Object.keys(options).length) out.options = options; else delete out.options;
+  return out;
+}
+
 /** A run's connection as one flat set of settings, the shape a profile has. */
 function connectionSettings(c                             )           {
   const { options, ...rest } = c || {};
@@ -3776,7 +3900,7 @@ function answerOfKey(key        )
 
 /** Whom target [i] asks in job [k]: its step's own connection or profile,
     where it names either, else the target's. */
-function targetAnswerOf(doc                                                           , i        , k        )                     {
+function targetAnswerOf(doc                             , i        , k        )                     {
   const t = targetsOf(doc)[i];
   const st = targetStepOf(doc, i, k);
   const own = st?.connection != null || st?.profile != null;
@@ -3787,7 +3911,7 @@ function targetAnswerOf(doc
 }
 
 /** The answer key of target [i] in job [k], or undefined where it asks none. */
-function targetAnswerKey(doc                                                           , i        , k        )                     {
+function targetAnswerKey(doc                             , i        , k        )                     {
   const a = targetAnswerOf(doc, i, k);
   return a ? answerKey(a.connection.id, a.profile?.id) : undefined;
 }
@@ -3868,9 +3992,9 @@ function encoderQuality(quality               )         {
 // ---- labels -----------------------------------------------------------------
 // A name is optional everywhere; a blank one is the number the canvas has
 // always shown, so a sentence names what the reader sees.
-const jobLabel = (doc                                         , k        )         =>
-  (doc.jobs?.[k]?.name || "").trim() || `Job ${k + 1}`;
-const scenarioLabel = (doc                                 , i        )         => targetLabel(doc, i);
+const jobLabel = (doc                              , k        )         =>
+  (jobsOf(doc)[k]?.name || "").trim() || `Job ${k + 1}`;
+const scenarioLabel = (doc                             , i        )         => targetLabel(doc, i);
 // The runner calls a job's link a stage; the model calls it a job.
 const jobWords = (s        )         => s && String(s).replace(/\bstage[ ](\d+)/g, "job $1");
 
@@ -3881,8 +4005,8 @@ function onlyFields(obj        , at        , allowed                   , bad
   for (const k of Object.keys(obj)) {
     if (allowed.includes(k)) continue;
     bad.push(LOOKS_LIKE_A_KEY.test(k)
-      ? `${at} carries "${k}", and a key never goes in a pipeline — $${keyFrom || "EVALSLAB_API_KEY_<ID>"} supplies it`
-      : `${at} has "${k}", which is not a pipeline field`);
+      ? `${at} carries "${k}", and a key never goes in an experiment — $${keyFrom || "EVALSLAB_API_KEY_<ID>"} supplies it`
+      : `${at} has "${k}", which is not an experiment field`);
   }
 }
 
@@ -3915,9 +4039,9 @@ SOURCE_TYPES.workflow = {
   icon: "workflow",
   description: "A cloud flow, with records of its steps' calls from its run history.",
   group: "Workflows",
-  // Each item reads as a call, as the Source's Calls group names them, though
+  // Each item reads as an item, as the Source's Items group names them, though
   // the file holding one is a record.
-  noun: "call",
+  noun: "item",
   uploads: [".json"],
   sendsImage: false,
   hasActions: true,
@@ -3959,9 +4083,9 @@ WORKFLOW_PLATFORMS["power-automate"] = {   // platform: the Power Automate adapt
 SOURCE_TYPES.dynamic = {
   label: "Dynamic",
   icon: "globe",
-  description: "Data produced on demand -- an HTTP GET, an API, a file or a command -- captured as Calls.",
+  description: "Data produced on demand -- an HTTP GET, an API, a file or a command -- captured as Items.",
   group: "Dynamic",
-  noun: "call",                    // the generic default; the provider's own overrides it
+  noun: "item",                    // the generic default; the provider's own overrides it
   uploads: [".txt", ".json", ".csv", ".md"],
   sendsImage: false,
   hasActions: false,
@@ -4090,7 +4214,7 @@ DYNAMIC_PROVIDERS["command"] = {   // provider: the Command adapter's own id
   id: "command",                   // provider: its id, the row's config.provider
   label: "Command",
   icon: "terminal",
-  noun: "call",
+  noun: "item",
   produceIcon: "square-terminal",
   tier: "local",
   config: ["command", "args"],
@@ -4238,8 +4362,8 @@ CONTENT_TYPES.text = {
 // model asked the prompt itself, or Echo answering with it, the prompt then
 // being the recorded reply.
 CONTENT_TYPES.prompt = {
-  label: "Prompt only",
-  description: "No item: each target's prompt is sent on its own.",
+  label: "(No content)",
+  description: "No item: each variant's prompt is sent on its own.",
   inline: true,
   bare: true,
   fields: ["type"],
@@ -4303,9 +4427,9 @@ LEGACY_TESTS.graded = {
   validate(t, ctx, bad){
     const d = t.dataset;
     if (!isRef(d) || (d.version != null && !isStr(d.version))) {
-      return void bad.push("a graded eval has to name its dataset as { id, name }");
+      return void bad.push("a graded eval has to name its Library eval as { id, name }");
     }
-    if (ctx.groups && !ctx.groups.some(x => x.id === d.id)) bad.push(`Eval group ${d.name || d.id} not found`);
+    if (ctx.groups && !ctx.groups.some(x => x.id === d.id)) bad.push(`Eval ${d.name || d.id} not found`);
   },
 };
 
@@ -4507,9 +4631,9 @@ function readRun(list                   , run             )                  {
     const off = each.filter(r => !r.pass);
     const first = each[0];
     if (!first) return [{ type: m.type, label: METRICS[m.type]?.label ?? m.type, weight: typeof m.weight === "number" ? m.weight : 1,
-                          pass: true, score: 1, reason: "no replies" }];
+                          pass: true, score: 1, reason: "no responses" }];
     return [{ ...first, pass: !off.length, score: each.length ? (each.length - off.length) / each.length : 1,
-              reason: off.length ? `${off.length} of ${each.length} replies: ${off[0] .reason}` : `all ${each.length} replies` }];
+              reason: off.length ? `${off.length} of ${each.length} responses: ${off[0] .reason}` : `all ${each.length} responses` }];
   });
 }
 
@@ -4518,7 +4642,7 @@ function readRun(list                   , run             )                  {
 // pipeline-check.js hold the eval group to.
 LEGACY_TESTS.metrics = {
   label: "Metrics",
-  description: "Checks of each reply, or of the whole run, scored all-must-pass or in weighted points.",
+  description: "Checks of each response, or of the whole run, scored all-metrics-pass or in points.",
   fields: ["type", "metrics", "mode", "threshold", "grader", "dataset", "over"],
   // A metric that reads terms (a case) reads only a kind that yields them.
   accepts: t => (Array.isArray(t.metrics) && t.metrics.some((m           ) => METRICS[m?.type]?.needsTerms)
@@ -4533,8 +4657,8 @@ LEGACY_TESTS.metrics = {
     }
     // The dataset whose cases a case metric reads, and whose own metrics join.
     if (t.dataset != null) {
-      if (!isRef(t.dataset) || (t.dataset.version != null && !isStr(t.dataset.version))) bad.push("the Metrics name their dataset as { id, name }");
-      else if (ctx.groups && !ctx.groups.some(x => x.id === t.dataset.id)) bad.push(`Eval group ${t.dataset.name || t.dataset.id} not found`);
+      if (!isRef(t.dataset) || (t.dataset.version != null && !isStr(t.dataset.version))) bad.push("the Metrics name their eval as { id, name }");
+      else if (ctx.groups && !ctx.groups.some(x => x.id === t.dataset.id)) bad.push(`Eval ${t.dataset.name || t.dataset.id} not found`);
     }
     if (!SCORING_MODES.includes(t.mode)) bad.push(`the Metrics are scored ${SCORING_MODES.join(" or ")}`);
     if (t.mode === "weighted" && typeof t.threshold !== "number") bad.push("weighted Metrics need a threshold: the points an item has to reach");
@@ -4626,8 +4750,8 @@ const wholeRunGroup = (t           )          => isObj(t.own) && Array.isArray(t
 // group does (readGroup), or -- a private group of Whole run metrics alone --
 // the whole run (readGroupRun).
 EVAL_TYPES.group = {
-  label: "Eval group",
-  description: "Checks of each reply, or of the whole run, from an eval group: linked from the Library, or this pipeline's own.",
+  label: "Eval",
+  description: "Checks of each response, or of the whole run, from an eval: linked from the Library, or this experiment's own.",
   fields: ["type", "group", "pin", "own", "grader"],
   // A metric that reads terms (a case) reads only a kind that yields them.
   accepts: t => ([...ownList(t)].some((m           ) => METRICS[m?.type]?.needsTerms)
@@ -4640,17 +4764,17 @@ EVAL_TYPES.group = {
     const named = (ref           , what        ) => {
       const n = isObj(ref) ? ref.n : undefined;
       if (!isRef(ref) || (ref.version != null && !isStr(ref.version)) || (n != null && !Number.isInteger(n))) {
-        return void bad.push(`${what} names its eval group as { id, name }`);
+        return void bad.push(`${what} names its eval as { id, name }`);
       }
       onlyFields(ref, what, ["id", "name", "version", "n"], bad);
       const held = ctx.groups?.find(x => x.id === ref.id);
-      if (ctx.groups && !held) bad.push(`Eval group ${ref.name || ref.id} not found`);
+      if (ctx.groups && !held) bad.push(`Eval ${ref.name || ref.id} not found`);
       return held;
     };
-    if (t.pin != null && !(Number.isInteger(t.pin) && t.pin > 0)) bad.push("a pin is a group's version: a whole number from 1");
+    if (t.pin != null && !(Number.isInteger(t.pin) && t.pin > 0)) bad.push("a pin is an eval's version: a whole number from 1");
     if (t.grader != null && !isRef(t.grader)) bad.push("the link names its grader as { id, name }");
     if (g != null) {
-      if (own != null) return void bad.push("an eval links a Library group or holds its own, not both");
+      if (own != null) return void bad.push("an eval links a Library eval or holds its own, not both");
       const held = named(g, "the link");
       if (held && t.pin != null && typeof held.versions === "number" && t.pin > held.versions) {
         bad.push(`${g.name || g.id} has no version ${t.pin}`);
@@ -4662,17 +4786,17 @@ EVAL_TYPES.group = {
       graderProblems(grader, ctx, bad);
       return;
     }
-    if (!isObj(own)) return void bad.push("an eval links a Library group, or holds its own");
-    if (t.pin != null) bad.push("a group of this pipeline's own versions with it, so it is never pinned");
-    if (own.version !== DATASET_BODY_VERSION) bad.push(`the group's own body is version ${DATASET_BODY_VERSION}`);
-    for (const key of ["scoring", "every", "run", "cases"]) if (own[key] == null) bad.push(`the group's own body has no ${key}`);
-    onlyFields(own, "the group's own body", ["version", "scoring", "grader", "every", "run", "cases", "casesFrom"], bad);
+    if (!isObj(own)) return void bad.push("an eval links a Library eval, or holds its own");
+    if (t.pin != null) bad.push("an eval of this experiment's own versions with it, so it is never pinned");
+    if (own.version !== DATASET_BODY_VERSION) bad.push(`the eval's own body is version ${DATASET_BODY_VERSION}`);
+    for (const key of ["scoring", "every", "run", "cases"]) if (own[key] == null) bad.push(`the eval's own body has no ${key}`);
+    onlyFields(own, "the eval's own body", ["version", "scoring", "grader", "every", "run", "cases", "casesFrom"], bad);
     if (bad.length) return;
     bad.push(...validateEvals(own));
-    if (own.casesFrom != null) named(own.casesFrom, "Cases from");
+    if (own.casesFrom != null) named(own.casesFrom, "Eval cases from");
     // Read item by item or over the run: one section at a time, until a
     // group's Whole run is reported beside its items (#233).
-    if (own.run.length && !wholeRunGroup(t)) bad.push("the group's own body reads each item or the whole run, not both");
+    if (own.run.length && !wholeRunGroup(t)) bad.push("the eval's own body reads each item or the whole run, not both");
     // The group's own grader, or the lab's.
     const grader = isRef(own.grader) ? own.grader : isRef(ctx.grader) ? ctx.grader : null;
     if (gradedIn(own.every) && !grader) bad.push("a model-graded metric needs a grader: pick one on the eval, or make a connection the lab's grader");
@@ -4737,8 +4861,8 @@ function caseIn(body                         , item        )              {
 // ignoring case, as the Single Test did.
 METRICS["has-items"] = {
   label: "Has items",
-  family: "The reply's text",
-  description: "Passes when the reply holds all, or any, of the items listed.",
+  family: "The response's text",
+  description: "Passes when the response holds all, or any, of the items listed.",
   options: [{ key: "values", label: "Items", type: "textarea" },
             { key: "need", label: "Needs", type: "select", choices: [{ value: "all", label: "all" }, { value: "any", label: "any" }] }],
   defaults: () => ({ values: "", need: "all" }),
@@ -4766,8 +4890,8 @@ const parseCountOf = (m        )                =>
 // A reply's length in characters, once trimmed.
 METRICS.length = {
   label: "Length",
-  family: "The reply's text",
-  description: "Compares the reply's length in characters.",
+  family: "The response's text",
+  description: "Compares the response's length in characters.",
   options: [{ key: "op", label: "Is", type: "select", choices: LENGTH_OPS.map(([value, label]) => ({ value, label })) },
             { key: "n", label: "Characters", type: "number" }],
   defaults: () => ({ op: "exactly", n: 0 }),
@@ -4787,7 +4911,7 @@ METRICS.length = {
 METRICS["parse-count"] = {
   label: "Parses",
   family: "The result",
-  description: "Passes when the reply reads as the format chosen, holding the number of results set.",
+  description: "Passes when the response reads as the format chosen, holding the number of results set.",
   // Unformatted is one result a reply, as the Single Test counted it.
   options: [{ key: "parse", label: "As", type: "select", choices: [{ value: "", label: "Unformatted" }, { value: "csv", label: "csv" },
                                                                     { value: "json", label: "json" }, { value: "xml", label: "xml" }] },
@@ -4940,11 +5064,11 @@ function metricCheck(m        )         {
 // Attach Content: the items a run goes over, job 1's first step.
 STEP_TYPES.attachContent = {
   label: "Attach Content", slot: "content", rank: 0,
-  description: "The items the run goes through: each is sent to every target.",
+  description: "The items the run goes through: each is sent to every variant.",
   in: null, out: "items",
   apply: "itemContent",   // run-evals.js, through its file-type registry
   fields: ["type", "content"],
-  firstJobOnly: "only job 1 attaches content -- a later job is handed the reply before it",
+  firstJobOnly: "only job 1 attaches content -- a later job is handed the response before it",
   validate(step, ctx, bad){
     const c = step?.content;
     if (!c) return void bad.push("set the content first");
@@ -5004,12 +5128,21 @@ STEP_TYPES.tokenMappings = {
 // Prompt: a target's words, asked of its model.
 STEP_TYPES.prompt = {
   label: "Prompt", slot: "target", asks: "prompt", modelFrom: "profile",
-  description: "Asks each target's model its prompt about the item.",
+  description: "Asks each variant's model its prompt about the item.",
   in: "item", out: "text",
   apply: "runPipeline",
-  fields: ["type", "prompt", "connection", "profile", "from"],
+  // A model and settings of its own go over its connection's (stagesFor):
+  // a preset kept on a Variant (#672).
+  fields: ["type", "prompt", "connection", "profile", "from", "model", "settings"],
   validate(step, _ctx, bad, at){
     if (!isStr(step.prompt)) bad.push(`${at}: prompt has to be text`);
+    if (step.model != null && !isStr(step.model)) bad.push(`${at}: model has to be text`);
+    if (step.settings != null) {
+      if (!isObj(step.settings) || !Object.values(step.settings).every(isStr)) bad.push(`${at}: settings are names to text`);
+      else for (const k of Object.keys(step.settings)) {
+        if (!requestSettingKeys().includes(k)) bad.push(`${at}: no connection type has a setting ${k}`);
+      }
+    }
   },
 };
 
@@ -5031,7 +5164,7 @@ function keyField(v         , at = "body")                {
 }
 STEP_TYPES.httpRequest = {
   label: "HTTP Request", slot: "target", asks: "request", verbatim: true, modelFrom: "step",
-  description: "Sends a Power Automate step's own request, rebuilt from each record, with each target's words in it.",
+  description: "Sends a Power Automate step's own request, rebuilt from each record, with each variant's words in it.",
   firstJobOnly: "an HTTP Request is sent from its item's record, so it is job 1's",
   // A new target starts from the flow's own words and fields, read by the
   // job's HTTP API ([step] carries it: requestStepOf).
@@ -5052,7 +5185,7 @@ STEP_TYPES.httpRequest = {
     // A key is the Setup profile's, sent by its Key header; one in the
     // template would be kept in the pipeline and every run of it.
     const hit = keyField(step.body) ?? keyField(step.query, "query");
-    if (hit) bad.push(`${at} carries a key at ${hit}, and a key never goes in a pipeline -- the connection sends it`);
+    if (hit) bad.push(`${at} carries a key at ${hit}, and a key never goes in an experiment -- the connection sends it`);
     if (!api) return;
     // Its fields, where its HTTP API has a place for them.
     for (const f of ["system", "model", "prefill"]         ) {
@@ -5083,7 +5216,7 @@ STEP_TYPES.httpRequest = {
 // against; over Prompt only they are the reply.
 STEP_TYPES.echo = {
   label: "Echo", slot: "target", asks: "nothing", local: true, replaces: "echo",
-  description: "Sends nothing: each text item is its own reply, to grade replies recorded earlier.",
+  description: "Sends nothing: each text item is its own response, to grade responses recorded earlier.",
   firstJobOnly: "Echo answers only job 1, with the item's own text",
   in: "item", out: "text",
   apply: "runPipeline",
@@ -5097,7 +5230,7 @@ STEP_TYPES.echo = {
 // the flow reads one. No profile, no prompt -- the record is the reply.
 STEP_TYPES.recorded = {
   label: "Recorded", slot: "target", asks: "nothing", local: true, replaces: "recorded",
-  firstJobOnly: "a call's recorded reply is job 1's",
+  firstJobOnly: "an item's recorded response is job 1's",
   in: "item", out: "text",
   apply: "runPipeline",
   // `prompt` only so the step satisfies the target-step shape; it is never
@@ -5122,7 +5255,7 @@ const localConnOf = (entry                           )
 // Read as: what the flow does to the reply before it reads it.
 STEP_TYPES.readAs = {
   label: "Read as", slot: "responses", rank: 0,
-  description: "What the flow makes of the reply before it reads it.",
+  description: "What the flow makes of the response before it reads it.",
   in: "text", out: "text",
   apply: "runPipeline",
   fields: ["type", "readAs"],
@@ -5133,8 +5266,8 @@ STEP_TYPES.readAs = {
 
 // Response Format Validation: the kind a reply is read as.
 STEP_TYPES.readReply = {
-  label: "Read Reply", slot: "responses", rank: 1,
-  description: "How the reply is read before evals and later jobs see it.",
+  label: "Read Response", slot: "responses", rank: 1,
+  description: "How the response is read before evals and later jobs see it.",
   in: "text", out: step => step.out?.kind,
   // Read inside the stage: runPipeline parses each reply as it comes back.
   apply: "runPipeline",
@@ -5153,7 +5286,7 @@ STEP_TYPES.readReply = {
 // A modifier: one change to the parsed reply, after the kind that takes it.
 STEP_TYPES.modifier = {
   label: "Modifier", slot: "responses", rank: 2, many: true,
-  description: "Changes the reply after it is read.",
+  description: "Changes the response after it is read.",
   in: "value", out: "value",
   apply: "runPipeline",
   fields: ["type", "modifier"],
@@ -5175,7 +5308,7 @@ STEP_TYPES.modifier = {
 // so only its shape is checked here.
 STEP_TYPES.filters = {
   label: "Filter sets", slot: "responses", rank: 2,
-  description: "Cleans and gates the reply with linked or private filter sets.",
+  description: "Cleans and gates the response with linked or private filter sets.",
   in: "value", out: "value",
   apply: "runPipeline",
   fields: ["type", "filterSets", "format"],
@@ -5223,17 +5356,263 @@ function withStep(job     , type              , step             )      {
   return { ...job, steps: ordered(step ? [...steps, step] : steps) };
 }
 
-/** A pipeline's content: job 1's content step, or none. */
-function contentOf(doc                                              )                 {
-  return stepOf                   (doc?.jobs?.[0], "attachContent")?.content ?? null;
+// ---- the flat step list and Variants: derive jobs/targets, serialise back ----
+// Version 20 stores a pipeline as its step list and Variants; every reader
+// reads the version-19 jobs and targets jobsOf / targetsOf derive, and every
+// edit is serialised back by withJobs / withTargets. The encoding is a
+// verbatim re-packaging, so the round-trip is byte-exact and stagesFor gives
+// the same stages (pipeline-model §20, #669). A doc still carrying `jobs` or
+// `targets` -- the shape upgradePipeline's chain builds before it serialises,
+// and any legacy caller -- is read through as it is.
+
+/** What a pipeline/run reader takes: the version-20 step list and Variants,
+    or the jobs-and-targets intermediate the upgrade builds before it
+    serialises -- the accessors read whichever is present. */
+                                                                                   
+                                                                                          
+
+const isGetItems = (st         )                     => isObj(st) && st.type === "getItems";
+const isRequest = (st         )                    => isObj(st) && st.type === "request";
+const isReadResponse = (st         )                         => isObj(st) && st.type === "readResponse";
+const isFilterV20 = (st         )                      => isObj(st) && st.type === "filter";
+
+/** Whether two JSON values say the same thing: object key order is ignored
+    and a key holding `undefined` counts as absent, as JSON writes them;
+    array order counts. */
+function sameJson(a         , b         )          {
+  if (a === b) return true;
+  if (Array.isArray(a)) return Array.isArray(b) && a.length === b.length && a.every((v, i) => sameJson(v, b[i]));
+  if (!isObj(a) || !isObj(b)) return false;
+  const keys = (o           ) => Object.keys(o).filter(k => o[k] !== undefined);
+  const ka = keys(a);
+  return ka.length === keys(b).length && ka.every(k => b[k] !== undefined && sameJson(a[k], b[k]));
+}
+
+/** The override to carry Variant [cur] over the Request's base [base], or
+    none where they are the same. A different step type, or a different set of
+    fields, is carried whole (it holds `type`, so mergeCell replaces); a cell
+    of the same shape carries only the fields whose value differs. */
+function cellDiff(base                        , cur                        )                                  {
+  if (!cur) return undefined;
+  if (!base) return clone(cur);
+  const bk = Object.keys(base).sort().join("\u0000"), ck = Object.keys(cur).sort().join("\u0000");
+  if (cur.type !== base.type || bk !== ck) return clone(cur);
+  const ov                          = {};
+  for (const key of Object.keys(cur)) if (key !== "type" && !sameJson((cur             )[key], (base             )[key])) ov[key] = clone((cur             )[key]);
+  return Object.keys(ov).length ? ov                        : undefined;
+}
+
+/** A Variant's cell over a Request's base [base]: the base where there is no
+    override, the override whole where it carries its own `type` (a different
+    Answered by, or a different shape), else the base with the override's
+    fields. */
+function mergeCell(base                        , ov                                 )             {
+  if (!ov) return clone(base ?? { type: "prompt", prompt: "" })              ;
+  if ("type" in ov) return clone(ov)              ;
+  return { ...clone(base ?? { type: "prompt", prompt: "" }), ...clone(ov) }              ;
+}
+
+/** [jobs] and [targets] as a version-20 step list and Variants. Variant A's
+    step in each job is the Request's base; a later Variant carries only its
+    overrides. A verbatim re-packaging: jobsOf and targetsOf read it back whole.
+    Given the list it replaces ([old]), the steps keep their order there and
+    the steps the jobs do not hold (keepOrder). */
+function serialize(jobs                , targets                   , old                          )                                                 {
+  const { steps, variants } = serializeFresh(jobs, targets);
+  return { steps: keepOrder(old, steps), variants };
+}
+
+/** [next], a freshly serialised step list, in the order [old] held its steps
+    (§20): the person moves steps in the Steps list, and an edit made through
+    the jobs view must not move them back. Each step of [old] takes its new
+    version where [next] has one (its id kept): a Request by its id, a Read
+    Response or Filter by the Request it reads, and the first Get items by
+    being the first. A later Get items, which the jobs view does not hold, is
+    kept as it is; and a Request already here with no Read Response gets
+    none, though the jobs view reads it as plain text. A step new
+    in [next] goes after the step before it there. With no [old], [next]. */
+function keepOrder(old                                     , next                )                 {
+  if (!Array.isArray(old)) return next;
+  const key = (st              ) => st.type === "request" ? `request:${st.id}`
+    : st.type === "getItems" ? null : `${st.type}:${st.request}`;
+  const byKey = new Map(next.flatMap(st => { const k = key(st); return k ? [[k, st]         ] : []; }));
+  const items = next.find(isGetItems);
+  const empty = (st              ) => st.type === "readResponse" && st.readAs == null && !st.out && !st.modifiers?.length;
+  // Each step of [next] placed, by the step it became in the result.
+  const placed = new Map                            ();
+  const out                 = [];
+  const firstItems = old.find(isGetItems);
+  for (const st of old.filter((o)                    => isObj(o))) {
+    if (isGetItems(st)) {
+      if (st !== firstItems) out.push(st);
+      else if (items) { const put = { ...items, id: st.id }; out.push(put); placed.set(items, put); }
+      continue;
+    }
+    const k = key(st);
+    const n = k ? byKey.get(k) : undefined;
+    if (n && !placed.has(n)) { const put = { ...n, id: st.id }; out.push(put); placed.set(n, put); }
+  }
+  // A Read Response the jobs view reads as plain text, for a Request already
+  // here that had none, stays away: the person removed it, or never added one.
+  const hadRead = new Set(old.flatMap(st => isReadResponse(st) ? [st.request] : []));
+  next.forEach((n, x) => {
+    if (placed.has(n)) return;
+    if (empty(n) && !hadRead.has((n                    ).request)
+        && old.some(st => isRequest(st) && st.id === (n                    ).request)) return;
+    let at = 0;
+    for (let y = x - 1; y >= 0; y--) {
+      const before = placed.get(next[y] );
+      if (before) { at = out.indexOf(before) + 1; break; }
+    }
+    out.splice(at, 0, n);
+    placed.set(n, n);
+  });
+  return out;
 }
 
-/** [doc] with its content set -- job 1's content step added, replaced, or
-    taken away for null. */
-function withContent                           (doc   , content                )    {
-  const [first, ...rest] = doc.jobs;
+function serializeFresh(jobs                , targets                   )                                                 {
+  const steps                 = [];
+  const content = stepOf                   (jobs[0], "attachContent")?.content ?? null;
+  if (content) steps.push({ type: "getItems", id: `items-${jobs[0] .id}`, content });
+  jobs.forEach((job, k) => {
+    const base = targets[0]?.steps?.[k];
+    const req              = { type: "request", id: job.id, name: job.name,
+      cell: base ? clone(base) : { type: "prompt", prompt: "" } };
+    if (sendsImage(job)) req.image = true;
+    const toks = tokensOf(job);
+    if (toks.length) req.tokens = toks;
+    const flow = flowStepOf(job);
+    if (flow) req.flow = flow;
+    steps.push(req);
+    const read                   = { type: "readResponse", id: `read-${job.id}`, request: job.id };
+    const readAs = readAsOf(job);
+    if (readAs != null) read.readAs = readAs;
+    const reply = replyOf(job);
+    if (reply) read.out = reply.out;
+    const mods = (job.steps || []).filter((st)                     => isObj(st) && st.type === "modifier").map(st => st.modifier);
+    if (mods.length) read.modifiers = mods;
+    steps.push(read);
+    const filt = filterStepOf(job);
+    if (filt) steps.push({ type: "filter", id: `filter-${job.id}`, request: job.id,
+      filterSets: filt.filterSets, ...(filt.format != null ? { format: filt.format } : {}) });
+  });
+  const variants            = targets.map((t, i) => {
+    const overrides                                      = {};
+    if (i > 0) jobs.forEach((job, k) => {
+      const ov = cellDiff(targets[0]?.steps?.[k], t.steps?.[k]);
+      if (ov) overrides[job.id] = ov;
+    });
+    return { id: t.id, name: t.name, connection: t.connection ?? null, profile: t.profile ?? null, overrides };
+  });
+  return { steps, variants };
+}
+
+/** The version-19 jobs a version-20 document holds: one per Request, its
+    Content (job 1's Get items, the Request's image, tokens and flow) and its
+    Responses (its Read Response and Filter) rebuilt from the step list. */
+function jobsOf(doc                                                                               )        {
+  if (Array.isArray(doc?.jobs)) return doc .jobs         ;
+  const all = Array.isArray(doc?.steps) ? doc .steps  : [];
+  const items = all.find(isGetItems);
+  const requests = all.filter(isRequest);
+  return requests.map((req, k) => {
+    const read = all.find((st)                         => isReadResponse(st) && st.request === req.id);
+    const filt = all.find((st)                      => isFilterV20(st) && st.request === req.id);
+    const inner         = [];
+    if (k === 0 && items) inner.push({ type: "attachContent", content: items.content });
+    if (req.flow) inner.push({ type: "flowStep", step: req.flow.step, loop: req.flow.loop ?? null, api: req.flow.api });
+    if (req.image) inner.push({ type: "attachImage" });
+    if (req.tokens && req.tokens.length) inner.push({ type: "tokenMappings", tokenMappings: req.tokens });
+    if (read?.readAs != null) inner.push({ type: "readAs", readAs: read.readAs });
+    if (read?.out) inner.push({ type: "readReply", out: read.out });
+    for (const m of read?.modifiers ?? []) inner.push({ type: "modifier", modifier: m });
+    if (filt) inner.push({ type: "filters", filterSets: filt.filterSets, ...(filt.format != null ? { format: filt.format } : {}) });
+    return { type: "job", id: req.id, name: req.name, steps: ordered(inner) };
+  });
+}
+
+/** [doc] with its jobs set, serialised back into the step list beside its
+    Variants (the targets left as they read now). */
+function withJobs                  (doc   , jobs                )    {
+  return { ...doc, ...serialize(jobs, targetsOf(doc             ), (doc             ).steps) };
+}
+
+/** [doc] with its targets set, serialised back into the Variants beside its
+    step list (the jobs left as they read now). */
+function withTargets                  (doc   , targets                   )    {
+  return { ...doc, ...serialize(jobsOf(doc             ), targets, (doc             ).steps) };
+}
+
+/** A pipeline's content: job 1's Get items step, or none. */
+function contentOf(doc                                                                               )                 {
+  if (Array.isArray(doc?.jobs)) return stepOf                   (doc .jobs [0], "attachContent")?.content ?? null;
+  return (Array.isArray(doc?.steps) ? doc .steps .find(isGetItems)?.content : null) ?? null;
+}
+
+/** Every Get items step's content, in list order, with the step's id and the
+    folder a run keeps its files under: the first at the top of the run's
+    files, as a run over one Source always was, and each later one under
+    `@N`, N its place among them -- a name no item can have, since an item's
+    name starts with a letter, a digit or `_` (§20). A version-19 document's
+    one content is the first. */
+function itemContents(doc                                                                               )                {
+  if (Array.isArray(doc?.jobs)) {
+    const content = contentOf(doc);
+    return content ? [{ step: "", content, dir: "" }] : [];
+  }
+  const steps = Array.isArray(doc?.steps) ? doc .steps  : [];
+  return steps.filter(isGetItems).map((st, k) => ({ step: st.id, content: st.content, dir: k ? `@${k + 1}` : "" }));
+}
+
+/** One Get items step's content, as itemContents reads it. */
+                              
+               
+                   
+              
+ 
+
+/** One item a run goes over: a file of a Source (its name, under its step's
+    folder), a text of the document's own, or the bare item a run with no
+    content of its own goes over, its prompt alone. */
+                          
+                      
+                
+                 
+              
+                                                                           
+                                                                        
+               
+ 
+
+/** The items [run] goes over, in order: each Get items step's in turn -- a
+    Source's files (the run's `files`, stamped at submit) or a text -- so a
+    second Get items adds more items, run through the same steps. A step
+    with no item of its own (No content) adds none; a run where no step adds
+    one goes over the bare item. */
+function runItemsOf(run                                                                               )            {
+  const out            = [];
+  const all = itemContents(run);
+  for (const { step, content, dir } of all) {
+    const type = isObj(content) ? CONTENT_TYPES[content.type] : undefined;
+    if (content?.type === "source") {
+      for (const name of content.files || []) out.push({ name, dir, step });
+    } else if (type?.inline && !type.bare) {
+      const text = type.text?.(content, {}) ?? "";
+      if (text.trim()) out.push({ name: null, text, dir, step });
+    }
+  }
+  const bare = all.find(x => isObj(x.content) && CONTENT_TYPES[x.content.type]?.bare);
+  if (!out.length && bare) out.push({ name: null, bare: true, dir: "", step: bare.step });
+  return out;
+}
+
+/** [doc] with its content set -- job 1's Get items added, replaced, or taken
+    away for null -- serialised back into the step list. */
+function withContent                  (doc   , content                )    {
+  const jobs = jobsOf(doc             );
+  const [first, ...rest] = jobs;
   if (!first) return doc;
-  return { ...doc, jobs: [withStep(first, "attachContent", content ? { type: "attachContent", content } : null), ...rest] };
+  return withJobs(doc, [withStep(first, "attachContent", content ? { type: "attachContent", content } : null), ...rest]);
 }
 
 /**
@@ -5244,7 +5623,7 @@ function withContent                           (doc   , content                )
  * only where a token places it, and an image or a document is sent as a part
  * of its own, so neither is joined. [ctx] reads a Source as validation does.
  */
-function contentJoined(doc                                                                                  , i        , k        ,
+function contentJoined(doc                             , i        , k        ,
                        ctx                = {})          {
   if (k !== 0 || targetEntryOf(doc, i, k)?.asks !== "prompt") return false;
   if (String(targetStepOf(doc, i, k)?.prompt ?? "").includes("{text}")) return false;
@@ -5252,9 +5631,18 @@ function contentJoined(doc
   return !!content && (CONTENT_TYPES[content.type]?.text?.(content, ctx) ?? null) != null;
 }
 
-/** A document's targets, in column order. */
-function targetsOf(doc                                                           )           {
-  return Array.isArray(doc?.targets) ? doc .targets             : [];
+/** A document's targets, in column order: each Variant as a column through
+    the Request steps, its cell in each the Request's base with the Variant's
+    override over it (version 20). A doc still carrying `targets` -- the shape
+    the upgrade builds before it serialises -- is read as it is. */
+function targetsOf(doc                                                                                                                           )           {
+  if (Array.isArray(doc?.targets)) return doc .targets            ;
+  const requests = (Array.isArray(doc?.steps) ? doc .steps  : []).filter(isRequest);
+  const variants = Array.isArray(doc?.variants) ? doc .variants  : [];
+  return variants.map(v => ({
+    id: v.id, name: v.name, connection: v.connection ?? null, profile: v.profile ?? null,
+    steps: requests.map(req => mergeCell(req.cell, v.overrides?.[req.id])),
+  }));
 }
 
 /** Target [i]'s letter, A for the first: the same in every job, so a
@@ -5263,24 +5651,24 @@ function targetLetter(i        )         {
   return i < 26 ? String.fromCharCode(65 + i) : String(i + 1);
 }
 
-/** Target [i]'s name, or its letter's: "Target A". */
-function targetLabel(doc                                                           , i        )         {
-  return (targetsOf(doc)[i]?.name || "").trim() || `Target ${targetLetter(i)}`;
+/** Target [i]'s name, or its letter's: "Variant A". */
+function targetLabel(doc                             , i        )         {
+  return (targetsOf(doc)[i]?.name || "").trim() || `Variant ${targetLetter(i)}`;
 }
 
 /** What target [i] sends in job [k]: its step there. */
-function targetStepOf(doc                                                           , i        , k        )                         {
+function targetStepOf(doc                             , i        , k        )                         {
   const st = targetsOf(doc)[i]?.steps?.[k];
   return isObj(st) ? st               : undefined;
 }
 
 /** The registry entry of target [i]'s step in job [k]: what it asks, and of whom. */
-const targetEntryOf = (doc                                                           , i        , k        )                            =>
+const targetEntryOf = (doc                             , i        , k        )                            =>
   STEP_TYPES[targetStepOf(doc, i, k)?.type ?? ""];
 
 /** What job [k]'s targets send, as the job's editor shows it: the first
     target's step type there, or Prompt's while there is none. */
-function jobTargetType(doc                                                           , k        )         {
+function jobTargetType(doc                             , k        )         {
   return targetStepOf(doc, 0, k)?.type ?? "prompt";
 }
 
@@ -5289,18 +5677,19 @@ function jobTargetType(doc
     connection that `replays`). A recorded-reply metric compares the recorded
     reply with itself there, so it says nothing (n/a). Asked through the
     registry, never a step id. */
-function recordedTargetOf(doc                                                           , i        )          {
+function recordedTargetOf(doc                             , i        )          {
   const entry = targetEntryOf(doc, i, 0);
   return !!(entry?.local && CONNECTION_TYPES[localConnOf(entry).type]?.replays);
 }
 
 /** [doc] with target [i]'s step in job [k] changed: [change] merged into
-    it, or the step [change] makes of it. */
-function withTarget                                 (doc   , i        , k        ,
+    it, or the step [change] makes of it. Serialised back into the Variants. */
+function withTarget                  (doc   , i        , k        ,
     change                                                        )    {
-  return { ...doc, targets: doc.targets.map((t, x) => (x !== i ? t : {
+  const targets = targetsOf(doc             ).map((t, x) => (x !== i ? t : {
     ...t, steps: t.steps.map((st, j) => (j !== k ? st : typeof change === "function" ? change(st) : { ...st, ...change }              )),
-  })) };
+  }));
+  return withTargets(doc, targets);
 }
 
 /** The token mappings [job]'s words are resolved under. */
@@ -5330,8 +5719,8 @@ const readAsOf = (job         )                => stepOf            (job, "readA
 
 /** What a transport builds target [i]'s request in job [k] from: the
     target's step, with the flow step and reading the job holds. */
-function requestStepOf(doc                                                       , i        , k        )                                         {
-  const job = doc.jobs[k];
+function requestStepOf(doc                                                                , i        , k        )                                         {
+  const job = jobsOf(doc)[k];
   return { ...flowStepOf(job), ...targetStepOf(doc, i, k), readAs: readAsOf(job) }                                          ;
 }
 
@@ -5560,7 +5949,7 @@ STEP_TYPES.job = {
     const unknown = steps.find(st => !slotOf(st));
     if (unknown) return void bad.push(`${at}: "${isObj(unknown) ? unknown.type : unknown}" is not a step this lab has`);
     if (steps.some(st => slotOf(st) === "target")) {
-      return void bad.push(`${at}: what a target sends is the target's own step, not the job's`);
+      return void bad.push(`${at}: what a variant sends is the variant's own step, not the job's`);
     }
     const twice = steps.find((st, x) => !STEP_TYPES[st.type] .many && steps.findIndex(o => o.type === st.type) !== x);
     if (twice) return void bad.push(`${at} has two ${STEP_TYPES[twice.type] .label ?? twice.type} steps`);
@@ -5645,18 +6034,18 @@ STEP_TYPES.evals = {
 
 // ---- the document -------------------------------------------------------------
 
-const PIPELINE_FIELDS                    = ["version", "id", "name", "jobs", "targets", "evals", "pass"];
+const PIPELINE_FIELDS                    = ["version", "id", "name", "steps", "variants", "evals", "pass"];
 // What resolving adds, and nothing else: the profiles it resolved to and the
 // run's own comment, which belongs to the run and never to the pipeline.
 const RUN_FIELDS = [...PIPELINE_FIELDS, "profiles", "comment", "plugins"];
 
 /** The one rule for a document that is not this version: refuse it, by name. */
 function versionProblem(doc         )                {
-  if (!isObj(doc)) return "a pipeline is a JSON object";
+  if (!isObj(doc)) return "an experiment is a JSON object";
   if (doc.version === PIPELINE_VERSION) return null;
   return doc.version == null
-    ? `this pipeline carries no version, and the lab reads version ${PIPELINE_VERSION}`
-    : `this pipeline is version ${JSON.stringify(doc.version)}, and the lab reads version ${PIPELINE_VERSION}`;
+    ? `this experiment carries no version, and the lab reads version ${PIPELINE_VERSION}`
+    : `this experiment is version ${JSON.stringify(doc.version)}, and the lab reads version ${PIPELINE_VERSION}`;
 }
 
 /** What an upgrade from version 2 needs from outside the document: the rules
@@ -5814,7 +6203,7 @@ function newFilterLink(set     )                {
   return { id: newId(), set: { id: set.id, name: set.name }, pin: null };
 }
 
-function jobsOf(next           )            {
+function chainsToJobs(next           )            {
   next.version = PIPELINE_VERSION;
   if (Array.isArray(next.chains)) {
     const entries = Object.entries(next).map(([k, v]) => (k === "chains" ? ["jobs", v] : [k, v]));
@@ -5970,23 +6359,57 @@ function ownBodiesNow(doc           )            {
   return out;
 }
 
+/** A jobs-and-targets intermediate (the version-19 shape) as a version-20
+    document: its step list and Variants, serialised, with a run's additions
+    kept in place (version 20, §20). The fields are in RUN_FIELDS order, so a
+    document re-read is byte-for-byte itself. */
+function serializeDoc(jt           )            {
+  const { steps, variants } = serialize(jobsOf(jt), targetsOf(jt), jt.steps);
+  const out            = { version: PIPELINE_VERSION, id: jt.id, name: jt.name, steps, variants,
+                           evals: jt.evals, pass: jt.pass };
+  for (const f of ["profiles", "comment", "plugins"]) if (jt[f] !== undefined) out[f] = jt[f];
+  return out;
+}
+
+/** A version-20 document as the jobs-and-targets intermediate, so the
+    normalisations that read jobs and targets (localSteps, ownBodiesNow,
+    profileRefs) can run before it is serialised back. */
+function jtOf(doc           )            {
+  const out            = { version: doc.version, id: doc.id, name: doc.name,
+                           jobs: jobsOf(doc), targets: targetsOf(doc), evals: doc.evals, pass: doc.pass };
+  // The step list it came from, which serializeDoc keeps the order of.
+  if (Array.isArray(doc.steps)) out.steps = doc.steps;
+  for (const f of ["profiles", "comment", "plugins"]) if (doc[f] !== undefined) out[f] = doc[f];
+  return out;
+}
+
 function upgradePipeline   (doc   , ctx             = {})    {
   // A current document is read as it is, but for a profile reference the Runs
   // tab saved whole (see profileRefs), which is cut back, a Read Reply's
   // leftover `preamble: false` (withoutLeftoverPreamble), and a step on a
-  // profile a target step stands in for (localSteps).
+  // profile a target step stands in for (localSteps). It is read as the jobs
+  // intermediate, normalised, and serialised back (serializeDoc), so a clean
+  // document comes back as the same object.
   if (isObj(doc) && doc.version === PIPELINE_VERSION) {
-    let out = doc             ;
-    if (fatProfileRef(out)) {
-      out = clone(out)             ;
-      profileRefs(out);
-    }
-    return localSteps(ownBodiesNow(withoutLeftoverPreamble(out)), ctx)     ;
+    const jt = jtOf(doc);
+    if (fatProfileRef(jt)) profileRefs(jt);
+    const out = serializeDoc(localSteps(ownBodiesNow(withoutLeftoverPreamble(jt)), ctx));
+    // The same document back when nothing moved: the page saves a stored
+    // pipeline whose upgrade is a new object, so a new one would rewrite every
+    // experiment on every load. Compared by content, not as text: a document
+    // stored in another key order (Import, the demo pack) has not changed.
+    return (sameJson(out, doc) ? doc : out)     ;
   }
-  if (!isObj(doc) || ![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18].includes(doc.version          )) return doc;
-  // Every version reads as 18 first, then as 19: a job's filters are one list
-  // around its Response Format (oneFilterList).
-  const nineteen = (d           )    => localSteps(ownBodiesNow(oneFilterList(d)), ctx)     ;
+  if (!isObj(doc) || ![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19].includes(doc.version          )) return doc;
+  // Every version reads up through the version-19 jobs-and-targets shape, then
+  // reshapes to the version-20 step list and Variants (serializeDoc).
+  const twenty = (jt           )    => serializeDoc(localSteps(ownBodiesNow(jt), ctx))     ;
+  // A version-19 document is already that shape; a Read Reply's leftover
+  // preamble is cut and its profile references trimmed, then it reshapes.
+  if (doc.version === 19) return twenty(withoutLeftoverPreamble(cutRefs(clone(doc)             )));
+  // Every version before 19 reads as 19 first: a job's filters are one list
+  // around its Response Format (oneFilterList), then it reshapes.
+  const nineteen = (d           )    => twenty(oneFilterList(d));
   if (doc.version === 18) return nineteen(withoutLeftoverPreamble(cutRefs(clone(doc)             )));
   // Every version reads as 17 first, then as 18: a saved-mode Source content
   // pins one response (savedPinned).
@@ -6262,9 +6685,9 @@ function nineOf(next           , ctx            )            {
   if (next.version === 9) { profileRefs(next); return next; }
   if (next.version === 8) return metricsOf(next);
   if (next.version === 7) return metricsOf(stepsOf(testsList(next)));
-  if (next.version === 6) return metricsOf(stepsOf(jobsOf(next)));
-  if (next.version === 5) return metricsOf(stepsOf(jobsOf(testsList(next))));
-  if (next.version === 3 || next.version === 4) return metricsOf(stepsOf(jobsOf(testsList(upgradeIds(next)))));
+  if (next.version === 6) return metricsOf(stepsOf(chainsToJobs(next)));
+  if (next.version === 5) return metricsOf(stepsOf(chainsToJobs(testsList(next))));
+  if (next.version === 3 || next.version === 4) return metricsOf(stepsOf(chainsToJobs(testsList(upgradeIds(next)))));
   if (next.version === 1) {
     next.version = 2;
     if (Array.isArray(next.chains)) {
@@ -6290,7 +6713,7 @@ function nineOf(next           , ctx            )            {
       if (isObj(cell)) cell.prompt = renamed(cell.prompt);
     }
   }
-  return metricsOf(stepsOf(jobsOf(testsList(upgradeIds(next)))));
+  return metricsOf(stepsOf(chainsToJobs(testsList(upgradeIds(next)))));
 }
 
 /** Version 1's two maps as a list of mappings. */
@@ -6303,13 +6726,14 @@ function tokenMappingsFromV1(set         )                {
   ];
 }
 
-/** A current-version document with one job and no scenario. Its job sends
-    the item's image, as a job over a Source would; one over text content
+/** A current-version document with one Request and no Variant. Its Request
+    sends the item's image, as a job over a Source would; one over text content
     has none to send, and the page turns it off with the content. */
 function blankPipeline(opts                                                           = {})           {
   const job = withImage(jobDefaults(opts.kind, opts.tokens), true);
+  const { steps, variants } = serialize([job], []);
   return { version: PIPELINE_VERSION, id: newId(), name: opts.name || "",
-           jobs: [job], targets: [], evals: [], pass: { mode: "all" } };
+           steps, variants, evals: [], pass: { mode: "all" } };
 }
 
 /** What is wrong with how a target or a step [at] names whom it asks: each
@@ -6322,6 +6746,102 @@ function answerRefsProblems(o           , at        , bad          )       {
   }
 }
 
+/** Each step of [doc]'s list as the Steps list names it, by its id: Get
+    items, Request N (numbered by the Requests before it), Read Response N
+    (the number of the Request it reads), Filter. */
+function stepNames(doc                                                        )                         {
+  const steps = Array.isArray(doc?.steps) ? doc .steps  : [];
+  const number = new Map(steps.filter(isRequest).map((r, k) => [r.id, k + 1]));
+  const out                         = {};
+  for (const st of steps) {
+    if (!isObj(st)) continue;
+    out[st.id] = st.type === "getItems" ? "Get items"
+      : st.type === "request" ? `Request ${number.get(st.id)}`
+      : st.type === "readResponse" ? `Read Response ${number.get(st.request) ?? ""}`.trim()
+      : "Filter";
+  }
+  return out;
+}
+
+/** Where each step of [doc]'s list that is out of order must go, by its id
+    (the order rules stepsProblems holds the document to): a Get items after
+    Request 1 comes before it; a Read Response or Filter above the Request it
+    reads comes after it. A step in order is not listed. */
+function stepFaults(doc                                                        )                         {
+  const steps = Array.isArray(doc?.steps) ? doc .steps  : [];
+  const names = stepNames(doc);
+  const first = steps.findIndex(isRequest);
+  const out                         = {};
+  steps.forEach((st, at) => {
+    if (isGetItems(st) && first >= 0 && at > first) out[st.id] = `Comes before ${names[steps[first] .id]}`;
+    if (isReadResponse(st) || isFilterV20(st)) {
+      const req = steps.findIndex(o => isRequest(o) && o.id === st.request);
+      if (req > at) out[st.id] = `Comes after ${names[steps[req] .id]}`;
+    }
+  });
+  return out;
+}
+
+/** The step types a version-20 pipeline's step list holds. */
+const PIPELINE_STEP_TYPES                    = ["getItems", "request", "readResponse", "filter"];
+
+/**
+ * Every reason [doc]'s step list and Variants are not a well-formed version-20
+ * pipeline (§20): a step of an unknown type, a Get items after Request 1, a
+ * Read Response or Filter before the Request it reads, and a Variant that is
+ * not an object with its overrides keyed by Request ids. The order rules name
+ * the step the out-of-order one must come before, so the page can point at it.
+ */
+function stepsProblems(doc           , bad          )       {
+  if (!Array.isArray(doc.steps)) return void bad.push("steps has to be a list");
+  const steps              = doc.steps;
+  const requestIds           = [];
+  const seen = new Set        ();
+  // The number of each Request, by its id, so a later step names it.
+  for (const st of steps) if (isRequest(st)) requestIds.push(isStr(st.id) ? st.id : "");
+  const numberOf = (id        ) => requestIds.indexOf(id) + 1;
+  let sawRequest = false;
+  steps.forEach((st) => {
+    if (!isObj(st) || !isStr(st.type) || !PIPELINE_STEP_TYPES.includes(st.type)) {
+      return void bad.push(`"${isObj(st) ? st.type : st}" is not a step this lab has`);
+    }
+    if (!isStr(st.id) || !st.id.trim()) bad.push(`a ${st.type} step has no id`);
+    else if (seen.has(st.id)) bad.push(`two steps have the id ${st.id}`);
+    else seen.add(st.id);
+    if (st.type === "getItems") {
+      if (sawRequest) bad.push("Get items comes before Request 1");
+    } else if (st.type === "request") {
+      sawRequest = true;
+    } else {
+      // Read Response N and Filter come after Request N.
+      const label = st.type === "readResponse" ? "Read Response" : "Filter";
+      if (!isStr(st.request) || !requestIds.includes(st.request)) {
+        bad.push(`a ${label} reads a Request the experiment does not have`);
+      } else {
+        const n = numberOf(st.request);
+        const at = steps.indexOf(st), req = steps.findIndex(o => isRequest(o) && o.id === st.request);
+        if (at < req) bad.push(`${label} ${n} comes after Request ${n}`);
+      }
+    }
+  });
+  if (!requestIds.length) bad.push("add a Request first");
+  if (!Array.isArray(doc.variants)) return void bad.push("variants has to be a list");
+  const vseen = new Set        ();
+  doc.variants.forEach((v           , i        ) => {
+    const at = targetLabel(doc, i);
+    if (!isObj(v)) return void bad.push(`${at} has to be an object`);
+    onlyFields(v, at, ["id", "name", "connection", "profile", "overrides"], bad);
+    if (!isStr(v.id) || !v.id.trim()) bad.push(`${at} has no id`);
+    else if (vseen.has(v.id)) bad.push(`${at} has the id of another variant`);
+    else vseen.add(v.id);
+    if (v.name != null && !isStr(v.name)) bad.push(`${at}: name has to be text`);
+    answerRefsProblems(v, at, bad);
+    if (v.overrides != null && (!isObj(v.overrides) || Object.keys(v.overrides).some(k => !requestIds.includes(k)))) {
+      bad.push(`${at}: overrides are keyed by Request ids`);
+    }
+  });
+}
+
 /**
  * Every reason [doc] cannot run, as sentences -- none when it can. The
  * reference lookups are [ctx]'s: `profiles(id)` and `sources(id)` answer with
@@ -6335,29 +6855,41 @@ function validatePipeline(input         , ctx          = {})           {
   const run = doc.profiles !== undefined;
   const c                = { ...ctx, run };
   if (run && !ctx.profiles) c.profiles = (key        ) => (runAnswer(doc, key)                        ) ?? null;
-  onlyFields(doc, "the pipeline", run ? RUN_FIELDS : PIPELINE_FIELDS, bad);
-  if (!isStr(doc.id) || !doc.id.trim()) bad.push("the pipeline has no id");
+  onlyFields(doc, "the experiment", run ? RUN_FIELDS : PIPELINE_FIELDS, bad);
+  if (!isStr(doc.id) || !doc.id.trim()) bad.push("the experiment has no id");
   if (doc.name != null && !isStr(doc.name)) bad.push("name has to be text");
   if (run && doc.comment != null && !isStr(doc.comment)) bad.push("comment has to be text");
-  if (!Array.isArray(doc.jobs) || !doc.jobs.length) {
-    return [...bad, "jobs has to be a list of at least one job"];
-  }
-  if (!targetsOf(doc).length) bad.push("add a target first");
-  // Content is job 1's Attach Content step; a job 1 without one has none yet.
+  // The version-20 step list and Variants are well-formed, so the jobs and
+  // targets the rest reads (jobsOf, targetsOf) can be derived from them.
+  stepsProblems(doc, bad);
+  if (bad.length) return bad;
+  // The derived jobs-and-targets view every semantic check below reads.
+  const jobs              = jobsOf(doc);
+  const jdoc            = { ...doc, jobs };
+  if (!jobs.length) return [...bad, "add a Request first"];
+  if (!targetsOf(doc).length) bad.push("add a variant first");
+  // Content is job 1's Get items step; a job 1 without one has none yet.
   if (!contentOf(doc)) bad.push("set the content first");
   if (run) profilesProblems(doc.profiles, bad);
-  doc.jobs.forEach((ch           , k        ) => STEP_TYPES.job .validate(ch, c, bad, k, doc));
+  jobs.forEach((ch           , k        ) => STEP_TYPES.job .validate(ch, c, bad, k, jdoc));
+  // A later Get items, which job 1 does not attach, is held to the same
+  // rules, named by its place.
+  itemContents(doc).slice(1).forEach(({ content }, k) => {
+    const said           = [];
+    STEP_TYPES.attachContent .validate ({ type: "attachContent", content }, c, said);
+    for (const s of said) bad.push(`Get items ${k + 2}: ${s}`);
+  });
   if (bad.length) return bad;
   const content = contentOf(doc)             ;
 
   const targets              = targetsOf(doc);
-  const n         = doc.jobs.length;
+  const n         = jobs.length;
   targets.forEach((t, i) => {
     const at = targetLabel(doc, i);
     if (!isObj(t)) return void bad.push(`${at} has to be an object`);
     onlyFields(t, at, ["id", "name", "connection", "profile", "steps"], bad);
     if (!isStr(t.id) || !t.id.trim()) bad.push(`${at} has no id`);
-    else if (targets.findIndex((o) => isObj(o) && o.id === t.id) !== i) bad.push(`${at} has the id of another target`);
+    else if (targets.findIndex((o) => isObj(o) && o.id === t.id) !== i) bad.push(`${at} has the id of another variant`);
     if (t.name != null && !isStr(t.name)) bad.push(`${at}: name has to be text`);
     answerRefsProblems(t, at, bad);
     if (!Array.isArray(t.steps) || t.steps.length !== n) {
@@ -6374,19 +6906,19 @@ function validatePipeline(input         , ctx          = {})           {
       const where = `${at}, ${jobLabel(doc, k)}`;
       if (!isObj(st)) return void bad.push(`${where} has to be an object`);
       const entry = STEP_TYPES[st.type];
-      if (entry?.slot !== "target") return void bad.push(`${where}: "${st.type}" is not something a target can send`);
+      if (entry?.slot !== "target") return void bad.push(`${where}: "${st.type}" is not something a variant can send`);
       if (entry.local && (st.profile != null || st.connection != null)) return void bad.push(`${where}: ${entry.label} asks no connection`);
       if (k > 0 && entry.firstJobOnly) return void bad.push(`${where}: ${entry.firstJobOnly}`);
       onlyFields(st, where, entry.fields ?? [], bad);
       // A request is read and placed by its job's HTTP API.
-      const flow = entry.asks === "request" ? flowStepOf(doc.jobs[k]) : null;
+      const flow = entry.asks === "request" ? flowStepOf(jobs[k]) : null;
       entry.validate(flow ? { ...st, api: flow.api } : st, c, bad, where);
       answerRefsProblems(st, where, bad);
       if (st.from != null && !isRef(st.from)) bad.push(`${where} has to name the prompt it was picked from as { id, name }`);
       // A request is a flow step's, rebuilt from its records, and its
       // template has no place for an image.
-      if (entry.asks === "request" && !flowStepOf(doc.jobs[k])) bad.push(`${where}: ${entry.label} needs the job's flow step`);
-      if (entry.asks === "request" && sendsImage(doc.jobs[k])) bad.push(`${where}: ${entry.label} has no place for an image`);
+      if (entry.asks === "request" && !flowStepOf(jobs[k])) bad.push(`${where}: ${entry.label} needs the job's flow step`);
+      if (entry.asks === "request" && sendsImage(jobs[k])) bad.push(`${where}: ${entry.label} has no place for an image`);
     });
   });
   if (bad.length) return bad;
@@ -6441,7 +6973,7 @@ function validatePipeline(input         , ctx          = {})           {
   const docType = (contentFiles || []).map(f => documentTypeOf(String((f                             )?.name ?? f)))
     .find(Boolean) ?? null;
   targets.forEach((_, i) => {
-    const conns = doc.jobs.map((_     , k        ) => (targetEntryOf(doc, i, k)?.local ? localConnOf(targetEntryOf(doc, i, k)) : lookup(targetAnswerOf(doc, i, k) )));
+    const conns = jobs.map((_     , k        ) => (targetEntryOf(doc, i, k)?.local ? localConnOf(targetEntryOf(doc, i, k)) : lookup(targetAnswerOf(doc, i, k) )));
     conns.forEach((p         , k        ) => {
       if (!local(p)) return;
       const entry = CONNECTION_TYPES[typeOf(p            )] ;
@@ -6463,27 +6995,28 @@ function validatePipeline(input         , ctx          = {})           {
       }
       // A request goes as the flow wrote it, so its connection has to speak
       // the job's HTTP API; one the lab cannot tell (Any endpoint) passes.
-      const api = step.asks === "request" ? flowStepOf(doc.jobs[k])?.api : undefined;
+      const api = step.asks === "request" ? flowStepOf(jobs[k])?.api : undefined;
       const speaks = api && api !== "raw" && type?.speaks ? type.speaks(p            ) : null;
       if (api && speaks && speaks !== api) {
         const name = targetAnswerOf(doc, i, k)?.connection.name || type .label;
         bad.push(`${n > 1 ? `${jobLabel(doc, k)}, ` : ""}${targetLabel(doc, i)}: ${name} can't send an ${HTTP_APIS[api]?.label ?? api} request`);
       }
-      if (docType && type && !type.documents && sendsImage(doc.jobs[k])) {
+      if (docType && type && !type.documents && sendsImage(jobs[k])) {
         const name = targetAnswerOf(doc, i, k)?.connection.name || type.label;
         bad.push(`${n > 1 ? `${jobLabel(doc, k)}, ` : ""}${targetLabel(doc, i)}: ${name} can't read ${docType.label}s`);
       }
     });
     // The model is the profile's unless the target's step carries it.
     const bare = conns.findIndex((p                           , k        ) => p && c.profiles && !local(p)
-      && targetEntryOf(doc, i, k)?.modelFrom !== "step" && !String(p.model || "").trim());
+      && targetEntryOf(doc, i, k)?.modelFrom !== "step" && !String(p.model || "").trim()
+      && !String(targetStepOf(doc, i, k)?.model || "").trim());
     if (bare >= 0) {
       bad.push(n > 1
         ? `no model on the connection ${jobLabel(doc, bare)} of ${targetLabel(doc, i)} uses — manage connections on the Setup tab`
         : `no model on ${targetLabel(doc, i)}'s connection — manage connections on the Setup tab`);
     }
   });
-  STEP_TYPES.evals .validate(doc.evals, c, bad, outOf(doc.jobs.at(-1)).kind, doc);
+  STEP_TYPES.evals .validate(doc.evals, c, bad, outOf(jobs.at(-1)).kind, doc);
   passProblems(doc.pass, Array.isArray(doc.evals) ? doc.evals.length : 0, bad);
   if (bad.length) return bad;
 
@@ -6491,9 +7024,9 @@ function validatePipeline(input         , ctx          = {})           {
   // says which job, instead of failing every item the same way.
   const text = CONTENT_TYPES[content?.type]?.text?.(content, c) ?? null;
   targets.forEach((_, i) => {
-    const stages          = doc.jobs.map((ch     , k        ) => ({ text: targetStepOf(doc, i, k) .prompt, kind: outOf(ch).kind,
+    const stages          = jobs.map((ch     , k        ) => ({ text: targetStepOf(doc, i, k) .prompt, kind: outOf(ch).kind,
                                                                    verbatim: !!targetEntryOf(doc, i, k)?.verbatim }));
-    const problem = jobProblem(stages, stages.map(() => () => {}), doc.jobs.map((ch     ) => tokensOf(ch)), text);
+    const problem = jobProblem(stages, stages.map(() => () => {}), jobs.map((ch     ) => tokensOf(ch)), text);
     if (problem) bad.push(`${targetLabel(doc, i)}: ${jobWords(problem)}`);
   });
   return bad;
@@ -6506,8 +7039,8 @@ function passProblems(pass         , n        , bad          )       {
     return void bad.push("pass has to be { mode: all } or { mode: atLeast, count }");
   }
   onlyFields(pass, "pass", pass.mode === "all" ? ["mode"] : ["mode", "count"], bad);
-  if (pass.mode === "atLeast" && !(Number.isInteger(pass.count) && pass.count > 0)) bad.push("pass at least has to count a whole number of groups from 1");
-  else if (pass.mode === "atLeast" && pass.count > n) bad.push(`pass asks for ${pass.count} groups, and the pipeline has ${n}`);
+  if (pass.mode === "atLeast" && !(Number.isInteger(pass.count) && pass.count > 0)) bad.push("pass at least has to count a whole number of evals from 1");
+  else if (pass.mode === "atLeast" && pass.count > n) bad.push(`pass asks for ${pass.count} evals, and the experiment has ${n}`);
 }
 
 /** How many of [items] are in [files] (names or `{ name }` entries): a
@@ -6540,7 +7073,7 @@ function pipelineWarnings(doc         , ctx          = {})           {
     if (!items?.length) return;
     const found = itemsFound(items, files);
     if (found < items.length) {
-      warn.push(`${evalLabel(doc             , j)}: ${found} of ${ref .name || ref .id}'s ${items.length} cases have their item in ${where}`);
+      warn.push(`${evalLabel(doc             , j)}: ${found} of ${ref .name || ref .id}'s ${items.length} eval cases have their item in ${where}`);
     }
   });
   return warn;
@@ -6591,7 +7124,7 @@ function connectionProblems(conn                           , at        , from
     // A key in an address is written into every log line and error message
     // that prints it.
     if (u && (u.username || u.password)) {
-      bad.push(`${at} has a key in its address, and a key never goes in a pipeline — $${from} supplies it`);
+      bad.push(`${at} has a key in its address, and a key never goes in an experiment — $${from} supplies it`);
     }
   }
   if (!isStr(conn.model)) bad.push(`${at}: model has to be text`);
@@ -6658,10 +7191,12 @@ function answerKeys(doc                                                  )
  * The run document: [doc] plus what its references resolved to, once, at
  * submit. `ctx.profiles(key)` answers an answer key with what it resolves to
  * (`answersOf`'s `resolve`), `ctx.files` is
- * the Source's file list as it reads now, `ctx.comment` is the run's own.
+ * the first Get items' Source's file list as it reads now and
+ * `ctx.filesOf(id)` any Source's (a later Get items reads it), `ctx.comment`
+ * is the run's own.
  */
 function resolvePipeline(doc          ,
-                         ctx                                                 
+                         ctx                                                                                                 
                                                                                                                                      = {})              {
   const run = clone(doc)             ;
   // What the lab supplies an eval -- its grader -- before the profiles it
@@ -6678,12 +7213,14 @@ function resolvePipeline(doc          ,
     const cid = isStr(p.id) && p.id ? p.id : answerOfKey(key).connection;
     run.profiles[key] = { ...conn, connection: cid };
   }
-  const content = contentOf(run)             ;
   // Saved response grades its one pinned response (#596), whatever else the
   // Source holds; the server keeps that response's bytes with the run.
-  if (content?.type === "source") {
-    content.files = CONTENT_TYPES.source .expand (content, isObj(content.pin) && content.live !== true ? [content.pin.name] : ctx.files);
-  }
+  itemContents(run).forEach(({ content: c }, k) => {
+    const content = c             ;
+    if (content?.type !== "source") return;
+    const files = k === 0 && ctx.files !== undefined ? ctx.files : ctx.filesOf?.(content.ref?.id);
+    content.files = CONTENT_TYPES.source .expand (content, isObj(content.pin) && content.live !== true ? [content.pin.name] : files);
+  });
   // Each Library group the evals read, as the version it grades with: the
   // body's fingerprint and, where the lab numbers them, `n` -- a pinned
   // link's pin.
@@ -6707,8 +7244,9 @@ function pipelineOfRun(run             , ctx             = {})           {
   delete doc.profiles;
   delete doc.comment;
   delete doc.plugins;
-  const content = contentOf(doc)             ;
-  if (content) { delete content.files; delete content.revs; }
+  for (const { content } of itemContents(doc)) {
+    if (isObj(content)) { delete (content             ).files; delete (content             ).revs; }
+  }
   // What the run recorded of each group it read is the run's. The grader
   // it carried stays, as a Metrics eval's did: a bundle writes it down.
   for (const t of doc.evals || []) {
@@ -6743,16 +7281,22 @@ function pipelineToYaml(doc          , ctx
   return yaml.dump(out, { lineWidth: -1, noRefs: true });
 }
 
-/** Every AI Connection reference in [doc] -- each target's, each of its
-    steps', each eval's grader -- replaced, in place, by [f] of it. A
-    Connection Profile is named by id and name, and left as it is. */
+/** Every AI Connection reference in [doc] -- each Variant's, each of its
+    steps', each eval's grader -- replaced, in place, by [f] of it. The
+    Variants and their Request steps are reached through the jobs-and-targets
+    intermediate and serialised back; a Connection Profile is named by id and
+    name, and left as it is. */
 function eachProfileRef(doc           , f                               )       {
-  for (const t of targetsOf(doc)) {
+  const jt = jtOf(doc);
+  for (const t of jt.targets) {
     if (t.connection) t.connection = f(t.connection);
     for (const st of Array.isArray(t.steps) ? t.steps : []) {
       if (st?.connection) st.connection = f(st.connection);
     }
   }
+  const re = serialize(jt.jobs, jt.targets, doc.steps);
+  doc.steps = re.steps;
+  doc.variants = re.variants;
   for (const t of Array.isArray(doc.evals) ? doc.evals : []) {
     if (isObj(t) && t.grader) t.grader = f(t.grader);
     if (isObj(t?.own) && t.own.grader) t.own.grader = f(t.own.grader);
@@ -6779,14 +7323,17 @@ function importPipeline(input         , ctx            = {})               {
   const v = versionProblem(doc);
   if (v) return { error: v };
   const profiles = ctx.profiles ?? [], sources = ctx.sources ?? [], groups = ctx.groups ?? [];
-  const next = clone(doc)             ;
+  // The references are remapped on the jobs-and-targets intermediate (where
+  // content, every target's connection and each step's live), then the result
+  // is serialised back into the version-20 step list and Variants.
+  const next = jtOf(doc);
   const missing           = [], seen = new Set        ();
   const lists = { profile: profiles, connectionProfile: ctx.connectionProfiles ?? [], source: sources, group: groups };
   const words = {
     profile: (ref                         ) => `Connection ${ref.slug || ref.name || ref.id} not found`,
     connectionProfile: (ref     ) => `Connection Profile ${ref.name || ref.id} not found`,
     source: (ref     ) => `Source ${ref.name || ref.id} not found`,
-    group: (ref     ) => `Eval group ${ref.name || ref.id} not found`,
+    group: (ref     ) => `Eval ${ref.name || ref.id} not found`,
   };
   const remap = (ref     , kind                    )      => {
     const hit = lists[kind].find(x => x.id === ref.id) || lists[kind].find(x => x.name === ref.name);
@@ -6808,8 +7355,10 @@ function importPipeline(input         , ctx            = {})               {
     if (!seen.has(sentence)) { seen.add(sentence); missing.push(sentence); }
     return { id: ref.slug, name: isStr(ref.name) && ref.name ? ref.name : ref.slug };
   };
-  const content = contentOf(next)             ;
-  if (content?.type === "source") content.ref = remap(content.ref, "source");
+  for (const { content: c } of itemContents(next)) {
+    const content = c             ;
+    if (content?.type === "source") content.ref = remap(content.ref, "source");
+  }
   const split = (connection         )             => {
     const p = preSplit && isRef(connection) && profiles.some(x => x.id === connection.id) ? ctx.connectionSplit?.(connection.id) : null;
     return p ? { id: p.id, name: p.name ?? "" } : null;
@@ -6845,14 +7394,16 @@ function importPipeline(input         , ctx            = {})               {
   // keep the ones it carries, so export → import → export is the same
   // document and a re-import can recognise the same pipeline (#93).
   mintIds(next);
+  // Serialised back into the version-20 shape the lab reads.
+  const out = serializeDoc(next);
   // What a document may still lack on import is its references -- matched
   // above and listed as missing. Anything else the model says is wrong is a
   // document the lab cannot edit and run as it stands, so it is refused by
   // the first such sentence. Validated with no lookups, so a reference a
   // later step will satisfy is never the refusal.
-  const bad = validatePipeline(next).filter(s => !/ not found$/.test(s));
+  const bad = validatePipeline(out).filter(s => !/ not found$/.test(s));
   if (bad.length) return { error: bad[0]  };
-  return { doc: next, missing };
+  return { doc: out, missing };
 }
 
 /** Mint, in place, the ids a current-version document must have that it
@@ -6868,8 +7419,10 @@ function mintIds(doc           )            {
   for (const t of Array.isArray(doc.evals) ? doc.evals : []) {
     if (isObj(t) && (!isStr(t.id) || !t.id)) t.id = newId();
   }
-  // Nor need it say how its linked groups pass together: all of them.
-  if (!("pass" in doc)) doc.pass = { mode: "all" };
+  // Nor need it say how its linked groups pass together: all of them. (A
+  // document serialised to version 20 carries a `pass` key even when it was
+  // absent, so a null one is filled too.)
+  if (doc.pass == null) doc.pass = { mode: "all" };
   return doc;
 }
 
@@ -7134,7 +7687,8 @@ function readBundle(files             , ctx                                = {})
 function stagesFor(run             , i        , resolveFilters                                                          ) 
                                                                                                         
                                                                                {
-  const stages = run.jobs.map((ch, k) => {
+  const jobs = jobsOf(run);
+  const stages = jobs.map((ch, k) => {
     const { kind, modifiers: _mods, ...settings } = outOf(ch);
     // The modifiers a run applies, with the filters below the format a
     // synthetic modifier a link where the filters step sits (#339), and those
@@ -7149,7 +7703,7 @@ function stagesFor(run             , i        , resolveFilters
     const { connection: _c, ...conn } = held || {}                       ;
     return { id: answerConnectionId(key, held), ...conn };
   };
-  const connections = run.jobs.map((_, k) => {
+  const connections = jobs.map((_, k) => {
     // A step answered here asks nothing: the profile a run made before it
     // kept is what it ran as, else Echo itself.
     const key = targetAnswerKey(run, i, k);
@@ -7157,12 +7711,19 @@ function stagesFor(run             , i        , resolveFilters
       const held = key != null ? runAnswer(run, key) : undefined;
       return held && CONNECTION_TYPES[held.type]?.local ? asked(key , held) : { id: "", ...localConnOf(targetEntryOf(run, i, k)) };
     }
-    return key != null ? asked(key, runAnswer(run, key)) : { id: "" };
+    if (key == null) return { id: "" };
+    // A Request's own Model goes over its connection's, where the step's
+    // model is the connection's to send (a Prompt; an HTTP Request places
+    // its own in the body).
+    const { model, settings: own } = targetStepOf(run, i, k) ?? {};
+    const conn = asked(key, runAnswer(run, key));
+    if (targetEntryOf(run, i, k)?.modelFrom !== "profile") return conn;
+    return withOwnSettings(model?.trim() ? { ...conn, model: model.trim() } : conn, own);
   });
   // What a transport that builds its own request (an HTTP Request) builds
   // it from in each job, and this target's step there.
-  return { stages, tokens: run.jobs.map(tokensOf), connections,
-           calls: run.jobs.map((_, k) => requestStepOf(run, i, k)), cells: run.jobs.map((_, k) => targetStepOf(run, i, k) ) };
+  return { stages, tokens: jobs.map(tokensOf), connections,
+           calls: jobs.map((_, k) => requestStepOf(run, i, k)), cells: jobs.map((_, k) => targetStepOf(run, i, k) ) };
 }
 
 /** The Setup profile scenario [i] of a run ran under, as History shows it: keyless. */
@@ -7180,11 +7741,11 @@ function scenarioProfile(run             , i        )
 }
 
 /** The kind a run's result is read as: its last job's. */
-const lastKind = (doc                           )                => outOf(doc.jobs?.at(-1))?.kind ?? null;
+const lastKind = (doc                              )                => outOf(jobsOf(doc).at(-1))?.kind ?? null;
 
 /** A value of a modifier on a run's last job -- the case mode History prints. */
-const lastModifier = (doc                           , type        )                  =>
-  (outOf(doc.jobs?.at(-1))?.modifiers || []).find(m => m.type === type) || null;
+const lastModifier = (doc                              , type        )                  =>
+  (outOf(jobsOf(doc).at(-1))?.modifiers || []).find(m => m.type === type) || null;
 
 /** What a modifier is set to, in a few words, from its entry's own options:
     a choice's label, a number, "3 rules" -- or "on" for one with none. What
@@ -7237,8 +7798,8 @@ function itemScores(run             , kase                         , res
 
 /** What production recorded as the reply to an item, for a run's metrics: its
     last job's call says, from the item's record, or nobody does. */
-function recordedReplyOf(run                          , record         )                {
-  const last = run.jobs.at(-1), flow = flowStepOf(last);
+function recordedReplyOf(run                              , record         )                {
+  const last = jobsOf(run).at(-1), flow = flowStepOf(last);
   return record && flow ? STEP_TYPES.flowStep .production ({ ...flow, readAs: readAsOf(last) }, record) : null;
 }
 
@@ -7246,18 +7807,21 @@ function recordedReplyOf(run                          , record         )
  * itemScores for the runner, which can wait: an eval that reads every item
  * (`read`: the Metrics, which may ask a grader) scores one with no case too.
  */
-async function itemScoresAsync(run             , kase                         , res                    ,
+async function itemScoresAsync(run             , kase                         , res                                   ,
                                more           = {})                                                        {
   const out                                        = {};
   let stopped = false;
+  // The runner hands over a reply it just made, the re-score and the page a
+  // stored one; a metric reads the same fields of either.
+  const reply = res                      ;
   for (const t of evalsOf(run)) {
     const type = EVAL_TYPES[t.type];
     if (isWholeRun(type, t) || (!type?.read && !(type?.score && kase))) continue;
     if (stopped) { out[t.id] = SKIPPED; continue; }
     // An eval with nothing to read on this item leaves no entry, as a graded
     // eval does on an item with no case.
-    const s = type.read ? await type.read(t, kase ?? null, res, { plain: !OUTPUT_KINDS[lastKind(run) ?? ""]?.terms, ...more })
-      : type.score (t, kase , res);
+    const s = type.read ? await type.read(t, kase ?? null, reply, { plain: !OUTPUT_KINDS[lastKind(run) ?? ""]?.terms, ...more })
+      : type.score (t, kase , reply);
     if (!s) continue;
     out[t.id] = s;
     if (!s.pass && !t.continueOnFailure) stopped = true;
@@ -7265,6 +7829,35 @@ async function itemScoresAsync(run             , kase                         ,
   return Object.keys(out).length ? out : null;
 }
 
+/**
+ * A finished run's stored results re-scored, the kept replies untouched and
+ * each per-item eval's verdict recomputed against the eval bodies [more]
+ * hands back. This is how the Results view scores a run against the Eval as
+ * it reads now (#657): with [more.group] resolving each linked group to its
+ * current version, and [more.item] each result's own name, an edited eval
+ * case is read at its latest version, and the run itself is not touched --
+ * nothing here is written back.
+ *
+ * No model is asked: pass no [more.grader] and a model-graded metric reads as
+ * unmet, exactly as the eval case editor's live preview does, so the view
+ * makes no call. The one scorer is itemScoresAsync -- the same the runner's
+ * --rescore reaches -- so the page and the runner cannot disagree. A
+ * whole-run eval settles in scenarioEvals from the replies, so it is not
+ * re-read here; only per-item verdicts move.
+ */
+async function rescoreResults(run             , results                                            ,
+                              more                         = {})                        {
+  return Promise.all((results || []).map(async it => {
+    if (!isObj(it) || !Array.isArray(it.scenarios)) return it              ;
+    const per           = { ...more, item: isStr(it.name) ? it.name : null };
+    const scenarios = await Promise.all((it.scenarios                ).map(async side =>
+      isObj(side) && side.res
+        ? { ...side, scores: await itemScoresAsync(run, null, side.res, per) }
+        : side));
+    return { ...(it              ), scenarios }              ;
+  }));
+}
+
 /**
  * Every eval's reading of scenario [i] of a run, in the run's order, from
  * the items so far. [settled] says every item is in: only then has a
@@ -7310,13 +7903,41 @@ function scenarioEvals(run             , i        , items
   });
 }
 
+/**
+ * A link's Whole run verdict, per Target, keyed by the eval's id: a Library
+ * group's `run` metrics read over the replies so far (readGroupRun). A private
+ * group's Whole run is scenarioEvals' own (it holds the body); a link's body
+ * is held apart, so it is read here, beside the link's items (§17). [resolve]
+ * gives a link's body by its reference: the runner's --groups, or the page's
+ * kept or current versions. One that gives none reads nothing.
+ */
+function wholeRunsOf(run             , items                                                               ,
+                     resolve                                       )                                    {
+  const kind = lastKind(run);
+  return targetsOf(run).map((_, i) => {
+    const out                                  = {};
+    const ress = (items || []).map(it => (it && !it.unrun ? it.scenarios?.[i]?.res : undefined));
+    for (const t of evalsOf(run)) {
+      if (t.type !== "group" || isWholeRun(EVAL_TYPES.group, t)) continue;
+      const body = groupOf(t, { group: resolve });
+      const v = Array.isArray(body.run) && body.run.length ? readGroupRun(body               , ress, kind) : null;
+      if (v) out[t.id] = v;
+    }
+    return out;
+  });
+}
+
 /** One eval group's verdict over a scenario (§17): a whole-run group's own
-    verdict, or a per-item group's "every item it read passed"; null where it
-    was skipped, or had nothing to read yet. */
+    verdict, or a per-item group's "every item it read passed" -- and, for a
+    link reading a Whole run beside its items, that too: either failing fails
+    it, as the runner's verdict does. Null where it was skipped, or had
+    nothing to read yet. */
 function groupPass(o             )                 {
   if (o.skipped) return null;
   if (o.whole) return o.verdict?.ran ? o.verdict.pass : null;
-  return o.ran ? o.passed === o.ran : null;
+  const item = o.ran ? o.passed === o.ran : null;
+  const whole = o.wholeRun?.ran ? o.wholeRun.pass : null;
+  return item === false || whole === false ? false : item ?? whole;
 }
 
 /** A scenario's pass or fail over every eval that read it: null where none
@@ -7366,25 +7987,25 @@ function passVerdict(pass                             , passes
 function validateEvals(ev           , files                                          )           {
   const bad           = [];
   if (!ev || typeof ev !== "object" || Array.isArray(ev)) {
-    return ["the graded set has to be a JSON object with a `cases` list"];
+    return ["an eval has to be a JSON object with a `cases` list"];
   }
   if (ev.cases != null && !Array.isArray(ev.cases)) bad.push("cases has to be a list");
   // 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 (!isObj(sc) || !SCORING_MODES.includes(sc.mode)) bad.push(`an eval is scored ${SCORING_MODES.join(" or ")}`);
+    else if (sc.mode === "weighted" && typeof sc.threshold !== "number") bad.push("an eval scored in points needs Pass at: the points an item has to reach");
+    else if (sc.threshold != null && typeof sc.threshold !== "number") bad.push("an eval'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.grader != null && !isRef(ev.grader)) bad.push("an eval names its grader as { id, name }, or null");
+  if (ev.every != null) metricsProblems(ev.every, "Every item metrics", bad);
   if (ev.run != null) {
-    metricsProblems(ev.run, "Whole run", bad);
+    metricsProblems(ev.run, "Whole run metrics", 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 (entry?.graded) bad.push(`Whole run metrics: ${entry.label} is model-graded, so it cannot read a whole run`);
+      else if (entry?.perItem) bad.push(`Whole run metrics: ${entry.label} reads one item at a time, so it cannot read a whole run`);
     }
   }
   if (bad.length) return bad;
@@ -7395,13 +8016,13 @@ function validateEvals(ev           , files
   const seen = new Set        ();
   for (const c of graded) {
     if (!isObj(c)) {
-      bad.push("cases holds something that is not a case");
+      bad.push("cases holds something that is not an eval case");
       continue;
     }
-    if (!isStr(c.id) || !c.id.trim()) bad.push("a case has no id");
+    if (!isStr(c.id) || !c.id.trim()) bad.push("an eval case has no id");
     else if (seen.has(c.id)) bad.push(`${c.id} is graded twice`);
     else seen.add(c.id);
-    if (!caseItem(c).trim()) bad.push(`${c.id || "a case"} names no item`);
+    if (!caseItem(c).trim()) bad.push(`${c.id || "an eval case"} names no item`);
     if (c.todo != null && typeof c.todo !== "boolean") bad.push(`${c.id}: todo is true or false`);
     if (c.note != null && !isStr(c.note)) bad.push(`${c.id}: note has to be text`);
     if (c.metrics != null) metricsProblems(c.metrics, String(c.id), bad);
@@ -7483,8 +8104,8 @@ function validateEvals(ev           , files
   // set and graded by nobody is one nobody discovers is ungraded.
   for (const f of shown) {
     if (!gradedAt(f)) {
-      bad.push(`${f} is in the Source and this dataset does not grade it, `
-             + `so the Cases view does not list it`);
+      bad.push(`${f} is in the Source and this eval does not grade it, `
+             + `so the Eval Cases view does not list it`);
     }
   }
   return bad;
@@ -7548,18 +8169,18 @@ export {
     tallyPercent, runPipeline, validateEvals, evalsWarnings, evalsJson, readList,
     scoreSingle, singleRules, parseCount, lengthHolds, countHolds, COUNT_OPS, LENGTH_OPS,
     COUNT_OP_LABEL, LENGTH_OP_LABEL,
-    PIPELINE_VERSION, DATASET_BODY_VERSION, STEP_TYPES, CONTENT_TYPES, OUTPUT_KINDS, MODIFIERS, EVAL_TYPES, LEGACY_TESTS, METRICS, readMetrics, metricSummary, metricCheck, itemScoresAsync, recordedReplyOf,
+    PIPELINE_VERSION, DATASET_BODY_VERSION, STEP_TYPES, CONTENT_TYPES, OUTPUT_KINDS, MODIFIERS, EVAL_TYPES, LEGACY_TESTS, METRICS, readMetrics, metricSummary, metricCheck, itemScoresAsync, rescoreResults, recordedReplyOf,
     SOURCE_TYPES, DEFAULT_SOURCE_TYPE, sourceTypeOf, WORKFLOW_PLATFORMS, platformOf, DYNAMIC_PROVIDERS, providerOf, WIZARDS, wizardProgress,
     registerKinds, defaultKind, jobDefaults, applyModifiers, keyVar, slugOf, uniqueSlug, isSlug, withSlugs, SLUG_MAX, connectionOf, addressOf, connectionSettings,
     splitProfile, mergeAnswer, answerKey, answerOfKey, answersOf, runAnswer, answerConnectionId, connectionScoped,
     connectionRequest, connectionBase, connectionSend, connectionReply, connectionReplyProblem, replyFinish, contentJoined, connectionImage, connectionProblems,
 CONNECTION_FIELDS, SETTING_KEYS, OPTION_FIELDS, jobLabel, scenarioLabel, jobWords, versionProblem,
-    contentOf, withContent, replyOf,
+    contentOf, itemContents, runItemsOf, withContent, replyOf, jobsOf, withJobs, withTargets, serialize, stepNames, stepFaults,
     targetsOf, targetLetter, targetLabel, targetStepOf, targetEntryOf, jobTargetType, targetAnswerOf, targetAnswerKey, recordedTargetOf, withTarget,
     tokensOf, withTokens, sendsImage, withImage, flowStepOf, requestStepOf, readAsOf, outOf, withOut, slotEntry, SLOTS,
     filterSetsOf, filterFormatOf, withFilterSets, formatPlace, stageModifiers, beforeFilters, gradedText,
     blankPipeline, upgradePipeline, fatProfileRef, newId, newEval, newLink, validatePipeline, resolvePipeline, pipelineOfRun, stagesFor, profileIds, answerKeys,
-    scenarioProfile, lastKind, lastModifier, modifierSummary, itemScores, scenarioEvals, scenarioPasses, groupPass, overallVerdict, passVerdict, isSkipped, failedScore,
+    scenarioProfile, lastKind, lastModifier, modifierSummary, itemScores, scenarioEvals, wholeRunsOf, scenarioPasses, groupPass, overallVerdict, passVerdict, isSkipped, failedScore,
     evalLabel, evalsOf, evalsDataset, casesRef, groupOf, groupOfMetrics, pipelineWarnings, itemsFound, previewOf, isWholeRun, EVAL_FIELDS,
     pipelineToYaml, importPipeline, yamlToPipeline, exportBundle, readBundle, bundleProblems, junitXml,
     pluginHost, legacyTagsOut, legacyTagsModifiers, legacyTagsJob, splitItems, tidy, tryExamples, itemRulesProblems, dropBy, rejectBy, matcher,