evals-lab 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -5,6 +5,74 @@ Newest first. Read a release's **Upgrade notes** before installing it: an
 upgrade can rewrite what the lab keeps in your data directory, and an older
 version cannot always read it back.
 
+## 0.8.0
+
+### Upgrade notes
+
+- No stored document changes format: pipelines stay version 13, and eval
+  groups and exports stay version 8, so 0.7.0 still reads what 0.8.0 saves.
+- On first start, 0.8.0 adds a table recording which workspaces may use each
+  Target profile and account. Nothing is narrowed: every connection stays
+  shared with every workspace until you change it.
+
+### Added
+
+- Several workspaces. Make, rename and archive them in Setup › Workspaces,
+  and switch between them from the header's workspace menu. Each one has its
+  own address (`/w/<slug>`) and its own datasets, prompts, Sources, pipelines
+  and runs. The theme choice (Dark, Light, Match system) has moved into that
+  menu.
+- Target profiles and accounts can be shared with every workspace, with some,
+  or with each new one. A run in a workspace a profile isn't shared with says
+  so and offers to share it.
+- `evals-lab run --lab … --workspace <slug>` runs a lab's pipeline in a named
+  workspace. Without it, the default workspace is used, as before.
+- Setup › Wizards, and a header pill showing a wizard's progress. The first
+  wizard, Test a Power Automate workflow, ticks off each step as you do it.
+  Plugins can add workflow platforms and wizards.
+- Judged against recorded has an **Expected** setting: tick which of Better,
+  Same and Worse pass (Better and Same by default, as before).
+- A Recorded target's menu has **Preview replies…**, showing what each call
+  recorded.
+- Test… asks for a grader when a check needs one. You can create the test
+  without one and add it later.
+
+### Changed
+
+- Model-graded checks no longer need a prompt written. The grader is told
+  what the target was asked; Judged against recorded's Task is now optional
+  Additional guidance.
+- A grader's answer is held to a fixed JSON shape where its API supports
+  that (Anthropic, OpenAI-compatible, llama.cpp, Ollama). An answer that
+  still can't be read is asked for once more, then reported as a grader
+  error rather than a verdict.
+- Test… on a step whose reply is plain words judges the reply against the
+  recorded one, instead of requiring the exact same words.
+- Rubric's and Factual's threshold reads **Expected: score at least**.
+- New profile: Anthropic and Ollama (Cloud) no longer ask for an address. A
+  proxy or gateway address goes under Advanced. Temperature is hidden, and
+  never sent, for models that reject it (Claude Opus 4.7 and later, the
+  5-series Claude models, OpenAI reasoning models). Image settings are now
+  the folded Vision Capabilities group.
+- The Test… dialog is "Create new pipeline test", with a Create button.
+- Library › Sources › a flow: Actions come before Calls, and each call's
+  request reads In sync or Out of sync.
+- Run results: Take B as expected is in each call's row menu, and the
+  Results table no longer has checkboxes.
+- The wizard pill's button is Open wizard, which shows the wizard's steps.
+
+### Fixed
+
+- An HTTP endpoint profile whose address included a path (such as
+  `https://api.anthropic.com/v1/messages`) sent the path twice, so every
+  call came back Not found.
+- An Anthropic profile with a blank address was sent to the lab's own Ollama.
+- A run said "this run has none" for a grader that its Library eval group
+  named.
+- The wizard pill didn't tick a step until the page was reloaded.
+- A Microsoft 365 sign-in now shows which tenants it reaches, so a lab that
+  works across tenants is not tied to one.
+
 ## 0.7.0
 
 ### Upgrade notes

package/bin/run.js

@@ -51,6 +51,8 @@ const USAGE = `Usage: evals-lab run <bundle-dir | pipeline.yaml> [options]
                      and their keys, and the run in its History. LAB_PASSWORD
                      is sent when it is set.
   --pipeline <name>  the lab's pipeline to run, by its name or its id.
+  --workspace <slug> the lab's workspace to run in, by its /w/<slug> address.
+                     Default: the lab's default workspace.
   --wait             wait for the lab's run to finish, and exit with its
                      verdict. Without it the run's id is printed once it is
                      queued. --json, --junit, --summary, --min-pass and
@@ -70,9 +72,9 @@ class Refused extends Error {
 // What the command line asks for, or a Refused saying what is wrong with it.
 function runOptions(argv) {
   const o = { bundle: null, items: null, json: null, junit: null, summary: null, minPass: null, progress: false,
-              lab: null, pipeline: null, wait: false };
+              lab: null, pipeline: null, workspace: null, wait: false };
   const value = { "--items": "items", "--json": "json", "--junit": "junit", "--summary": "summary", "--min-pass": "minPass",
-                  "--lab": "lab", "--pipeline": "pipeline" };
+                  "--lab": "lab", "--pipeline": "pipeline", "--workspace": "workspace" };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === "--help" || a === "-h") o.help = true;
@@ -96,6 +98,8 @@ function runOptions(argv) {
     if (waits.length && !o.wait) {
       throw new Refused(`--${waits[0].replace("minPass", "min-pass")} reads the finished run: add --wait`, true);
     }
+  } else if (o.workspace != null) {
+    throw new Refused("--workspace is for a lab's run: name the lab with --lab", true);
   } else if (o.wait) {
     throw new Refused("--wait is for a lab's run: a bundle's always waits", true);
   } else if (o.bundle == null) {
@@ -276,15 +280,18 @@ const POLL_MISSES = 20;
 
 // The lab's API at [base], as [env]'s LAB_PASSWORD opens it: HTTP Basic, the
 // password alone, as server.py takes it. A refusal says what the lab said.
-function labApi(base, env) {
+// [workspace], when given, is the slug every call carries as X-Workspace, so
+// the run reads and queues in that workspace rather than the lab's default.
+function labApi(base, env, workspace) {
   const auth = env.LAB_PASSWORD
     ? { Authorization: `Basic ${Buffer.from(`:${env.LAB_PASSWORD}`).toString("base64")}` } : {};
+  const scope = workspace ? { "X-Workspace": workspace } : {};
   return async (method, route, body, { missing = false } = {}) => {
     let res;
     try {
       res = await fetch(base + route, {
         method, redirect: "manual",
-        headers: { ...auth, ...(body !== undefined ? { "Content-Type": "application/json" } : {}) },
+        headers: { ...auth, ...scope, ...(body !== undefined ? { "Content-Type": "application/json" } : {}) },
         ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
       });
     } catch (e) {
@@ -319,6 +326,21 @@ function pipelineNamed(saved, name, base) {
   return found[0];
 }
 
+// The lab's workspace --workspace [slug] names, by its /w/<slug> address -- or
+// a Refused naming the slugs it has, as pipelineNamed does for pipelines. The
+// server falls back to its default for an unknown slug, so the CLI checks the
+// slug itself; an archived workspace cannot be run against.
+function workspaceNamed(workspaces, slug, base) {
+  const active = workspaces.filter(w => w && !w.archived);
+  const found = active.find(w => w.slug === slug);
+  if (found) return found;
+  if (workspaces.some(w => w && w.slug === slug)) {
+    throw new Refused(`${base}'s workspace at /w/${slug} is archived`);
+  }
+  throw new Refused(`${base} has no workspace at /w/${slug}`
+    + (active.length ? `: it has ${active.map(w => JSON.stringify(w.slug)).join(", ")}` : ""));
+}
+
 // The row's verdicts with --min-pass relaxing each eval read item by item,
 // as the worker's --min-pass does: it only ever turns a fail into a pass.
 const relaxed = (verdicts, minPass) => minPass == null ? verdicts : verdicts.map(evals =>
@@ -356,7 +378,16 @@ function rowSuites(core, run, verdicts, items) {
 /** [o]'s pipeline, queued on its lab; with --wait, followed to its verdict. */
 async function runOnLab(core, o, { env, stdout, say }) {
   const base = o.lab.replace(/\/+$/, "");
-  const call = labApi(base, env);
+  // Resolve --workspace to the slug every call carries; the lab's pipelines,
+  // Sources and eval groups are per-workspace, so the whole run reads and
+  // queues inside it. Without it, the lab's default workspace is used and the
+  // X-Workspace header is omitted, so existing CI is unchanged.
+  let workspace = null;
+  if (o.workspace != null) {
+    const { workspaces } = await labApi(base, env)("GET", "/api/workspaces");
+    workspace = workspaceNamed(Array.isArray(workspaces) ? workspaces : [], o.workspace, base).slug;
+  }
+  const call = labApi(base, env, workspace);
 
   // What the page reads before it submits: the lab's pipelines and Target
   // profiles, the Source the pipeline reads and the eval groups it may link.

package/lab/VERSION

@@ -1 +1 @@
-0.7.0 (2026.10.06-456)
+0.8.0 (2026.10.07-484)

package/lab/evals-core.mjs

@@ -657,6 +657,9 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                                                                               
                                                               
                           
+                                                                              
+                                                          
+                       
                     
                                                                        
                     
@@ -667,9 +670,10 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
 
 /** What a metric needs besides the reply: a model to grade with. */
                             
-                                                                           
-                        
-                                            
+                                                                        
+                                                                        
+                               
+                                                                              
                                                                             
                                                                             
                                                           
@@ -723,6 +727,13 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                     
                                                                                     
                        
+                                                                             
+                                                                           
+                 
+                       
+                                                                             
+                                                  
+                    
  
 
 /** What an earlier eval that failed and does not continue leaves a later one. */
@@ -797,6 +808,9 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                         
                       
                         
+                                                                    
+                                                
+                                                                  
                                                                              
                                                  
 
@@ -881,9 +895,9 @@ import list, { ECHO, legacyTagsOut, splitItems, tidy, tryExamples, itemRulesProb
                       
                                                                                                    
                                                                        
+                                                                            
                                                                           
-                                                                
-                                                                                            
+                                                                                                                 
  
 
 /** Lookups, and whether it is a run document being validated. */
@@ -1041,7 +1055,7 @@ const platformOf = (src
                                                          
                   
                                                            
-                                                                           
+                                                                                                             
                                                                            
                        
                                                 
@@ -1323,6 +1337,10 @@ function datasetRules(body         )                  {
                   
                
                                                
+                                                                            
+                                                                             
+                                                
+                                      
  
 
 /** An HTTP request as a connection type builds it, for the relay to send. */
@@ -1346,6 +1364,10 @@ function datasetRules(body         )                  {
                        
                                          
                                                                                                                   
+                                                                             
+                                                                            
+                                          
+                                                                                                       
                                                                        
                                                                                          
                                                                                                   
@@ -1354,8 +1376,9 @@ function datasetRules(body         )                  {
                                                                            
                                  
                     
-                                                                           
-                                                                 
+                                                                          
+                                                                               
+                                                                         
                
                                                                              
                                                                          
@@ -1708,6 +1731,8 @@ function ollamaType(id        , label        , cloud         )                 {
         body: { model: conn.model, messages: [message], options, stream: false },
       };
     },
+    // Ollama's own: the schema is the format.
+    structured: (body, schema) => ({ ...body, format: schema }),
     parseReply(j) {
       const r = j                                                                   ;
       return { raw: r?.message?.content ?? "", finishReason: r?.done_reason ?? null };
@@ -1754,7 +1779,7 @@ function recordedRaw(record         )         {
 // the flow reads a reply; `local` is the no-Read-as fallback.
 CONNECTION_TYPES.recorded = {
   id: "recorded", label: "Recorded", settings: [], keyless: true, picker: false, replays: true,
-  description: "Replays the reply production recorded for each call. Sends nothing.",
+  description: "Answers each call with the reply it got when it was recorded. Sends nothing.",
   local: (_item, _sent, record) => recordedRaw(record),
   request: sendsNothing, parseReply: sendsNothing, listModels: sendsNothing, parseModels: () => [],
 };
@@ -1769,19 +1794,25 @@ function localAnswer(conn          , text               , sent        , record
   return { raw, ms: 0, conn: (conn.name                      ) ?? null, ...(text == null ? { readAgainst: "" } : {}) };
 }
 
+/** A chat completions body asking for a reply held to [schema]: OpenAI's
+    response_format, which llama-server and most compatible servers take too. */
+const chatSchema = (body                         , schema                         )                          =>
+  ({ ...body, response_format: { type: "json_schema", json_schema: { name: "reply", strict: true, schema } } });
+
 CONNECTION_TYPES["openai-compatible"] = {
   id: "openai-compatible", label: "OpenAI-compatible",
   description: "OpenAI, OpenRouter, vLLM, LM Studio: any chat completions endpoint.",
   settings: [
-    { key: "temperature", label: "Temperature", control: "text", default: "", hint: "" },
+    // A reasoning model refuses a temperature.
+    { key: "temperature", label: "Temperature", control: "text", default: "", hint: "",
+      appliesTo: (conn) => !/^(gpt-5|o\d)/i.test(String(conn.model ?? "")) },
     { key: "nPredict", label: "Reply tokens", control: "text", default: "", hint: "" },
   ],
-  // /v1/chat/completions, covering OpenAI, OpenRouter, vLLM, LM Studio. The
-  // reasoning-model temperature rule and max_completion_tokens stay with this
-  // type, as the hosted providers reject the fields a llama.cpp server takes.
+  // /v1/chat/completions, covering OpenAI, OpenRouter, vLLM, LM Studio.
+  // max_completion_tokens stays with this type, as the hosted providers
+  // reject the fields a llama.cpp server takes.
   request(conn, prompt, dataUrl, base, key) {
     const hosted = isHostedUrl(base);
-    const isReasoning = /^(gpt-5|o\d)/i.test(String(conn.model ?? ""));
     const temp = asNumber(conn.temperature);
     const predict = asNumber(conn.nPredict);
     return {
@@ -1789,7 +1820,7 @@ CONNECTION_TYPES["openai-compatible"] = {
       headers: bearer(key),
       body: {
         model: conn.model,
-        ...(isReasoning || temp == null ? {} : { temperature: temp }),
+        ...(temp == null ? {} : { temperature: temp }),
         ...(predict == null ? {} : hosted ? { max_completion_tokens: predict } : { max_tokens: predict }),
         messages: [{ role: "user", content: [
           { type: "text", text: prompt },
@@ -1798,15 +1829,23 @@ CONNECTION_TYPES["openai-compatible"] = {
       },
     };
   },
+  structured: chatSchema,
   parseReply: chatReply,
   listModels, parseModels: idsFrom,
 };
 
+/** The Claude models that refuse a sampling setting: Opus from 4.7, and
+    every Opus, Sonnet, Fable and Mythos from 5. Older ones (Opus 4.6, Sonnet
+    4.6, Haiku 4.5) take one. */
+const CLAUDE_FIXED_SAMPLING = /claude-(opus-4-[7-9]|(opus|sonnet|fable|mythos)-[5-9])/i;
+
 CONNECTION_TYPES.anthropic = {
   id: "anthropic", label: "Anthropic",
   description: "Claude, through Anthropic's Messages API.",
+  url: "https://api.anthropic.com",
   settings: [
-    { key: "temperature", label: "Temperature", control: "text", default: "", hint: "" },
+    { key: "temperature", label: "Temperature", control: "text", default: "", hint: "",
+      appliesTo: (conn) => !CLAUDE_FIXED_SAMPLING.test(String(conn.model ?? "")) },
     { key: "maxTokens", label: "Reply tokens", control: "text", default: "", hint: "" },
   ],
   // The Messages API: the x-api-key and anthropic-version headers, base64
@@ -1831,6 +1870,9 @@ CONNECTION_TYPES.anthropic = {
       },
     };
   },
+  // The Messages API's structured outputs. A model that cannot hold one
+  // refuses the request, and the grader asks again without it.
+  structured: (body, schema) => ({ ...body, output_config: { ...(body.output_config                      ), format: { type: "json_schema", schema } } }),
   parseReply(j) {
     const r = j                                                                                ;
     const raw = (r?.content || []).filter(b => b.type === "text").map(b => b.text).join("");
@@ -1903,6 +1945,8 @@ CONNECTION_TYPES["llama.cpp"] = {
       },
     };
   },
+  // llama-server takes OpenAI's response_format, a schema and all.
+  structured: chatSchema,
   parseReply: chatReply,
   listModels, parseModels: idsFrom,
   // A reply that arrived is still a failure when this profile asked for the
@@ -2098,12 +2142,14 @@ function extraHeaders(raw         )                         {
   }
   return out;
 }
-/** An address as a whole-request type hangs paths off it: its origin, no /v1. */
+/** An address as a whole-request type hangs paths off it: its origin, no
+    path. A step's path is the whole path production called, so an address
+    entered with one (`…/v1/messages`) would send it twice. */
 function originBase(raw         )         {
-  let s = String(raw || "").trim().replace(/\/+$/, "");
+  let s = String(raw || "").trim();
   if (!s) return "";
   if (!/^https?:\/\//.test(s)) s = "https://" + s;
-  return s;
+  try { return new URL(s).origin; } catch { return s.replace(/\/+$/, ""); }
 }
 const wholeRequestsOnly = ()        => { throw new Error("an HTTP endpoint is sent an HTTP Request step's request, not a prompt"); };
 CONNECTION_TYPES.http = {
@@ -2230,9 +2276,14 @@ function splitOllama(p         )          {
  * connection carries its type's settings under `options`, so they are merged
  * up before the type reads them.
  */
-function connectionRequest(conn          , prompt        , dataUrl               , base        , key                )              {
+function connectionRequest(conn          , prompt        , dataUrl               , base        , key                ,
+                           schema                                 )              {
   const flat           = { ...conn, ...(conn?.options || {}) };
-  return typeEntry(flat).request(flat, prompt, dataUrl, base, key);
+  const type = typeEntry(flat);
+  // A setting the model refuses is not sent, whatever the profile holds.
+  for (const s of type.settings) if (s.appliesTo && !s.appliesTo(flat)) delete flat[s.key];
+  const req = type.request(flat, prompt, dataUrl, base, key);
+  return schema && type.structured ? { ...req, body: type.structured(req.body                           , schema) } : req;
 }
 
 /** Where [conn]'s requests hang off: its type's own reading of its address,
@@ -2934,6 +2985,15 @@ function registerKinds(k       )       {
                                                                          
                                                      
                                                   
+                                                                              
+                                                                             
+                                                                           
+                                                                           
+                                                                       
+                                                           
+                                                                            
+                                                    
+                                       
  
 
 function pluginHost(pluginId        )             {
@@ -2961,6 +3021,14 @@ function pluginHost(pluginId        )             {
       taken(CONNECTION_TYPES, "connection type", [t.id]);
       CONNECTION_TYPES[t.id] = t;
     },
+    registerWorkflowPlatform(t) {
+      taken(WORKFLOW_PLATFORMS, "workflow platform", [t.id]);
+      WORKFLOW_PLATFORMS[t.id] = t;
+    },
+    registerWizard(w) {
+      taken(WIZARDS, "wizard", [w.id]);
+      WIZARDS[w.id] = w;
+    },
   };
 }
 
@@ -3058,6 +3126,13 @@ function withSlugs                                              (list
 /** Whether [s] is a slug as a profile may hold one. */
 const isSlug = (s         )              => isStr(s) && SLUG.test(s) && s.length <= SLUG_MAX;
 
+/** Where [p] connects: its address, or blank, its type's own -- an Anthropic
+    profile left blank reaches Anthropic. Blank for a type with none means the
+    lab's own Ollama, which the runner and the relay fill in. */
+function addressOf(p                                   )         {
+  return String(p.url ?? "").trim() || CONNECTION_TYPES[typeOf(p            )]?.url || "";
+}
+
 /** A stored profile as a run carries it: its request settings, no key. */
 function connectionOf(p         )             {
   const type = typeOf(p);
@@ -3066,7 +3141,7 @@ function connectionOf(p         )             {
   // temperature is a common field, carried at the top like px/format/quality;
   // the options bag holds the type's own settings only.
   for (const k of settings) if (k !== "temperature" && String(p[k] ?? "").trim()) options[k] = p[k];
-  const out             = { name: p.name || "unnamed", url: p.url || "", model: p.model || "", type };
+  const out             = { name: p.name || "unnamed", url: addressOf(p), model: p.model || "", type };
   if (isSlug(p.slug)) out.slug = p.slug;
   for (const k of ["px", "format", "quality"]         ) if (p[k] != null && p[k] !== "") out[k] = p[k]             ;
   if (String(p.temperature ?? "").trim()) out.temperature = p.temperature                   ;
@@ -3187,6 +3262,70 @@ WORKFLOW_PLATFORMS["power-automate"] = {   // platform: the Power Automate adapt
   render: body => JSON.stringify(body, null, 2),
 };
 
+// ---- Setup Wizards (docs/workflow-sources.md § Wizards) ---------------------
+//
+// A wizard is a registry entry whose steps each say where they happen and a
+// done-when predicate on lab state. Steps tick automatically: `done(lab)` reads
+// the cheap state the page already holds (a workflow Source exists, a pipeline
+// with a Recorded target exists, a run of it is in History), never a poll. One
+// wizard runs at a time, held in the browser-only `promptlab.wizard` store; a
+// header pill shows its progress and the Setup › Wizards section draws the same
+// walk-through. The registry lives here so a plugin registers a wizard through
+// the same host as every other kind (PluginHost.registerWizard, phase 7); the
+// page ships the built-in "Test a workflow" and owns its routes and selectors
+// (web/src/app/wizards.ts). The predicates run with the page's privileges and
+// only read lab state, so a plugin wizard is no new trust (docs/packs.md).
+
+/** The slice of lab state a wizard step's `done` reads: what the page already
+    holds, so a tick costs a predicate and not a request. A reader names a field
+    it needs; a wizard that reads more declares it here. */
+                           
+                                               
+                                                         
+                                                                     
+                                           
+                                                                    
+                                                           
+                                                                     
+                                                           
+ 
+
+                             
+             
+                
+                                                                            
+                 
+                                                                   
+                                                                             
+                
+                                                                             
+                                                                       
+                 
+                                                                    
+                               
+ 
+
+                              
+             
+                
+                                                                      
+                
+                               
+ 
+
+const WIZARDS                              = Object.create(null);
+
+/** How far a wizard has got on [lab]: each step's tick, how many are done, and
+    the first step not yet done -- the one the checklist marks current and Go
+    to step heads for. `current` is -1 once every step is done. */
+function wizardProgress(entry             , lab          )   
+                                                                 
+  {
+  const ticks = entry.steps.map((s) => s.done(lab));
+  const done = ticks.filter(Boolean).length;
+  return { ticks, done, total: entry.steps.length, current: ticks.findIndex((t) => !t) };
+}
+
 CONTENT_TYPES.source = {
   label: "Source",
   description: "Every file or record in a Source from the Library.",
@@ -3364,6 +3503,7 @@ function metricInput(res                    , kase             , more          )
   const last = res.transcript?.at(-1);
   const text = last?.got ?? res.raw ?? "";
   return { text, said: last?.said ?? null, terms: res.terms ?? [], replies: [text], plain: !!more.plain,
+           asked: last?.sent ?? null,
            // A case that has been given its own expected reply ("Take B as
            // expected") is compared with that; otherwise the Source's recorded
            // reply for the item.
@@ -3382,7 +3522,7 @@ function runInput(ress                                       , plain         )
     terms.push(...(r.terms || []));
     ms += r.ms ?? 0;
   }
-  return { text: replies.join("\n"), said: null, terms, replies, plain, error: null, ms, recorded: null, kase: null };
+  return { text: replies.join("\n"), said: null, terms, replies, plain, error: null, ms, recorded: null, asked: null, kase: null };
 }
 
 /** One metric's reading of [input]: `of`, `not` and a failure all applied,
@@ -3643,16 +3783,21 @@ EVAL_TYPES.group = {
     want: [m.not ? "not" : "", metricSummary(m), typeof m.weight === "number" && m.weight !== 1 ? `×${m.weight}` : ""]
       .filter(Boolean).join(" ") })),
   profiles: t => (isObj(t.own) && isRef(t.own.grader) ? [t.own.grader] : isRef(t.grader) ? [t.grader] : []),
-  // A run carries the lab's grader where the group names none and may ask
-  // one: a model-graded metric of its own, or a case's. A link's group is
-  // the Library's, so the run's copy of the link carries it.
+  // A run carries the grader each group asks, so its profile goes with the
+  // run: a link's is the Library group's own, or the lab's where it names
+  // none -- the run's copy of the link carries it. A private group takes the
+  // lab's where it names none and may ask one: a model-graded metric of its
+  // own, or a case's.
   resolve(t, ctx){
-    if (!isRef(ctx.grader)) return t;
-    const grader = { id: ctx.grader.id, name: ctx.grader.name };
+    const ref = (g         )             => (isRef(g) ? { id: g.id, name: g.name } : null);
+    const lab = ref(ctx.grader);
     if (isObj(t.own)) {
-      return !isRef(t.own.grader) && (gradedIn(t.own.every) || isRef(t.own.casesFrom)) ? { ...t, own: { ...t.own, grader } } : t;
+      return lab && !isRef(t.own.grader) && (gradedIn(t.own.every) || isRef(t.own.casesFrom))
+        ? { ...t, own: { ...t.own, grader: lab } } : t;
     }
-    return isRef(t.group) && !isRef(t.grader) ? { ...t, grader } : t;
+    if (!isRef(t.group) || isRef(t.grader)) return t;
+    const grader = ref(ctx.groups?.find(g => g.id === (t.group       ).id)?.grader) ?? lab;
+    return grader ? { ...t, grader } : t;
   },
   wholeRun: wholeRunGroup,
   verdict: (t, ress, kind) => {
@@ -3849,6 +3994,9 @@ function metricSummary(m        )         {
     const v = m[o.key];
     if (o.type === "select") return o.choices.find(c => c.value === v)?.label ?? "";
     if (o.type === "checkbox") return !!v === !!fresh[o.key] ? "" : v ? o.label.toLowerCase() : `${o.label.toLowerCase()} off`;
+    // The choices ticked, by their labels, where they are not a new one's.
+    if (o.type === "multi") return !Array.isArray(v) || JSON.stringify(v) === JSON.stringify(fresh[o.key]) ? ""
+      : o.choices.filter(c => v.includes(c.value)).map(c => c.label).join(" or ");
     // 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);
@@ -4014,7 +4162,7 @@ STEP_TYPES.echo = {
 // the flow reads one. No profile, no prompt -- the record is the reply.
 STEP_TYPES.recorded = {
   label: "Recorded", slot: "target", asks: "nothing", local: true, replaces: "recorded",
-  description: "Replays the reply production recorded for each call. Sends nothing.",
+  description: "Answers each call with the reply it got when it was recorded. Sends nothing.",
   firstJobOnly: "a call's recorded reply is job 1's",
   in: "item", out: "text",
   apply: "runPipeline",
@@ -5342,7 +5490,8 @@ function exportBundle(doc          , ctx
   // What the lab would supply at submit, written down: no lab supplies it later.
   const out = clone(doc)             ;
   out.evals = (Array.isArray(out.evals) ? out.evals : [])
-    .map((t           ) => EVAL_TYPES[t?.type]?.resolve?.(t, { grader: ctx.grader ?? null }) ?? t);
+    .map((t           ) => EVAL_TYPES[t?.type]?.resolve?.(t, { grader: ctx.grader ?? null,
+      groups: Object.entries(ctx.datasets ?? {}).map(([id, d]) => ({ id, name: d.name, grader: d.body.grader ?? null })) }) ?? t);
   const table                           = {};
   for (const id of profileIds(out)) {
     const p = profiles.find(x => x.id === id);
@@ -5883,8 +6032,8 @@ export {
     scoreSingle, singleRules, parseCount, lengthHolds, countHolds, COUNT_OPS, LENGTH_OPS,
     COUNT_OP_LABEL, LENGTH_OP_LABEL,
     PIPELINE_VERSION, DATASET_BODY_VERSION, STEP_TYPES, CONTENT_TYPES, OUTPUT_KINDS, MODIFIERS, EVAL_TYPES, LEGACY_TESTS, METRICS, readMetrics, metricSummary, itemScoresAsync, recordedReplyOf,
-    SOURCE_TYPES, DEFAULT_SOURCE_TYPE, sourceTypeOf, WORKFLOW_PLATFORMS, platformOf,
-    registerKinds, defaultKind, jobDefaults, applyModifiers, keyVar, slugOf, uniqueSlug, isSlug, withSlugs, SLUG_MAX, connectionOf, connectionSettings,
+    SOURCE_TYPES, DEFAULT_SOURCE_TYPE, sourceTypeOf, WORKFLOW_PLATFORMS, platformOf, WIZARDS, wizardProgress,
+    registerKinds, defaultKind, jobDefaults, applyModifiers, keyVar, slugOf, uniqueSlug, isSlug, withSlugs, SLUG_MAX, connectionOf, addressOf, connectionSettings,
     connectionRequest, connectionBase, connectionSend, connectionReply, connectionReplyProblem, connectionImage, connectionProblems,
 CONNECTION_FIELDS, SETTING_KEYS, OPTION_FIELDS, jobLabel, scenarioLabel, jobWords, versionProblem,
     contentOf, withContent, replyOf,