evals-lab 0.1.4 → 0.3.0

package/lab/evals-core.mjs

@@ -26,7 +26,7 @@
 // WHAT IS NOT HERE. Preparing an image: the tab has a canvas and the
 // script has not, so `prepare()` stays in the page and the script shells out
 // to ImageMagick with the same arithmetic. Rendering: the tab writes HTML and
-// the script writes JSON. Both read the same verdict out of `scoreCase`.
+// the script writes JSON. Both read the same verdict out of the same Metrics.
 //
 // `runner-check.js` runs one set through two of the callers and asserts the
 // verdicts and the totals are identical, because sharing a file is a claim
@@ -94,49 +94,76 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                    
  
 
-/** A Call that prompts a model: each scenario's cell says with what words
-    and whom to ask; the step says whether the item's image goes too, and the
-    token mappings the words are resolved under. */
+/** The Power Automate step a job's records are calls of (job 1, Content):
+    the action's name its expressions read it by, the loop item() means,
+    and the HTTP API its replies speak -- how production's reply is read. */
+                               
+                   
+               
+                      
+              
+ 
+
+/** The item's image goes beside every target's words in this job. */
+                                  
+                      
+ 
+
+/** The token mappings a job's words are resolved under. */
+                                    
+                        
+                               
+ 
+
+/** What the flow does to the reply before it reads it -- its Parse JSON's
+    content -- as an expression over body('<step>'). First of Responses. */
                              
                  
-                     
-                               
+                 
  
 
-/** How a job's reply is read: its output kind, and the modifiers applied. */
+/** Response Format Validation: the output kind a reply is read as, and that
+    kind's own settings. A job with none reads its reply as text. */
                                 
                     
-           
+                              
  
 
-/** A Call that sends a Power Automate step's request (docs/power-automate.md
-    § The HTTP Request step): the flow's own template -- method, path, query
-    and body, Workflow Definition Language expressions and all -- evaluated
-    against each item's record. The Setup profile gives the address and the
-    key; each scenario's cell the words, model, settings and prefill the
-    HTTP API puts in the body. */
-                                  
+/** One change applied to the parsed reply, after the Format Validation
+    whose kind accepts it. */
+                               
+                   
+                     
+ 
+
+/** A job's steps: its Content stage, then its Responses (§16). */
+                                                                                         
+                                              
+
+/** A target step that prompts a model: its words, resolved under the job's
+    token mappings, and a profile of its own where it names one. */
+                                          
+                 
+ 
+
+/** A target step that sends a Power Automate step's request
+    (docs/power-automate.md § The HTTP Request step): the flow's own template
+    -- method, path, query and body, Workflow Definition Language expressions
+    and all -- with the target's words and fields placed in the body by its
+    HTTP API, evaluated against each item's record. The profile gives the
+    address and the key. */
+                                               
                       
-                                                                      
-               
                                                     
               
                  
                
                                 
                 
-                                                                            
-                                                                           
-                  
-                        
-                                                                        
-                      
  
 
-                                                                                    
-
-/** A job is its steps, in fixed slots (pipeline-model §3): an Attach Content
-    on job 1 only, one Call, then Read Reply. */
+/** A job is its steps, staged (pipeline-model §16): Content, then
+    Responses. What each target sends in it is the target's own. */
                       
               
                                                                       
@@ -170,13 +197,14 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
 
                                                                   
 
-/** One cell of a scenario: what to ask in that job, and whom. */
+/** What a target's step says beside its type: what to ask in that job,
+    and whom, where it names a profile of its own. */
                        
                  
                 
-                                                                           
                                                                           
-                                                               
+                                                                         
+                                                      
                   
                  
                                     
@@ -187,17 +215,25 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
              
  
 
-                           
-                                                                         
+/** What a target sends in one job: one of the target step types. */
+                                                                                                                                
+
+/** 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. */
+                         
+                                                                       
                                                 
              
                
-               
-                 
+                                                                          
+                                                       
+                      
+                      
  
 
-/** What every test carries whatever its type: an id minted once and never
-    shown, an optional name ("Test 2" when blank), and whether the tests after
+/** 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). */
                              
              
@@ -224,7 +260,7 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                   
  
 
-/** Checks of every reply (TEST_TYPES.metrics): its own for every item, and
+/** Checks of every reply (EVAL_TYPES.metrics): its own for every item, and
     a case's own for its item; all must pass, or weighted points reach the
     threshold. A model-graded one asks the grader. */
                                                  
@@ -239,11 +275,11 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                         
  
 
-/** A test, from version 9: Metrics. A Single Test or a Graded set is what an
+/** An eval, from version 9: Metrics. A Single Test or a Graded set is what an
     older document held (upgradePipeline reads it converted). */
                                
 
-/** A pipeline's tests, in the order they read a run. */
+/** A pipeline's evals, in the order they read a run. */
                            
 
                            
@@ -255,7 +291,7 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
              
                
               
-                        
+                    
                
  
 
@@ -323,7 +359,7 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
 /** A pipeline read from YAML, references remapped to this lab. */
                                    
                 
-                                                                            
+                                                                             
                                                                          
                     
  
@@ -335,6 +371,9 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                             
                                                                                  
                                                                 
+                                                                           
+                                                                          
+                                                   
  
 
 /** An import's outcome: the remapped pipeline, or one sentence refusing it. */
@@ -417,12 +456,23 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                 
                        
                                     
+                                                                         
+                                                                           
+                           
+                              
+ 
+
+/** What an expression token reads: a record's scope, its time, the loop. */
+                              
+                             
+                     
+                       
  
 
 /** A stage of a run as a transport asks it: stagesFor's answer. */
                           
                
-                                                                                 
+                                                                                        
                     
                
                      
@@ -432,75 +482,47 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
 
 // ---- grading ----
 
-/** A graded case, as cases.json writes one.
-
-    The item a case grades is named by `filename`: a dataset joins on a file
-    name, and nothing about that is an image -- the next dataset addresses
-    a row of a spreadsheet or a line of a log by the same key. The field had
-    an older name while the lab was one app's bench, and it is still *read*:
-    a set re-synced from that app's repository arrives spelled that way, and
-    a case that silently stopped matching would be worse than one that reads
-    both.
-    `caseFile` is the one reader; `evalsJson` is the one writer, and it writes
-    `filename`. */
+/** A graded case (dataset body version 5): an Item and the Metrics its
+    reply is held to.
+
+    The item is named by `item`: a dataset joins on an item's name in the
+    Source it grades, exactly, and nothing about that is an image -- the
+    next dataset addresses a row of a spreadsheet or a line of a log by the
+    same key. Version 4 called it `filename`, and the lab's first app had a
+    name of its own for it; `upgradeDatasetBody` reads both as `item`.
+
+    A case's metrics are what a good answer is: each a metric as a
+    pipeline's Metrics eval holds one, added to the eval's own for this item
+    when an eval names the dataset. One with weight 0 is watched -- reported,
+    never scored. */
                        
               
-                    
-                                                                    
-                                                                       
+                
+                                                                            
                  
-               
-                    
-                     
-                    
-                   
-                           
-                           
-                                                            
-                   
-                                                                          
+                                            
+                
                      
-                                                                           
-                                                                   
-                      
-                    
                          
  
 
-/** A graded set: cases.json. */
+/** A graded set: a dataset's body, or anything holding its cases. */
                           
                  
                          
  
 
-/** One row the Datasets tab's Cases group draws, as gradedSetFrom builds it:
-    a case of a set validateEvals accepts, so it has its id and file. */
+/** One row of the Library's Dataset group's cases table, as gradedSetFrom builds it:
+    a case of a set validateEvals accepts, so it has its id and item. */
                                          
              
-                   
+               
                
  
 
 /** A requirement as a score reports it: a term, or the group it was. */
                                             
 
-/** How a graded case read a reply: the same shape both engines agree on. */
-                            
-                
-                       
-                     
-                       
-                        
-                     
-                    
-                 
-                
-                
-                       
-                     
-                    
- 
-
 /** A run's totals, summed across cases. */
                         
               
@@ -509,7 +531,7 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
              
  
 
-/** The whole-run verdict of a test type, where it has one of its own. */
+/** The whole-run verdict of an eval type, where it has one of its own. */
                                   
                 
                   
@@ -520,7 +542,7 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                        
  
 
-/** One thing a test asserts, as its type names it: "Exact" "outdoor". */
+/** One thing an eval asserts, as its type names it: "Exact" "outdoor". */
                        
               
                 
@@ -549,7 +571,7 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                  
  
 
-/** A per-item test's score as a stored row carries it. */
+/** A per-item eval's score as a stored row carries it. */
                                                                                                               
                                                                              
                                                                                        
@@ -628,6 +650,9 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
     more entry, and no reader changes. */
                               
                 
+                                                                           
+                                                                               
+                  
                                                                        
                        
                                                                                 
@@ -648,12 +673,12 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                        
  
 
-/** What an earlier test that failed and does not continue leaves a later one. */
+/** What an earlier eval that failed and does not continue leaves a later one. */
                                           
 
                                               
 
-/** One test's reading of one scenario of a run (scenarioTests). */
+/** One eval's reading of one scenario of a run (scenarioEvals). */
                               
              
                 
@@ -710,7 +735,7 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
 
 // ---- the registries ----
 
-/** An option a modifier or a test type exposes for editing. */
+/** An option a modifier or an eval type exposes for editing. */
                         
                                                                                                
                                                 
@@ -770,7 +795,7 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                                                                    
                                     
                                             
-                                                                              
+                                                                               
                              
                                                                     
                                         
@@ -846,10 +871,10 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                                                                             
  
 
-/** A test type: what it checks of a document, and how it scores a run. */
+/** An eval type: what it checks of a document, and how it scores a run. */
                                 
                 
-                                                                
+                                                                 
                        
                             
                                            
@@ -859,11 +884,11 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                                                                   
                                                                 
                                                                                                    
-                                                                               
+                                                                                
                                                                                 
                                
                                            
-                                                                       
+                                                                         
                                                                         
                                                                       
                                                                                                                
@@ -884,7 +909,7 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                                                                          
  
 
-/** What a test's `read` is handed besides the reply: production's reply to
+/** What an eval's `read` is handed besides the reply: production's reply to
     the item, and a grader, where the run has them. */
                            
                              
@@ -894,45 +919,54 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                                                                            
  
 
-/** A job's slots, in the order they run. */
-                                                    
-const SLOTS                      = ["content", "call", "reply"];
+/** A job's stages, in the order they run (pipeline-model §16). A target's
+    step is in no job: it is the target's, in that job's place. */
+                                                          
+const SLOTS                      = ["content", "target", "responses"];
 
                                 
                     
                                                           
                 
-                                                                           
-                                                                    
-                                                                        
+                                                                   
+                                                                         
+                                                                      
+                                                                          
                                                                       
-                                                                        
                                                                         
                   
+                                                                       
+                                      
+                
+                                                                    
+                 
                                                  
                  
                                                             
                        
-                                                                         
+                                                                             
+                                                          
+                  
+                                                                      
                   
+                                                                        
+                                                                
+                    
                                                                          
                                                              
                      
-                                                                        
-                         
-                                 
                                                                           
+                         
                                  
-                                                           
+                                                                  
                         
+                                                                        
                                                                          
-                                                                               
-                                  
+                                                       
+                                        
                                                                            
-                                                                        
+                                                                                
                                                                  
-                                                                         
-                                                                                   
                              
                                                             
                                            
@@ -945,42 +979,122 @@ const SLOTS                      = ["content", "call", "reply"];
  * submitted against, so nothing grades from a file.
  */
                               
+                                                                           
+                            
+                                       
+                                                                          
+                      
+                     
                           
                 
  
 
+/** The dataset body's version: 6 marks itself; 5 named its Source; 4 and
+    earlier, neither. */
+const DATASET_BODY_VERSION = 6         ;
+
+/** The metrics whose Ignore case version 6 made mean what it says for a
+    reply read as a list, as well as one read as text. */
+const CASE_FOLDING = ["contains", "contains-all", "contains-any"];
+
 /**
- * [body] as this version of a dataset (4), from any earlier one. Version 1
+ * [body] as this version of a dataset (6), from any earlier one. Version 1
  * held `imageCases`, each with `minTags`/`maxTags`, and the parser's
  * `replays` and `conformance` (now fixtures/replays.json beside the checks).
  * Version 2 held `rules`, which clean a job's answer and so belong to the
  * job (docs/pipeline-model.md §13): they leave, and the terms a case
  * watches for are its `watch`. Version 3 held the `prompt` a new scenario
- * started from, which the Prompt library holds now: it leaves. Every reader of a body calls this: the runner, the page, a
- * run's kept copy. A reader that needs a version-2 body's rules -- to upgrade
- * a pipeline graded against it -- takes them first (`datasetRules`).
- * Anything else comes back as it was.
+ * started from, which the Prompt library holds now: it leaves. Version 4's
+ * case named its item `filename` and said what a good answer is in
+ * expectations; each becomes the metric it is (`caseMetrics`), `why` is the
+ * `note`, `traits` go, and the body names no Source yet. Version 5 matched
+ * a list's items ignoring case whatever a Contains metric's Ignore case
+ * said, so each of its Contains metrics says Ignore case (`caseOfV5`), and
+ * the body says its version. Every reader of a
+ * body calls this: the runner, the page, a run's kept copy. A reader that
+ * needs a version-2 body's rules -- to upgrade a pipeline graded against
+ * it -- takes them first (`datasetRules`). Pure: the same body gives the
+ * same answer, and server.py's upgrade_body is its twin. Anything else
+ * comes back as it was.
  */
 function upgradeDatasetBody   (body   )                  {
   if (!isObj(body)) return body;
-  if (!("imageCases" in body || "rules" in body)) {
-    if (!("prompt" in body)) return body;
-    const { prompt: _library, ...rest } = body             ;
-    return rest               ;
-  }
+  if (body.version === DATASET_BODY_VERSION) return body;
   const b = body             ;
-  // vocab: the names older versions gave these fields
-  const RENAMED                         = { minTags: "minCount", maxTags: "maxCount", textInImage: "watch" };  // vocab: as above
-  const renamed = (c           ) => {
-    if (!isObj(c)) return c;
-    const out            = {};
-    for (const [k, v] of Object.entries(c)) out[RENAMED[k] ?? k] = v;
-    return out;
-  };
+  // A body that names its Source, even as null, is version 5.
+  if ("source" in b) {
+    return { version: DATASET_BODY_VERSION, ...b, ...(Array.isArray(b.cases) ? { cases: b.cases.map(caseOfV5) } : {}) };
+  }
   const raw = Array.isArray(b.cases) ? b.cases : Array.isArray(b.imageCases) ? b.imageCases : null;
   // Not a body of any version -- a copy kept while a dataset was an overlay.
   if (!raw) return body;
-  return { cases: (canonicalCases({ cases: raw.map(renamed) })                     ).cases };
+  return { version: DATASET_BODY_VERSION, source: null, cases: raw.map(caseOfV4).map(caseOfV5) };
+}
+
+/** A version-5 case as a version-6 one: each Contains metric says Ignore
+    case, as version 5 matched a list's items whatever it said. A reply read
+    as text did mind its setting, but a case's metrics were written for a
+    list -- each one converted from version 4, and each the case form made. */
+function caseOfV5(c         )          {
+  if (!isObj(c) || !Array.isArray(c.metrics)) return c;
+  return { ...c, metrics: c.metrics.map((m           ) => (isObj(m) && CASE_FOLDING.includes(m.type) && m.ignoreCase !== true
+    ? { ...m, ignoreCase: true } : m)) };
+}
+
+// vocab: the names older versions gave these fields
+const CASE_RENAMED                         = { minTags: "minCount", maxTags: "maxCount", textInImage: "watch", photo: "filename" };  // vocab: as above
+/** What a version-4 case said, which its metrics say now. */
+const CASE_V4 = ["filename", "why", "traits", "expect", "anyOf", "forbid", "allow", "minCount", "maxCount", "watch", "discarded"];
+
+/** One case of any earlier version as a version-5 one: its id, item, todo
+    and note, its expectations as metrics ahead of any metrics it held, and
+    anything else it carried kept as it was. */
+function caseOfV4(c         )          {
+  if (!isObj(c)) return c;
+  const was            = {};
+  for (const [k, v] of Object.entries(c)) {
+    const key = CASE_RENAMED[k] ?? k;
+    // A case naming its item both ways keeps the newer key's.
+    if (!(key in was) || key === k) was[key] = v;
+  }
+  if (isStr(was.item)) delete was.filename;
+  const out            = {};
+  if ("id" in was) out.id = was.id;
+  out.item = isStr(was.item) ? was.item : isStr(was.filename) ? was.filename : "";
+  out.todo = was.todo === true;
+  out.note = isStr(was.note) ? was.note : isStr(was.why) ? was.why : "";
+  out.metrics = [...caseMetrics(was), ...(Array.isArray(was.metrics) ? was.metrics : [])];
+  for (const [k, v] of Object.entries(was)) {
+    if (!(k in out) && !CASE_V4.includes(k)) out[k] = v;
+  }
+  return out;
+}
+
+/** A version-4 case's expectations as the metrics that say the same:
+    `expect` is Contains all, each `anyOf` group a Contains any, each
+    forbidden term a Contains turned round with the `allow` phrases that
+    excuse it, the count bounds an Item count, `discarded` the Discarded
+    metric, and each watched term a Contains any of weight 0 -- reported,
+    never scored. The order is the one scoreCase read them in, so a reason
+    reads in the order it did. */
+function caseMetrics(c           )           {
+  const list = (v         )           => (Array.isArray(v) ? v.filter(isStr) : []);
+  if (c.discarded === true) return [{ type: "discarded" }];
+  const out           = [];
+  const expect = list(c.expect), allow = list(c.allow);
+  if (expect.length) out.push({ type: "contains-all", values: expect.join("\n") });
+  for (const g of Array.isArray(c.anyOf) ? c.anyOf : []) {
+    if (list(g).length) out.push({ type: "contains-any", values: list(g).join("\n") });
+  }
+  for (const t of list(c.forbid)) {
+    // An exception excuses only the forbidden term inside it.
+    const except = allow.filter(a => termIn([a], t));
+    out.push({ type: "contains", value: t, not: true, ...(except.length ? { except: except.join("\n") } : {}) });
+  }
+  const min = Number.isInteger(c.minCount) ? c.minCount : null, max = Number.isInteger(c.maxCount) ? c.maxCount : null;
+  if (min != null || max != null) out.push({ type: "item-count", min, max });
+  for (const t of list(c.watch)) out.push({ type: "contains-any", values: t, weight: 0 });
+  return out;
 }
 
 /** The rules a version-1 or version-2 dataset body held, or null: what a
@@ -996,6 +1110,9 @@ function datasetRules(body         )                  {
                                                 
                                             
                                             
+                                                                           
+                                                                        
+                                            
                                                 
                                         
  
@@ -1023,6 +1140,10 @@ function datasetRules(body         )                  {
                                  
              
                 
+                                                                        
+                                                                        
+                          
+                   
                                                                          
                        
                                          
@@ -1067,7 +1188,7 @@ function datasetRules(body         )                  {
  
 
 /** What a Call hands its connection. */
-                                            
+                                                        
 
 /** What the core hands a registry module (kinds/list.ts) to register with. */
                             
@@ -1120,7 +1241,9 @@ function mappingsFor(prompt        )                {
                                                                             
                                                   
                 
-                                                 
+                                                                        
+                  
+                                                                              
                                                           
  
 
@@ -1157,6 +1280,32 @@ TOKEN_TYPES.block = {
   validate(m, at, bad){ if (typeof m.enabled !== "boolean") bad.push(`${at}: a block's enabled has to be true or false`); },
 };
 
+// Expression: a Power Automate expression, evaluated against the item's
+// record -- `@triggerBody()?['note']`, or text with `@{…}` in it -- so a
+// prompt can say what the flow's own request says (docs/pipeline-model.md
+// §16 › Targets).
+TOKEN_TYPES.expression = {
+  label: "Expression",
+  fields: ["value"],
+  defaults: () => ({ value: "" }),
+  notation: name => `{${name}}`,
+  names: name => [name],
+  order: 1,
+  apply(prompt, m, record){
+    const token = `{${m.name}}`;
+    if (!prompt.includes(token)) return prompt;
+    if (!record) throw new WdlError(`{${m.name}} reads the item's record, and this item is not one`);
+    try {
+      return prompt.replaceAll(token, asText(evaluate(m.value ?? "", { scope: record.scope || {}, now: record.at ?? null, loop: record.loop ?? null })));
+    } catch (e) {
+      throw new WdlError(`{${m.name}}: ${(e         ).message}`);
+    }
+  },
+  validate(m, at, bad){
+    if (!isStr(m.value)) bad.push(`${at}: an expression's value has to be text`);
+  },
+};
+
 /** A mapping of [type] named [name], holding its type's defaults. */
 function tokenMapping(name        , type        )               {
   return { name, type, ...(TOKEN_TYPES[type]?.defaults() ?? {}) };
@@ -1186,12 +1335,12 @@ function tokenMappingsProblems(list         , at        , bad          )       {
  * The tokens are a parameter and not a global, because only one of the three
  * callers has a localStorage to have loaded a set from.
  */
-function resolvePrompt(tpl        , tokens               )         {
+function resolvePrompt(tpl        , tokens               , record                     = null)         {
   const order = (m              ) => TOKEN_TYPES[m.type]?.order ?? Infinity;
   let out = tpl;
   for (const m of [...tokens].sort((a, b) => order(a) - order(b))) {
     const type = TOKEN_TYPES[m.type];
-    if (type) out = type.apply(out, m);
+    if (type) out = type.apply(out, m, record);
   }
   // Dropping a block leaves the spaces that surrounded it.
   return out.replace(/[ \t]{2,}/g, " ").trim();
@@ -1231,8 +1380,10 @@ function textPrompt(instruction        , text        )         {
 }
 
 // Mirrors TagRules' WORD. The unit the echo guard and the eval matcher both
-// work in, so that "New Zealand." and "new zealand" are the same two words.
-const words = (s         )           => String(s||"").toLowerCase().match(/[\p{L}\p{N}]+/gu) || [];
+// work in, so that "New Zealand." and "new zealand" are the same two words --
+// unless [keepCase], for a metric whose Ignore case is off.
+const words = (s         , keepCase = false)           =>
+  (keepCase ? String(s||"") : String(s||"").toLowerCase()).match(/[\p{L}\p{N}]+/gu) || [];
 
 // The request Tagger builds, field for field -- when the target reads those
 // fields. A llama.cpp server does; the hosted OpenAI-shaped providers do
@@ -1376,8 +1527,10 @@ CONNECTION_TYPES["ollama-cloud"] = ollamaType("ollama-cloud", "Ollama (Cloud)",
 // each scenario holds one. Only job 1 can use it: a later job's item is the
 // job before's answer, not a file.
 const sendsNothing = ()        => { throw new Error("Echo answers from the item and sends no request"); };
+// Echo is a target step now (STEP_TYPES.echo), with no profile; the type
+// stays so a stored run, or a profile made before, still reads.
 CONNECTION_TYPES.echo = {
-  id: "echo", label: "Echo", settings: [], keyless: true,
+  id: "echo", label: "Echo", settings: [], keyless: true, picker: false,
   description: "No model: answers with each text item itself, to grade replies recorded earlier.",
   local: (item, sent) => item.text ?? sent,
   request: sendsNothing, parseReply: sendsNothing, listModels: sendsNothing, parseModels: () => [],
@@ -1547,16 +1700,19 @@ CONNECTION_TYPES["llama.cpp"] = {
                 
                                                                            
                              
-                                                                              
+                                                                            
                                                                    
-                                                 
+                                                        
                               
-                                                               
+                                                                      
                                                                                             
                                                                
                                             
                                               
                                                                   
+                                                                          
+                                                                          
+                              
                                                                              
                                          
                                                      
@@ -1622,6 +1778,7 @@ HTTP_APIS.anthropic = {
     const r = j                                                                                ;
     return { raw: (r?.content || []).filter(b => b?.type === "text").map(b => b.text).join(""), finishReason: r?.stop_reason ?? null };
   },
+  wrap: text => ({ type: "message", role: "assistant", content: [{ type: "text", text }], stop_reason: "end_turn" }),
   withPrefill(j, prefill) {
     const r = j             ;
     if (!isObj(r) || !Array.isArray(r.content)) return j;
@@ -1667,6 +1824,7 @@ const openAiApi = (label        , matches                     )               =>
     return { ...b, messages: msgs };
   },
   reply: chatReply,
+  wrap: text => ({ object: "chat.completion", choices: [{ index: 0, message: { role: "assistant", content: text }, finish_reason: "stop" }] }),
 });
 HTTP_APIS.openai = openAiApi("OpenAI", u => u.hostname === "api.openai.com");
 HTTP_APIS["azure-openai"] = openAiApi("Azure OpenAI", u => u.hostname.endsWith(".openai.azure.com"));
@@ -1684,6 +1842,9 @@ HTTP_APIS.raw = {
     try { return JSON.parse(cell.prompt); } catch { throw new Error("the body is not JSON"); }
   },
   reply: j => ({ raw: isStr(j) ? j : JSON.stringify(j), finishReason: null }),
+  // A body the flow reads is JSON where it parses as JSON, as the HTTP
+  // action hands it on, and text otherwise.
+  wrap: text => { try { return JSON.parse(text); } catch { return text; } },
 };
 
 /** The HTTP API a flow's request to [uri] speaks: the first entry that
@@ -1938,11 +2099,12 @@ function budgetLabel(target         )         {
 // A term is present when its words appear in some item, in order and adjacent:
 // "cat" is in "cat" and in "tabby cat", and is not in "cathedral". Anything
 // looser scores "new zealand" against "zealandia" and flatters every run.
-function termIn(items                   , term        )          {
-  const t = words(term);
+// Letter case counts only where a metric's Ignore case is off.
+function termIn(items                   , term        , ignoreCase = true)          {
+  const t = words(term, !ignoreCase);
   if (!t.length) return false;
   return items.some(item => {
-    const w = words(item);
+    const w = words(item, !ignoreCase);
     for (let i = 0; i + t.length <= w.length; i++) {
       if (t.every((x, j) => w[i + j] === x)) return true;
     }
@@ -1969,153 +2131,55 @@ function forbiddenIn(items                   , term        , allow
  * check green. `evals-check.js` calls this directly.
  */
 function gradedSetFrom(ev         )              {
-  return (ev.cases || []).map(c => ({ ...c, filename: caseFile(c), half: "cases" })             );
+  return (ev.cases || []).map(c => ({ ...c, item: caseItem(c), half: "cases" })             );
 }
 
-/**
- * The file a case grades, whichever of the two keys names it.
- *
- * One reader, so that accepting the older spelling is a fact about this
- * function rather than a branch every caller carries. Everything that joins a
- * case to an item -- the runner, the Datasets tab, a mapping against a Source
- * -- goes through here.
- */
-function caseFile(kase                                                            )         {  // vocab: the older spelling
-  const name = kase?.filename ?? kase?.photo;  // vocab: the older spelling
-  return typeof name === "string" ? name : "";
+/** The item a case grades: its `item`, or "" for none. The one reader, so
+    everything that joins a case to an item -- the runner, the Library, a
+    run's Results -- joins on the same key, exactly. */
+function caseItem(kase                                       )         {
+  return isStr(kase?.item) ? kase .item           : "";
 }
 
-/**
- * A graded set with every case naming its file as `filename`.
- *
- * What `evalsJson` writes, so the committed bytes carry one key and a set
- * re-synced from an app's own repository is normalised the first time it is
- * exported. The key takes the place the older one held, so normalising a set
- * changes the spelling of
- * one key and not the order of any.
- */
-function canonicalCases(ev         )          {
-  const OLD = "photo";  // vocab: the older spelling of filename
-  const set = ev                                ;
-  const cases = set && typeof set === "object" && Array.isArray(set.cases) ? set.cases : null;
-  if (!cases || !cases.some(c => c && typeof c === "object" && OLD in (c          ))) return ev;
-  return {
-    ...set,
-    cases: cases.map(c => {
-      if (!c || typeof c !== "object" || !(OLD in (c          ))) return c;
-      const out                          = {};
-      for (const [k, v] of Object.entries(c                           )) {
-        if (k === OLD) { if (!("filename" in (c          ))) out["filename"] = v; }
-        else out[k] = v;
-      }
-      return out;
-    }),
-  };
-}
+/** One graded case's reading of a reply, now: its own metrics, scored as a
+    Metrics eval scores them (all must pass; weight 0 is watched, never
+    scored), with what they found, missed and invented carried up, and
+    `watch` the readings of weight 0. What the page draws and the runner's
+    case-by-case report writes. A model-graded metric needs a grader and the
+    wait for one, so here it reads as not met: the runner's `--run` asks it. */
+                                                  
+                           
+                       
+                        
+                     
+                                      
+                     
+                                                        
+                    
+                                                       
+                         
+                                          
+                
+ 
 
-/**
- * One graded case, one result.
- *
- * Every expectation is a group, and a plain `expect` term is a group of one:
- * the requirements are the `expect` terms and the `anyOf` groups alike, and
- * the score is found requirements over all of them plus `forbid`. A count
- * bound stays pass/fail: an item that produced two perfect terms when five
- * were wanted has not done what was asked.
- *
- * Pure on purpose, and returning `reasons` as plain sentences rather than
- * markup. The dashboard was the first consumer; `run-evals.js` is the second
- * and CI the third, and neither can reach into a page for a rendered cell.
- * Issue #248 wants a failure written out as a task an agent can act on.
- */
-function scoreCase(kase      , res                                                              )            {
-  // A case that expects its answer discarded passes on a discard and on
-  // nothing else: the answer the job threw away is the finding.
-  if (kase.discarded === true) {
-    const thrown = !!res.error && res.error.startsWith("discarded: ");
-    const n = (res.terms || []).length;
-    return { pass: thrown, score: thrown ? 1 : 0, discarded: !!res.error, found: [], missed: [], invented: [],
-             unmet: [], under: false, over: false, count: res.error ? 0 : n, watchFound: [], watchTotal: 0,
-             reasons: thrown ? [] : [res.error ? `Error - ${res.error}` : `FAIL: kept ${n} items, and the case expects the answer discarded`] };
-  }
-  // A discarded answer is a failed item: whatever the pipeline produced
-  // along the way does not count.
-  const discarded = !!res.error;
-  const terms = discarded ? [] : (res.terms || []);
-  const expect = kase.expect || [], forbid = kase.forbid || [];
-
-  // `missed` stays populated for a discarded reply even though it reads as
-  // vacuous, because the score depends on it: docs/datasets.md has such a reply
-  // scoring zero against everything the entry asked for, groups included, and
-  // `addToTally` gets there through `found + missed + invented`. Clear it and
-  // a run that discarded every item would contribute nothing to the
-  // total instead of contributing a nought, which flatters it.
-  //
-  // One member of a group is enough. Without this rule the set manufactures
-  // failures out of synonyms.
-  //
-  // A requirement reads back as a term when it had one member and as the
-  // group itself where a synonym list was allowed, so `missed` carries just
-  // enough to state the reason: "FAIL: Missed dog" for a plain expect term,
-  // "none of dog / puppy" for a group.
-  //
-  // Nothing satisfies a group when nothing was stored, so a discarded reply
-  // misses every requirement rather than none -- the same cast that makes its
-  // count bounds not breached by one. `unmet` is a finding only now that
-  // `missed` names the unsatisfied groups itself, but the run report has
-  // always carried it, so it stays.
-  const met = (g          ) => g.some(t => termIn(terms, t));
-  const spoken = (g          )              => g.length === 1 ? g[0]  : g;
-  const requirements = [...expect.map(t => [t]), ...(kase.anyOf || [])];
-  const found = requirements.filter(met).map(spoken);
-  const missed = requirements.filter(g => !met(g)).map(spoken);
-  const invented = forbid.filter(t => forbiddenIn(terms, t, kase.allow));
-  const unmet = discarded ? []
-    : (kase.anyOf || []).filter(g => !g.some(t => termIn(terms, t)));
-
-  const n = terms.length;
-  // A null bound is not checked -- and neither is a bound on a reply that was
-  // discarded. Nothing was counted out and found wanting there; the reply was
-  // thrown away before it had a count, and saying "0 items, wanted at least 4"
-  // states a second failure that never happened.
-  const under = !discarded && kase.minCount != null && n < kase.minCount;
-  const over = !discarded && kase.maxCount != null && n > kase.maxCount;
-
-  const denom = requirements.length + invented.length;
-  // A case that passes is one whose whole expectation was met, not one that
-  // scored well: an unsatisfied group is in `missed` alongside any term
-  // missed, so pass needs nothing more than the terms already covered.
-  const pass = !discarded && !missed.length && !invented.length && !under && !over;
-
-  // `found` and `missed` are groups, not terms, so the reasons word them one
-  // by one: a bare term under one heading, a group on its own line.
-  const reasons           = [];
-  if (discarded) {
-    // Everything else would be derived from this one fact -- there are no
-    // terms -- and would bury it. `scoreHtml` above suppresses `missed` for
-    // the same reason: the reason that matters is already on the row.
-    reasons.push(`Error - ${res.error}`);
-  } else {
-    const plain = missed.filter(t => typeof t === "string");
-    if (plain.length) reasons.push(`FAIL: Missed ${plain.join(", ")}`);
-    for (const g of missed) {
-      if (Array.isArray(g)) reasons.push(`none of ${g.join(" / ")}`);
+function readCase(kase      , res                                   , plain = false)              {
+  const input = metricInput(res                      , kase, { plain });
+  const metrics = (Array.isArray(kase.metrics) ? kase.metrics : []).flatMap(m => {
+    const r = readMetric(m, input, {});
+    if (r && typeof (r                    ).then === "function") {
+      return [{ type: m.type, label: METRICS[m.type]?.label ?? m.type, weight: typeof m.weight === "number" ? m.weight : 1,
+                pass: false, score: 0, reason: "a model-graded metric needs a grader" }                 ];
     }
-    if (invented.length) reasons.push(`invented ${invented.join(", ")}`);
-    if (under) reasons.push(`${n} items, wanted at least ${kase.minCount}`);
-    if (over) reasons.push(`${n} items, wanted at most ${kase.maxCount}`);
-  }
-
-  // Observed rather than scored: a dataset that wants to know whether some
-  // terms turn up, without grading on them, lists them as `watch`.
-  const watch = kase.watch || [];
-  // `null`, not 1, when there are no requirements and nothing forbidden turned
-  // up: there is no score to report. Returning 1 there printed "fail 100%"
-  // beside an entry that asked for nothing -- a shape `evals-check.js` allows
-  // even though every graded case now names an expectation.
-  return { pass, score: denom ? found.length / denom : null, discarded,
-           found, missed, invented, unmet, under, over, count: n,
-           watchFound: watch.filter(t => termIn(terms, t)), watchTotal: watch.length,
-           reasons };
+    return r ? [r                 ] : [];
+  });
+  const s = scoreOf(metrics) ?? { pass: true, score: null, metrics };
+  const counted = metrics.filter(r => r.weight !== 0);
+  return { ...s, metrics, found: s.found ?? [], missed: s.missed ?? [], invented: s.invented ?? [],
+           discarded: !!res.error, count: res.error ? 0 : (res.terms || []).length,
+           // A reply the job threw away fails on that one fact, which would
+           // be buried under everything that derives from it.
+           reasons: res.error && !s.pass ? [`Error - ${res.error}`] : counted.filter(r => !r.pass).map(r => `${r.label}: ${r.reason}`),
+           watch: metrics.filter(r => r.weight === 0) };
 }
 
 /**
@@ -2156,11 +2220,12 @@ const emptyTally = ()        => ({ ran: 0, passed: 0, found: 0, of: 0 });
 // docs/datasets.md: an item naming more terms should weigh more than
 // one naming fewer, and averaging percentages lets the easiest case carry the
 // score.
-function addToTally(t       , s                                                           )       {
+function addToTally(t       , s                                                             )       {
+  const found = s.found?.length ?? 0;
   t.ran++;
   if (s.pass) t.passed++;
-  t.found += s.found.length;
-  t.of += s.found.length + s.missed.length + s.invented.length;
+  t.found += found;
+  t.of += found + (s.missed?.length ?? 0) + (s.invented?.length ?? 0);
 }
 
 // The headline percentage, in one place because it is a number and this file
@@ -2175,7 +2240,7 @@ function tallyPercent(t       )                {
 // A whole-run assertion with no graded set: All of / Any of / None of, a
 // parse, a count, an exact reply and a length bound. It lives in the shared
 // core because it is a pass/fail the tab, the worker and History all have to
-// agree on -- the same one-definition rule that keeps `scoreCase` here.
+// agree on -- the same one-definition rule that keeps the case reader here.
 function parseCount(raw        , parse                           )                                           {
   // An unparsed reply is one result, not no result. It used to return null,
   // which made a Count of 1 fail as "null results" against a reply that
@@ -2432,7 +2497,7 @@ function jobProblem(stages                  , call
 // 1 the way `textPrompt` says, and any later stage that places {text}.
 async function runPipeline(stages                  , dataUrl               , call                        ,
                            opts             = {})                     {
-  const { tokens = TOKEN_DEFAULTS, mode, text = null } = opts;
+  const { tokens = TOKEN_DEFAULTS, mode, text = null, record = null } = opts;
   const transcript                    = [];
   const problem = jobProblem(stages, call, tokens, text);
   if (problem) return { error: problem, terms: [], transcript, ms: 0 };
@@ -2466,8 +2531,15 @@ async function runPipeline(stages                  , dataUrl               , cal
       forwarded.set("reply", prev.reply);
       for (const [name, v] of Object.entries(prev.rendered)) forwarded.set(name, v);
     }
-    // A verbatim stage's words are the call's own template, sent as written.
-    const instruction = st.verbatim ? st.text : resolvePrompt(st.text, tokenSet(tokens, i));
+    // A verbatim stage's words are its target step's own template, sent as written.
+    // An expression token that cannot be read is the stage's error, said
+    // before anything is sent.
+    let instruction        ;
+    try { instruction = st.verbatim ? st.text : resolvePrompt(st.text, tokenSet(tokens, i), record); }
+    catch (e) {
+      if (!(e instanceof WdlError)) throw e;
+      return result({ error: named(e.message) });
+    }
     const fill = (to                       ) => instruction.replace(TOKEN, (m, name        ) =>
       forwarded.has(name) ? to(forwarded.get(name) ) : m);
     const sent = st.verbatim ? instruction : i === 0 && text != null ? textPrompt(instruction, text) : fill(v => v);
@@ -2558,10 +2630,10 @@ function applyModifiers   (list                                 , kind        ,
 // queue and run-evals.js alike, and every one of them reads it through the
 // functions below rather than through a translation of its own.
 //
-// The lab is generic, so what a reply is, what a test scores and how a value
+// The lab is generic, so what a reply is, what an eval scores and how a value
 // is changed are registry entries. The ones here are the lab's own, and so
 // are kinds/list.ts's -- the List kind and its modifiers. A dataset
-// registers nothing: it is data a graded test names by id, and a run carries.
+// registers nothing: it is data a graded eval names by id, and a run carries.
 
 // 2: a job's mappings are a list of { name, type, … } (tokenMappings), where
 // version 1 kept them as two maps (tokens: { values, blocks }).
@@ -2577,10 +2649,16 @@ function applyModifiers   (list                                 , kind        ,
 // 7: `chains` are `jobs`: the field renames and each job's `type` is "job".
 // 8: a job is its steps -- job 1's Attach Content (the pipeline's content), a
 // Call (Prompt: the image flag and token mappings), Read Reply (the output).
-// 9: a test is Metrics. A Single Test and a Graded set are read as the Metrics
+// 9: an eval is Metrics. A Single Test and a Graded set are read as the Metrics
 // they convert to (LEGACY_TESTS' toMetrics, proven equal by
 // metrics-parity-check.js).
-const PIPELINE_VERSION = 9         ;
+// 10: a job's steps are its stages (pipeline-model §16) -- Content (Attach
+// Content, the flow step, Attach Image, Token mappings) and Responses (Read
+// as, Response Format Validation, modifiers) -- and its call is gone: each
+// scenario is a target, whose own step in each job is what it sends there.
+// 11: `tests` are `evals`: the key renames and nothing in an eval changes,
+// so a stored result's scores, keyed by eval id, read as they did.
+const PIPELINE_VERSION = 12         ;
 
 // Plain objects, so an entry is added by assignment and a reader never needs
 // to know which registered it.
@@ -2588,7 +2666,7 @@ const STEP_TYPES                                = Object.create(null);
 const CONTENT_TYPES                                   = Object.create(null);
 const OUTPUT_KINDS                                  = Object.create(null);
 const MODIFIERS                                = Object.create(null);
-const TEST_TYPES                                = Object.create(null);
+const EVAL_TYPES                                = Object.create(null);
 const METRICS                              = Object.create(null);
 const SOURCE_TYPES                                  = Object.create(null);
 
@@ -2602,11 +2680,15 @@ let defaultOutputKind = "text";
 const defaultKind = () => defaultOutputKind;
 const kindOf = (st                               )         => st.kind ?? defaultOutputKind;
 
+/** A module's eval types, under either spelling (Kinds.testTypes). */
+const evalTypesOf = (k                                        )                                =>
+  ({ ...(k.testTypes || {}), ...(k.evalTypes || {}) });
+
 /** A module's entries into the registries, in one call. */
 function registerKinds(k       )       {
   Object.assign(OUTPUT_KINDS, k.outputKinds || {});
   Object.assign(MODIFIERS, k.modifiers || {});
-  Object.assign(TEST_TYPES, k.testTypes || {});
+  Object.assign(EVAL_TYPES, evalTypesOf(k));
   Object.assign(SOURCE_TYPES, k.sourceTypes || {});
   Object.assign(METRICS, k.metrics || {});
   if (k.defaultKind) defaultOutputKind = k.defaultKind;
@@ -2637,7 +2719,7 @@ function pluginHost(pluginId        )             {
     registerKinds(k) {
       taken(OUTPUT_KINDS, "output kind", Object.keys(k.outputKinds || {}));
       taken(MODIFIERS, "modifier", Object.keys(k.modifiers || {}));
-      taken(TEST_TYPES, "test type", Object.keys(k.testTypes || {}));
+      taken(EVAL_TYPES, "eval type", Object.keys(evalTypesOf(k)));
       taken(METRICS, "metric", Object.keys(k.metrics || {}));
       // The server keeps its own copy of the Source types, to refuse a row of
       // one it does not know, and a plugin never reaches the server's code.
@@ -2741,8 +2823,7 @@ function encoderQuality(quality               )         {
 // 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        )         =>
-  (doc.scenarios?.[i]?.name || "").trim() || `Scenario ${i + 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");
 
@@ -2850,7 +2931,7 @@ CONTENT_TYPES.text = {
 // being the recorded reply.
 CONTENT_TYPES.prompt = {
   label: "Prompt only",
-  description: "No item: each scenario's prompt is sent on its own.",
+  description: "No item: each target's prompt is sent on its own.",
   inline: true,
   bare: true,
   fields: ["type"],
@@ -2904,11 +2985,9 @@ LEGACY_TESTS.single = {
   },
 };
 
-// A dataset's cases, scored item by item with scoreCase. The test
-// references the dataset the way a pipeline references a Source, and the run
-// carries the body it was submitted against. It scores the terms a value
-// yields, so it accepts every kind that yields any: plain text has none, and
-// would fail every case.
+// A dataset's cases, scored item by item. The eval references the dataset
+// the way a pipeline references a Source, and the run carries the body it
+// was submitted against.
 LEGACY_TESTS.graded = {
   label: "Graded set",
   fields: ["type", "dataset"],
@@ -2916,16 +2995,15 @@ 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 test has to name its dataset as { id, name }");
+      return void bad.push("a graded eval has to name its dataset as { id, name }");
     }
     if (ctx.datasets && !ctx.datasets.some(x => x.id === d.id)) bad.push(`Dataset ${d.name || d.id} not found`);
   },
-  score: (t, kase, res) => scoreCase(kase, res),
 };
 
 // Metrics: checks of each reply, deterministic or model-graded, from the
 // METRICS registry (metrics/builtin.ts registers the lab's own), with the
-// test's own list for every item and a case's `metrics` for its item. Scored
+// eval's own list for every item and a case's `metrics` for its item. Scored
 // all-must-pass -- every metric passes -- or weighted: points, each metric's
 // score times its weight, against a threshold (#150's points, a negative
 // weight taking them away).
@@ -2934,6 +3012,13 @@ LEGACY_TESTS.graded = {
 const METRIC_FIELDS                    = ["type", "not", "weight", "metric", "of", "every"];
 const SCORING_MODES = ["all", "weighted"];
 
+/** A metric's list option -- Contains all's values, Contains's exceptions --
+    one entry a line, or a list of them. */
+function metricLines(v         )           {
+  const all = Array.isArray(v) ? v.map(x => String(x ?? "")) : String(v ?? "").split("\n");
+  return all.map(x => x.trim()).filter(Boolean);
+}
+
 /** What is wrong with a list of metrics, as sentences naming [at]. */
 function metricsProblems(list         , at        , bad          )       {
   if (!Array.isArray(list)) return void bad.push(`${at}: metrics has to be a list`);
@@ -3003,14 +3088,16 @@ function readMetric(m        , input             , ctx           )
   } catch (e) { return timed(failed(e)); }
 }
 
-/** A test's score from its metrics' readings, the way [mode] says: all must
+/** An eval's score from its metrics' readings, the way [mode] says: all must
     pass, or weighted points against [threshold]. What a case metric found,
     missed and invented is carried up, for a run's totals. Null for none. */
 function scoreOf(metrics                 , mode = "all", threshold                = null)                     {
   if (!metrics.length) return null;
-  const detail = metrics.some(r => r.found || r.missed || r.invented) ? {
-    found: metrics.flatMap(r => r.found ?? []), missed: metrics.flatMap(r => r.missed ?? []),
-    invented: metrics.flatMap(r => r.invented ?? []) } : {};
+  // A watched reading (weight 0) is reported, and counts toward nothing.
+  const scored = metrics.filter(r => r.weight !== 0);
+  const detail = scored.some(r => r.found || r.missed || r.invented) ? {
+    found: scored.flatMap(r => r.found ?? []), missed: scored.flatMap(r => r.missed ?? []),
+    invented: scored.flatMap(r => r.invented ?? []) } : {};
   if (mode === "weighted") {
     const points = metrics.reduce((sum, r) => sum + r.weight * r.score, 0);
     return { pass: points >= (threshold ?? 0), score: points, points: true, metrics, ...detail };
@@ -3053,7 +3140,7 @@ function readRun(list                   , run             )                  {
   });
 }
 
-TEST_TYPES.metrics = {
+EVAL_TYPES.metrics = {
   label: "Metrics",
   description: "Checks of each reply, or of the whole run, scored all-must-pass or in weighted points.",
   fields: ["type", "metrics", "mode", "threshold", "grader", "dataset", "over"],
@@ -3077,16 +3164,16 @@ TEST_TYPES.metrics = {
     if (t.mode === "weighted" && typeof t.threshold !== "number") bad.push("weighted Metrics need a threshold: the points an item has to reach");
     if (t.threshold != null && typeof t.threshold !== "number") bad.push("the Metrics' threshold has to be a number");
     if (t.grader != null && !isRef(t.grader)) bad.push("the Metrics name their grader as { id, name }");
-    // The test's own grader, or the lab's.
+    // The eval's own grader, or the lab's.
     const grader = isRef(t.grader) ? t.grader : isRef(ctx.grader) ? ctx.grader : null;
-    if (gradedIn(t.metrics) && !grader) bad.push("a model-graded metric needs a grader: pick one on the test, or make a Setup profile the lab's grader");
+    if (gradedIn(t.metrics) && !grader) bad.push("a model-graded metric needs a grader: pick one on the eval, or make a Target profile the lab's grader");
     // A grader is asked words, and needs a model to ask.
     const p = grader && ctx.profiles ? ctx.profiles(grader.id) : null;
-    if (grader && ctx.profiles && !p) bad.push(`Setup profile ${grader.name || grader.id} not found`);
+    if (grader && ctx.profiles && !p) bad.push(`Target profile ${grader.name || grader.id} not found`);
     else if (p) {
       const type = CONNECTION_TYPES[typeOf(p            )];
       if (type && !(type.answers ?? ["prompt"]).includes("prompt")) bad.push(`the grader has to be asked words, and ${type.label} is not`);
-      else if (!type?.local && !String((p            ).model || "").trim()) bad.push("no model on the grader's Setup profile");
+      else if (!type?.local && !String((p            ).model || "").trim()) bad.push("no model on the grader's Target profile");
     }
   },
   rules: t => (Array.isArray(t.metrics) ? t.metrics : []).map((m        , x        ) => ({
@@ -3094,7 +3181,7 @@ TEST_TYPES.metrics = {
     want: [m.not ? "not" : "", metricSummary(m), typeof m.weight === "number" && m.weight !== 1 ? `×${m.weight}` : ""]
       .filter(Boolean).join(" ") })),
   profiles: t => (isRef(t.grader) ? [t.grader] : []),
-  // A run carries the lab's grader on a test that names none and may ask one:
+  // A run carries the lab's grader on an eval that names none and may ask one:
   // a model-graded metric of its own, or a case's, over a dataset.
   resolve: (t, ctx) => (!isRef(t.grader) && isRef(ctx.grader) && (gradedIn(t.metrics) || isRef(t.dataset))
     ? { ...t, grader: { id: ctx.grader.id, name: ctx.grader.name } } : t),
@@ -3109,44 +3196,28 @@ TEST_TYPES.metrics = {
              ran: run.replies.length,
              checks: metrics.map((r, x) => ({ key: `m${x}`, label: r.label, want: "", pass: r.pass, ...(r.pass ? {} : { note: r.reason }) })) };
   },
-  // Rule m{x} is the test's own metric x, read in that place on every item.
+  // Rule m{x} is the eval's own metric x, read in that place on every item.
   // A score stored before Metrics -- a Graded set's, read as its conversion --
   // has no readings of its own: its one metric's reading is the score's.
   ruleOf: (score, key, t) => (score.metrics ? score.metrics[Number(key.slice(1))]?.pass ?? null
     : Array.isArray(t?.metrics) && t.metrics.length === 1 ? score.pass : null),
-  // Every item, with its case's own metrics where it has a case.
-  read: async (t, kase, res, more) => (await readMetrics([...(t.metrics || []), ...((kase?.metrics                        ) || [])],
+  // Every item, with its case's own metrics where the eval names the
+  // dataset and the item has a case there.
+  read: async (t, kase, res, more) => (await readMetrics([...(t.metrics || []), ...((isRef(t.dataset) && kase?.metrics) || [])],
     metricInput(res, kase, more), graderCtx(t, more), t.mode, t.threshold)),
 };
 
 // ---- the lab's own scorers, as metrics ----------------------------------------
-// What the Graded set and the Single Test check, one metric each, so a test of
-// either converts to Metrics that read a run exactly as it did
-// (metrics-parity-check.js). Here rather than in metrics/builtin.ts because
-// each is the core's own matcher.
-
-// An item's case, as the Graded set scores it: its expectations, forbidden
-// terms and count bounds, with what it found, missed and invented kept.
-METRICS.case = {
-  label: "Matches its case",
-  description: "Scores the reply against the item's case in the dataset: the items it expects, forbids and how many.",
-  perItem: true,
-  needsTerms: true,
-  options: [],
-  defaults: () => ({}),
-  score(input) {
-    if (!input.kase) return null;
-    const s = scoreCase(input.kase, { ...(input.error ? { error: input.error } : {}), terms: input.terms });
-    return { pass: s.pass, score: s.score ?? (s.pass ? 1 : 0), reason: s.reasons.join(" · ") || "all matched",
-             found: s.found, missed: s.missed, invented: s.invented };
-  },
-};
+// What the Single Test checks, one metric each, so an eval of it converts to
+// Metrics that read a run exactly as it did (metrics-parity-check.js). Here
+// rather than in metrics/builtin.ts because each is the core's own matcher.
 
 // Items the reply holds -- all of them, or any -- matched as the lab matches
 // a term; a kind that yields none is matched in the replies' text instead,
 // 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.",
   options: [{ key: "values", label: "Items", type: "textarea" },
             { key: "need", label: "Needs", type: "select", choices: [{ value: "all", label: "all" }, { value: "any", label: "any" }] }],
@@ -3166,6 +3237,7 @@ METRICS["has-items"] = {
 // 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.",
   options: [{ key: "op", label: "Is", type: "select", choices: LENGTH_OPS.map(([value, label]) => ({ value, label })) },
             { key: "n", label: "Characters", type: "number" }],
@@ -3181,6 +3253,7 @@ METRICS.length = {
 // as the count says.
 METRICS["parse-count"] = {
   label: "Parses",
+  family: "The result",
   description: "Passes when the reply 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" },
@@ -3199,12 +3272,13 @@ METRICS["parse-count"] = {
   },
 };
 
-/** What every test carries, kept across a conversion. */
+/** What every eval carries, kept across a conversion. */
 const common = (t           ) => ({ id: t.id, name: t.name ?? "", continueOnFailure: t.continueOnFailure !== false });
 
-// A Graded set is a Metrics test over the same dataset, its one metric the case.
+// A Graded set is a Metrics eval over the same dataset, with none of its own:
+// each case's metrics are what it scored (dataset-parity-check.js).
 LEGACY_TESTS.graded .toMetrics = t => ({ ...common(t), type: "metrics", mode: "all", threshold: null, grader: null,
-  dataset: t.dataset, over: "item", metrics: [{ type: "case" }] });
+  dataset: t.dataset, over: "item", metrics: [] });
 
 // A Single Test is Metrics over the whole run: its lists over the run's items
 // together, and exact, length and parse over each reply alone.
@@ -3222,7 +3296,7 @@ LEGACY_TESTS.single .toMetrics = t => {
   return { ...common(t), type: "metrics", mode: "all", threshold: null, grader: null, dataset: null, over: "run", metrics };
 };
 
-/** The grader a Metrics test names, reached through what the runner hands it. */
+/** The grader a Metrics eval names, reached through what the runner hands it. */
 function graderCtx(t           , more          )            {
   const ask = isRef(t.grader) ? more.grader?.(t.grader) : undefined;
   return ask ? { ask } : {};
@@ -3232,27 +3306,33 @@ function graderCtx(t           , more          )            {
     for one with none set: what History prints beside its name. */
 function metricSummary(m        )         {
   const entry = METRICS[m.type];
-  // Each option as it reads in the editor: a choice's label, a box that is
-  // ticked by its own label, text by its first line.
+  // Each option as it reads in the editor: a choice's label, a box by its
+  // own label where it is not as a new metric has it (ticked, or "off"),
+  // text by its first line.
+  const fresh = entry?.defaults() ?? {};
   const said = (entry?.options || []).map(o => {
     const v = m[o.key];
     if (o.type === "select") return o.choices.find(c => c.value === v)?.label ?? "";
-    if (o.type === "checkbox") return v ? o.label.toLowerCase() : "";
+    if (o.type === "checkbox") return !!v === !!fresh[o.key] ? "" : v ? o.label.toLowerCase() : `${o.label.toLowerCase()} off`;
     // Text that runs to lines (a schema) reads as its first words, run together.
     return v == null || isObj(v) ? "" : String(v).replace(/\s+/g, " ").trim().slice(0, 40);
   }).filter(Boolean);
   return said.join(", ");
 }
 
-// ---- a job's steps (pipeline-model §3) -------------------------------------
+// ---- a job's steps, and a target's (pipeline-model §16) ----------------------
+
+// Content: what a job is given. Attach Content and the flow step are job
+// 1's; any job may send the item's image and map tokens.
 
 // Attach Content: the items a run goes over, job 1's first step.
 STEP_TYPES.attachContent = {
-  label: "Attach Content", slot: "content",
-  description: "The items the run goes through: each is sent to every scenario.",
+  label: "Attach Content", slot: "content", rank: 0,
+  description: "The items the run goes through: each is sent to every target.",
   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",
   validate(step, ctx, bad){
     const c = step?.content;
     if (!c) return void bad.push("set the content first");
@@ -3263,20 +3343,65 @@ STEP_TYPES.attachContent = {
   },
 };
 
-// Prompt: a Call that sends each scenario's words to its model.
+// The flow step: the Power Automate action a job's records are calls of.
+STEP_TYPES.flowStep = {
+  label: "Flow step", slot: "content", rank: 1,
+  description: "The Power Automate step each record is a call of.",
+  in: "item", out: "item",
+  apply: "runPipeline",
+  fields: ["type", "step", "loop", "api"],
+  firstJobOnly: "a flow step's records are job 1's items",
+  // Production's reply is the record's result, read as the flow reads it.
+  production(flow, record){
+    const result = isObj(record) && isObj(record.result) ? record.result : null;
+    if (!result || typeof result.status !== "number") return null;
+    try {
+      return httpReplyOf(flow, { prompt: "" }, result.body, result.status,
+                         { scope: record.scope || {}, now: record.at ?? null }).raw;
+    } catch { return null; }
+  },
+  validate(step, _ctx, bad, at){
+    if (!isStr(step.step) || !step.step.trim()) bad.push(`${at}: a flow step names the action it is`);
+    if (step.loop != null && !isStr(step.loop)) bad.push(`${at}: loop names a loop or is null`);
+    if (!HTTP_APIS[step.api]) bad.push(`${at}: "${step.api}" is not an HTTP API this lab has`);
+  },
+};
+
+// Attach Image: the item's image beside every target's words.
+STEP_TYPES.attachImage = {
+  label: "Attach Image", slot: "content", rank: 2,
+  description: "Sends each item's image beside the words.",
+  in: "item", out: "item",
+  apply: "runPipeline",
+  fields: ["type"],
+  validate(){},
+};
+
+// Token mappings: what the words' {tokens} are resolved to.
+STEP_TYPES.tokenMappings = {
+  label: "Token mappings", slot: "content", rank: 3,
+  description: "What each {token} in the words is filled in with.",
+  in: "item", out: "item",
+  apply: "runPipeline",
+  fields: ["type", "tokenMappings"],
+  validate(step, _ctx, bad, at){ tokenMappingsProblems(step.tokenMappings, at, bad); },
+};
+
+// Targets: what each target sends. A target's own steps, one per job.
+
+// Prompt: a target's words, asked of its model.
 STEP_TYPES.prompt = {
-  label: "Prompt", slot: "call", asks: "prompt", modelFrom: "profile",
-  description: "Asks each scenario's model its prompt about the item.",
+  label: "Prompt", slot: "target", asks: "prompt", modelFrom: "profile",
+  description: "Asks each target's model its prompt about the item.",
   in: "item", out: "text",
   apply: "runPipeline",
-  fields: ["type", "withImage", "tokenMappings"],
+  fields: ["type", "prompt", "profile", "from"],
   validate(step, _ctx, bad, at){
-    if (typeof step.withImage !== "boolean") bad.push(`${at}: withImage has to be true or false`);
-    tokenMappingsProblems(step.tokenMappings, at, bad);
+    if (!isStr(step.prompt)) bad.push(`${at}: prompt has to be text`);
   },
 };
 
-// HTTP Request: a Call that sends a Power Automate step's own request,
+// HTTP Request: a target that sends a Power Automate step's own request,
 // rebuilt for each item from its record (docs/power-automate.md).
 const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"];
 /** The first field under [v] named like a key, as a path, or null. */
@@ -3293,63 +3418,85 @@ function keyField(v         , at = "body")                {
   return null;
 }
 STEP_TYPES.httpRequest = {
-  label: "HTTP Request", slot: "call", asks: "request", verbatim: true, modelFrom: "cell",
-  description: "Sends a Power Automate step's own request, rebuilt from each record, with each scenario's words in it.",
-  cellFields: ["system", "model", "settings", "prefill"],
-  firstJobOnly: "an HTTP Request is sent from its item's record, so it is job 1's call",
-  // Production's reply is the record's result, read as the flow reads it.
-  production(call, record){
-    const result = isObj(record) && isObj(record.result) ? record.result : null;
-    if (!result || typeof result.status !== "number") return null;
-    try {
-      return httpReplyOf(call, { prompt: "" }, result.body, result.status,
-                         { scope: record.scope || {}, now: record.at ?? null }).raw;
-    } catch { return null; }
-  },
-  // A new scenario starts from the flow's own words and fields.
-  newCell: (call) => (HTTP_APIS[call.api] ?? HTTP_APIS.raw ).cellOf(call.body),
-  // A cell's fields, where its HTTP API has a place for them.
-  cellProblems(cell, call, at, bad){
-    const api = HTTP_APIS[call.api];
+  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.",
+  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.
+  newStep: (step) => ({ type: "httpRequest", api: step.api, method: step.method, path: step.path,
+                        query: clone(step.query), body: clone(step.body),
+                        ...(HTTP_APIS[step.api] ?? HTTP_APIS.raw ).cellOf(step.body) }),
+  in: "item", out: "text",
+  apply: "runPipeline",
+  fields: ["type", "api", "method", "path", "query", "body", "prompt", "profile", "from", "system", "model", "settings", "prefill"],
+  validate(step, _ctx, bad, at){
+    const api = HTTP_APIS[step.api];
+    if (!api) bad.push(`${at}: "${step.api}" is not an HTTP API this lab has`);
+    if (!HTTP_METHODS.includes(step.method)) bad.push(`${at}: the method is one of ${HTTP_METHODS.join(", ")}`);
+    if (!isStr(step.path) || !/^[/@]/.test(step.path)) bad.push(`${at}: the path starts with /`);
+    if (!isObj(step.query) || !Object.values(step.query).every(isStr)) bad.push(`${at}: the query is names to text`);
+    if (!isStr(step.prompt)) bad.push(`${at}: prompt has to be text`);
+    // 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 Target profile sends it`);
     if (!api) return;
+    // Its fields, where its HTTP API has a place for them.
     for (const f of ["system", "model", "prefill"]         ) {
-      if (cell[f] == null) continue;
-      if (!isStr(cell[f])) bad.push(`${at}: ${f} has to be text`);
+      if (step[f] == null) continue;
+      if (!isStr(step[f])) bad.push(`${at}: ${f} has to be text`);
       else if (!api.fields.includes(f)) bad.push(`${at}: ${api.label} has no place for a ${f}`);
     }
-    if (cell.settings != null) {
-      if (!isObj(cell.settings) || !Object.values(cell.settings).every(isStr)) bad.push(`${at}: settings are names to text`);
-      else for (const k of Object.keys(cell.settings)) {
+    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 (!api.settings.includes(k)) bad.push(`${at}: ${api.label} has no setting ${k}`);
       }
     }
-    if (isStr(cell.prompt)) {
-      try { api.place(call.body, cell        ); }
+    if (isStr(step.prompt)) {
+      try { api.place(step.body, step        ); }
       catch (e) { bad.push(`${at}: ${(e         ).message}`); }
     }
   },
+};
+
+// Echo: a target that sends nothing and needs no profile -- each text item
+// is its own reply, to grade replies recorded earlier (#97). Job 1's, over
+// text items only. Its words, where it has any, are what the reply is read
+// 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.",
+  firstJobOnly: "Echo answers only job 1, with the item's own text",
   in: "item", out: "text",
   apply: "runPipeline",
-  fields: ["type", "step", "api", "method", "path", "query", "body", "readAs", "loop"],
+  fields: ["type", "prompt", "from"],
   validate(step, _ctx, bad, at){
-    if (!isStr(step.step) || !step.step.trim()) bad.push(`${at}: an HTTP Request names the flow step it is`);
-    if (!HTTP_APIS[step.api]) bad.push(`${at}: "${step.api}" is not an HTTP API this lab has`);
-    if (!HTTP_METHODS.includes(step.method)) bad.push(`${at}: the method is one of ${HTTP_METHODS.join(", ")}`);
-    if (!isStr(step.path) || !/^[/@]/.test(step.path)) bad.push(`${at}: the path starts with /`);
-    if (!isObj(step.query) || !Object.values(step.query).every(isStr)) bad.push(`${at}: the query is names to text`);
-    if (step.readAs != null && !isStr(step.readAs)) bad.push(`${at}: readAs is an expression or null`);
-    if (step.loop != null && !isStr(step.loop)) bad.push(`${at}: loop names a loop or is null`);
-    // 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 Setup profile sends it`);
+    if (!isStr(step.prompt)) bad.push(`${at}: prompt has to be text`);
   },
 };
 
-// Read Reply: how a job's answer is read -- its kind and modifiers.
+/** What a local target step is answered as: Echo's own connection, with no
+    address, key or model. */
+const ECHO_CONNECTION = { name: "Echo", url: "", model: "", type: "echo" };
+
+// Responses: how a job's reply is read, in order -- possibly not at all.
+
+// 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.",
+  in: "text", out: "text",
+  apply: "runPipeline",
+  fields: ["type", "readAs"],
+  validate(step, _ctx, bad, at){
+    if (!isStr(step.readAs) || !step.readAs.trim()) bad.push(`${at}: readAs is an expression`);
+  },
+};
+
+// Response Format Validation: the kind a reply is read as.
 STEP_TYPES.readReply = {
-  label: "Read Reply", slot: "reply",
-  description: "How the reply is read before tests and later jobs see it.",
+  label: "Read Reply", slot: "responses", rank: 1,
+  description: "How the reply 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",
@@ -3360,30 +3507,42 @@ STEP_TYPES.readReply = {
       return void bad.push(`${at} answers as "${out?.kind}", which is not an output kind this lab has`);
     }
     const kindEntry = OUTPUT_KINDS[out.kind] ;
-    onlyFields(out, `${at}'s output`, ["kind", "modifiers", ...(kindEntry.settings || []).map(o => o.key)], bad);
+    onlyFields(out, `${at}'s output`, ["kind", ...(kindEntry.settings || []).map(o => o.key)], bad);
     kindEntry.validateSettings?.(out, `${at}'s output`, bad);
-    if (!Array.isArray(out.modifiers)) return void bad.push(`${at}: modifiers has to be a list`);
-    for (const m of out.modifiers) {
-      const entry = isObj(m) && MODIFIERS[m.type];
-      if (!entry) { bad.push(`${at}: "${m?.type}" is not a modifier this lab has`); continue; }
-      if (entry.accepts && !entry.accepts.includes(out.kind)) {
-        bad.push(`${at}: ${entry.label || m.type} does not apply to ${OUTPUT_KINDS[out.kind] .noun || out.kind}`);
-      }
-      entry.validate?.(m            , `${at}: ${entry.label || m.type}`, bad);
+  },
+};
+
+// 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.",
+  in: "value", out: "value",
+  apply: "runPipeline",
+  fields: ["type", "modifier"],
+  validate(step, _ctx, bad, at, kind){
+    const m = step.modifier;
+    const entry = isObj(m) && MODIFIERS[m.type];
+    if (!entry) return void bad.push(`${at}: "${m?.type}" is not a modifier this lab has`);
+    if (entry.accepts && !entry.accepts.includes(kind)) {
+      bad.push(`${at}: ${entry.label || m.type} does not apply to ${OUTPUT_KINDS[kind]?.noun || kind}`);
     }
+    entry.validate?.(m            , `${at}: ${entry.label || m.type}`, bad);
   },
 };
 
-// ---- reading a job's steps ---------------------------------------------------
-// Every reader asks these, never a step's position: a job's slots are fixed,
-// but which of them a job has (Attach Content is job 1's alone) is its own.
+// ---- reading a job's steps, and a target's -----------------------------------
+// Every reader asks these, never a step's position or the document's shape:
+// which steps a job holds is its own, and a version that moves a field
+// changes these alone (pipeline-model §16).
+
+                                                              
 
 const slotOf = (st         )                       =>
   (isObj(st) ? STEP_TYPES[st.type          ]?.slot : undefined);
 
-/** The step in [job]'s [slot], whatever type fills it. */
-const stepIn =                 (job                                                , slot          )                =>
-  (job?.steps || []).find(st => slotOf(st) === slot)                 ;
+/** [job]'s step of [type], when it holds one. */
+const stepOf =                 (job         , type           )                =>
+  (job?.steps || []).find(st => isObj(st) && st.type === type)                 ;
 
 /** The registry entry that fills [slot] by default: what a new step there is. */
 function slotEntry(slot          )                                                     {
@@ -3391,9 +3550,26 @@ function slotEntry(slot          )
   return hit ? { type: hit[0], entry: hit[1] } : undefined;
 }
 
+/** Where a step sits: its stage, then its place in it. */
+const placeOf = (st         )         => {
+  const e = isObj(st) ? STEP_TYPES[st.type          ] : undefined;
+  return (e?.slot ? SLOTS.indexOf(e.slot) : SLOTS.length) * 100 + (e?.rank ?? 0);
+};
+
+/** [steps] in stage order, each stage in its own order; steps that tie
+    (modifiers) keep theirs. */
+const ordered = (steps                 )         =>
+  steps.map((st, x) => ({ st, x })).sort((a, b) => placeOf(a.st) - placeOf(b.st) || a.x - b.x).map(o => o.st);
+
+/** [job] with its step of [type] set to [step], or taken away for null. */
+function withStep(job     , type              , step             )      {
+  const steps = job.steps.filter(st => st.type !== type);
+  return { ...job, steps: ordered(step ? [...steps, step] : steps) };
+}
+
 /** A pipeline's content: job 1's content step, or none. */
 function contentOf(doc                                              )                 {
-  return stepIn                   (doc?.jobs?.[0], "content")?.content ?? null;
+  return stepOf                   (doc?.jobs?.[0], "attachContent")?.content ?? null;
 }
 
 /** [doc] with its content set -- job 1's content step added, replaced, or
@@ -3401,26 +3577,94 @@ function contentOf(doc                                              )
 function withContent                           (doc   , content                )    {
   const [first, ...rest] = doc.jobs;
   if (!first) return doc;
-  const steps = first.steps.filter(st => slotOf(st) !== "content");
-  const type = slotEntry("content") .type;
-  return { ...doc, jobs: [{ ...first, steps: content ? [{ type, content }        , ...steps] : steps }, ...rest] };
+  return { ...doc, jobs: [withStep(first, "attachContent", content ? { type: "attachContent", content } : null), ...rest] };
+}
+
+/** A document's targets, in column order. */
+function targetsOf(doc                                                           )           {
+  return Array.isArray(doc?.targets) ? doc .targets             : [];
+}
+
+/** Target [i]'s name, or the number it has always shown. */
+function targetLabel(doc                                                           , i        )         {
+  return (targetsOf(doc)[i]?.name || "").trim() || `Target ${i + 1}`;
+}
+
+/** What target [i] sends in job [k]: its step there. */
+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        )                            =>
+  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        )         {
+  return targetStepOf(doc, 0, k)?.type ?? "prompt";
+}
+
+/** The Setup profile target [i] asks in job [k]: its step's own, or the target's. */
+function targetProfileOf(doc                                                           , i        , k        )                  {
+  return targetStepOf(doc, i, k)?.profile ?? targetsOf(doc)[i]?.profile ?? undefined;
+}
+
+/** [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        ,
+    change                                                        )    {
+  return { ...doc, targets: doc.targets.map((t, x) => (x !== i ? t : {
+    ...t, steps: t.steps.map((st, j) => (j !== k ? st : typeof change === "function" ? change(st) : { ...st, ...change }              )),
+  })) };
+}
+
+/** The token mappings [job]'s words are resolved under. */
+const tokensOf = (job         )                => stepOf                   (job, "tokenMappings")?.tokenMappings ?? [];
+
+/** [job] resolving its words under [list]: none takes the step away. */
+const withTokens = (job     , list               )      =>
+  withStep(job, "tokenMappings", list.length ? { type: "tokenMappings", tokenMappings: list } : null);
+
+/** Whether [job] sends the item's image beside its words. */
+const sendsImage = (job         )          => !!stepOf(job, "attachImage");
+
+/** [job] sending the item's image, or not. */
+const withImage = (job     , on         )      => withStep(job, "attachImage", on ? { type: "attachImage" } : null);
+
+/** The Power Automate step [job]'s records are calls of: its name, which the
+    flow's expressions read it by, the loop item() means, and the HTTP API
+    its replies speak. None for a job that is not one. */
+function flowStepOf(job         )                                                            {
+  const f = stepOf              (job, "flowStep");
+  return f ? { step: f.step, loop: f.loop ?? null, api: f.api } : null;
 }
 
-/** A job's call: the step that asks something and is answered. */
-const callOf = (job                                                )             =>
-  stepIn            (job, "call")              ;
+/** What the flow does to [job]'s reply before it reads it, as an expression
+    over the step's body; null reads the reply's own text. */
+const readAsOf = (job         )                => stepOf            (job, "readAs")?.readAs ?? null;
 
-/** The registry entry of a job's call: what it asks, and of whom. */
-const callEntryOf = (job                                                )                            =>
-  STEP_TYPES[(stepIn(job, "call")                    )?.type ?? ""];
+/** 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];
+  return { ...flowStepOf(job), ...targetStepOf(doc, i, k), readAs: readAsOf(job) }                                          ;
+}
+
+/** What httpRequestOf builds a request from: a target's template, and the
+    loop its flow step sits in. */
+                                                                                                                          
+/** What httpReplyOf reads a reply with: the flow step, its API, its reading. */
+                                                                                                     
 
 /** The request an HTTP Request [step] sends for [cell] over an item whose
     record read [ctx]'s scope: the cell's words and fields placed in the
     flow's body by its HTTP API, then every expression evaluated. */
-function httpRequestOf(step                 , cell      , ctx                          ) 
+function httpRequestOf(step              , cell      , ctx                          ) 
                                                                                    {
   const api = HTTP_APIS[step.api] ?? HTTP_APIS.raw ;
-  const at = { ...ctx, loop: step.loop };
+  const at = { ...ctx, loop: step.loop ?? null };
   const path = String(evaluate(step.path, at));
   // A path an expression wrote whole -- an address -- keeps its path and query.
   const [p, q] = /^https?:\/\//i.test(path) ? (() => { const u = new URL(path); return [u.pathname, u.search]; })() : [path, ""];
@@ -3431,35 +3675,50 @@ function httpRequestOf(step                 , cell      , ctx
 /** What the flow reads of a reply [j] to [step]: its readAs evaluated with the
     reply as the step's body -- the prefill put back in front, as the flow has
     to -- or the HTTP API's own text. */
-function httpReplyOf(step                 , cell      , j         , status        ,
+function httpReplyOf(step            , cell      , j         , status        ,
                      ctx                          )                                                             {
   const api = HTTP_APIS[step.api] ?? HTTP_APIS.raw ;
   const whole = cell.prefill && api.withPrefill ? api.withPrefill(j, cell.prefill) : j;
   const { raw: said, finishReason } = api.reply(whole);
   if (!step.readAs) return { raw: said, said, finishReason };
   const scope = { ...ctx.scope, actions: { ...(ctx.scope.actions || {}), [step.step]: { body: whole, statusCode: status } } };
-  return { raw: asText(evaluate(step.readAs, { ...ctx, scope, loop: step.loop })), said, finishReason };
+  return { raw: asText(evaluate(step.readAs, { ...ctx, scope, loop: step.loop ?? null })), said, finishReason };
 }
 
-/** A job's reply step. */
-const replyOf = (job                                                )                =>
-  stepIn               (job, "reply")                 ;
-
-/** How a job's reply is read: its kind, settings and modifiers. */
-const outOf = (job                                                )      => replyOf(job)?.out;
+/** A reply [text] from a model asked in words, read as the flow reads its
+    step's reply: put in the body the flow's API would have sent it in
+    (`HttpApiEntry.wrap`), then read through the job's Read as -- so a
+    model's words and production's are read alike. */
+function readFlowReply(flow            , text        , record             )                                {
+  const api = HTTP_APIS[flow.api] ?? HTTP_APIS.raw ;
+  const read = httpReplyOf({ ...flow, api: HTTP_APIS[flow.api] ? flow.api : "raw" }, { prompt: "" }, api.wrap(text), 200,
+                           { scope: record.scope || {}, now: record.at ?? null });
+  return { raw: read.raw, said: text };
+}
 
-/** [job] with the step in [slot] changed by [change]. */
-function withSlot(job     , slot          , change                    )      {
-  return { ...job, steps: job.steps.map(st => (slotOf(st) === slot ? change(st) : st)) };
+/** A job's Response Format Validation, when it has one. */
+const replyOf = (job         )                            => stepOf               (job, "readReply");
+
+/** How a job's reply is read: its kind, settings and modifiers. A job with
+    no Format Validation reads its reply as text -- the text kind, by name,
+    so a stored document never changes meaning when a plugin registers a
+    kind of its own. */
+function outOf(job         )      {
+  const read = replyOf(job)?.out ?? { kind: "text", ...(OUTPUT_KINDS.text?.settingDefaults?.() || {}) };
+  const modifiers = (job?.steps || []).filter((st)                     => isObj(st) && st.type === "modifier").map(st => st.modifier);
+  return { ...read, modifiers }       ;
 }
 
-/** [job] reading its reply as [out]. */
-const withOut = (job     , out     )      => withSlot(job, "reply", st => ({ ...st, out }        ));
+/** [job] reading its reply as [out]: its Format Validation and modifiers. */
+function withOut(job     , out     )      {
+  const { modifiers, ...read } = out;
+  const steps = job.steps.filter(st => st.type !== "readReply" && st.type !== "modifier");
+  return { ...job, steps: ordered([...steps, { type: "readReply", out: read },
+    ...(modifiers || []).map(modifier => ({ type: "modifier", modifier })        )]) };
+}
 
-/** [job] with its call changed by [patch]. */
-const withCall = (job     , patch                     )      => withSlot(job, "call", st => ({ ...st, ...patch }        ));
 /** A new id: random, so one minted in one browser never collides with one
-    minted in another. A pipeline, its jobs and its scenarios each carry one
+    minted in another. A pipeline, its jobs and its targets each carry one
     (#93), minted once and never shown. */
 function newId()         {
   const bytes = new Uint8Array(6);
@@ -3470,104 +3729,99 @@ function newId()         {
 /** A new job: the kind a stage answers in, that kind's own modifiers, and
     a copy of the token set. */
 function jobDefaults(kind         = defaultOutputKind, tokens                = TOKEN_DEFAULTS)      {
-  return {
-    type: "job", id: newId(), name: "",
-    steps: [
-      { type: "prompt", withImage: false, tokenMappings: clone(tokens) },
-      { type: "readReply",
-        out: { kind, ...(OUTPUT_KINDS[kind]?.settingDefaults?.() || {}), modifiers: OUTPUT_KINDS[kind]?.modifiers?.() || [] } },
-    ],
-  };
+  const job      = withTokens({ type: "job", id: newId(), name: "", steps: [] }, clone(tokens));
+  return withOut(job, { kind, ...(OUTPUT_KINDS[kind]?.settingDefaults?.() || {}), modifiers: OUTPUT_KINDS[kind]?.modifiers?.() || [] });
 }
 STEP_TYPES.job = {
   in: "item", out: job => outOf(job         )?.kind,
   apply: "runPipeline",
   fields: ["type", "id", "name", "steps"],
   defaults: jobDefaults,
-  // A job's steps sit in fixed slots: Attach Content first, on job 1 only;
-  // one Call; Read Reply last. Each step is its entry's to check.
+  // A job's steps run in stage order: Content, then Responses, each in its
+  // own order. A target's step is the target's, never a job's. Each step is
+  // its entry's to check.
   validate(c, ctx, bad, k, doc){
     const at = jobLabel(doc, k);
     if (!isObj(c) || c.type !== "job") return void bad.push(`${at} has to be a job step`);
     onlyFields(c, at, STEP_TYPES.job .fields , bad);
-    // An id is a job's own, like a scenario's: stable across renames, so a
+    // An id is a job's own, like a target's: stable across renames, so a
     // stored run keeps pointing at the job that actually ran (#93).
     if (!isStr(c.id) || !c.id.trim()) bad.push(`${at} has no id`);
     else if ((doc.jobs               ).findIndex((o) => isObj(o) && o.id === c.id) !== k) bad.push(`${at} has the id of another job`);
     if (c.name != null && !isStr(c.name)) bad.push(`${at}: name has to be text`);
     if (!Array.isArray(c.steps)) return void bad.push(`${at}: steps has to be a list`);
     const steps              = c.steps;
-    // A job's steps are the entries with a slot; one without (a job, the
-    // tests) or of no type the lab has is not one.
+    // A job's steps are the entries with a stage; one without (a job, the
+    // evals) or of no type the lab has is not one.
     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`);
-    const slots = steps.map(st => slotOf(st) );
-    const want             = [...(k === 0 && slots[0] === "content" ? ["content"            ] : []), "call", "reply"];
-    if (slots.join() !== want.join()) {
-      // One sentence for the one mistake, the likeliest first.
-      const label = (slot          ) => slotEntry(slot)?.entry.label ?? slot;
-      bad.push(k > 0 && slots.includes("content")
-        ? `${at}: only job 1 attaches content -- a later job is handed the reply before it`
-        : slots.filter(x => x === "call").length !== 1 ? `${at} has to have one call step`
-        : `${at}: steps are ${label("content")} (job 1), one call, then ${label("reply")}`);
-      return;
+    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`);
+    }
+    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`);
+    if (steps.some((st, x) => x > 0 && placeOf(st) < placeOf(steps[x - 1]))) {
+      return void bad.push(`${at}: steps are its Content, then its Responses, each in order`);
     }
+    const kind = outOf(c       ).kind;
     for (const st of steps) {
       const entry = STEP_TYPES[st.type] ;
+      const label = `${at}'s ${entry.label ?? st.type}`;
       if (k > 0 && entry.firstJobOnly) { bad.push(`${at}: ${entry.firstJobOnly}`); continue; }
-      onlyFields(st, `${at}'s ${entry.label ?? st.type}`, entry.fields ?? [], bad);
-      entry.validate(st, ctx, bad, at);
+      onlyFields(st, label, entry.fields ?? [], bad);
+      entry.validate(st, ctx, bad, label, kind);
     }
   },
 };
-// What a test carries besides its type's own fields.
-const TEST_FIELDS                    = ["id", "name", "continueOnFailure"];
+// What an eval carries besides its type's own fields.
+const EVAL_FIELDS                    = ["id", "name", "continueOnFailure"];
 
-/** Test [j]'s name, or the number it has always shown. */
-const testLabel = (doc                                                 , j        )         =>
-  (doc.tests?.[j]?.name || "").trim() || `Test ${j + 1}`;
+/** Eval [j]'s name, or the number it has always shown. */
+const evalLabel = (doc                                                 , j        )         =>
+  (doc.evals?.[j]?.name || "").trim() || `Eval ${j + 1}`;
 
-/** A test type that settles over the whole run rather than item by item. */
+/** An eval type that settles over the whole run rather than item by item. */
 const isWholeRun = (type                           , t            )          =>
   type?.wholeRun && t ? type.wholeRun(t) : !!type?.verdict && !type?.score;
 
 /**
- * A document's tests as a list, whatever version wrote it: a queue row keeps
- * the run document it was submitted with, so a run from before version 6
- * holds one test or null, read here as the upgrade reads it (testsList).
+ * A document's evals as a list, whatever version wrote it: a queue row keeps
+ * the run document it was submitted with, so a run from before version 11
+ * spells them `tests`, and one from before version 6 holds one or null, read
+ * here as the upgrade reads it (testsList, evalsKey).
  */
-function testsOf(doc                                        )         {
-  const t = doc?.tests;
+function evalsOf(doc                                                         )         {
+  const t = doc?.evals ?? doc?.tests;
   if (Array.isArray(t)) return t          ;
   return isObj(t) ? [{ id: "t1", name: "", ...t, continueOnFailure: true }        ] : [];
 }
 
-/** The dataset a document's tests grade against, where one does: a run
+/** The dataset a document's evals grade against, where one does: a run
     grades against one (validatePipeline says so), so the first names it. */
-function testsDataset(doc                     )                                      {
-  const t = testsOf(doc).find((x         ) => isObj(x) && isRef(x.dataset));
+function evalsDataset(doc                     )                                      {
+  const t = evalsOf(doc).find((x         ) => isObj(x) && isRef(x.dataset));
   return t && "dataset" in t ? t.dataset : null;
 }
 
-STEP_TYPES.tests = {
+STEP_TYPES.evals = {
   in: "results", out: "verdict",
   apply: "score",
-  validate(tests, ctx, bad, lastKind, doc){
-    if (!Array.isArray(tests)) return void bad.push("tests has to be a list, empty for an unscored run");
+  validate(evals, ctx, bad, lastKind, doc){
+    if (!Array.isArray(evals)) return void bad.push("evals has to be a list, empty for an unscored run");
     const seen = new Set        ();
-    tests.forEach((t           , j        ) => {
-      const at = testLabel(doc, j);
-      const type = isObj(t) && TEST_TYPES[t.type];
+    evals.forEach((t           , j        ) => {
+      const at = evalLabel(doc, j);
+      const type = isObj(t) && EVAL_TYPES[t.type];
       if (!type) return void bad.push(`${at} is of type "${t?.type}", which is not one this lab has`);
       const before = bad.length;
       if (!isStr(t.id) || !t.id.trim()) bad.push(`${at} has no id`);
-      else if (seen.has(t.id)) bad.push(`${at} has the id of another test`);
+      else if (seen.has(t.id)) bad.push(`${at} has the id of another eval`);
       else seen.add(t.id);
       if (t.name != null && !isStr(t.name)) bad.push(`${at}: name has to be text`);
       if (typeof t.continueOnFailure !== "boolean") bad.push(`${at}: continueOnFailure has to be true or false`);
-      onlyFields(t, at, [...type.fields, ...TEST_FIELDS], bad);
+      onlyFields(t, at, [...type.fields, ...EVAL_FIELDS], bad);
       type.validate(t, ctx, bad);
-      // Which kinds a test scores is only worth saying of a test that is whole.
+      // Which kinds an eval scores is only worth saying of an eval that is whole.
       if (bad.length > before) return;
       const accepts = typeof type.accepts === "function" ? type.accepts(t) : type.accepts;
       if (accepts && lastKind && OUTPUT_KINDS[lastKind] && !accepts.includes(lastKind)) {
@@ -3576,14 +3830,14 @@ STEP_TYPES.tests = {
       }
     });
     // A run is handed one dataset's body to grade against (server-side-runs §4).
-    const named = new Set(tests.filter((t           ) => isObj(t) && isRef(t.dataset)).map((t           ) => t.dataset.id));
-    if (named.size > 1) bad.push("the tests grade against one dataset at a time");
+    const named = new Set(evals.filter((t           ) => isObj(t) && isRef(t.dataset)).map((t           ) => t.dataset.id));
+    if (named.size > 1) bad.push("the evals grade against one dataset at a time");
   },
 };
 
 // ---- the document -------------------------------------------------------------
 
-const PIPELINE_FIELDS                    = ["version", "id", "name", "jobs", "scenarios", "tests"];
+const PIPELINE_FIELDS                    = ["version", "id", "name", "jobs", "targets", "evals"];
 // 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"];
@@ -3600,9 +3854,13 @@ function versionProblem(doc         )                {
 /** What an upgrade from version 2 needs from outside the document: the rules
     of the dataset a pipeline was graded against, which the retired
     version-2 list kind read every reply under. Without them a job is upgraded with no
-    rules, as a run with no graded test parsed. */
+    rules, as a run with no graded eval parsed. */
                              
                                                                 
+                                                                    
+                                                                         
+                                                              
+                                                   
  
 
 /**
@@ -3621,7 +3879,8 @@ function versionProblem(doc         )                {
  * as it was, for versionProblem to name. A copy: the caller's document is not
  * touched. From version 5, its test -- or none -- becomes a list of one (or
  * none), the test's id `t1`. From version 6, `chains` are `jobs`: the field
- * renames and every job's `type` becomes `"job"`.
+ * renames and every job's `type` becomes `"job"`. From version 10, its
+ * `tests` are `evals` (evalsKey).
  */
 /** Every id a current document must carry, minted for the ones [doc] lacks.
     An id it already has is kept. */
@@ -3637,25 +3896,33 @@ function upgradeIds(doc           )            {
   return doc;
 }
 
+/** A document's columns and their steps, wherever its version keeps them:
+    version 10's targets, or an earlier one's scenarios and their cells. */
+function columnsOf(doc           )                                              {
+  const list = Array.isArray(doc?.targets) ? doc.targets : Array.isArray(doc?.scenarios) ? doc.scenarios : [];
+  return list.filter(isObj).map((column           ) => ({
+    column, steps: (Array.isArray(column.steps) ? column.steps : Array.isArray(column.stages) ? column.stages : []).filter(isObj),
+  }));
+}
+
 /** Every profile reference cut to { id, name }. The Runs tab once kept the
     whole Setup profile a scenario picked -- key and all -- so a document saved
     then is cleaned as it is read, and validation refuses one that is not. */
 function profileRefs(doc           )       {
   const cut = (r         ) => (isObj(r) && isStr(r.id) ? { id: r.id, name: isStr(r.name) ? r.name : "" } : r);
-  for (const sc of Array.isArray(doc.scenarios) ? doc.scenarios : []) {
-    if (!isObj(sc)) continue;
-    if ("profile" in sc) sc.profile = cut(sc.profile);
-    for (const cell of Array.isArray(sc.stages) ? sc.stages : []) {
-      if (isObj(cell) && cell.profile != null) cell.profile = cut(cell.profile);
-    }
+  for (const { column, steps } of columnsOf(doc)) {
+    if ("profile" in column) column.profile = cut(column.profile);
+    for (const st of steps) if (st.profile != null) st.profile = cut(st.profile);
   }
 }
 
+/** [doc] with its profile references cut (profileRefs), for chaining. */
+const cutRefs = (doc           )            => { profileRefs(doc); return doc; };
+
 /** Whether any profile reference in a pipeline holds more than { id, name }. */
 function fatProfileRef(doc         )          {
   const fat = (r         ) => isObj(r) && Object.keys(r).some(k => k !== "id" && k !== "name");
-  return isObj(doc) && Array.isArray(doc.scenarios) && doc.scenarios.some((sc           ) =>
-    isObj(sc) && (fat(sc.profile) || (Array.isArray(sc.stages) && sc.stages.some((c           ) => isObj(c) && fat(c.profile)))));
+  return isObj(doc) && columnsOf(doc).some(({ column, steps }) => fat(column.profile) || steps.some(st => fat(st.profile)));
 }
 
 /** Version 5 to 6: the one test, or none, as a list. Its id is `t1`, so
@@ -3670,9 +3937,9 @@ function testsList(doc           )            {
   return doc;
 }
 
-/** A new test of [type] at the lab's defaults, named [name], continuing on failure. */
-function newTest(type        , name = "", fields                          = {})       {
-  const own = TEST_TYPES[type]?.defaults?.() ?? { type };
+/** A new eval of [type] at the lab's defaults, named [name], continuing on failure. */
+function newEval(type        , name = "", fields                          = {})       {
+  const own = EVAL_TYPES[type]?.defaults?.() ?? { type };
   return { ...own, ...fields, type, id: newId(), name, continueOnFailure: true }        ;
 }
 
@@ -3723,22 +3990,148 @@ function metricsOf(next           )            {
   return next;
 }
 
+/** Version 9 to 10: a job's stages, and each scenario a target
+    (pipeline-model §16). A job's call becomes what it held for the whole
+    job -- a Prompt's image flag and token mappings, an HTTP Request's flow
+    step and reading -- and each scenario's cell in it, with the call's
+    template where it has one, that target's own step there. Read Reply's
+    modifiers are steps of their own after it. What each held is moved as it
+    was, so the run sends the same requests and reads them the same way
+    (fixtures/stages-v9.json, held to it by pipeline-check.js). */
+function targetsFromScenarios(next           )            {
+  next.version = PIPELINE_VERSION;
+  const jobs              = Array.isArray(next.jobs) ? next.jobs : [];
+  const calls = jobs.map(job => (isObj(job) && Array.isArray(job.steps)
+    ? job.steps.find((st           ) => isObj(st) && (st.type === "prompt" || st.type === "httpRequest")) : undefined));
+  jobs.forEach((job, k) => {
+    if (!isObj(job) || !Array.isArray(job.steps)) return;
+    job.steps = job.steps.flatMap((st           ) => {
+      if (!isObj(st)) return [st];
+      if (st === calls[k] && st.type === "prompt") {
+        return [...(st.withImage ? [{ type: "attachImage" }] : []),
+                ...(Array.isArray(st.tokenMappings) && st.tokenMappings.length ? [{ type: "tokenMappings", tokenMappings: st.tokenMappings }] : [])];
+      }
+      if (st === calls[k]) {
+        return [{ type: "flowStep", step: st.step, loop: st.loop ?? null, api: st.api },
+                ...(st.readAs != null ? [{ type: "readAs", readAs: st.readAs }] : [])];
+      }
+      if (st.type === "readReply" && isObj(st.out)) {
+        const { modifiers, ...out } = st.out;
+        return [{ type: "readReply", out },
+                ...(Array.isArray(modifiers) ? modifiers : []).map((modifier           ) => ({ type: "modifier", modifier }))];
+      }
+      return [st];
+    });
+  });
+  const targets = (Array.isArray(next.scenarios) ? next.scenarios : []).map((sc           ) => {
+    if (!isObj(sc)) return sc;
+    const { stages, ...rest } = sc;
+    return { ...rest, steps: (Array.isArray(stages) ? stages : []).map((cell           , k        ) => {
+      const call = calls[k];
+      if (!isObj(cell) || !isObj(call)) return cell;
+      const { step: _step, loop: _loop, readAs: _readAs, withImage: _image, tokenMappings: _tokens, ...shape } = call;
+      return { ...clone(shape), ...cell };
+    }) };
+  });
+  // In the scenarios' place, so the document reads in the same order.
+  return Object.fromEntries(Object.entries(next).map(([key, v]) => (key === "scenarios" ? ["targets", targets] : [key, v])));
+}
+
+/** Version 10 to 11: `tests` are `evals` -- the key renames in place, so an
+    upgraded document reads the same, key for key, and each eval is as it
+    was. Every version before 11 passes through here. */
+function evalsKey(next           )            {
+  next.version = PIPELINE_VERSION;
+  // `tests` is the spelling of every version before 11.
+  if (!("tests" in next)) return next;
+  return Object.fromEntries(Object.entries(next).filter(([k]) => k !== "evals")
+    .map(([k, v]) => (k === "tests" ? ["evals", v] : [k, v])));
+}
+
+/** Version 11 to 12: a Contains metric's Ignore case holds where the reply
+    is matched item by item, as it does where it is matched as text, and it
+    is kept as written. Until version 11's last hours (#199) every Contains
+    metric matched the reply's text and minded its Ignore case, so what a
+    stored metric says is what its author meant; only the item-by-item
+    matching #199 added, case-blind for a few hours, read it otherwise.
+    Every version before 12 ends here. */
+function caseAsWritten(next           )            {
+  next.version = PIPELINE_VERSION;
+  return next;
+}
+
 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.
+  // tab saved whole (see profileRefs), which is cut back, and a step on a
+  // profile a target step stands in for (localSteps).
   if (isObj(doc) && doc.version === PIPELINE_VERSION) {
-    if (!fatProfileRef(doc)) return doc;
-    const cleaned = clone(doc)             ;
-    profileRefs(cleaned);
-    return cleaned     ;
+    let out = doc             ;
+    if (fatProfileRef(out)) {
+      out = clone(out)             ;
+      profileRefs(out);
+    }
+    return localSteps(withoutCaseMetric(out), ctx)     ;
   }
-  if (!isObj(doc) || ![1, 2, 3, 4, 5, 6, 7, 8].includes(doc.version          )) return doc;
-  let next = clone(doc)             ;
-  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 (!isObj(doc) || ![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11].includes(doc.version          )) return doc;
+  if (doc.version === 11) return localSteps(withoutCaseMetric(caseAsWritten(cutRefs(clone(doc)             ))), ctx)     ;
+  // Every version before 10 reads as version 9 first, then as 10, then as 11
+  // and 12.
+  // A version-10 document is cut as a current one was (profileRefs); the
+  // earlier ones are cut on their way through nineOf.
+  const ten = doc.version === 10 ? cutRefs(clone(doc)             ) : targetsFromScenarios(nineOf(clone(doc)             , ctx));
+  return localSteps(withoutCaseMetric(caseAsWritten(evalsKey(ten))), ctx)     ;
+}
+
+/** [doc] with no Metrics eval holding the `case` metric: a dataset's cases
+    are metrics now (dataset body version 5), which an eval naming the
+    dataset adds for each item, so the case's own metrics carry what that
+    metric scored. Read so at every version, the current one included, as a
+    document saved before it went still holds it. The same document where
+    none does. */
+function withoutCaseMetric(doc           )            {
+  const has = (t         ) => isObj(t) && Array.isArray(t.metrics) && t.metrics.some((m           ) => isObj(m) && m.type === "case");
+  if (!Array.isArray(doc.evals) || !doc.evals.some(has)) return doc;
+  return { ...doc, evals: doc.evals.map((t           ) => (has(t)
+    ? { ...t, metrics: t.metrics.filter((m           ) => !(isObj(m) && m.type === "case")) } : t)) };
+}
+
+/** [doc] with each step asked of a profile whose type a target step stands
+    in for (`replaces`: Echo for an Echo profile) read as that step -- its
+    words kept, and no profile, since it asks none -- once the profiles'
+    types are known: [ctx]'s, or a run document's own. A target whose every
+    step then asks none, or names its own, keeps no profile either. The same
+    document, untouched, when there is nothing to read so. */
+function localSteps(doc           , ctx            )            {
+  const typeOfProfile = ctx.profileType
+    ?? (isObj(doc.profiles) ? (id        ) => (isObj(doc.profiles[id]) ? doc.profiles[id].type : undefined) : null);
+  if (!typeOfProfile) return doc;
+  const stands = new Map(Object.entries(STEP_TYPES).filter(([, e]) => e.slot === "target" && e.replaces).map(([type, e]) => [e.replaces , type]));
+  const as = (ref         ) => (isObj(ref) && isStr(ref.id) ? stands.get(typeOfProfile(ref.id) ?? "") : undefined);
+  const turns = (t           , st           ) => isObj(st) && STEP_TYPES[st.type]?.asks === "prompt" && as(st.profile ?? t.profile);
+  const targets              = Array.isArray(doc.targets) ? doc.targets : [];
+  if (!targets.some(t => isObj(t) && Array.isArray(t.steps) && t.steps.some((st           ) => turns(t, st)))) return doc;
+  const next = clone(doc)             ;
+  for (const t of next.targets               ) {
+    if (!isObj(t) || !Array.isArray(t.steps)) continue;
+    t.steps = t.steps.map((st           ) => {
+      const type = turns(t, st);
+      return type ? { type, prompt: st.prompt, ...(st.from ? { from: st.from } : {}) } : st;
+    });
+    // A run keeps the profile it ran as, so its report names it as it did.
+    if (!isObj(doc.profiles) && as(t.profile)
+        && t.steps.every((st           ) => isObj(st) && (STEP_TYPES[st.type]?.local || st.profile != null))) t.profile = null;
+  }
+  return next;
+}
+
+/** [next] as version 9 held it, from any version before 10. */
+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 === 1) {
     next.version = 2;
     if (Array.isArray(next.chains)) {
@@ -3764,7 +4157,7 @@ function upgradePipeline   (doc   , ctx             = {})    {
       if (isObj(cell)) cell.prompt = renamed(cell.prompt);
     }
   }
-  return metricsOf(stepsOf(jobsOf(testsList(upgradeIds(next)))))     ;
+  return metricsOf(stepsOf(jobsOf(testsList(upgradeIds(next)))));
 }
 
 /** Version 1's two maps as a list of mappings. */
@@ -3781,9 +4174,9 @@ function tokenMappingsFromV1(set         )                {
     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 = withCall(jobDefaults(opts.kind, opts.tokens), { withImage: true });
+  const job = withImage(jobDefaults(opts.kind, opts.tokens), true);
   return { version: PIPELINE_VERSION, id: newId(), name: opts.name || "",
-           jobs: [job], scenarios: [], tests: [] };
+           jobs: [job], targets: [], evals: [] };
 }
 
 /**
@@ -3808,37 +4201,50 @@ function validatePipeline(input         , ctx          = {})           {
   if (!Array.isArray(doc.jobs) || !doc.jobs.length) {
     return [...bad, "jobs has to be a list of at least one job"];
   }
-  if (!Array.isArray(doc.scenarios) || !doc.scenarios.length) bad.push("add a scenario first");
+  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.
-  if (!stepIn(doc.jobs[0], "content")) bad.push("set the content first");
+  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));
   if (bad.length) return bad;
   const content = contentOf(doc)             ;
 
-  const scenarios              = doc.scenarios;
+  const targets              = targetsOf(doc);
   const n         = doc.jobs.length;
-  scenarios.forEach((sc, i) => {
-    const at = scenarioLabel(doc, i);
-    if (!isObj(sc)) return void bad.push(`${at} has to be an object`);
-    onlyFields(sc, at, ["id", "name", "profile", "stages"], bad);
-    if (!isStr(sc.id) || !sc.id.trim()) bad.push(`${at} has no id`);
-    else if (scenarios.findIndex((o) => isObj(o) && o.id === sc.id) !== i) bad.push(`${at} has the id of another scenario`);
-    if (sc.name != null && !isStr(sc.name)) bad.push(`${at}: name has to be text`);
-    if (!isRef(sc.profile)) bad.push(`${at} has to name its Setup profile as { id, name }`);
-    else onlyFields(sc.profile, `${at}'s profile`, ["id", "name"], bad);
-    if (!Array.isArray(sc.stages) || sc.stages.length !== n) {
-      bad.push(`${at} has ${Array.isArray(sc.stages) ? sc.stages.length : "no"} prompts for ${n} job${n === 1 ? "" : "s"}`);
+  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", "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`);
+    if (t.name != null && !isStr(t.name)) bad.push(`${at}: name has to be text`);
+    if (t.profile != null && !isRef(t.profile)) bad.push(`${at} has to name its Target profile as { id, name }`);
+    else if (t.profile != null) onlyFields(t.profile, `${at}'s profile`, ["id", "name"], bad);
+    if (!Array.isArray(t.steps) || t.steps.length !== n) {
+      bad.push(`${at} has ${Array.isArray(t.steps) ? t.steps.length : "no"} prompts for ${n} job${n === 1 ? "" : "s"}`);
       return;
     }
-    sc.stages.forEach((cell           , k        ) => {
-      if (!isObj(cell)) return void bad.push(`${at}, ${jobLabel(doc, k)} has to be an object`);
-      const call = callEntryOf(doc.jobs[k]);
-      onlyFields(cell, `${at}, ${jobLabel(doc, k)}`, ["prompt", "profile", "from", ...(call?.cellFields || [])], bad);
-      call?.cellProblems?.(cell, callOf(doc.jobs[k]), `${at}, ${jobLabel(doc, k)}`, bad);
-      if (cell.profile != null && !isRef(cell.profile)) bad.push(`${at}, ${jobLabel(doc, k)} has to name its Setup profile as { id, name }`);
-      else if (cell.profile != null) onlyFields(cell.profile, `${at}, ${jobLabel(doc, k)}'s profile`, ["id", "name"], bad);
-      if (cell.from != null && !isRef(cell.from)) bad.push(`${at}, ${jobLabel(doc, k)} has to name the prompt it was picked from as { id, name }`);
+    // A target with no profile of its own is one whose steps need none, or
+    // each name theirs.
+    if (t.profile == null && t.steps.some((st           ) => !(isObj(st) && STEP_TYPES[st.type]?.local) && !(isObj(st) && st.profile != null))) {
+      bad.push(`${at} has to name its Target profile as { id, name }`);
+    }
+    t.steps.forEach((st           , k        ) => {
+      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.local && st.profile != null) return void bad.push(`${where}: ${entry.label} asks no profile`);
+      if (k > 0 && entry.firstJobOnly) return void bad.push(`${where}: ${entry.firstJobOnly}`);
+      onlyFields(st, where, entry.fields ?? [], bad);
+      entry.validate(st, c, bad, where);
+      if (st.profile != null && !isRef(st.profile)) bad.push(`${where} has to name its Target profile as { id, name }`);
+      else if (st.profile != null) onlyFields(st.profile, `${where}'s profile`, ["id", "name"], 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 (bad.length) return bad;
@@ -3849,68 +4255,76 @@ function validatePipeline(input         , ctx          = {})           {
     const p = c.profiles ? c.profiles(ref.id) : {};
     if (!p && !missing.has(ref.id)) {
       missing.add(ref.id);
-      bad.push(`Setup profile ${ref.name || ref.id} not found`);
+      bad.push(`Target profile ${ref.name || ref.id} not found`);
     }
     return p;
   };
   // A type that answers from the item (Echo) has no model, answers only
   // job 1, and answers only a text item.
   const local = (p         ) => !!p && typeof p === "object" && !!CONNECTION_TYPES[typeOf(p            )]?.local;
-  // Every scenario needs a prompt in every job. A blank one is an error
+  // Every target needs a prompt in every job. A blank one is an error
   // rather than a stage dropped, which would hand the job before it
   // straight to the job after it, under numbers nobody sees. The one it
   // may leave blank is job 1 answered from the item's own text (Echo over
   // a Source or Text): the reply is the item, and a prompt would only be
   // what it is read against. Over Prompt only the prompt is the reply.
+  // What target [i] asks in job [k]: Echo's own connection for a step
+  // answered here, else its profile as the lookups hold it.
+  const askedOf = (i        , k        ) => (targetEntryOf(doc, i, k)?.local ? ECHO_CONNECTION
+    : c.profiles ? c.profiles(targetProfileOf(doc, i, k) .id) : null);
   const itemsHaveText = !!content && !CONTENT_TYPES[content.type]?.bare;
   for (let k = 0; k < n; k++) {
-    const i = scenarios.findIndex(sc => (!isStr(sc.stages[k].prompt) || !sc.stages[k].prompt.trim())
-      && !(k === 0 && itemsHaveText && local(c.profiles ? c.profiles((sc.stages[0].profile || sc.profile).id) : null)));
-    if (i >= 0) bad.push(n > 1 ? `${jobLabel(doc, k)}, ${scenarioLabel(doc, i)} has no prompt`
-                               : `${scenarioLabel(doc, i)} has no prompt`);
+    const i = targets.findIndex((_, i) => {
+      const words = targetStepOf(doc, i, k)?.prompt;
+      return (!isStr(words) || !words.trim())
+        && !(k === 0 && itemsHaveText && local(askedOf(i, 0)));
+    });
+    if (i >= 0) bad.push(n > 1 ? `${jobLabel(doc, k)}, ${targetLabel(doc, i)} has no prompt`
+                               : `${targetLabel(doc, i)} has no prompt`);
   }
   const contentFiles                   = content?.type === "source"
     ? (c.sources?.(content.ref?.id)?.files ?? content.files ?? null) : null;
   const nonText = (contentFiles || []).map(f => String((f                             )?.name ?? f))
     .find(n => !/\.(?:txt|md|csv)$/i.test(n));
-  scenarios.forEach((sc, i) => {
-    const conns = sc.stages.map((cell      ) => lookup(cell.profile || sc.profile));
+  targets.forEach((_, i) => {
+    const conns = doc.jobs.map((_     , k        ) => (targetEntryOf(doc, i, k)?.local ? ECHO_CONNECTION : lookup(targetProfileOf(doc, i, k) )));
     conns.forEach((p         , k        ) => {
       if (!local(p)) return;
       const label = CONNECTION_TYPES[typeOf(p            )] .label;
-      if (k > 0) bad.push(`${jobLabel(doc, k)}, ${scenarioLabel(doc, i)}: ${label} answers only job 1, with the item's own text`);
-      else if (nonText) bad.push(`${scenarioLabel(doc, i)}: ${label} answers each text item with its own text, and ${nonText} is not text`);
+      if (k > 0) bad.push(`${jobLabel(doc, k)}, ${targetLabel(doc, i)}: ${label} answers only job 1, with the item's own text`);
+      else if (nonText) bad.push(`${targetLabel(doc, i)}: ${label} answers each text item with its own text, and ${nonText} is not text`);
     });
-    // A connection answers what its job's call asks: words, or a whole request.
+    // A connection answers what its target's step asks: words, or a whole request.
     conns.forEach((p         , k        ) => {
-      const call = callEntryOf(doc.jobs[k]);
-      // Only a profile that was looked up says what it answers.
-      if (!c.profiles || !p || !isObj(p) || !call) return;
+      const step = targetEntryOf(doc, i, k);
+      // Only a profile that was looked up says what it answers; a step
+      // answered here asks none.
+      if (!c.profiles || !p || !isObj(p) || !step || step.local) return;
       const type = CONNECTION_TYPES[typeOf(p            )];
-      if (type && !(type.answers ?? ["prompt"]).includes(call.asks ?? "prompt")) {
-        bad.push(`${n > 1 ? `${jobLabel(doc, k)}, ` : ""}${scenarioLabel(doc, i)}: ${call.label ?? "this call"} needs a profile that answers it, and ${type.label} does not`);
+      if (type && !(type.answers ?? ["prompt"]).includes(step.asks ?? "prompt")) {
+        bad.push(`${n > 1 ? `${jobLabel(doc, k)}, ` : ""}${targetLabel(doc, i)}: ${step.label ?? "this step"} needs a profile that answers it, and ${type.label} does not`);
       }
     });
-    // The model is the profile's unless the call's cell carries it.
+    // The model is the profile's unless the target's step carries it.
     const bare = conns.findIndex((p                           , k        ) => p && c.profiles && !local(p)
-      && callEntryOf(doc.jobs[k])?.modelFrom !== "cell" && !String(p.model || "").trim());
+      && targetEntryOf(doc, i, k)?.modelFrom !== "step" && !String(p.model || "").trim());
     if (bare >= 0) {
       bad.push(n > 1
-        ? `no model on the profile ${jobLabel(doc, bare)} of ${scenarioLabel(doc, i)} uses — manage profiles on the Setup tab`
-        : `no model on ${scenarioLabel(doc, i)}'s Setup profile — manage profiles on the Setup tab`);
+        ? `no model on the profile ${jobLabel(doc, bare)} of ${targetLabel(doc, i)} uses — manage profiles on the Setup tab`
+        : `no model on ${targetLabel(doc, i)}'s Target profile — manage profiles on the Setup tab`);
     }
   });
-  STEP_TYPES.tests .validate(doc.tests, c, bad, outOf(doc.jobs.at(-1)).kind, doc);
+  STEP_TYPES.evals .validate(doc.evals, c, bad, outOf(doc.jobs.at(-1)).kind, doc);
   if (bad.length) return bad;
 
   // Asked before anything is sent, so a misspelt token costs nothing and
   // says which job, instead of failing every item the same way.
   const text = CONTENT_TYPES[content?.type]?.text?.(content, c) ?? null;
-  scenarios.forEach((sc, i) => {
-    const stages          = doc.jobs.map((ch     , k        ) => ({ text: sc.stages[k].prompt, kind: outOf(ch).kind,
-                                                                   verbatim: !!callEntryOf(ch)?.verbatim }));
-    const problem = jobProblem(stages, stages.map(() => () => {}), doc.jobs.map((ch     ) => callOf(ch).tokenMappings), text);
-    if (problem) bad.push(`${scenarioLabel(doc, i)}: ${jobWords(problem)}`);
+  targets.forEach((_, i) => {
+    const stages          = doc.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);
+    if (problem) bad.push(`${targetLabel(doc, i)}: ${jobWords(problem)}`);
   });
   return bad;
 }
@@ -3990,16 +4404,16 @@ function connectionProblems(conn                           , at        , from
 }
 
 /** The profile ids a pipeline references, scenarios first, in order. */
-function profileIds(doc                                                       )           {
+function profileIds(doc                                                  )           {
   const ids           = [];
-  for (const sc of doc.scenarios || []) {
-    for (const ref of [sc.profile, ...(sc.stages || []).map((c      ) => c.profile)]) {
+  for (const t of targetsOf(doc)) {
+    for (const ref of [t.profile, ...(Array.isArray(t.steps) ? t.steps : []).map(st => st?.profile)]                              ) {
       if (ref?.id && !ids.includes(ref.id)) ids.push(ref.id);
     }
   }
-  // Then the ones a test asks (a grader), so a run carries them too.
-  for (const t of testsOf(doc)) {
-    for (const ref of TEST_TYPES[t.type]?.profiles?.(t) ?? []) if (ref?.id && !ids.includes(ref.id)) ids.push(ref.id);
+  // Then the ones an eval asks (a grader), so a run carries them too.
+  for (const t of evalsOf(doc)) {
+    for (const ref of EVAL_TYPES[t.type]?.profiles?.(t) ?? []) if (ref?.id && !ids.includes(ref.id)) ids.push(ref.id);
   }
   return ids;
 }
@@ -4012,9 +4426,9 @@ function profileIds(doc                                                       )
 function resolvePipeline(doc          ,
                          ctx                                                                            = {})              {
   const run = clone(doc)             ;
-  // What the lab supplies a test -- its grader -- before the profiles it
+  // What the lab supplies an eval -- its grader -- before the profiles it
   // asks are carried.
-  run.tests = (Array.isArray(run.tests) ? run.tests : []).map((t           ) => TEST_TYPES[t?.type]?.resolve?.(t, ctx) ?? t);
+  run.evals = (Array.isArray(run.evals) ? run.evals : []).map((t           ) => EVAL_TYPES[t?.type]?.resolve?.(t, ctx) ?? t);
   run.profiles = {};
   for (const id of profileIds(run)) {
     const p = ctx.profiles?.(id);
@@ -4023,7 +4437,7 @@ function resolvePipeline(doc          ,
   const content = contentOf(run)             ;
   if (content?.type === "source") content.files = CONTENT_TYPES.source .expand (content, ctx.files);
   if (ctx.datasetVersion) {
-    for (const t of run.tests || []) if (isRef(t.dataset)) t.dataset.version = ctx.datasetVersion;
+    for (const t of run.evals || []) if (isRef(t.dataset)) t.dataset.version = ctx.datasetVersion;
   }
   if (isStr(ctx.comment)) run.comment = ctx.comment;
   return run;
@@ -4037,7 +4451,7 @@ function pipelineOfRun(run             , ctx             = {})           {
   delete doc.plugins;
   const content = contentOf(doc)             ;
   if (content) { delete content.files; delete content.revs; }
-  for (const t of doc.tests || []) if (isObj(t.dataset)) delete t.dataset.version;
+  for (const t of doc.evals || []) if (isObj(t.dataset)) delete t.dataset.version;
   return doc;
 }
 
@@ -4076,7 +4490,7 @@ function importPipeline(input         , ctx            = {})               {
   const missing           = [], seen = new Set        ();
   const lists = { profile: profiles, source: sources, dataset: datasets };
   const words = {
-    profile: (ref     ) => `Setup profile ${ref.name || ref.id} not found`,
+    profile: (ref     ) => `Target profile ${ref.name || ref.id} not found`,
     source: (ref     ) => `Source ${ref.name || ref.id} not found`,
     dataset: (ref     ) => `Dataset ${ref.name || ref.id} not found`,
   };
@@ -4089,15 +4503,20 @@ function importPipeline(input         , ctx            = {})               {
   };
   const content = contentOf(next)             ;
   if (content?.type === "source") content.ref = remap(content.ref, "source");
-  for (const sc of next.scenarios || []) {
-    sc.profile = remap(sc.profile, "profile");
-    for (const cell of sc.stages || []) {
-      if (cell.profile) cell.profile = remap(cell.profile, "profile");
+  for (const t of targetsOf(next)) {
+    if (t.profile) t.profile = remap(t.profile, "profile");
+    for (const st of Array.isArray(t.steps) ? t.steps : []) {
+      if (st?.profile) st.profile = remap(st.profile, "profile");
     }
   }
-  for (const t of Array.isArray(next.tests) ? next.tests : []) {
+  for (const t of Array.isArray(next.evals) ? next.evals : []) {
     if (isRef(t?.dataset)) t.dataset = remap(t.dataset, "dataset");
   }
+  // Its references are this lab's now, so a step asking this lab's Echo
+  // profile is read as an Echo step (upgradePipeline did it for ids that
+  // already matched).
+  const local = localSteps(next, ctx);
+  if (local !== next) Object.assign(next, local);
   // A hand-written file needs no id of its own: mint the ones it lacks, and
   // keep the ones it carries, so export → import → export is the same
   // document and a re-import can recognise the same pipeline (#93).
@@ -4119,10 +4538,10 @@ function mintIds(doc           )            {
   for (const ch of Array.isArray(doc.jobs) ? doc.jobs : []) {
     if (isObj(ch) && (!isStr(ch.id) || !ch.id)) ch.id = newId();
   }
-  for (const sc of Array.isArray(doc.scenarios) ? doc.scenarios : []) {
-    if (isObj(sc) && (!isStr(sc.id) || !sc.id)) sc.id = newId();
+  for (const t of Array.isArray(doc.targets) ? doc.targets : []) {
+    if (isObj(t) && (!isStr(t.id) || !t.id)) t.id = newId();
   }
-  for (const t of Array.isArray(doc.tests) ? doc.tests : []) {
+  for (const t of Array.isArray(doc.evals) ? doc.evals : []) {
     if (isObj(t) && (!isStr(t.id) || !t.id)) t.id = newId();
   }
   return doc;
@@ -4146,26 +4565,34 @@ function yamlToPipeline(text        , ctx            )               {
  */
 function stagesFor(run             , i        ) 
                                                                                                         
-                                     {
-  const sc = run.scenarios[i] ;
+                                                                               {
   const stages = run.jobs.map((ch, k) => {
     const { kind, modifiers, ...settings } = outOf(ch);
-    return { text: sc.stages[k] .prompt, kind, withImage: !!callOf(ch).withImage,
-             verbatim: !!callEntryOf(ch)?.verbatim, modifiers: modifiers || [], settings };
+    return { text: targetStepOf(run, i, k) .prompt, kind, withImage: sendsImage(ch),
+             verbatim: !!targetEntryOf(run, i, k)?.verbatim, modifiers: modifiers || [], settings };
   });
-  const connections = run.jobs.map((ch, k) => {
-    const id = sc.stages[k] .profile?.id ?? sc.profile.id;
+  const connections = run.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.
+    if (targetEntryOf(run, i, k)?.local) {
+      const id = targetProfileOf(run, i, k)?.id;
+      const held = id != null ? run.profiles?.[id] : undefined;
+      return held && CONNECTION_TYPES[held.type]?.local ? { id: id , ...held } : { id: "", ...ECHO_CONNECTION };
+    }
+    const id = targetProfileOf(run, i, k) .id;
     return { id, ...(run.profiles?.[id] || {}) };
   });
-  // Each job's call step and this scenario's cell in it, for a transport
-  // that builds its own request from them (an HTTP Request).
-  return { stages, tokens: run.jobs.map(ch => callOf(ch).tokenMappings), connections,
-           calls: run.jobs.map(ch => stepIn(ch, "call") ), cells: sc.stages };
+  // 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) ) };
 }
 
 /** The Setup profile scenario [i] of a run ran under, as History shows it: keyless. */
 function scenarioProfile(run             , i        )                                                          {
-  const id = run.scenarios?.[i]?.profile?.id;
+  const id = targetsOf(run)[i]?.profile?.id;
+  // A target that asks nothing ran as Echo.
+  if (id == null && targetEntryOf(run, i, 0)?.local) return { id: "", name: ECHO_CONNECTION.name, settings: { ...ECHO_CONNECTION } };
   const conn = id != null ? run.profiles?.[id] : null;
   return conn ? { id: id , name: conn.name, settings: connectionSettings(conn                       ) } : null;
 }
@@ -4192,14 +4619,14 @@ function modifierSummary(m          )         {
   return said.length ? said.join(", ") : "on";
 }
 
-// ---- the tests, in order (docs/pipeline-model.md §3) ---------------------------
-// Tests only read a run: none changes what a later one sees, and none stops
+// ---- the evals, in order (docs/pipeline-model.md §3) ---------------------------
+// Evals only read a run: none changes what a later one sees, and none stops
 // the model being sent the next item. What order changes is Continue on
-// failure. A per-item test that fails and does not continue stops the tests
+// failure. A per-item eval that fails and does not continue stops the evals
 // after it for that item alone -- they read Skipped there, and a whole-run
-// test after it pools the items it did not stop. A whole-run test settles
+// eval after it pools the items it did not stop. A whole-run eval settles
 // once every item is in, and one that fails then and does not continue
-// leaves every test after it Skipped.
+// leaves every eval after it Skipped.
 
 const SKIPPED          = Object.freeze({ skipped: true          });
 const isSkipped = (s         )               => isObj(s) && s.skipped === true;
@@ -4207,16 +4634,16 @@ const isSkipped = (s         )               => isObj(s) && s.skipped === true;
 const failedScore = (s                              )          => !!s && !isSkipped(s) && !s.pass;
 
 /**
- * One reply's scores under a run's per-item tests, by test id, in order: a
- * test with no case to score leaves no entry, and one after a failure that
+ * One reply's scores under a run's per-item evals, by eval id, in order: a
+ * eval with no case to score leaves no entry, and one after a failure that
  * does not continue reads Skipped. Null where nothing was scored.
  */
-function itemScores(run             , kase                         , res                    )                                             {
+function itemScores(run             , kase                         , res                    )                                               {
   if (!kase) return null;
-  const out                                      = {};
+  const out                                        = {};
   let stopped = false;
-  for (const t of testsOf(run)) {
-    const type = TEST_TYPES[t.type];
+  for (const t of evalsOf(run)) {
+    const type = EVAL_TYPES[t.type];
     if (!type?.score) continue;
     if (stopped) { out[t.id] = SKIPPED; continue; }
     const s = type.score(t, kase, res);
@@ -4229,25 +4656,24 @@ function itemScores(run             , kase                         , res
 /** What production replied to an item, for a run's metrics: its last job's
     call says, from the item's record, or nobody does. */
 function productionOf(run                          , record         )                {
-  const last = run.jobs.at(-1);
-  const call = stepIn(last, "call");
-  return record ? STEP_TYPES[(call                    )?.type ?? ""]?.production?.(call, record) ?? null : null;
+  const last = run.jobs.at(-1), flow = flowStepOf(last);
+  return record && flow ? STEP_TYPES.flowStep .production ({ ...flow, readAs: readAsOf(last) }, record) : null;
 }
 
 /**
- * itemScores for the runner, which can wait: a test that reads every item
+ * 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                    ,
                                more           = {})                                                        {
   const out                                        = {};
   let stopped = false;
-  for (const t of testsOf(run)) {
-    const type = TEST_TYPES[t.type];
+  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; }
-    // A test with nothing to read on this item leaves no entry, as a graded
-    // test does on an item with no case.
+    // 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);
     if (!s) continue;
@@ -4258,22 +4684,22 @@ async function itemScoresAsync(run             , kase                         ,
 }
 
 /**
- * Every test's reading of scenario [i] of a run, in the run's order, from
+ * 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
- * whole-run test settled, so only then does its failure skip the tests
+ * whole-run eval settled, so only then does its failure skip the evals
  * after it.
  */
-function scenarioTests(run             , i        , items                                             ,
+function scenarioEvals(run             , i        , items                                             ,
                        settled = true)                {
   const cells = (items || []).map(it => (it && !it.unrun ? it.scenarios?.[i] : undefined));
-  // Which items a per-item test has stopped so far, for the tests after it.
+  // Which items a per-item eval has stopped so far, for the evals after it.
   const stopped = cells.map(() => false);
   let skipRest = false;
-  const tests = testsOf(run);
-  return tests.map((t, j) => {
-    const type = TEST_TYPES[t.type];
+  const evals = evalsOf(run);
+  return evals.map((t, j) => {
+    const type = EVAL_TYPES[t.type];
     const whole = isWholeRun(type, t);
-    const base = { id: t.id, label: testLabel({ tests }, j), whole, skipped: skipRest,
+    const base = { id: t.id, label: evalLabel({ evals }, j), whole, skipped: skipRest,
                    verdict: null                          , rules: type?.rules?.(t) ?? [], items: cells.map(() => null)                        ,
                    ran: 0, passed: 0, skippedItems: 0 };
     if (skipRest) {
@@ -4300,7 +4726,7 @@ function scenarioTests(run             , i        , items
   });
 }
 
-/** A scenario's pass or fail over every test that read it: null where none
+/** A scenario's pass or fail over every eval that read it: null where none
     has anything to say yet. */
 function scenarioPasses(outcomes                        )                 {
   let said = false;
@@ -4341,95 +4767,77 @@ function validateEvals(ev           , files
     return ["the graded set 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");
+  if (ev.source != null && !isRef(ev.source)) bad.push("a dataset names its Source as { id, name }, or null");
   if (bad.length) return bad;
 
   const graded              = ev.cases || [];
   // Identity first: every rule below reports which case is at fault, so a
   // case with no usable id makes the rest of the report unreadable.
-  const seen = new Map                ();
+  const seen = new Set        ();
   for (const c of graded) {
-    {
-      if (!c || typeof c !== "object" || Array.isArray(c)) {
-        bad.push("cases holds something that is not a case");
-        continue;
-      }
-      if (typeof c.id !== "string" || !c.id.trim()) bad.push("a case has no id");
-      else if (seen.has(c.id)) bad.push(`${c.id} is graded twice`);
-      else seen.set(c.id, "cases");
-      if (!caseFile(c).trim()) {
-        bad.push(`${c.id || "a case"} names no file`);
-      }
-      for (const key of ["expect", "forbid", "allow", "anyOf", "watch", "traits"]) {
-        if (c[key] != null && !Array.isArray(c[key])) bad.push(`${c.id}: ${key} has to be a list`);
-      }
-      for (const key of ["minCount", "maxCount"]) {
-        if (c[key] != null && !Number.isInteger(c[key])) bad.push(`${c.id}: ${key} has to be a whole number`);
-      }
-      if (c.discarded != null && c.discarded !== true) bad.push(`${c.id}: discarded is true or left out`);
-      // A case's own metrics, which a Metrics test adds to its own for this item.
-      if (c.metrics != null) metricsProblems(c.metrics, String(c.id), bad);
+    if (!isObj(c)) {
+      bad.push("cases holds something that is not a case");
+      continue;
     }
+    if (!isStr(c.id) || !c.id.trim()) bad.push("a 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 (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);
   }
   if (bad.length) return bad;
 
-  // A term the scorer cannot match is a term that can never be produced, so
-  // the case is unpassable however well the model answers.
+  // What a case says, read from its metrics: a term the scorer cannot match
+  // can never be produced, so the case is unpassable however well the model
+  // answers -- and the same goes for a bound no reply can meet.
   const matchable = (term        ) => termIn([String(term).trim()], term);
-
+  const values = (m        )           => metricLines(m.type === "contains" ? m.value : m.values);
   for (const c of graded) {
     if (c.todo) continue;
     const say = (m        ) => bad.push(`${c.id}: ${m}`);
-    const expect = c.expect || [], forbid = c.forbid || [], anyOf = c.anyOf || [];
-
-    if (c.discarded === true) {
+    const scored = (c.metrics                         ?? []).filter(m => m.weight !== 0);
+    if (!scored.length) { say("graded but states nothing to expect"); continue; }
+    if (scored.some(m => m.type === "discarded" && !m.not)) {
       // What is discarded holds nothing, so there is nothing else to expect.
-      if (expect.length || anyOf.length || forbid.length || c.minCount != null || c.maxCount != null) {
-        say("expects its answer discarded, and states something the answer should hold too");
-      }
+      if (scored.length > 1) say("expects its answer discarded, and states something the answer should hold too");
       continue;
     }
-    const metrics = Array.isArray(c.metrics) ? c.metrics : [];
-    if (!expect.length && !anyOf.length && !metrics.length) say("graded but states nothing to expect");
-    for (const t of expect) if (!matchable(t)) say(`expects ${t}, which its own scorer cannot match`);
-    for (const g of anyOf) {
-      if (!Array.isArray(g)) { say("an anyOf group has to be a list of terms"); continue; }
-      if (!g.length) say("an anyOf group is empty, so nothing can satisfy it");
-      for (const t of g) if (!matchable(t)) say(`offers ${t}, which its own scorer cannot match`);
-    }
-    // An exception excuses only the forbidden terms inside it, so one that
-    // holds none of them changes nothing and reads as if it did.
-    for (const a of c.allow || []) {
-      if (!forbid.some((t        ) => termIn([a], t))) say(`allows ${a}, which holds nothing it forbids`);
+    const wants = scored.filter(m => !m.not && (m.type === "contains-all" || m.type === "contains-any"));
+    const forbids = scored.filter(m => m.not && m.type === "contains");
+    for (const m of wants) for (const t of values(m)) if (!matchable(t)) say(`expects ${t}, which its own scorer cannot match`);
+    // An exception excuses only the forbidden term inside it, so one that
+    // holds it not changes nothing and reads as if it did.
+    for (const m of forbids) {
+      for (const e of metricLines(m.except)) if (!termIn([e], String(m.value ?? ""), m.ignoreCase === true)) say(`allows ${e}, which holds nothing it forbids`);
     }
     // A term on both lists cannot be produced and cannot be withheld.
-    for (const t of [...expect, ...anyOf.flat()]) {
-      if (forbid.includes(t)) say(`${t} is both expected and forbidden`);
-    }
-    const { minCount: lo, maxCount: hi } = c;
-    if (lo != null && hi != null && lo > hi) say(`minCount ${lo} is above maxCount ${hi}`);
-    if (lo != null && lo < 1) say(`minCount ${lo} is not a bound`);
-    // The mirror of the floor: a ceiling below one says no answer is
-    // acceptable, which is an entry that can never pass rather than a
-    // strict one.
-    if (hi != null && hi < 1) say(`maxCount ${hi} leaves no answer that could pass`);
-    // A case that names more distinct things than the reply may carry, in
-    // the scorer's own counting of a thing (#486: an expect term is one, an
-    // anyOf group is one), can never pass however well the model answers.
-    const things = expect.length + anyOf.length;
-    if (hi != null && things > hi) {
-      say(`asks for ${things} things and maxCount ${hi} admits ${hi}`);
+    const forbidden = new Set(forbids.map(m => String(m.value ?? "")));
+    for (const m of wants) for (const t of values(m)) if (forbidden.has(t)) say(`${t} is both expected and forbidden`);
+    for (const m of scored.filter(m => m.type === "item-count" && !m.not)) {
+      const lo = m.min == null || m.min === "" ? null : Number(m.min), hi = m.max == null || m.max === "" ? null : Number(m.max);
+      if (lo != null && hi != null && lo > hi) say(`at least ${lo} is above at most ${hi}`);
+      // A ceiling below one says no answer is acceptable, which is a case
+      // that can never pass rather than a strict one.
+      if (hi != null && hi < 1) say(`at most ${hi} leaves no answer that could pass`);
+      // A case that names more distinct things than the reply may carry, in
+      // the scorer's own counting of a thing (#486: each term Contains all
+      // wants is one, each Contains any is one), can never pass.
+      const things = wants.reduce((n, w) => n + (w.type === "contains-all" ? values(w).length : 1), 0);
+      if (hi != null && things > hi) say(`asks for ${things} things and at most ${hi} admits ${hi}`);
     }
   }
 
-  // One file, one set of expectations. A file here twice is two sets of
-  // them, graded separately, and both would be listed.
+  // One item, one case. An item here twice is two cases of it, graded
+  // separately, and both would be listed.
   const where = new Map                 ();
   for (const c of graded) {
-    const name = caseFile(c);
+    const name = caseItem(c);
     const counted = where.get(name);
     if (counted) {
-      bad.push(`${name} is graded twice — one file, `
-             + `two sets of expectations. Grade it once.`);
+      bad.push(`${name} is graded twice — one item, `
+             + `two cases. Grade it once.`);
     } else where.set(name, true);
   }
   const gradedAt = (name        ) => where.has(name);
@@ -4450,7 +4858,7 @@ function validateEvals(ev           , files
   for (const f of shown) {
     if (!gradedAt(f)) {
       bad.push(`${f} is in the Source and this dataset does not grade it, `
-             + `so the Evals tab does not list it`);
+             + `so the Cases view does not list it`);
     }
   }
   return bad;
@@ -4472,7 +4880,9 @@ function evalsWarnings(ev           , prompt        )           {
   const want = Number(n), warn           = [];
   for (const c of ev.cases || []) {
     if (!c || c.todo) continue;
-    const things = (c.expect || []).length + (c.anyOf || []).length;
+    const things = (Array.isArray(c.metrics) ? c.metrics             : [])
+      .filter(m => !m.not && m.weight !== 0 && (m.type === "contains-all" || m.type === "contains-any"))
+      .reduce((k, m) => k + (m.type === "contains-all" ? metricLines(m.values).length : 1), 0);
     if (things > want) {
       warn.push(`${c.id}: asks for ${things} things and the prompt asks for up to ${want}`);
     }
@@ -4491,7 +4901,7 @@ function evalsWarnings(ev           , prompt        )           {
  * `evals-check.js` asserts the round trip against the real file.
  */
 function evalsJson(ev         )         {
-  return JSON.stringify(canonicalCases(ev), null, 2) + "\n";
+  return JSON.stringify(ev, null, 2) + "\n";
 }
 
 
@@ -4505,22 +4915,24 @@ registerMetrics({ registerKinds });
 export {
     TOKEN_DEFAULTS, TOKEN_TYPES, tokenMapping, tokenNames, resolvePrompt, tokenSet, textPrompt, words,
     loopReplyError, preparedSize,
-    termIn, forbiddenIn, scoreCase, gradedSetFrom, caseFile, canonicalCases, upgradeDatasetBody, datasetRules, upgradeResults, emptyTally, addToTally, isHostedUrl,
+    termIn, forbiddenIn, readCase, gradedSetFrom, caseItem, caseMetrics, metricLines, upgradeDatasetBody, datasetRules, upgradeResults, emptyTally, addToTally, isHostedUrl,
     SEED, REPLY_TOKENS_BEFORE, ANTHROPIC_MAX_TOKENS, asNumber, pinReplyTokens, mappingsFor,
-    CONNECTION_TYPES, HTTP_APIS, httpApiFor, httpRequestOf, httpReplyOf, callEntryOf, WdlError, localAnswer, typeOf, profileType, convertProfile, splitOllama, DECODING_KEYS, apiBase,
+    CONNECTION_TYPES, HTTP_APIS, httpApiFor, httpRequestOf, httpReplyOf, readFlowReply, WdlError, localAnswer, typeOf, profileType, convertProfile, splitOllama, DECODING_KEYS, apiBase,
     EDGE_448, budgetLabel, IMAGE_FORMATS, encoderQuality,
     tallyPercent, runPipeline, validateEvals, evalsWarnings, evalsJson, readList,
     scoreSingle, singleRules, parseCount, lengthHolds, countHolds, COUNT_OPS, LENGTH_OPS,
     COUNT_OP_LABEL, LENGTH_OP_LABEL,
-    PIPELINE_VERSION, STEP_TYPES, CONTENT_TYPES, OUTPUT_KINDS, MODIFIERS, TEST_TYPES, LEGACY_TESTS, METRICS, readMetrics, metricSummary, itemScoresAsync, productionOf,
+    PIPELINE_VERSION, DATASET_BODY_VERSION, STEP_TYPES, CONTENT_TYPES, OUTPUT_KINDS, MODIFIERS, EVAL_TYPES, LEGACY_TESTS, METRICS, readMetrics, metricSummary, itemScoresAsync, productionOf,
     SOURCE_TYPES, DEFAULT_SOURCE_TYPE, sourceTypeOf,
     registerKinds, defaultKind, jobDefaults, applyModifiers, keyVar, connectionOf, connectionSettings,
     connectionRequest, connectionBase, connectionSend, connectionReply, connectionReplyProblem, connectionImage, connectionProblems,
 CONNECTION_FIELDS, SETTING_KEYS, OPTION_FIELDS, jobLabel, scenarioLabel, jobWords, versionProblem,
-    contentOf, withContent, callOf, replyOf, outOf, withOut, withCall, slotEntry, SLOTS,
-    blankPipeline, upgradePipeline, fatProfileRef, newId, newTest, validatePipeline, resolvePipeline, pipelineOfRun, stagesFor, profileIds,
-    scenarioProfile, lastKind, lastModifier, modifierSummary, itemScores, scenarioTests, scenarioPasses, isSkipped, failedScore,
-    testLabel, testsOf, testsDataset, isWholeRun, TEST_FIELDS,
+    contentOf, withContent, replyOf,
+    targetsOf, targetLabel, targetStepOf, targetEntryOf, jobTargetType, targetProfileOf, withTarget,
+    tokensOf, withTokens, sendsImage, withImage, flowStepOf, readAsOf, outOf, withOut, slotEntry, SLOTS,
+    blankPipeline, upgradePipeline, fatProfileRef, newId, newEval, validatePipeline, resolvePipeline, pipelineOfRun, stagesFor, profileIds,
+    scenarioProfile, lastKind, lastModifier, modifierSummary, itemScores, scenarioEvals, scenarioPasses, isSkipped, failedScore,
+    evalLabel, evalsOf, evalsDataset, isWholeRun, EVAL_FIELDS,
     pipelineToYaml, importPipeline, yamlToPipeline,
     pluginHost, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProblems, dropBy, rejectBy, matcher,
 };