veriquote 0.2.2 → 0.3.0

package/dist/types.d.ts

@@ -52,6 +52,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. */
@@ -60,8 +67,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. */
@@ -70,6 +78,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. */
 export type EntailmentClass = 'entailed' | 'partially_entailed' | 'overstated' | 'insufficient' | 'contradicted';
@@ -108,8 +122,15 @@ 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;
     /**

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "veriquote",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Deterministic + semantic verification of quote-grounded LLM citations (EVI1 protocol): fuzzy verbatim-quote matching and an LLM entailment judge for transparent, per-claim hallucination detection.",
   "keywords": [
     "llm",
@@ -20,7 +20,7 @@
   "author": "NavigNine (https://navignine.com)",
   "repository": {
     "type": "git",
-    "url": "https://github.com/rickintoplace/veriquote.git"
+    "url": "git+https://github.com/rickintoplace/veriquote.git"
   },
   "homepage": "https://github.com/rickintoplace/veriquote#readme",
   "bugs": {
@@ -30,7 +30,7 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "bin": {
-    "veriquote": "./bin/veriquote.mjs"
+    "veriquote": "bin/veriquote.mjs"
   },
   "exports": {
     ".": {

package/src/cli/main.ts

@@ -262,6 +262,13 @@ function judgeFromEnv(args: Args, io: CliIo): { judge?: EntailmentJudge; model?:
 
 // ------------------------------------------------------------------ output
 
+const MATCH_LABEL: Record<string, string> = {
+  exact: 'verbatim',
+  normalized: 'verbatim',
+  elided: 'verbatim with omission',
+  fuzzy: 'fuzzy',
+};
+
 function renderHuman(
   report: VerificationReport,
   gate: GateResult,
@@ -289,7 +296,7 @@ function renderHuman(
     const match =
       cit.textMatch.method === 'not_found'
         ? red(`quote not in source (best ${cit.textMatch.score.toFixed(2)})`)
-        : `${cit.textMatch.method === 'fuzzy' ? 'fuzzy' : 'verbatim'} ${cit.textMatch.score.toFixed(2)}`;
+        : `${MATCH_LABEL[cit.textMatch.method]} ${cit.textMatch.score.toFixed(2)}`;
     const judged = cit.entailment
       ? cit.entailment.class === 'error'
         ? yellow('judge error')
@@ -297,8 +304,12 @@ function renderHuman(
       : '';
     out.push(`${mark} ${cit.claimId} [${cit.sourceIndex}]  ${[match, judged].filter(Boolean).join(' · ')}`);
     out.push(`    ${truncate(cit.claimText || '(no claim text)', 160)}`);
+    const hides = gate.problems.find((p) => p.claimId === cit.claimId && p.sourceIndex === cit.sourceIndex)?.type === 'ellipsis_hides_qualifier';
     if (bad && cit.textMatch.method === 'not_found') out.push(dim('    the quoted text does not occur in the source'));
-    else if (bad && cit.entailment?.reasons.length) out.push(dim(`    ${cit.entailment.reasons.map((r) => r.trim().replace(/[.;]+$/, '')).join('; ')}`));
+    else if (hides) {
+      const cues = (cit.textMatch.omittedCues ?? []).map((c) => `"${c}"`).join(', ');
+      out.push(dim(`    the ellipsis leaves out ${cues}; run with a judge to check the full passage`));
+    } else if (bad && cit.entailment?.reasons.length) out.push(dim(`    ${cit.entailment.reasons.map((r) => r.trim().replace(/[.;]+$/, '')).join('; ')}`));
     else if (bad && cit.score !== null && cit.textMatch.method !== 'not_found') {
       out.push(dim(`    combined score ${cit.score.toFixed(2)} is below the minimum ${minScore.toFixed(2)}`));
     }

package/src/gate.ts

@@ -19,7 +19,8 @@ export type ProblemType =
   | 'quote_not_in_source'
   | 'contradicted_by_source'
   | 'overstated'
-  | 'weakly_supported';
+  | 'weakly_supported'
+  | 'ellipsis_hides_qualifier';
 
 export interface GateProblem {
   claimId: string;
@@ -90,14 +91,26 @@ export function gateReport(
 
 function isProblem(c: CitationVerification, minScore: number): boolean {
   if (c.textMatch.method === 'not_found') return true;
+  if (hidesQualifier(c)) return true;
   const cls = c.entailment?.class;
   if (cls === 'contradicted' || cls === 'overstated') return true;
   // A null score means the judge errored; an outage is not evidence against the claim.
   return c.score !== null && c.score < minScore;
 }
 
+/**
+ * The ellipsis leaves out a word such as "not" or "except", and no judge has
+ * read the full passage. A judge verdict settles it either way ("not only …
+ * but also" is harmless), so this only fires without one.
+ */
+function hidesQualifier(c: CitationVerification): boolean {
+  const judged = c.entailment && c.entailment.class !== 'error';
+  return !judged && (c.textMatch.omittedCues?.length ?? 0) > 0;
+}
+
 function problemType(c: CitationVerification): ProblemType {
   if (c.textMatch.method === 'not_found') return 'quote_not_in_source';
+  if (hidesQualifier(c)) return 'ellipsis_hides_qualifier';
   if (c.entailment?.class === 'contradicted') return 'contradicted_by_source';
   if (c.entailment?.class === 'overstated') return 'overstated';
   return 'weakly_supported';
@@ -141,6 +154,8 @@ const FIX: Record<ProblemType, string> = {
   contradicted_by_source: 'the cited source contradicts this claim — remove the claim or correct it to match the source',
   overstated: 'this claim is stronger or more general than the evidence — weaken it to exactly what the quote supports',
   weakly_supported: 'this claim is only weakly supported — cite a better passage or soften the wording',
+  ellipsis_hides_qualifier:
+    'the ellipsis in the quote leaves out a word that may reverse or limit the statement — quote the passage without the omission, or split it into separate quotes',
 };
 
 function correctionInstructions(problems: GateProblem[], uncited: string[]): string {

package/src/index.ts

@@ -19,6 +19,7 @@ export {
   parseAnswer,
   parseEvi1Appendix,
   stripEvi1Appendix,
+  stripForDisplay,
   serializeEvi1Appendix,
   extractClaims,
   stripClaimMarkers,

package/src/match/fuzzy.ts

@@ -3,8 +3,11 @@
  *
  * Strategy, in order of preference:
  *   1. exact raw substring,
- *   2. exact substring after normalization (quotes, dashes, case, whitespace),
- *   3. best sliding window by character-trigram Dice similarity, with a
+ *   2. exact substring after normalization (quotes, dashes, case, whitespace,
+ *      an ellipsis at either end),
+ *   3. elided: the fragments around inner ellipses occur literally, in order,
+ *      with at most `maxElisionGap` characters left out between them,
+ *   4. best sliding window by character-trigram Dice similarity, with a
  *      coarse scan followed by a fine refinement around the best offset.
  *
  * Everything here is pure and deterministic: same inputs, same result.
@@ -25,6 +28,11 @@ export interface MatchOptions {
   fuzzyThreshold?: number;
   /** Window sizes to try, as multiples of the quote length. Default [0.85, 1, 1.15]. */
   windowScales?: number[];
+  /**
+   * Most (normalized) characters one ellipsis may stand for. Fragments further
+   * apart are separate passages, not one elided quote. Default 300.
+   */
+  maxElisionGap?: number;
 }
 
 const DEFAULTS: Required<MatchOptions> = {
@@ -32,8 +40,43 @@ const DEFAULTS: Required<MatchOptions> = {
   shortQuoteLength: 90,
   fuzzyThreshold: 0.4,
   windowScales: [0.85, 1, 1.15],
+  maxElisionGap: 300,
 };
 
+/** "...", "…" (NFKC turns it into "..."), "[...]", "(...)", ". . ." — in normalized text. */
+const ELLIPSIS = /\s*(?:\[\s*\.(?:\s?\.){2,}\s*\]|\(\s*\.(?:\s?\.){2,}\s*\)|\.(?:\s?\.){2,})\s*/g;
+/** An elided quote needs one fragment at least this long to anchor it. */
+const MIN_ELISION_ANCHOR = 20;
+/** Elided matches rank just below literal ones. */
+const ELIDED_SCORE = 0.99;
+
+/**
+ * Words that reverse, limit or qualify a statement, in English and German.
+ * Found in the text an ellipsis leaves out, they make the elision worth a
+ * second look: "the landlord is … permitted to terminate" may have dropped
+ * a "not".
+ */
+const CUE_WORDS = [
+  // negation
+  'not', 'no', 'never', 'none', 'neither', 'nor', 'without', 'cannot', 'nothing', 'nobody',
+  'nicht', 'kein', 'keine', 'keinen', 'keinem', 'keiner', 'keines', 'nie', 'niemals', 'weder', 'ohne',
+  // exception, condition, limitation
+  'except', 'unless', 'excluding', 'only', 'außer', 'ausser', 'ausgenommen', 'sofern', 'nur',
+  // contrast
+  'but', 'however', 'although', 'though', 'whereas', 'despite',
+  'aber', 'jedoch', 'obwohl', 'allerdings', 'trotz',
+];
+const CUE = new RegExp(`(?<![\\p{L}\\p{N}])(?:${CUE_WORDS.join('|')})(?![\\p{L}\\p{N}])|(?<=\\p{L})n't(?!\\p{L})`, 'gu');
+
+/** Cue words in the given ranges of normalized text, deduplicated, in order of appearance. */
+function cuesIn(text: string, ranges: Array<[number, number]>): string[] {
+  const found = new Set<string>();
+  for (const [from, to] of ranges) {
+    for (const m of text.slice(from, to).matchAll(CUE)) found.add(m[0]);
+  }
+  return [...found];
+}
+
 /** Multiset of character trigrams of `s` as gram -> count. */
 export function trigramCounts(s: string): Map<string, number> {
   const out = new Map<string, number>();
@@ -192,15 +235,31 @@ export function matchQuoteAgainstText(
   const t = normalizeForMatch(text);
   if (!q.text || !t.text) return empty;
 
-  const normIndex = t.text.indexOf(q.text);
-  if (normIndex !== -1) {
-    return {
-      method: 'normalized',
-      score: 1,
-      start: t.map[normIndex],
-      end: mapEndOffset(t.map, normIndex + q.text.length - 1, text),
-      field: 'text',
-    };
+  const fragments = q.text.split(ELLIPSIS).filter(Boolean);
+  if (fragments.length === 1) {
+    const normIndex = t.text.indexOf(fragments[0]);
+    if (normIndex !== -1) {
+      return {
+        method: 'normalized',
+        score: 1,
+        start: t.map[normIndex],
+        end: mapEndOffset(t.map, normIndex + fragments[0].length - 1, text),
+        field: 'text',
+      };
+    }
+  } else if (fragments.some((f) => f.length >= MIN_ELISION_ANCHOR)) {
+    const span = findElided(fragments, t.text, opts.maxElisionGap);
+    if (span) {
+      const cues = cuesIn(t.text, span.gaps);
+      return {
+        method: 'elided',
+        score: ELIDED_SCORE,
+        start: t.map[span.start],
+        end: mapEndOffset(t.map, span.end - 1, text),
+        field: 'text',
+        ...(cues.length ? { omittedCues: cues } : {}),
+      };
+    }
   }
 
   const hit = bestFuzzyWindow(q.text, t.text, opts.windowScales);
@@ -219,6 +278,34 @@ export function matchQuoteAgainstText(
   };
 }
 
+interface ElidedSpan {
+  start: number;
+  end: number;
+  /** The omitted stretches between fragments, as [from, to) in `text`. */
+  gaps: Array<[number, number]>;
+}
+
+/**
+ * First span of `text` holding every fragment literally, in order, with gaps of
+ * at most `maxGap`; offsets refer to `text`. Null if there is none.
+ */
+function findElided(fragments: string[], text: string, maxGap: number): ElidedSpan | null {
+  for (let first = text.indexOf(fragments[0]); first !== -1; first = text.indexOf(fragments[0], first + 1)) {
+    let end = first + fragments[0].length;
+    const gaps: Array<[number, number]> = [];
+    for (const fragment of fragments.slice(1)) {
+      // The earliest occurrence leaves the most room for the fragments after it.
+      const at = text.indexOf(fragment, end);
+      if (at === -1) return null;
+      if (at - end > maxGap) break;
+      gaps.push([end, at]);
+      end = at + fragment.length;
+    }
+    if (gaps.length === fragments.length - 1) return { start: first, end, gaps };
+  }
+  return null;
+}
+
 /** Exclusive end offset in the original text for the normalized char at `lastIndex`. */
 function mapEndOffset(map: Int32Array, lastIndex: number, original: string): number {
   const srcIndex = map[Math.max(0, Math.min(lastIndex, map.length - 1))];

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)) {