evals-lab 0.1.4 → 0.2.0

package/lab/evals-core.mjs

@@ -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,13 +215,21 @@ 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
@@ -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. */
                           
                
-                                                                                 
+                                                                                        
                     
                
                      
@@ -894,45 +944,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"];
 
                                 
                     
                                                           
                 
-                                                                           
-                                                                    
-                                                                        
+                                                                   
+                                                                         
+                                                                      
+                                                                          
                                                                       
-                                                                        
                                                                         
                   
+                                                                       
+                                      
+                
+                                                                    
+                 
                                                  
                  
                                                             
                        
-                                                                         
+                                                                             
+                                                          
                   
+                                                                      
+                  
+                                                                        
+                                                                
+                    
                                                                          
                                                              
                      
-                                                                        
-                         
-                                 
                                                                           
+                         
                                  
-                                                           
+                                                                  
                         
+                                                                        
                                                                          
-                                                                               
-                                  
+                                                       
+                                        
                                                                            
-                                                                        
+                                                                                
                                                                  
-                                                                         
-                                                                                   
                              
                                                             
                                            
@@ -1023,6 +1082,10 @@ function datasetRules(body         )                  {
                                  
              
                 
+                                                                        
+                                                                        
+                          
+                   
                                                                          
                        
                                          
@@ -1067,7 +1130,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 +1183,9 @@ function mappingsFor(prompt        )                {
                                                                             
                                                   
                 
-                                                 
+                                                                        
+                  
+                                                                              
                                                           
  
 
@@ -1157,6 +1222,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 +1277,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();
@@ -1376,8 +1467,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 +1640,19 @@ CONNECTION_TYPES["llama.cpp"] = {
                 
                                                                            
                              
-                                                                              
+                                                                            
                                                                    
-                                                 
+                                                        
                               
-                                                               
+                                                                      
                                                                                             
                                                                
                                             
                                               
                                                                   
+                                                                          
+                                                                          
+                              
                                                                              
                                          
                                                      
@@ -1622,6 +1718,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 +1764,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 +1782,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
@@ -2432,7 +2533,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 +2567,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);
@@ -2580,7 +2688,11 @@ function applyModifiers   (list                                 , kind        ,
 // 9: a test 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.
+const PIPELINE_VERSION = 10         ;
 
 // Plain objects, so an entry is added by assignment and a reader never needs
 // to know which registered it.
@@ -2741,8 +2853,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 +2961,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"],
@@ -3079,14 +3190,14 @@ TEST_TYPES.metrics = {
     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.
     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 test, 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        ) => ({
@@ -3244,15 +3355,19 @@ function metricSummary(m        )         {
   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 +3378,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,62 +3453,84 @@ 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",
+  label: "Read Reply", slot: "responses", rank: 1,
   description: "How the reply is read before tests and later jobs see it.",
   in: "text", out: step => step.out?.kind,
   // Read inside the stage: runPipeline parses each reply as it comes back.
@@ -3360,30 +3542,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 +3585,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 +3612,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 }              )),
+  })) };
 }
 
-/** A job's call: the step that asks something and is answered. */
-const callOf = (job                                                )             =>
-  stepIn            (job, "call")              ;
+/** The token mappings [job]'s words are resolved under. */
+const tokensOf = (job         )                => stepOf                   (job, "tokenMappings")?.tokenMappings ?? [];
 
-/** The registry entry of a job's call: what it asks, and of whom. */
-const callEntryOf = (job                                                )                            =>
-  STEP_TYPES[(stepIn(job, "call")                    )?.type ?? ""];
+/** [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;
+}
+
+/** 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;
+
+/** 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 +3710,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,53 +3764,47 @@ 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
+    // A job's steps are the entries with a stage; one without (a job, the
     // tests) 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);
     }
   },
 };
@@ -3583,7 +3871,7 @@ STEP_TYPES.tests = {
 
 // ---- the document -------------------------------------------------------------
 
-const PIPELINE_FIELDS                    = ["version", "id", "name", "jobs", "scenarios", "tests"];
+const PIPELINE_FIELDS                    = ["version", "id", "name", "jobs", "targets", "tests"];
 // 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"];
@@ -3603,6 +3891,10 @@ function versionProblem(doc         )                {
     rules, as a run with no graded test parsed. */
                              
                                                                 
+                                                                    
+                                                                         
+                                                              
+                                                   
  
 
 /**
@@ -3637,25 +3929,30 @@ 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);
   }
 }
 
 /** 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
@@ -3723,22 +4020,107 @@ 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])));
+}
+
 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(out, ctx)     ;
+  }
+  if (!isObj(doc) || ![1, 2, 3, 4, 5, 6, 7, 8, 9].includes(doc.version          )) return doc;
+  // Every version before 10 reads as version 9 first, then as 10.
+  return localSteps(targetsFromScenarios(nineOf(clone(doc)             , ctx)), ctx)     ;
+}
+
+/** [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;
   }
-  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)))))     ;
+  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 +4146,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 +4163,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: [], tests: [] };
 }
 
 /**
@@ -3808,37 +4190,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,55 +4244,63 @@ 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);
@@ -3906,11 +4309,11 @@ function validatePipeline(input         , ctx          = {})           {
   // 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,10 +4393,10 @@ 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);
     }
   }
@@ -4076,7 +4479,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 +4492,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 : []) {
     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,8 +4527,8 @@ 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 : []) {
     if (isObj(t) && (!isStr(t.id) || !t.id)) t.id = newId();
@@ -4146,26 +4554,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;
 }
@@ -4229,9 +4645,8 @@ 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;
 }
 
 /**
@@ -4507,7 +4922,7 @@ export {
     loopReplyError, preparedSize,
     termIn, forbiddenIn, scoreCase, gradedSetFrom, caseFile, canonicalCases, 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,
@@ -4517,7 +4932,9 @@ export {
     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,
+    contentOf, withContent, replyOf,
+    targetsOf, targetLabel, targetStepOf, targetEntryOf, jobTargetType, targetProfileOf, withTarget,
+    tokensOf, withTokens, sendsImage, withImage, flowStepOf, readAsOf, outOf, withOut, 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,