fix: strip bullet-glyph artifacts and redundant stitching from served answers

src/components/clinical-dashboard/display-text.ts

@@ -1,5 +1,6 @@
 import {
  normalizeExtractedGlyphs,
+ normalizeInlineBulletGlyphs,
  sourceTextForCompactDisplay,
  sourceTextForClinicalProse,
  sourceTextForClinicalProsePreservingBreaks,
@@ -35,7 +36,9 @@ export function looksLikeDisplayArtifact(value: string) {
 
 export function sanitizeDisplayText(value: string, options: DisplayTextSanitizeOptions = {}) {
  const normalized = normalizeDisplayText(
- options.compactSource ? sourceTextForCompactDisplay(value) : sourceTextForClinicalProse(value),
+ options.compactSource
+ ? sourceTextForCompactDisplay(value)
+ : normalizeInlineBulletGlyphs(sourceTextForClinicalProse(value)),
  );
  if (!normalized) return "";
  const artifactStart = normalized.search(

src/lib/rag-answer-text.ts

@@ -1,6 +1,7 @@
 import {
  clinicalProseUsefulness,
  isLowYieldClinicalText,
+ normalizeInlineBulletGlyphs,
  sourceTextForClinicalProse,
 } from "@/lib/source-text-sanitizer";
 
@@ -204,8 +205,9 @@ function separateSettingRunOns(value: string): string {
 }
 
 export function polishClinicalAnswerProse(value: string) {
- const cleaned = normalizeSectionText(value)
- .replace(/\*\*([^*]+)\*\*/g, "$1")
+ // Bold markers come off before bullet normalization so an emphasized item
+ // ("o **Reduce dose**") still reads as a sub-bullet to the "o" matcher.
+ const cleaned = normalizeInlineBulletGlyphs(normalizeSectionText(value).replace(/\*\*([^*]+)\*\*/g, "$1"))
  .replace(productCatalogueFragmentPattern, " ")
  .replace(brandOrFormularyFragmentPattern, " ")
  .replace(imprestLocationPattern, " ")

src/lib/rag-extractive-answer.ts

@@ -24,7 +24,12 @@ import {
  splitBalancedWords,
 } from "@/lib/rag-answer-text";
 import { ragProviderMode } from "@/lib/rag-provider";
-import { isLowYieldClinicalText, sourceTextForClinicalProse } from "@/lib/source-text-sanitizer";
+import {
+ isLowYieldClinicalText,
+ normalizeInlineBulletGlyphs,
+ sourceTextForClinicalProse,
+ sourceTextForClinicalProsePreservingBreaks,
+} from "@/lib/source-text-sanitizer";
 import type {
  AnswerSection,
  AnswerSectionKind,
@@ -65,9 +70,55 @@ type ExtractedClinicalFact = {
 const extractiveLabelPattern =
  /\b(?:Medication point|Table evidence|Threshold\/action|Risk\/escalation|Workflow step|Section summary|Source point|Dose detail|Monitoring)\s*:\s*/gi;
 
+// Structural labels that are pure boilerplate — never merged into a
+// following fragment and never rewritten into "For <label>, …". Clinical
+// headings that happen to share a word are exempt: "Source control"
+// (infection-source management) and "Reference range/interval" (lab values)
+// are evidence, not provenance or bibliography labels.
+// "section" is anchored to the label start so structural "Section 2:" is
+// excluded while clinical phrases like "Caesarean section:" merge normally.
+const structuralHeadingStoplistPattern =
+ /\b(?:source(?!\s+control\b)|table|figure|page|summary|example|appendix|reference(?!\s+(?:range|interval)s?\b)|contents)\b|^\s*section\b/i;
+
+// Advisory labels ("Caution:", "Warning:") classify the fact that follows as
+// a caveat — they merge with their bullet items like directive headings do,
+// but keep their colon form instead of becoming "For caution, …".
+const advisoryHeadingPattern = /\b(?:note|warning|caution|important|nb)\b/i;
+
+// Headings that carry the clinical action themselves ("Do not use:",
+// "Avoid:"). These must merge with their bullet items — the item alone often
+// lacks the verb ("Pregnancy") — but must keep their colon form instead of
+// being rewritten into noun context ("For avoid, pregnancy").
+const directiveHeadingPattern =
+ /\b(?:avoid|do|does|not|use|stop|cease|withhold|hold|discontinue|monitor|check|give|administer|contraindicat\w*|must|should|review|refer|contact|seek|consider|is|are|was|were)\b/i;
+
+// A leading section heading carried into a fact ("Acute Mania: 750mg…")
+// becomes readable context ("For acute mania, 750mg…") instead of a colon
+// fragment glued mid-sentence. All-caps tokens (acronyms like "IR") keep
+// their casing, so labels containing one are left for the dose rewrite below.
+const leadingHeadingContextPattern = /^([A-Z][A-Za-z]+(?:[ /-][A-Za-z()]+){0,3}):\s+(?=\S)/;
+
+// "Label: <dose>" reads as "Label is <dose>" only when the colon is directly
+// followed by a numeric dose ("IR product: 750 to 1000mg" → "IR product is
+// 750 to 1000mg"); prose labels without a dose keep their colon. A label
+// ending in a preposition/verb particle is not a heading — "reduce dose to:
+// 500mg" must not become "reduce dose to is 500mg".
+const doseLabelColonPattern =
+ /([A-Za-z][\w-]*(?:\s+[\w-]+){0,3})(?<!\b(?:to|by|at|of|in|on|with|into|onto|towards|per|over|under|from)):\s+(?=\d[^:]{0,24}?(?:mg|mcg|microg|m[lL]|units?|mmol|g)\b)/g;
+
+function rewriteLeadingHeadingContext(value: string) {
+ return value.replace(leadingHeadingContextPattern, (match, label: string) => {
+ if (structuralHeadingStoplistPattern.test(label)) return match;
+ if (advisoryHeadingPattern.test(label)) return match;
+ if (directiveHeadingPattern.test(label)) return match;
+ if (/\b[A-Z]{2,}\b/.test(label)) return match;
+ return `For ${label.toLowerCase()}, `;
+ });
+}
+
 /** Clean extractive point text. */
 function cleanExtractivePointText(value: string) {
-return sourceTextForClinicalProse(value)
+const rewritten = normalizeInlineBulletGlyphs(sourceTextForClinicalProse(value))
  .replace(/\b(?:clinical_table|table_crop|diagram_crop)\b/gi, " ")
  .replace(
  /^(?:clinical\s+)?table\s+(?:showing|detailing|listing|outlining|describing)\b.*?:\s*(?=\b(?:if|when|for|cease|stop|withhold|contact|repeat|monitor|clozapine)\b)/i,
@@ -90,6 +141,11 @@ function cleanExtractivePointText(value: string) {
  .replace(/\s+([,.;:])/g, "$1")
  .replace(/(?:\.\s*){2,}/g, ". ")
  .trim();
+ // Directive/advisory labels keep their colon — "Avoid: 12.5 mg…" must not
+ // become the noun-label sentence "Avoid is 12.5 mg…".
+ return rewriteLeadingHeadingContext(rewritten).replace(doseLabelColonPattern, (match, label: string) =>
+ directiveHeadingPattern.test(label) || advisoryHeadingPattern.test(label) ? match : `${label} is `,
+ );
 }
 
 const extractiveClinicalDirectivePattern =
@@ -506,10 +562,51 @@ function isLowValueExtractiveCaption(clause: string) {
  return !extractiveClinicalDirectivePattern.test(clause);
 }
 
+// A short section heading ("Acute Mania:", "Day 1:", "do not use:",
+// "eGFR <30:", "K+ >5.5 mmol/L:", "48-72 hours:") left standing alone by the
+// bullet split. Merged into the fragment that follows it so the indication,
+// schedule, or threshold context survives the minimum-length filter instead
+// of being dropped — a dose or action without its day/step/threshold/time
+// window is unsafe. Clinical threshold notation is too varied to enumerate
+// character-by-character (comparators, electrolyte "+", degrees, micro
+// signs), so any short colon-terminated fragment with alphanumeric content
+// and no sentence punctuation qualifies (internal periods are decimals —
+// the sentence split has already happened); structural labels ("Page 4:",
+// "Table 2:") stay excluded by the stoplist and the word cap bounds it.
+const shortHeadingFragmentPattern = /^[^!?;:]{2,40}:$/;
+
+function isShortHeadingFragment(fragment: string) {
+ return (
+ shortHeadingFragmentPattern.test(fragment) &&
+ /[A-Za-z0-9]/.test(fragment) &&
+ fragment.split(/\s+/).length <= 4 &&
+ !structuralHeadingStoplistPattern.test(fragment)
+ );
+}
+
 /** Split clinical evidence sentences. */
-function splitClinicalEvidenceSentences(value: string) {
-return sourceTextForClinicalProse(value)
+export function splitClinicalEvidenceSentences(value: string) {
+const fragments = normalizeInlineBulletGlyphs(sourceTextForClinicalProsePreservingBreaks(value), { joiner: "\n" })
  .split(/\r?\n+|(?<=[.!?])\s+|\s+[•]\s+|\s+\|\s+/)
+ .map((fragment) => fragment.trim())
+ .filter(Boolean);
+ const merged: string[] = [];
+ let pendingHeading = "";
+ for (const fragment of fragments) {
+ if (isShortHeadingFragment(fragment)) {
+ // Sentence-case an OCR-lowercased heading ("day 1:" → "Day 1:") so the
+ // merged fact reads as a sentence start rather than being discarded as
+ // a mid-sentence fragment by the lowercase-start quality gate. Mixed-
+ // case clinical tokens ("eGFR <30:") keep their casing — they already
+ // pass that gate, and "EGFR" would corrupt the abbreviation.
+ const cased = /^[a-z][a-z]/.test(fragment) ? upperFirst(fragment) : fragment;
+ pendingHeading = pendingHeading ? `${pendingHeading} ${cased}` : cased;
+ continue;
+ }
+ merged.push(pendingHeading ? `${pendingHeading} ${fragment}` : fragment);
+ pendingHeading = "";
+ }
+ return merged
  .map(cleanExtractivePointText)
  .filter(
  (sentence) =>
@@ -703,6 +800,12 @@ function tableFactsToClinicalFacts(result: SearchResult, query: string, intent:
  .filter((fact): fact is ExtractedClinicalFact => Boolean(fact));
 }
 
+function withTerminalPunctuation(value: string | null | undefined) {
+ const trimmed = value?.trim();
+ if (!trimmed) return null;
+ return /[.:;!?]$/.test(trimmed) ? trimmed : `${trimmed}.`;
+}
+
 /** Extract clinical facts from results. */
 function extractClinicalFactsFromResults(results: SearchResult[], query: string, intent: AnswerIntent, limit = 8) {
  const seen = new Set<string>();
@@ -717,12 +820,27 @@ function extractClinicalFactsFromResults(results: SearchResult[], query: string,
  facts.push(fact);
  }
 
+ // Each evidence segment gets terminal punctuation before joining: the
+ // prose cleaner collapses the newlines, and without it a bare section
+ // heading or synopsis tail glues onto the next segment's first sentence
+ // ("Dosing Twice daily dosing should…"). The heading gets a colon so it
+ // reads as a label for the content that follows it — unless the content
+ // already opens with the heading text, where prepending it would only
+ // fabricate a contentless "Label: Label." fact.
+ const sectionHeading = result.section_heading?.trim();
+ const contentLeadsWithHeading = Boolean(
+ sectionHeading && (result.content ?? "").trim().toLowerCase().startsWith(sectionHeading.toLowerCase()),
+ );
  const text = [
- result.retrieval_synopsis,
- result.section_heading,
- result.content,
- result.adjacent_context,
- ...(result.memory_cards ?? []).map((card) => card.content),
+ withTerminalPunctuation(result.retrieval_synopsis),
+ sectionHeading && !contentLeadsWithHeading
+ ? /[.:;!?]$/.test(sectionHeading)
+ ? sectionHeading
+ : `${sectionHeading}:`
+ : null,
+ withTerminalPunctuation(result.content),
+ withTerminalPunctuation(result.adjacent_context),
+ ...(result.memory_cards ?? []).map((card) => withTerminalPunctuation(card.content)),
  ]
  .filter(Boolean)
  .join("\n");
@@ -750,17 +868,27 @@ function extractClinicalFactsFromResults(results: SearchResult[], query: string,
 }
 
 /** Sentence from fact. */
-function sentenceFromFact(fact: ExtractedClinicalFact, query: string) {
+export function sentenceFromFact(
+ fact: ExtractedClinicalFact,
+ query: string,
+ options: { suppressEntityPrefix?: boolean } = {},
+) {
  const text = sanitizeAnswerText(cleanExtractivePointText(fact.text)).replace(/[.;,\s]+$/, "");
  if (!text) return "";
  const entity = queryEntityTokens(query, classifyAnswerIntent(query, classifyRagQuery(query).queryClass))[0];
  const needsEntityPrefix =
+ !options.suppressEntityPrefix &&
  entity &&
  fact.kind !== "bottom_line" &&
  !queryTokenMatchesText(entity, text) &&
  !/^(?:for|in|when|if|avoid|do not|must not|withhold|cease|stop|monitor|check|refer|arrange)\b/i.test(text);
- const sentence = needsEntityPrefix ? `For ${entity}, ${text.charAt(0).toLowerCase()}${text.slice(1)}` : text;
- return completeExtractiveSentence(sentence, query);
+ // Complete the bare fact first, then attach the entity once. Prefixing
+ // before completion let the "The guidance is that…" wrapper swallow the
+ // prefix and duplicate the entity ("For lithium, … that for lithium, …").
+ const completed = completeExtractiveSentence(text, query);
+ if (!completed || !needsEntityPrefix) return completed;
+ if (!/^The guidance\b/.test(completed)) return `For ${entity}, ${lowerFirst(completed)}`;
+ return completed.replace(/^The guidance/, `The guidance for ${entity}`);
 }
 
 /** Lower first. */
@@ -885,12 +1013,25 @@ function buildFactSynthesizedAnswer(args: {
  }
 
  const leadFacts = facts.slice(0, args.intent === "dose" ? 2 : 1);
- const answer = sanitizeAnswerText(
- leadFacts
- .map((fact) => sentenceFromFact(fact, args.query))
- .filter(Boolean)
- .join(" "),
- );
+ // Once the lead answer names the query entity, later lead sentences skip
+ // their own entity prefix so the entity is not repeated in every sentence.
+ // Derived exactly the way sentenceFromFact derives its prefix entity (from
+ // the query's own classification, not the routed intent) so the suppression
+ // gate can never disagree with the prefix it is gating.
+ const entity = queryEntityTokens(
+ args.query,
+ classifyAnswerIntent(args.query, classifyRagQuery(args.query).queryClass),
+ )[0];
+ let accumulated = "";
+ const leadSentences: string[] = [];
+ for (const fact of leadFacts) {
+ const suppressEntityPrefix = Boolean(entity && accumulated && queryTokenMatchesText(entity, accumulated));
+ const sentence = sentenceFromFact(fact, args.query, { suppressEntityPrefix });
+ if (!sentence) continue;
+ leadSentences.push(sentence);
+ accumulated = `${accumulated} ${sentence}`.trim();
+ }
+ const answer = sanitizeAnswerText(leadSentences.join(" "));
  const answerSections = buildFactSections(facts, args.query);
  return {
  answer: boldHighYieldClinicalText(answer, args.query),

src/lib/smart-rag-api.ts

@@ -1,7 +1,7 @@
 import { citationFromResult, documentCitationHref, formatCompactCitationLabel } from "@/lib/citations";
 import { sourceStrengthForSimilarity } from "@/lib/evidence";
 import { buildRetrievalIntent, summarizeRetrievalSelection } from "@/lib/retrieval-selection";
-import { sourceTextForDisplay } from "@/lib/source-text-sanitizer";
+import { normalizeInlineBulletGlyphs, sourceTextForDisplay } from "@/lib/source-text-sanitizer";
 import type {
  AnswerResponseMode,
  ConflictOrGap,
@@ -41,7 +41,7 @@ const queryClassIntent: Record<RagQueryClass, SmartRagApiPlan["intent"]> = {
 };
 
 function compact(value: string, limit: number) {
- const normalized = sourceTextForDisplay(value).replace(/\s+/g, " ").trim();
+ const normalized = normalizeInlineBulletGlyphs(sourceTextForDisplay(value)).replace(/\s+/g, " ").trim();
  if (normalized.length <= limit) return normalized;
  return `${normalized.slice(0, limit - 3).trim()}...`;
 }