evals-lab 0.13.0 → 0.15.0

package/lab/kinds/list.mjs

@@ -87,7 +87,7 @@ const inRange = (b       ) => (v        ) =>
 /** The stateless predicates an item matcher takes, on the item alone. */
 export const MATCHER_KEYS = ["terms", "regex", "length", "words", "tokens", "digitShare"]         ;
 
-/** Every condition a Drop item (and a Rewrite item's limit) may hold: the
+/** Every condition a Remove of the items that match may hold: the
     stateless matcher keys, and the two that read the item in context --
     `duplicate` (a case-insensitive repeat of one kept earlier in this pass)
     and `echoes` (made only of the stage instruction's words), #405. */
@@ -225,29 +225,25 @@ export function tryExamples(rule          , scope                   )
 // ---- filters: the generic reply filter (issue #335) ----------------------------
 //
 // A Filter is the reusable unit #334 introduces: it supersedes the inline
-// ItemRule a Drop items or Reject the answer modifier carries today. Where a
-// rule was a bare matcher with examples, a filter has a base TYPE from a
-// registry (not an enum) -- "drop-item" cleans each item of a list reply,
-// "reject-reply" gates the whole answer -- generic conditions reusing the
-// matcher above (ANDed), Options, and Tests that are its own checks. The two
-// base types evaluate here, beside the matcher and rejectHolds they are built
-// from; the Library-stored filter-set body, the pipeline link that carries
-// one, and their version live in evals-core.ts, as DatasetBody and the
-// eval-group link do. Nothing here replaces the Drop items / Reject modifiers:
-// Runs wires a filter set into Responses and migrates the inline rules in a
-// later phase (#339), so both base types and the ItemRule shape stand.
+// ItemRule a Drop items or Reject the answer modifier carried. Where a rule
+// was a bare matcher with examples, a filter has a base TYPE from a registry
+// (not an enum) -- one of seven verbs (#615) -- generic conditions reusing the
+// matcher above (ANDed), Options, and Tests that are its own checks. The verbs
+// evaluate here, beside the matcher they are built from; the Library-stored
+// filter-set body, the pipeline link that carries one, and their version live
+// in evals-core.ts, as DatasetBody and the eval-group link do.
 
 /** How a filter test splits its sample reply into items: by the named
     delimiter and always by newline, as a run's parse does. "none" keeps the
-    reply whole, for a reject-reply filter that reads the text. */
+    reply whole: a test of the filter on a reply's text. */
 export const FILTER_SEPARATORS = ["comma", "lines", "semicolon", "none"]         ;
                                                                  
 
 /** A sample reply and what the filter should leave of it: the editor splits
     the sample by `separator`, applies the filter, and shows whether the result
-    reads as `expectedOutput`. A drop-item filter's expected output is the
-    items it keeps; a reject-reply filter's is blank when the reply should be
-    rejected, or left non-blank when it should pass. */
+    reads as `expectedOutput`: the items or text it leaves, or for a Reject,
+    blank when the reply should be rejected and anything else when it should
+    pass. */
                              
                              
                       
@@ -261,31 +257,35 @@ export const FILTER_SEPARATORS = ["comma", "lines", "semicolon", "none"]
                  
  
 
-/** A filter (issue #335, #405): a base TYPE fixed at creation (a FILTER_TYPES
-    id), generic conditions in `match` (the matcher's keys for its type, ANDed),
-    an optional `op` carrying the type's own operation (Rewrite's and Keep
-    first's -- Drop item and the rejects hold none), Options and Tests. `id` is
-    its name, as an ItemRule's was. */
+/** A filter (issue #335, #615): a base TYPE fixed at creation -- one of the
+    FILTER_TYPES verbs -- generic conditions in `match` (the matcher's keys
+    for its type, ANDed), an optional `op` carrying the verb's own settings,
+    Options and Tests. `id` is its name, as an ItemRule's was. */
                          
              
                
                
                                  
-                                                                              
-                                                                            
-                                                                              
-                                           
+                                                                             
+                                                                         
+                                                                                 
                                
                          
                       
  
 
-/** What a filter works over: the text the reply came as (which a text-scope
-    filter rewrites, and the items are parsed from), the items parsed from it,
-    and the stage's instruction a filter may read (an item that echoes it). */
+/** What a filter runs on (#615): the reply's `text` -- above a format that
+    reads items, or anywhere in a job whose format reads text -- or each of
+    its `items`, below a format that reads them. A text reply is a list of one
+    item, so every verb means the same on either. */
+                                        
+
+/** What a filter works over: the text the reply came as (which a filter on
+    the text rewrites, and the items are parsed from), the items parsed from
+    it, and the stage's instruction a filter may read (an item that echoes it). */
                                                                                    
 
-/** What applying a filter or a set left: the reply text (a Rewrite text filter
+/** What applying a filter or a set left: the reply text (a filter on the text
     changes it), the items kept, what was dropped and by which filter, and --
     the first filter that rejected -- the reply's rejection (null when none). */
                                 
@@ -293,92 +293,198 @@ export const FILTER_SEPARATORS = ["comma", "lines", "semicolon", "none"]
                                                                             
                                         
                    
-                                                                         
+                                                                    
                      
  
 
-/** A base filter type (#334's decision: a registry, not an enum). A reader
-    asks the entry by `filter.type`; nothing branches on the id. */
+/** A base filter type: a verb (#334's decision: a registry, not an enum; #615
+    made them seven verbs). A reader asks the entry by `filter.type`; nothing
+    branches on the id. */
                                   
-                                                
+                                             
                 
-                                                                           
+                                                                  
                  
-                                                                           
-                                                                           
-                                                                       
+                                                                 
                 
-                                             
+                                                                                 
+                                                                             
+                                                     
+                                       
                                                                             
                                                                     
                                 
+                                                                            
+                                                  
+                                                                 
                                                                              
                                                                    
                     
+                                                                           
+                                                                     
+                                                                       
+                                                                                  
+                                                                               
+                                
+                                                     
+                                                                            
+                                                                              
+                                                                     
+                                     
                                                                             
                                                                             
                                                     
                                                                              
+                                                                           
+                                                                             
+                      
                                                                          
-                                                                    
-                                                           
  
 
-/** The whole-answer conditions a Reject text filter reads over the raw text:
-    `blank`, and `regex` searched anywhere in it (unanchored, case-insensitive
-    -- a text reject looks for a phrase, not a whole-string match). */
-function rejectTextHolds(m                         , text        )          {
+/** Whether a reply whose text is [body] and items are [items] meets Reject's
+    conditions [m]: `blank` (the text is blank), `regex` (searched anywhere in
+    the text, case-insensitive -- a reject looks for a phrase, not a whole
+    string), `itemCount`, and the `share` of the items `items` matches. Every
+    one given must hold; one that states none never fires. */
+function rejectFires(m                         , body        , items                   )          {
   const conds            = [];
-  if (m.blank === true) conds.push(!text.trim());
-  if (typeof m.regex === "string") { const r = m.regex; let re               ; try { re = new RegExp(r, "i"); } catch { re = null; } conds.push(!!re && re.test(text)); }
+  if (m.blank === true) conds.push(!body.trim());
+  if (typeof m.regex === "string") { let re               ; try { re = new RegExp(m.regex, "i"); } catch { re = null; } conds.push(!!re && re.test(body)); }
+  if (m.itemCount && typeof m.itemCount === "object") conds.push(inRange(m.itemCount         )(items.length));
+  if (m.share && typeof m.share === "object") {
+    const test = matcher(m.items                           );
+    // A share with nothing to measure cannot fire.
+    conds.push(!!test && inRange(m.share         )(items.length ? items.filter(t => test(t)).length / items.length : 0));
+  }
   return conds.length > 0 && conds.every(Boolean);
 }
 
-/** The function a Rewrite item filter's `op` names: Tidy, or Case in its
-    mode. An unknown op leaves the item as it is. */
-function rewriteItem(op                                     )                           {
-  if (op?.kind === "tidy") return tidy;
-  if (op?.kind === "case") { const mode = op.mode          ; return t => applyCase(t, mode); }
-  return t => t;
-}
-
-/** The function a Rewrite text filter's `op` names: Remove thinking, Remove
-    preamble, or Replace pattern (a regex, global, and its replacement). An
-    unknown op leaves the text as it is; a pattern that will not compile throws,
-    so Ignore failures can carry a run past it. */
-function rewriteText(op                                     )                           {
-  if (op?.kind === "thinking") return removeThinking;
-  if (op?.kind === "preamble") return removePreamble;
-  if (op?.kind === "replace") {
-    const re = new RegExp(String(op.pattern ?? ""), "g");
-    const to = typeof op.replacement === "string" ? op.replacement : "";
-    return text => text.replace(re, to);
+/** A reply's text as the one item it is (#615): none when it is blank. */
+const oneItem = (body        )           => (body.trim() ? [body.trim()] : []);
+
+/** A verb that changes one piece of text at a time, applied to [reply]: to
+    its text, or to each item its `match` limits it to (none: every one). Run
+    on the text, a [change] that leaves nothing (null) rejects the reply, as an
+    Extract that matched nothing always has; run on the items, the item goes,
+    as does one it leaves blank (as Tidy always dropped one it emptied). */
+function eachPiece(filter        , reply             , on          , change                                 )                {
+  const test = matcher(filter.match);
+  if (on === "text") {
+    if (test && !test(reply.body)) return outcome(reply);
+    const body = change(reply.body);
+    return { body: body ?? reply.body, items: reply.items, dropped: [], reject: body == null ? filter.id : null };
   }
-  return text => text;
+  const items           = [], dropped            = [];
+  for (const t of reply.items) {
+    const next = !test || test(t) ? change(t) : t;
+    if (next == null) dropped.push({ item: t, by: filter.id });
+    else if (next) items.push(next);
+  }
+  return { body: reply.body, items, dropped, reject: null };
 }
 
-/** The lab's base filter types (#405). Generic code asks this registry by
-    `filter.type`; it never names an id. `rewrite-text`/`reject-text` read the
-    raw reply before it is read into items (the Pre-format stage); the rest
-    read the items after (the Post-format stage). */
+/** One item as Trim with bullets leaves it (tidy); a text, each line so. */
+const tidyLines = (text        )         => text.split("\n").map(tidy).filter(Boolean).join("\n");
+
+/** What Remove takes out of a piece of text, by its `kind`: a thinking
+    block, a preamble, code fences. "items" is Remove's own reading of its
+    matcher, not a rewrite. */
+const REMOVALS                                           = {
+  thinking: removeThinking,
+  preamble: removePreamble,
+  // A fence's own lines go -- the opening one with its language, and the
+  // closing one -- wherever they sit, so a reply fenced whole or a fence
+  // after a line of preamble both read as what was inside.
+  fences: text => text.replace(FENCE_LINE, ""),
+};
+
+const FENCE_LINE = /^[ \t]*```[^`\n]*(?:\n|$)/gm;
+
+/** Keep first's units. */
+const KEEP_UNITS = [{ value: "items", label: "Items" }, { value: "lines", label: "Lines" }, { value: "chars", label: "Characters" }];
+
+/** Why a pattern does not compile, as a sentence, or none. */
+const patternProblems = (pattern         , at        )           => {
+  if (typeof pattern !== "string" || !pattern) return [`${at} needs a pattern`];
+  try { new RegExp(pattern); return []; } catch { return [`${at}'s pattern does not compile`]; }
+};
+
+const caseProblems = (op                                     , at        )           =>
+  (CASE_MODES.includes(op?.mode          ) ? [] : [`${at}'s case needs a mode`]);
+
+/** The lab's base filter types: seven verbs (#615), A to Z. Generic code asks
+    this registry by `filter.type`; it never names an id. Where a filter runs
+    -- on the text or on each item -- is its place in the list, around the
+    job's Response Format, never its type. */
 export const FILTER_TYPES                                  = {
-  "rewrite-text": {
-    label: "Rewrite text", about: "Remove thinking, a preamble or a pattern from the reply's text.", scope: "text", conditions: [],
-    opProblems: (f, at) => opKindProblems(f.op, at, {
-      thinking: [], preamble: [], replace: ["pattern", "replacement"],
-    }),
-    apply: (filter, reply) => ({ body: rewriteText(filter.op)(reply.body), items: reply.items, dropped: [], reject: null }),
+  "change-case": {
+    label: "Change case", about: "Lower, upper, sentence or title case.", icon: "a-large-small",
+    matches: "limit", conditions: MATCHER_KEYS,
+    defaultOp: () => ({ mode: "LOWER" }),
+    opProblems: (f, at) => [...caseProblems(f.op, at), ...extraOpKeys(f.op, ["mode"], at)],
+    apply: (filter, reply, on) => eachPiece(filter, reply, on, t => applyCase(t, filter.op?.mode          )),
+  },
+  "extract": {
+    label: "Extract", about: "The first match of a pattern.", icon: "scan-search",
+    conditions: [], rawReply: () => true,
+    defaultOp: () => ({ pattern: "" }),
+    opProblems: (f, at) => [...patternProblems(f.op?.pattern, at), ...extraOpKeys(f.op, ["pattern"], at)],
+    apply(filter, reply, on) {
+      // The first match, or its first group if it has one; none, nothing left.
+      const re = new RegExp(String(filter.op?.pattern ?? ""));
+      return eachPiece(filter, reply, on, t => { const m = re.exec(t); return m ? (m.length > 1 ? m[1] ?? "" : m[0]) : null; });
+    },
+  },
+  "keep-first": {
+    label: "Keep first", about: "The first N items, lines or characters.", icon: "text-search",
+    conditions: [], choices: { unit: KEEP_UNITS },
+    defaultOp: () => ({ n: 10, unit: "items" }),
+    opProblems: (f, at) => [
+      ...(Number.isInteger(f.op?.n) && (f.op .n          ) >= 1 ? [] : [`${at} needs a whole number of 1 or more`]),
+      ...(KEEP_UNITS.some(u => u.value === f.op?.unit) ? [] : [`${at} keeps items, lines or characters`]),
+      ...extraOpKeys(f.op, ["n", "unit"], at)],
+    apply(filter, reply, on) {
+      const n = filter.op?.n          ;
+      if (filter.op?.unit === "items") {
+        // A text is one item, which the first N always keep.
+        if (on === "text") return outcome(reply);
+        return { body: reply.body, items: reply.items.slice(0, n), dropped: reply.items.slice(n).map(t => ({ item: t, by: pastN(n) })), reject: null };
+      }
+      return eachPiece(filter, reply, on, filter.op?.unit === "chars" ? t => t.slice(0, n) : t => t.split("\n").slice(0, n).join("\n"));
+    },
   },
-  "reject-text": {
-    label: "Reject text", about: "Discard the reply when it is blank or matches a pattern.", scope: "text", conditions: ["blank", "regex"], rejects: true,
-    apply: (filter, reply) => ({ body: reply.body, items: reply.items, dropped: [], reject: rejectTextHolds(filter.match, reply.body) ? filter.id : null }),
+  "reject": {
+    label: "Reject", about: "Discard the reply when it matches its conditions.", icon: "trash",
+    matches: "reply", conditions: ["blank", "regex", "itemCount", "share", "items"], rejects: true,
+    apply: (filter, reply, on) => ({ body: reply.body, items: reply.items, dropped: [],
+      reject: rejectFires(filter.match, reply.body, on === "text" ? oneItem(reply.body) : reply.items) ? filter.id : null }),
   },
-  "drop-item": {
-    label: "Drop item", about: "Remove the items that match its conditions.", scope: "item", conditions: ITEM_CONDITIONS,
-    apply(filter, reply) {
+  "remove": {
+    label: "Remove", about: "A thinking block, a preamble, code fences, or the items that match.", icon: "eraser",
+    matches: "item", conditions: ITEM_CONDITIONS,
+    kinds: [
+      { kind: "thinking", label: "Thinking block", about: "A <think>…</think> block" },
+      { kind: "preamble", label: "Preamble", about: "Everything up to the first colon" },
+      { kind: "fences", label: "Code fences", about: "Each ``` line, keeping what it fences" },
+      { kind: "items", label: "Items that match" },
+    ],
+    defaultOp: (kind = "items") => ({ kind }),
+    matchesWith: op => op?.kind === "items",
+    rawReply: f => f.op?.kind !== "items",
+    opProblems(f, at) {
+      const kind = f.op?.kind          ;
+      if (kind !== "items" && !(kind in REMOVALS)) return [`${at} has nothing to remove`];
+      return [...extraOpKeys(f.op, ["kind"], at),
+              ...(kind !== "items" && Object.keys(f.match ?? {}).length ? [`${at} takes no conditions`] : [])];
+    },
+    apply(filter, reply, on) {
+      const kind = filter.op?.kind          ;
+      if (kind !== "items") return eachPiece({ ...filter, match: {} }, reply, on, REMOVALS[kind] ?? (t => t));
       const test = matcher(filter.match);
       if (!test) return outcome(reply);
       const said = reply.instruction && reply.instruction.trim() ? new Set(words(reply.instruction)) : new Set        ();
+      // A text is one item: matched, nothing of it is left.
+      if (on === "text") return test(reply.body, { seen: new Set(), said }) ? { ...outcome(reply), body: "" } : outcome(reply);
       const seen = new Set        ();
       const items           = [], dropped            = [];
       for (const t of reply.items) {
@@ -388,58 +494,61 @@ export const FILTER_TYPES                                  = {
       return { body: reply.body, items, dropped, reject: null };
     },
   },
-  "rewrite-item": {
-    label: "Rewrite item", about: "Tidy each item, or change its case.", scope: "item", conditions: MATCHER_KEYS,
-    opProblems: (f, at) => opKindProblems(f.op, at, { tidy: [], case: ["mode"] }, op =>
-      op.kind === "case" && !CASE_MODES.includes(op.mode          ) ? [`${at}'s case needs a mode`] : []),
-    apply(filter, reply) {
-      const test = matcher(filter.match);
-      const rewrite = rewriteItem(filter.op);
-      // Only matched items are rewritten; a blank result is dropped, as Tidy
-      // has always dropped an item it emptied.
-      const items = reply.items.map(t => (!test || test(t) ? rewrite(t) : t)).filter(Boolean);
-      return { body: reply.body, items, dropped: [], reject: null };
+  "replace": {
+    label: "Replace", about: "Text or a pattern, with other text.", icon: "replace",
+    conditions: [],
+    kinds: [
+      { kind: "text", label: "Text", about: "Every occurrence, matched exactly" },
+      { kind: "pattern", label: "Pattern", about: "Every match of a regular expression" },
+    ],
+    defaultOp: (kind = "text") => (kind === "pattern" ? { kind, pattern: "", replacement: "" } : { kind, find: "", replacement: "" }),
+    opProblems(f, at) {
+      const op = f.op;
+      if (op?.kind === "text") {
+        return [...(typeof op.find === "string" && op.find ? [] : [`${at} needs text to find`]),
+                ...extraOpKeys(op, ["kind", "find", "replacement"], at)];
+      }
+      if (op?.kind === "pattern") return [...patternProblems(op.pattern, at), ...extraOpKeys(op, ["kind", "pattern", "replacement"], at)];
+      return [`${at} replaces text or a pattern`];
     },
-  },
-  "keep-first": {
-    label: "Keep first", about: "Keep the first N items.", scope: "list", conditions: [],
-    opProblems: (f, at) => (Number.isInteger(f.op?.n) && (f.op .n          ) >= 1
-      ? extraOpKeys(f.op, ["n"], at) : [`${at} needs a whole number of 1 or more`]),
-    apply(filter, reply) {
-      const n = filter.op?.n          ;
-      return { body: reply.body, items: reply.items.slice(0, n), dropped: reply.items.slice(n).map(t => ({ item: t, by: pastN(n) })), reject: null };
+    apply(filter, reply, on) {
+      const op = filter.op ?? {};
+      const to = typeof op.replacement === "string" ? op.replacement : "";
+      if (op.kind === "pattern") {
+        const re = new RegExp(String(op.pattern ?? ""), "g");
+        return eachPiece(filter, reply, on, t => t.replace(re, to));
+      }
+      const find = String(op.find ?? "");
+      return eachPiece(filter, reply, on, t => (find ? t.split(find).join(to) : t));
     },
   },
-  "reject-reply": {
-    label: "Reject reply", about: "Discard the whole reply when its items match its conditions.", scope: "answer", conditions: ["blank", "itemCount", "share", "items"], rejects: true,
-    apply: (filter, reply) => ({ body: reply.body, items: reply.items, dropped: [], reject: rejectHolds(filter.match, reply.body, reply.items) ? filter.id : null }),
+  "trim": {
+    label: "Trim", about: "Whitespace and blank lines, and bullets and numbering if you choose.", icon: "scissors",
+    matches: "limit", conditions: MATCHER_KEYS,
+    defaultOp: () => ({ bullets: false }),
+    opProblems: (f, at) => [...(typeof f.op?.bullets === "boolean" ? [] : [`${at}'s bullets has to be true or false`]),
+                            ...extraOpKeys(f.op, ["bullets"], at)],
+    // With bullets, an item is tidied -- its bullet, numbering, stray quotes
+    // and stops gone, its spaces collapsed -- and a text each of its lines.
+    apply: (filter, reply, on) => eachPiece(filter, reply, on,
+      filter.op?.bullets ? (on === "text" ? tidyLines : tidy) : t => t.trim()),
   },
 };
 
 /** The reply unchanged -- a filter that matches nothing. */
 const outcome = (reply             )                => ({ body: reply.body, items: reply.items, dropped: [], reject: null });
 
-/** Why [op]'s `kind` is not one of [kinds] (and its extra keys beyond that
-    kind's), one sentence each. [more] adds a kind's own checks. */
-function opKindProblems(op                                     , at        ,
-    kinds                                   , more                                            )           {
-  if (!op || typeof op !== "object" || Array.isArray(op)) return [`${at} has no operation`];
-  const kind = op.kind          ;
-  if (typeof kind !== "string" || !(kind in kinds)) return [`${at}'s operation is not one this filter has`];
-  return [...extraOpKeys(op, ["kind", ...kinds[kind] ], at), ...(more ? more(op) : [])];
-}
-
 /** Why [op] holds a key that is not [allowed], one sentence each. */
 function extraOpKeys(op                                     , allowed                   , at        )           {
   return op ? Object.keys(op).filter(k => !allowed.includes(k)).map(k => `${at} has "${k}", which is not one of its settings`) : [];
 }
 
-/** Apply one filter to [reply], honouring its Options: `repeat` passes over
-    the reply (a filter that rejects stops at the first that fires), and
-    `ignoreFailures` leaves the reply as it was if the filter errors -- a
-    condition or pattern that cannot be read -- rather than failing the run.
-    Pure. */
-export function applyFilter(filter        , reply             )                {
+/** Apply one filter to [reply] [on] its text or its items, honouring its
+    Options: `repeat` passes over the reply (a filter that rejects stops at the
+    first that fires), and `ignoreFailures` leaves the reply as it was if the
+    filter errors -- a condition or pattern that cannot be read -- rather than
+    failing the run. Pure. */
+export function applyFilter(filter        , reply             , on           = "items")                {
   const entry = FILTER_TYPES[filter.type];
   if (!entry) return outcome(reply);
   const passes = Number.isInteger(filter.options?.repeat) && filter.options.repeat > 0 ? filter.options.repeat : 1;
@@ -449,7 +558,7 @@ export function applyFilter(filter        , reply             )                {
   let reject                = null;
   for (let pass = 0; pass < passes && reject == null; pass++) {
     try {
-      const out = entry.apply(filter, { body, items, instruction });
+      const out = entry.apply(filter, { body, items, instruction }, on);
       body = out.body;
       items = out.items;
       dropped.push(...out.dropped);
@@ -464,21 +573,17 @@ export function applyFilter(filter        , reply             )                {
   return { body, items, dropped, reject };
 }
 
-/** Apply a filter set's filters to [reply], in order: a Rewrite text filter
-    reshapes the text the next reads, each item filter narrows or rewrites the
-    items, and the first filter that rejects gates the answer and stops the
-    rest. Given a [stage], only the filters whose type runs there apply: a set
-    belongs to no stage (#432), so one linked both Pre-format and Post-format runs
-    its text filters on the raw reply and the rest on the items. Pure. */
-export function applyFilterSet(filters                   , reply             , stage                   )                {
+/** Apply [filters] to [reply] in order, [on] its text or its items (#615:
+    where they sit around the job's Response Format, never their type): each
+    reshapes the text or narrows the items the next reads, and the first that
+    rejects gates the answer and stops the rest. Pure. */
+export function applyFilterSet(filters                   , reply             , on           = "items")                {
   const instruction = reply.instruction ?? "";
   let body = reply.body, items = reply.items;
   const dropped            = [], rewrote           = [];
   let emptied                    ;
   for (const filter of filters) {
-    const scope = FILTER_TYPES[filter.type]?.scope;
-    if (stage && scope && (scope === "text") !== (stage === "text")) continue;
-    const out = applyFilter(filter, { body, items, instruction });
+    const out = applyFilter(filter, { body, items, instruction }, on);
     if (out.body !== body) rewrote.push(filter.id);
     body = out.body;
     if (items.length && !out.items.length) emptied = filter.id;
@@ -504,24 +609,26 @@ export function splitSample(sample        , separator                 )
   return parts.map(s => s.trim()).filter(Boolean);
 }
 
-/** Each of [filter]'s tests, tried against the filter alone: the sample read
-    the way the filter's scope reads it, the filter applied, and the result
-    compared with the expected output. A rejecting filter passes when the reply
-    is rejected exactly if the expected output is blank; a Rewrite text filter
-    when the text it leaves reads as the expected text; an item or list filter
-    when the items it keeps read as the expected items. */
+/** Each of [filter]'s tests, tried against the filter alone. A test's
+    separator says what its sample is: "none" a reply's text, which the filter
+    runs on as text; any other, items, which it runs on each of. A rejecting
+    filter passes when the reply is rejected exactly if the expected output is
+    blank; on the text, when the text it leaves reads as the expected text (or,
+    where it rejects, the expected output is blank); on items, when the items
+    it keeps read as the expected items. */
 export function tryFilter(filter        )                                                   {
   const entry = FILTER_TYPES[filter.type];
-  const scope = entry?.scope ?? "item";
   return (filter.tests || []).map(test => {
-    // A text filter reads the whole sample; an item or list filter splits it.
-    const items = scope === "text" ? [] : splitSample(test.sampleInput, test.separator);
-    const out = applyFilter(filter, { body: test.sampleInput, items, instruction: "" });
+    const on           = test.separator === "none" ? "text" : "items";
+    const items = on === "text" ? [] : splitSample(test.sampleInput, test.separator);
+    const out = applyFilter(filter, { body: test.sampleInput, items, instruction: "" }, on);
     if (entry?.rejects) {
       const rejected = out.reject != null;
-      return { test, ok: rejected === !test.expectedOutput.trim(), got: rejected ? "rejected" : (scope === "text" ? out.body : out.items.join(", ")) };
+      return { test, ok: rejected === !test.expectedOutput.trim(), got: rejected ? "rejected" : (on === "text" ? out.body : out.items.join(", ")) };
     }
-    if (scope === "text") {
+    if (on === "text") {
+      // A filter on the text that rejects (Extract, matching nothing) leaves nothing.
+      if (out.reject != null) return { test, ok: !test.expectedOutput.trim(), got: "rejected" };
       const got = out.body.trim();
       return { test, ok: got === test.expectedOutput.trim(), got };
     }
@@ -558,7 +665,7 @@ const isObj = (v         )                               => !!v && typeof v ===
 
 /** Why [filters] are not a filter list the lab reads, one sentence each: each
     has a name, no name twice, a base type it has, whole-number repeat of 1 or
-    more, a boolean ignore-failures, conditions its type's scope takes, and an
+    more, a boolean ignore-failures, conditions its type takes, and an
     operation its type takes (or none, for a type with none). */
 export function filterProblems(filters         , at        )           {
   if (!Array.isArray(filters)) return [`${at}: filters has to be a list`];
@@ -577,25 +684,24 @@ export function filterProblems(filters         , at        )           {
       if (typeof o.ignoreFailures !== "boolean") bad.push(`${at}: ${id}'s ignore failures has to be true or false`);
     }
     bad.push(...filterMatchProblems(f.match, entry.conditions, at, id));
-    if (entry.opProblems) bad.push(...entry.opProblems(f, `${at}: ${id}`));
-    else if (f.op != null) bad.push(`${at}: ${id} takes no operation`);
+    if (entry.opProblems) {
+      bad.push(...(isObj(f.op) ? entry.opProblems(f, `${at}: ${id}`) : [`${at}: ${id} has no operation`]));
+    } else if (f.op != null) bad.push(`${at}: ${id} takes no operation`);
   }
   return bad;
 }
 
 /** The filter an inline ItemRule becomes (issue #335): its name, why and
-    matcher kept as they are, its base [type] the one the modifier carrying it
-    fixed ("drop-item" for Drop items, "reject-reply" for Reject the answer),
-    its Options the defaults, and its examples its tests -- a caught example
-    becomes a sample the filter should empty (drop-item) or reject
-    (reject-reply), a kept example one it should leave. Pure: the match is
-    carried unchanged, so the filter cleans a reply exactly as the rule did.
-    The only reader of the old shape, for Runs to migrate its inline rules
-    (#339). */
-export function filterFromItemRule(rule          , type        )         {
-  const scope = FILTER_TYPES[type]?.scope ?? "item";
+    matcher kept as they are, its verb the one the modifier carrying it fixed
+    -- Remove (its items that match) for Drop items, Reject for Reject the
+    answer -- its Options the defaults, and its examples its tests: a caught
+    example becomes a sample the filter should empty or reject, a kept example
+    one it should leave. Pure: the match is carried unchanged, so the filter
+    cleans a reply exactly as the rule did. The only reader of the old shape,
+    for Runs to migrate its inline rules (#339). */
+export function filterFromItemRule(rule          , type                     )         {
   const ex = rule.examples || {};
-  const caught = scope === "item" ? ex.drops || [] : ex.rejects || [];
+  const caught = type === "remove" ? ex.drops || [] : ex.rejects || [];
   const tests               = [
     ...caught.map((s)             => ({ separator: "comma", sampleInput: s, expectedOutput: "" })),
     ...(ex.keeps || []).map((s)             => ({ separator: "comma", sampleInput: s, expectedOutput: s })),
@@ -604,11 +710,59 @@ export function filterFromItemRule(rule          , type        )         {
     id: rule.id, type,
     ...(rule.why != null ? { why: rule.why } : {}),
     match: rule.match ? { ...rule.match } : {},
+    ...(type === "remove" ? { op: { kind: "items" } } : {}),
     options: { ignoreFailures: false, repeat: 1 },
     tests,
   };
 }
 
+/** A version-3 filter's types (#405's six), and whether each read the
+    reply's text (Pre-format, or after a format that reads text) or its items
+    (after a format that reads them). Only the upgrade to version 4 reads them. */
+export const V3_TEXT_TYPES                    = ["rewrite-text", "reject-text"];
+
+/** A version-3 filter as the version-4 verb that reads a reply exactly as it
+    did (#615): Rewrite text's operations each their verb (Remove thinking /
+    preamble / code fences a Remove, Replace text / pattern a Replace, Trim,
+    Change case, Keep first and Extract their own), Reject text and Reject
+    reply a Reject, Drop item a Remove of the items that match, Rewrite item's
+    Tidy a Trim with bullets and its Case a Change case (each keeping the items
+    it limits to), and Keep first a Keep first of items. A text filter's tests
+    read the sample whole ("none"), as a text filter's always did. A filter of
+    no version-3 type comes back as it was. Pure; server.py's filter_v4 is its
+    twin. */
+export function filterV4(f        )         {
+  if (!isObj(f)) return f;
+  const op = isObj(f.op) ? f.op : {};
+  const as = (type        , next                 )         => {
+    const { op: _op, ...rest } = f;
+    const out         = { ...rest, type, ...next }          ;
+    if (V3_TEXT_TYPES.includes(f.type) && Array.isArray(f.tests)) {
+      out.tests = f.tests.map(t => (isObj(t) ? { ...t, separator: "none"          } : t));
+    }
+    return out;
+  };
+  switch (f.type) {
+    case "rewrite-text":
+      switch (op.kind) {
+        case "thinking": case "preamble": case "fences": return as("remove", { op: { kind: op.kind } });
+        case "trim": return as("trim", { op: { bullets: false } });
+        case "literal": return as("replace", { op: { kind: "text", find: op.find, replacement: op.replacement ?? "" } });
+        case "replace": return as("replace", { op: { kind: "pattern", pattern: op.pattern, replacement: op.replacement ?? "" } });
+        case "case": return as("change-case", { op: { mode: op.mode } });
+        case "first": return as("keep-first", { op: { n: op.n, unit: op.unit } });
+        case "extract": return as("extract", { op: { pattern: op.pattern } });
+        default: return f;
+      }
+    case "reject-text": case "reject-reply": return as("reject", {});
+    case "drop-item": return as("remove", { op: { kind: "items" } });
+    case "rewrite-item":
+      return op.kind === "case" ? as("change-case", { op: { mode: op.mode } }) : as("trim", { op: { bullets: true } });
+    case "keep-first": return as("keep-first", { op: { n: op.n, unit: "items" } });
+    default: return f;
+  }
+}
+
 // ---- the modifiers -------------------------------------------------------------
 
 /** What an item's numbering looks like: "[1] suv", "(2) car", "3. dirt",
@@ -651,17 +805,17 @@ export function applyCase(item        , mode        )         {
   }
 }
 
-/** The id of the synthetic modifier a linked or private Post-format filter
-    set applies under at run time (#339, #405): it is never in a document or
-    the Add menu -- a job carries a `filters` step, which `stageModifiers`
-    turns into one of these where the step sits, so a set cleans and gates a
-    list reply exactly as it reads. The Pre-format (text) stage runs its
-    filters on the raw reply before it is read, not as a modifier. */
+/** The id of the synthetic modifier the filters below a job's Response Format
+    apply under at run time (#339, #615): it is never in a document or the Add
+    menu -- a job carries a `filters` step, which `stageModifiers` turns into
+    these where the step sits, so a set cleans and gates a list reply's items
+    exactly as it reads. The filters above the format run on the raw reply
+    before it is read, not as a modifier. */
 export const FILTER_MODIFIER = "filterSet";
 
 const LIST_MODIFIERS                                       = {
-  // A Post-format filter set's filters, applied where its link sits: the
-  // run's only reader of a resolved items-stage set, hidden from the Add menu
+  // The filters below the format, applied to the items where the step sits:
+  // the run's only reader of them, hidden from the Add menu
   // (a set is linked in Responses, not added as a modifier). The lab's own
   // cleaning modifiers are retired (#405) -- every cleaning step is a filter.
   [FILTER_MODIFIER]: {
@@ -715,31 +869,32 @@ export const CLEANING_MODIFIERS = ["reject", "drop", "tidy", "drop-echoes", "ded
 const baseFilter = (id        , type        , extra                  = {})         =>
   ({ id, type, match: {}, options: { ignoreFailures: false, repeat: 1 }, tests: [], ...extra });
 
-/** The Post-format filter(s) a retired cleaning modifier [m] becomes, in the
-    same order and reading a reply the same way: Tidy and Case are a Rewrite
-    item, Drop prompt echoes and Remove duplicates a Drop item on the `echoes`
-    and `duplicate` conditions, Keep first its own type, and Drop items / Reject
-    each of their rules a Drop item / Reject reply (filterFromItemRule). The
-    drop reasons a run shows stay the names they read as before. */
+/** The filter(s) below the format a retired cleaning modifier [m] becomes,
+    in the same order and reading a reply the same way: Tidy is a Trim with
+    bullets, Case a Change case, Drop prompt echoes and Remove duplicates a
+    Remove on the `echoes` and `duplicate` conditions, Keep first a Keep first
+    of items, and Drop items / Reject each of their rules a Remove / Reject
+    (filterFromItemRule). The drop reasons a run shows stay the names they read
+    as before. */
 export function cleaningFilters(m          )           {
   switch (m.type) {
-    case "reject": return ((m.rules              ) || []).map(r => filterFromItemRule(r, "reject-reply"));
-    case "drop": return ((m.rules              ) || []).map(r => filterFromItemRule(r, "drop-item"));
-    case "tidy": return [baseFilter("tidy", "rewrite-item", { op: { kind: "tidy" } })];
-    case "drop-echoes": return [baseFilter(ECHO, "drop-item", { match: { echoes: true } })];
-    case "dedupe": return [baseFilter(DUPLICATE, "drop-item", { match: { duplicate: true } })];
-    case "keep-first": return [baseFilter("keep first", "keep-first", { op: { n: m.n           } })];
-    case "case": return [baseFilter("case", "rewrite-item", { op: { kind: "case", mode: (m.mode          ) ?? "LOWER" } })];
+    case "reject": return ((m.rules              ) || []).map(r => filterFromItemRule(r, "reject"));
+    case "drop": return ((m.rules              ) || []).map(r => filterFromItemRule(r, "remove"));
+    case "tidy": return [baseFilter("tidy", "trim", { op: { bullets: true } })];
+    case "drop-echoes": return [baseFilter(ECHO, "remove", { match: { echoes: true }, op: { kind: "items" } })];
+    case "dedupe": return [baseFilter(DUPLICATE, "remove", { match: { duplicate: true }, op: { kind: "items" } })];
+    case "keep-first": return [baseFilter("keep first", "keep-first", { op: { n: m.n          , unit: "items" } })];
+    case "case": return [baseFilter("case", "change-case", { op: { mode: (m.mode          ) ?? "LOWER" } })];
     default: return [];
   }
 }
 
-/** The Pre-format (text) filters the List `preamble` setting becomes:
-    Remove thinking then Remove preamble, which together read a reply exactly as
+/** The filters above the format the List `preamble` setting becomes: Remove
+    thinking then Remove preamble, which together read a reply exactly as
     `preamble: true` did (#405). */
 export function preambleFilters()           {
-  return [baseFilter("remove thinking", "rewrite-text", { op: { kind: "thinking" } }),
-          baseFilter("remove preamble", "rewrite-text", { op: { kind: "preamble" } })];
+  return [baseFilter("remove thinking", "remove", { op: { kind: "thinking" } }),
+          baseFilter("remove preamble", "remove", { op: { kind: "preamble" } })];
 }
 
 /**