veriquote 0.2.2 → 0.4.0

package/src/protocol/evi1.ts

@@ -11,7 +11,14 @@
  *     c1|5|"verbatim quote from source 5"
  *     END_EVI1
  *
+ * A (claim, source) pair may have several lines when one passage does not
+ * cover the whole claim. With `evidenceFirst` prompting the block comes
+ * before the answer instead; the parser accepts either position.
+ *
  * Quotes are single-line, with `\n`, `\"` and `\\` escapes.
+ *
+ * The parser is lenient about how the appendix is framed (see
+ * `parseEvi1Appendix`), strict about the evidence lines themselves.
  */
 
 import type { Claim, EvidenceItem, ParsedAnswer } from '../types.js';
@@ -20,10 +27,25 @@ import { collapseWhitespace } from '../match/normalize.js';
 export const EVI1_START = 'EVI1';
 export const EVI1_END = 'END_EVI1';
 
-const EVIDENCE_LINE = /^(c\d+)\|(\d+)\|"([\s\S]*)"$/;
+const EVIDENCE_LINE = /^(c\d+)\s*\|\s*(\d+)\s*\|\s*"([\s\S]*)"$/;
 const CLAIM_MARKER = /\{c(\d+)\}/g;
 const CITATION_GROUP_BEFORE_CLAIM = /((?:\[\d+\])+)$/;
 
+// Models and gateways garble the appendix slightly: "**EVI1**", "EVI1:",
+// "EVI1 c1|2|...", a code fence around it, END_EVI11 or no END_EVI1 at all.
+// The lookahead keeps a sentence about the EVI1 gene from opening an appendix.
+const START_LINE = /^[\s*_`>#]*EVI1[\s*_`:]*(?=$|c\d+\s*\|)/;
+const END_LINE = /^[\s*_`]*END_EVI1/;
+const EVIDENCE_PREFIX = /^\s*c\d+\s*\|\s*\d+\s*\|/;
+// Without END_EVI1, the appendix runs as long as lines look like evidence,
+// malformed ones included (they get a warning, not the answer body).
+const EVIDENCE_LIKE = /^\s*c\d+\s*\|/;
+const FENCE_LINE = /^\s*```\s*\w*\s*$/;
+// While streaming, the last line may be the beginning of an EVI1, evidence or END_EVI1 line.
+const PARTIAL_START =
+  /^[\s*_`>#]*(?:E(?:V(?:I(?:1[\s*_`:]*(?:c\d*)?)?)?)?)?$|^[\s*_`]*EN(?:D(?:_(?:E(?:V(?:I1?)?)?)?)?)?$|^\s*c\d*(?:\s*\|\s*\d*)?\s*$/;
+const PARTIAL_MARKER = /\{(?:c\d*)?$/;
+
 /** Unescape an EVI1 quote payload (`\\`, `\n`, `\"`) in a single pass. */
 function unescapeQuote(s: string): string {
   return s.replace(/\\(.)/g, (_, c: string) => (c === 'n' ? '\n' : c));
@@ -35,41 +57,110 @@ function escapeQuote(s: string): string {
 }
 
 interface AppendixLocation {
-  /** Index of the line containing EVI1_START. */
-  startLine: number;
-  /** Index of the line containing EVI1_END. */
-  endLine: number;
+  /** First line to cut: the EVI1 line (or first evidence line), or a fence opened just before it. */
+  cutStart: number;
+  /**
+   * First line after the appendix: past END_EVI1 and a closing fence, or,
+   * without END_EVI1, the first line that is not evidence (an answer after an
+   * evidence-first block), else `lines.length`.
+   */
+  cutEnd: number;
+  /** Candidate evidence lines, the text after an inline `EVI1` header included. */
+  body: string[];
 }
 
-function locateAppendix(lines: string[]): AppendixLocation | null {
+const isBlank = (line: string) => !line.trim();
+
+/**
+ * Whether the EVI1 line at `start` really opens the appendix: the next
+ * non-blank line is evidence, or END_EVI1 follows somewhere.
+ * A heading "## EVI1" followed by prose does not.
+ */
+function opensAppendix(lines: string[], start: number): boolean {
+  if (lines[start].replace(START_LINE, '').trim()) return true; // "EVI1 c1|…"
+  let i = start + 1;
+  while (i < lines.length && (isBlank(lines[i]) || FENCE_LINE.test(lines[i]))) i++;
+  if (EVIDENCE_PREFIX.test(lines[i] ?? '')) return true;
+  return lines.slice(i).some((l) => END_LINE.test(l));
+}
+
+/**
+ * Start of the appendix: the last EVI1 line, or else a run of evidence lines
+ * that ends the text. -1 if there is none.
+ */
+function findAppendixStart(lines: string[]): number {
   // Scan from the end so answer text that merely mentions "EVI1" is ignored.
-  for (let end = lines.length - 1; end >= 0; end--) {
-    if (lines[end].trim() !== EVI1_END) continue;
-    for (let start = end - 1; start >= 0; start--) {
-      if (lines[start].trim() === EVI1_START) return { startLine: start, endLine: end };
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (START_LINE.test(lines[i]) && opensAppendix(lines, i)) return i;
+  }
+  let i = lines.length - 1;
+  while (i >= 0 && (isBlank(lines[i]) || END_LINE.test(lines[i]) || FENCE_LINE.test(lines[i]))) i--;
+  const last = i;
+  while (i >= 0 && EVIDENCE_PREFIX.test(lines[i])) i--;
+  return i < last ? i + 1 : -1;
+}
+
+function locateAppendix(lines: string[]): AppendixLocation | null {
+  const start = findAppendixStart(lines);
+  if (start < 0) return null;
+
+  const headerRest = lines[start].replace(START_LINE, '');
+  let endLine = END_LINE.test(headerRest) ? start : -1;
+  for (let i = start + 1; endLine < 0 && i < lines.length; i++) {
+    if (END_LINE.test(lines[i])) endLine = i;
+  }
+  let stop = endLine >= 0 ? endLine : start + 1;
+  if (endLine < 0) {
+    while (stop < lines.length && (isBlank(lines[stop]) || FENCE_LINE.test(lines[stop]) || EVIDENCE_LIKE.test(lines[stop]))) stop++;
+    // Blank lines before the answer that follows belong to the answer.
+    if (stop < lines.length) while (stop > start + 1 && isBlank(lines[stop - 1])) stop--;
+  }
+  const body = endLine === start ? [] : [headerRest, ...lines.slice(start + 1, stop)];
+
+  // A fence the model opened around the appendix goes with it, but not one
+  // that closes an earlier code block.
+  let cutStart = start;
+  let openedFence = /^\s*```/.test(lines[start]);
+  let before = start - 1;
+  while (before >= 0 && isBlank(lines[before])) before--;
+  if (!openedFence && before >= 0 && FENCE_LINE.test(lines[before])) {
+    const fences = lines.slice(0, before + 1).filter((l) => FENCE_LINE.test(l)).length;
+    if (fences % 2 === 1) {
+      cutStart = before;
+      openedFence = true;
     }
-    return null;
   }
-  return null;
+
+  let cutEnd = endLine < 0 ? stop : endLine + 1;
+  if (openedFence && endLine >= 0 && !/```/.test(lines[endLine])) {
+    let after = cutEnd;
+    while (after < lines.length && isBlank(lines[after])) after++;
+    if (after < lines.length && FENCE_LINE.test(lines[after])) cutEnd = after + 1;
+  }
+  return { cutStart, cutEnd, body };
 }
 
 /**
  * Parse the EVI1 appendix of a raw model answer.
  * Returns the evidence items plus warnings for malformed lines;
- * `null` when no complete appendix is present.
+ * `null` when no appendix is present.
+ *
+ * Tolerant of common deviations: a decorated start line (`**EVI1**`,
+ * `EVI1:`, `EVI1 c1|…`), a code fence around the appendix, a missing or
+ * garbled `END_EVI1`, and a missing `EVI1` line when the answer ends in
+ * evidence lines.
  */
 export function parseEvi1Appendix(
   answer: string,
 ): { items: EvidenceItem[]; warnings: string[] } | null {
-  const lines = String(answer).split('\n');
-  const loc = locateAppendix(lines);
+  const loc = locateAppendix(String(answer).split('\n'));
   if (!loc) return null;
 
   const items: EvidenceItem[] = [];
   const warnings: string[] = [];
-  for (let i = loc.startLine + 1; i < loc.endLine; i++) {
-    const line = lines[i].trim();
-    if (!line) continue;
+  for (const raw of loc.body) {
+    const line = raw.trim();
+    if (!line || FENCE_LINE.test(line)) continue;
     const m = line.match(EVIDENCE_LINE);
     if (!m) {
       warnings.push(`EVI1: malformed evidence line ignored: ${truncate(line, 80)}`);
@@ -85,16 +176,51 @@ export function parseEvi1Appendix(
   return { items, warnings };
 }
 
+function cutAppendix(lines: string[], loc: AppendixLocation): string {
+  const head = lines.slice(0, loc.cutStart);
+  const tail = lines.slice(loc.cutEnd);
+  // An evidence-first block leaves blank lines before the answer.
+  if (head.every(isBlank)) {
+    head.length = 0;
+    while (tail.length && isBlank(tail[0])) tail.shift();
+  }
+  return head.concat(tail).join('\n').trimEnd();
+}
+
 /** Remove the EVI1 appendix from a raw answer; returns the answer body. */
 export function stripEvi1Appendix(answer: string): string {
   const lines = String(answer).split('\n');
   const loc = locateAppendix(lines);
-  if (!loc) return answer;
-  return lines
-    .slice(0, loc.startLine)
-    .concat(lines.slice(loc.endLine + 1))
-    .join('\n')
-    .trimEnd();
+  return loc ? cutAppendix(lines, loc) : answer;
+}
+
+/** Whether the last line may be the beginning of an appendix (but not a fence closing a code block). */
+function isPartialStart(lines: string[]): boolean {
+  const last = lines[lines.length - 1];
+  if (isBlank(last) || !PARTIAL_START.test(last)) return false;
+  return !/```/.test(last) || lines.filter((l) => /^\s*```/.test(l)).length % 2 === 1;
+}
+
+/**
+ * The answer as a reader should see it, also while it is still streaming:
+ * the appendix (complete or not) is cut, as is a last line that may be the
+ * beginning of one (`E`, `EV`, `EVI`, `EVI1`, `c1|…`), and all `{cX}`
+ * markers are removed, including a half-streamed `{c…` at the end.
+ * `[n]` citation markers are kept.
+ */
+export function stripForDisplay(text: string): string {
+  let lines = String(text).split('\n');
+  const popBlank = () => {
+    while (lines.length && isBlank(lines[lines.length - 1])) lines.pop();
+  };
+  popBlank();
+  while (lines.length && isPartialStart(lines)) {
+    lines.pop();
+    popBlank();
+  }
+  const loc = locateAppendix(lines);
+  if (loc) lines = cutAppendix(lines, loc).split('\n');
+  return stripClaimMarkers(lines.join('\n').replace(PARTIAL_MARKER, '')).trimEnd();
 }
 
 /** Serialize evidence items into an EVI1 appendix block. */
@@ -173,24 +299,43 @@ export function parseAnswer(answer: string): ParsedAnswer {
 
   const body = stripEvi1Appendix(answer);
   const { claims, warnings: claimWarnings } = extractClaims(body);
-  warnings.push(...claimWarnings);
+  // A claim marker without its [n] group still names its sources in the
+  // appendix; take them from there instead of losing the claim's evidence.
+  const noGroup = new Set<string>();
+  for (const c of claims) {
+    if (c.sourceIndexes.length) continue;
+    const fromAppendix = [...new Set(evidence.filter((e) => e.claimId === c.id).map((e) => e.sourceIndex))];
+    if (!fromAppendix.length) continue;
+    c.sourceIndexes = fromAppendix;
+    noGroup.add(`Claim ${c.id}: no citation group directly before marker.`);
+  }
+  warnings.push(
+    ...claimWarnings.map((w) =>
+      noGroup.has(w) ? w.replace(/\.$/, '; sources taken from the EVI1 appendix.') : w,
+    ),
+  );
 
   const cited = new Set(
     claims.flatMap((c) => c.sourceIndexes.map((n) => `${c.id}|${n}`)),
   );
+  // Several lines for one (claim, source) pair are allowed: a claim may need
+  // two passages of the same source. Only repeated quotes are dropped.
   const evidenced = new Set<string>();
+  const seenLines = new Set<string>();
   const dedupedEvidence: typeof evidence = [];
   for (const it of evidence) {
     const key = `${it.claimId}|${it.sourceIndex}`;
-    if (evidenced.has(key)) {
-      warnings.push(`EVI1: duplicate evidence for ${key}; keeping first occurrence.`);
+    const line = `${key}|${collapseWhitespace(it.quote)}`;
+    if (seenLines.has(line)) {
+      warnings.push(`EVI1: repeated quote for ${key}; keeping first occurrence.`);
       continue;
     }
-    evidenced.add(key);
+    seenLines.add(line);
     dedupedEvidence.push(it);
-    if (!cited.has(key)) {
+    if (!evidenced.has(key) && !cited.has(key)) {
       warnings.push(`EVI1: evidence for ${key} has no matching citation in the answer.`);
     }
+    evidenced.add(key);
   }
   for (const key of cited) {
     if (!evidenced.has(key)) {

package/src/protocol/prompt.ts

@@ -13,6 +13,12 @@ export interface CitationPromptOptions {
   quoteLengthRange?: [number, number];
   /** Minimum quote length in characters (with stated exceptions). Default 60. */
   minQuoteLength?: number;
+  /**
+   * Put the EVI1 block before the answer: the model selects its passages
+   * first, then writes only what they support. The parser accepts either
+   * position; a streaming client shows nothing until END_EVI1. Default false.
+   */
+  evidenceFirst?: boolean;
 }
 
 /** Build the EVI1 citation instruction block for the answering model. */
@@ -22,8 +28,25 @@ export function buildCitationInstructions(options: CitationPromptOptions = {}):
     maxCitationsPerClaim = 2,
     quoteLengthRange = [80, 240],
     minQuoteLength = 60,
+    evidenceFirst = false,
   } = options;
 
+  const appendixIntro = evidenceFirst
+    ? `Before you write the answer, output the evidence block. Select the passages
+you will rely on first, one line per planned claim and source, then write the
+answer so that every cited sentence states only what its lines support.`
+    : 'After you finish the answer, append an appendix:';
+  const afterBlock = evidenceFirst
+    ? '- After END_EVI1, write the user-facing answer. The claim ids {cX} in the answer must be the ones used in the block.'
+    : '- Do NOT output anything after END_EVI1.';
+  const important = evidenceFirst
+    ? `- The user-facing answer starts AFTER END_EVI1. Nothing but the block comes before it.
+- The block is required only when you use citations. If you use no
+  citations, do NOT output EVI1/END_EVI1.`
+    : `- The user-facing answer must end BEFORE the EVI1 appendix starts.
+- The appendix is required only when you used citations. If you used no
+  citations, do NOT output EVI1/END_EVI1.`;
+
   return `
 [CITATION BUDGET]
 - Keep citations sparse. Only cite new, load-bearing information.
@@ -50,17 +73,20 @@ export function buildCitationInstructions(options: CitationPromptOptions = {}):
   Example: "...water expands when freezing.[2][5]{c1}"
   Bad: "...freezing.[2] {c1}"
   Bad: "...freezing.[2].{c1}"
-- Every sentence OR bullet that contains citations MUST end with exactly ONE claim marker {cX}.
+- Every sentence OR bullet that contains citations MUST end with exactly ONE claim marker {cX},
+  directly after its [n] group. Never write {cX} without the [n] group, even though the
+  appendix names the source as well.
 - X starts at 1 and increases by 1 for each new cited sentence/bullet in THIS answer.
 - Do NOT place {cX} anywhere else. Uncited sentences get no claim marker.
 
-[QUOTE-BASED EVIDENCE APPENDIX (MANDATORY)]
-After you finish the answer, append an appendix:
+[QUOTE-BASED EVIDENCE ${evidenceFirst ? 'BLOCK' : 'APPENDIX'} (MANDATORY)]
+${appendixIntro}
 - Start with a line containing exactly: EVI1
 - Then output one line per (claim, source) pair in this exact format:
   cX|n|"QUOTE"
+  If one passage does not cover the claim, add further lines for the same pair.
 - End with a line containing exactly: END_EVI1
-- Do NOT output anything after END_EVI1.
+${afterBlock}
 - Do NOT wrap EVI1..END_EVI1 in code fences or markdown.
 
 [COMPLETENESS RULES (MANDATORY)]
@@ -71,10 +97,19 @@ After you finish the answer, append an appendix:
 - If you cannot provide a verbatim quote for a citation, REMOVE that citation
   from the answer. Never leave a citation unverified.
 
+[SUFFICIENCY RULES (MANDATORY)]
+- The quotes of a cited sentence must together contain EVERY detail it states:
+  each number, population, time frame, place, condition, comparison and hedge.
+- If one passage does not cover everything, add another line for the same claim
+  (same or other cited source). Otherwise remove the unquoted detail from the
+  sentence. Never add detail that no quote contains.
+
 Rules for QUOTE:
 - QUOTE must be copied verbatim from the provided source TEXT (not paraphrased).
-- QUOTE must be sufficient to support the claim; prefer the shortest quote that
-  still supports it (typically ${quoteLengthRange[0]}-${quoteLengthRange[1]} characters).
+- Prefer the shortest quote that still covers its part of the claim
+  (typically ${quoteLengthRange[0]}-${quoteLengthRange[1]} characters).
+- Copy one contiguous passage per line. Do NOT shorten a quote with "..." and do
+  NOT join separate passages into one quote; write each passage on its own line.
 - QUOTE must be at least ${minQuoteLength} characters unless it contains a numeric result or is
   a complete standalone sentence that uniquely supports the claim.
 - QUOTE must be a single line: escape newlines as \\n and double quotes as \\".
@@ -92,8 +127,6 @@ Rules for QUOTE:
   claim; when only conclusions are visible, use cautious language.
 
 IMPORTANT:
-- The user-facing answer must end BEFORE the EVI1 appendix starts.
-- The appendix is required only when you used citations. If you used no
-  citations, do NOT output EVI1/END_EVI1.
+${important}
 `.trim();
 }

package/src/report.ts

@@ -40,39 +40,54 @@ export async function verifyAnswer(options: VerifyOptions): Promise<Verification
   const warnings = [...parsed.warnings];
   const claimById = new Map(parsed.claims.map((c) => [c.id, c]));
 
-  const citations: CitationVerification[] = [];
+  // One citation per (claim, source) pair; a pair may carry several quotes.
+  const pairs = new Map<string, { claimId: string; sourceIndex: number; quotes: string[] }>();
   for (const item of parsed.evidence) {
-    const claim = claimById.get(item.claimId);
-    const source = sources[item.sourceIndex - 1];
+    const key = `${item.claimId}|${item.sourceIndex}`;
+    const pair = pairs.get(key) ?? { claimId: item.claimId, sourceIndex: item.sourceIndex, quotes: [] };
+    pair.quotes.push(item.quote);
+    pairs.set(key, pair);
+  }
+
+  const citations: CitationVerification[] = [];
+  for (const [key, pair] of pairs) {
+    const source = sources[pair.sourceIndex - 1];
     if (!source) {
-      warnings.push(
-        `EVI1: evidence ${item.claimId}|${item.sourceIndex} references a source that was not provided.`,
-      );
+      warnings.push(`EVI1: evidence ${key} references a source that was not provided.`);
       continue;
     }
-    const textMatch: QuoteMatch = matchQuoteAgainstSource(item.quote, source, match);
+    const parts = pair.quotes.map((quote) => ({ quote, textMatch: matchQuoteAgainstSource(quote, source, match) }));
+    const textMatch = combineMatches(parts.map((p) => p.textMatch));
+    for (const cue of textMatch.omittedCues ?? []) {
+      warnings.push(`Citation ${key}: the ellipsis in the quote leaves out "${cue}".`);
+    }
     citations.push({
-      claimId: item.claimId,
-      sourceIndex: item.sourceIndex,
-      claimText: claim?.text ?? '',
-      quote: item.quote,
+      claimId: pair.claimId,
+      sourceIndex: pair.sourceIndex,
+      claimText: claimById.get(pair.claimId)?.text ?? '',
+      quote: pair.quotes.join(' […] '),
       textMatch,
+      ...(parts.length > 1 ? { parts } : {}),
       score: textMatch.score,
     });
   }
 
   if (judge) {
     const judgeable = citations.filter((c) => c.claimText && c.quote);
-    const inputs: EntailmentInput[] = judgeable.map((c) => ({
-      id: `${c.claimId}|${c.sourceIndex}`,
-      claim: c.claimText,
-      quote: c.quote,
-      context: contextWindow(
-        sources[c.sourceIndex - 1],
-        c.textMatch,
-        contextWindowChars,
-      ),
-    }));
+    const inputs: EntailmentInput[] = judgeable.map((c) => {
+      const source = sources[c.sourceIndex - 1];
+      const parts = c.parts ?? [{ quote: c.quote, textMatch: c.textMatch }];
+      return {
+        id: `${c.claimId}|${c.sourceIndex}`,
+        claim: c.claimText,
+        // An ellipsis must not hide what it left out (a "not", a qualifier):
+        // the judge rates the passage as the source has it.
+        quote: parts
+          .map((p) => (p.textMatch.method === 'elided' ? matchedText(source, p.textMatch) ?? p.quote : p.quote))
+          .join(' […] '),
+        context: parts.map((p) => contextWindow(source, p.textMatch, contextWindowChars)).join(' […] '),
+      };
+    });
     const results = await judge.judge(inputs, { signal });
     if (results.length !== inputs.length) {
       warnings.push(
@@ -109,6 +124,23 @@ export async function verifyAnswer(options: VerifyOptions): Promise<Verification
   };
 }
 
+/** Several quotes for one pair count as their weakest match, carrying every cue. */
+function combineMatches(matches: QuoteMatch[]): QuoteMatch {
+  if (matches.length === 1) return matches[0];
+  const weakest = matches.reduce((a, b) => (b.score < a.score ? b : a));
+  const cues = [...new Set(matches.flatMap((m) => m.omittedCues ?? []))];
+  const { omittedCues: _, ...rest } = weakest;
+  return cues.length ? { ...rest, omittedCues: cues } : rest;
+}
+
+/** The matched region of the source field, if its offsets are known. */
+function matchedText(source: SourceDocument | undefined, m: QuoteMatch): string | undefined {
+  if (!source || m.start === undefined || m.end === undefined) return undefined;
+  const extra = /^extraTexts\[(\d+)\]$/.exec(m.field);
+  const text = extra ? source.extraTexts?.[Number(extra[1])] : source.text;
+  return text?.slice(m.start, m.end);
+}
+
 /** Source text around the matched region, for judge disambiguation. */
 function contextWindow(
   source: SourceDocument | undefined,

package/src/types.ts

@@ -57,6 +57,13 @@ export type MatchMethod =
   | 'exact'
   /** Substring after Unicode/typography normalization and case folding. */
   | 'normalized'
+  /**
+   * The quote omits text, marked with an ellipsis ("…", "...", "[…]"): every
+   * fragment occurs literally, in order and close together. `start`/`end`
+   * cover the whole passage, omitted text included, and that passage is what
+   * the judge sees.
+   */
+  | 'elided'
   /** Best fuzzy window by character-trigram Dice similarity. */
   | 'fuzzy'
   /** No window reached the fuzzy score threshold. */
@@ -66,8 +73,9 @@ export type MatchMethod =
 export interface QuoteMatch {
   method: MatchMethod;
   /**
-   * Similarity in [0, 1]. `1` only for exact/normalized hits; fuzzy scores
-   * are capped at 0.99 so a perfect score always implies a literal hit.
+   * Similarity in [0, 1]. `1` only for exact/normalized hits; elided and
+   * fuzzy scores are capped at 0.99 so a perfect score always implies a
+   * literal hit.
    */
   score: number;
   /** Start offset of the matched region in the original source field, if known. */
@@ -76,6 +84,12 @@ export interface QuoteMatch {
   end?: number;
   /** Which source field matched: `"text"` or `"extraTexts[i]"`. */
   field: string;
+  /**
+   * `elided` only: words in the omitted text that can reverse or limit a
+   * statement ("not", "except", "only", "however", …). A hint, not a verdict:
+   * the judge sees the full passage and decides.
+   */
+  omittedCues?: string[];
 }
 
 /** Qualitative entailment classes produced by the LLM judge. */
@@ -122,8 +136,12 @@ export interface CitationVerification {
   claimId: string;
   sourceIndex: number;
   claimText: string;
+  /** The quote; several quotes for the same (claim, source) pair are joined with " […] ". */
   quote: string;
+  /** The match of the quote; with several quotes, the weakest one (cues of all of them). */
   textMatch: QuoteMatch;
+  /** One entry per quote, present only when the pair has more than one. */
+  parts?: { quote: string; textMatch: QuoteMatch }[];
   /** Absent when verification ran without a judge. */
   entailment?: EntailmentResult;
   /**