incremnt 0.7.1 → 0.8.0

package/src/ask-answer-verifier.js

@@ -0,0 +1,857 @@
+import {
+  dateOnlyString,
+  executeCoachReadTool,
+  normalizeExerciseName
+} from './queries.js';
+
+export const ASK_ANSWER_VERIFIER_VERSION = 'ask-answer-verifier-v0.1';
+
+function normalizeText(value) {
+  return String(value ?? '').trim();
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function uniqueStrings(values) {
+  return [...new Set((values ?? []).filter(Boolean))];
+}
+
+function normalizeExcludeList(exclude) {
+  if (!exclude) return [];
+  if (Array.isArray(exclude)) return exclude.map((item) => String(item));
+  if (exclude instanceof Set) return [...exclude].map((item) => String(item));
+  return [String(exclude)];
+}
+
+function stableJsonStringify(value) {
+  if (Array.isArray(value)) return `[${value.map((item) => stableJsonStringify(item)).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJsonStringify(value[key])}`).join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function routedToolNames(routingMetadata = {}) {
+  return new Set([
+    ...(routingMetadata.toolsUsed ?? []),
+    ...(routingMetadata.evidencePlan?.executedTools ?? []),
+    ...(routingMetadata.evidencePlan?.requiredTools ?? []),
+    ...(routingMetadata.agenticToolInvocations ?? []).map((invocation) => invocation?.name)
+  ].filter(Boolean));
+}
+
+function compactObject(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined && item !== null));
+}
+
+function allExerciseNames(snapshot) {
+  const names = new Map();
+  for (const session of snapshot?.sessions ?? []) {
+    for (const exercise of session.exercises ?? []) {
+      if (!exercise?.name) continue;
+      const normalizedName = normalizeExerciseName(exercise.name);
+      if (normalizedName && !names.has(normalizedName)) names.set(normalizedName, exercise.name);
+    }
+    for (const exercise of session.prescriptionSnapshot?.exercises ?? []) {
+      const name = exercise?.exerciseName ?? exercise?.name;
+      if (!name) continue;
+      const normalizedName = normalizeExerciseName(name);
+      if (normalizedName && !names.has(normalizedName)) names.set(normalizedName, name);
+    }
+  }
+  for (const program of snapshot?.programs ?? []) {
+    for (const day of program.days ?? []) {
+      for (const exercise of day.exercises ?? []) {
+        const name = exercise?.name ?? exercise?.exerciseName;
+        if (!name) continue;
+        const normalizedName = normalizeExerciseName(name);
+        if (normalizedName && !names.has(normalizedName)) names.set(normalizedName, name);
+      }
+    }
+  }
+  return names;
+}
+
+export function findAskAnswerExerciseMentions(text, snapshot) {
+  const mentions = [];
+  for (const [normalizedName, displayName] of allExerciseNames(snapshot)) {
+    const pattern = new RegExp(`\\b${escapeRegExp(displayName)}\\b`, 'gi');
+    for (const match of String(text ?? '').matchAll(pattern)) {
+      mentions.push({
+        index: match.index ?? -1,
+        end: (match.index ?? -1) + match[0].length,
+        name: displayName,
+        normalizedName
+      });
+    }
+  }
+  return mentions
+    .filter((mention, index, allMentions) => !allMentions.some((candidate, candidateIndex) => (
+      candidateIndex !== index
+      && candidate.index <= mention.index
+      && candidate.end >= mention.end
+      && candidate.normalizedName.length > mention.normalizedName.length
+    )))
+    .sort((lhs, rhs) => lhs.index - rhs.index);
+}
+
+function sentenceBounds(text, start, end = start) {
+  const before = Math.max(
+    text.lastIndexOf('.', start),
+    text.lastIndexOf('!', start),
+    text.lastIndexOf('?', start),
+    text.lastIndexOf('\n', start)
+  );
+  const afterCandidates = ['.', '!', '?', '\n']
+    .map((char) => text.indexOf(char, end))
+    .filter((index) => index >= 0);
+  return {
+    start: before >= 0 ? before + 1 : 0,
+    end: afterCandidates.length > 0 ? Math.min(...afterCandidates) : text.length
+  };
+}
+
+function mentionForClaim(mentions, text, claim) {
+  const claimStart = claim.index ?? -1;
+  const claimEnd = claim.end ?? claimStart + String(claim.text ?? '').length;
+  if (claimStart < 0) return null;
+  const bounds = sentenceBounds(text, claimStart, claimEnd);
+  const candidates = mentions.filter((mention) => (
+    mention.index >= bounds.start
+    && mention.end <= bounds.end
+  ));
+  return candidates
+    .map((mention) => ({
+      mention,
+      distance: mention.end <= claimStart
+        ? claimStart - mention.end
+        : mention.index >= claimEnd
+          ? mention.index - claimEnd
+          : 0
+    }))
+    .sort((lhs, rhs) => lhs.distance - rhs.distance)[0]?.mention ?? null;
+}
+
+function hasNegationBefore(text, index, tokenPattern) {
+  const window = text.slice(Math.max(0, index - 40), index);
+  return tokenPattern.test(window);
+}
+
+function topSetFromSets(sets = []) {
+  return sets
+    .map((set) => ({
+      weight: Number(set?.weight),
+      reps: Number(set?.reps)
+    }))
+    .filter((set) => Number.isFinite(set.weight) && Number.isFinite(set.reps))
+    .sort((lhs, rhs) => (rhs.weight * (1 + rhs.reps / 30)) - (lhs.weight * (1 + lhs.reps / 30)))[0] ?? null;
+}
+
+function compareEvidenceTopSets(currentTopSet, previousTopSet) {
+  const currentWeight = Number(currentTopSet?.weight);
+  const previousWeight = Number(previousTopSet?.weight);
+  const currentReps = Number(currentTopSet?.reps);
+  const previousReps = Number(previousTopSet?.reps);
+  if (!Number.isFinite(currentWeight) || !Number.isFinite(previousWeight)) return null;
+  let loadDirection = 'same';
+  if (currentWeight > previousWeight) loadDirection = 'up';
+  if (currentWeight < previousWeight) loadDirection = 'down';
+  if (loadDirection === 'same' && Number.isFinite(currentReps) && Number.isFinite(previousReps)) {
+    if (currentReps > previousReps) loadDirection = 'up';
+    if (currentReps < previousReps) loadDirection = 'down';
+  }
+  return { loadDirection, previousTopSet };
+}
+
+function comparedToPreviousEvidence(row) {
+  if (row?.comparedToPreviousSession) return row.comparedToPreviousSession;
+  if (!row?.previousComparableSession) return null;
+  const currentTopSet = row?.topSet ?? topSetFromSets(row?.sets);
+  const previousTopSet = topSetFromSets(row.previousComparableSession.sets);
+  return compareEvidenceTopSets(currentTopSet, previousTopSet);
+}
+
+function rowTopSet(row) {
+  if (row?.topSet) return row.topSet;
+  const weight = Number(row?.weight);
+  const reps = Number(row?.reps);
+  if (Number.isFinite(weight) && Number.isFinite(reps)) return { weight, reps };
+  return null;
+}
+
+function addEvidenceRow(rows, toolName, row, inherited = {}) {
+  const exerciseName = row?.exerciseName ?? row?.name ?? inherited.exerciseName ?? null;
+  const normalizedName = normalizeExerciseName(exerciseName);
+  if (!normalizedName) return;
+  rows.push({
+    toolName,
+    exerciseName,
+    normalizedName,
+    date: row?.date ?? inherited.date ?? null,
+    daysAgo: row?.daysAgo ?? inherited.daysAgo ?? null,
+    recencyCutoffDays: row?.recencyCutoffDays ?? inherited.recencyCutoffDays ?? null,
+    isStale: row?.isStale ?? inherited.isStale ?? false,
+    topSet: rowTopSet(row),
+    comparedToPreviousSession: comparedToPreviousEvidence(row),
+    sets: Array.isArray(row?.sets) ? row.sets : []
+  });
+}
+
+function evidenceRows(toolResults = []) {
+  const rows = [];
+  for (const toolResult of toolResults) {
+    for (const row of toolResult?.rows ?? []) {
+      if (Array.isArray(row?.exercises)) {
+        for (const exercise of row.exercises) {
+          addEvidenceRow(rows, toolResult.toolName, exercise, {
+            date: row.date,
+            daysAgo: row.daysAgo,
+            recencyCutoffDays: row.recencyCutoffDays,
+            isStale: row.isStale
+          });
+        }
+      } else if (row?.first || row?.best || row?.latest) {
+        for (const point of [row.first, row.best, row.latest]) {
+          addEvidenceRow(rows, toolResult.toolName, point, {
+            exerciseName: row.exerciseName,
+            recencyCutoffDays: row.recencyCutoffDays,
+            isStale: row.isStale
+          });
+        }
+      } else {
+        addEvidenceRow(rows, toolResult.toolName, row);
+      }
+    }
+  }
+  return rows;
+}
+
+function replayAskToolResults(snapshot, routingMetadata = {}, { today = new Date(), exclude = [], executeTool = executeCoachReadTool } = {}) {
+  const results = [];
+  const failures = [];
+  const seen = new Set();
+  const toolParams = routingMetadata.toolParams ?? {};
+  const excludeList = normalizeExcludeList(exclude);
+  const invocations = [
+    ...uniqueStrings(routingMetadata.toolsUsed ?? []).map((toolName) => ({
+      name: toolName,
+      params: toolParams[toolName] ?? {}
+    })),
+    ...(routingMetadata.agenticToolInvocations ?? [])
+  ];
+
+  for (const invocation of invocations) {
+    const name = invocation?.name;
+    if (!name) continue;
+    const params = invocation?.params ?? {};
+    const key = `${name}:${stableJsonStringify(params)}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    try {
+      results.push(executeTool(snapshot, name, { ...params, today: params.today ?? dateOnlyString(today), exclude: excludeList }));
+    } catch (error) {
+      failures.push({
+        key: 'tool_replay_failed',
+        severity: 'blocking',
+        toolName: name,
+        reason: `Could not replay routed tool ${name}: ${error?.message ?? String(error)}`
+      });
+    }
+  }
+
+  return { toolResults: results, replayFailures: failures };
+}
+
+function extractWeightClaims(text) {
+  const claims = [];
+  const pattern = /\b(\d+(?:\.\d+)?)\s*(?:kg|kilograms?)\b/gi;
+  for (const match of normalizeText(text).matchAll(pattern)) {
+    claims.push({
+      text: match[0],
+      value: Number(match[1]),
+      index: match.index ?? -1,
+      end: (match.index ?? -1) + match[0].length
+    });
+  }
+  return claims;
+}
+
+function extractWeightedSetClaims(text) {
+  const claims = [];
+  const pattern = /\b(\d+(?:\.\d+)?)\s*(?:kg|kilograms?)\s*(?:x|×|for)\s*(\d+)\b/gi;
+  for (const match of normalizeText(text).matchAll(pattern)) {
+    claims.push({
+      text: match[0],
+      weight: Number(match[1]),
+      reps: Number(match[2]),
+      index: match.index ?? -1,
+      end: (match.index ?? -1) + match[0].length
+    });
+  }
+  return claims;
+}
+
+function weightsForRows(rows) {
+  const weights = [];
+  for (const row of rows) {
+    for (const set of row.sets ?? []) {
+      const weight = Number(set.weight);
+      if (Number.isFinite(weight)) weights.push(weight);
+    }
+    for (const source of [row.topSet, row.comparedToPreviousSession?.previousTopSet]) {
+      const weight = Number(source?.weight);
+      if (Number.isFinite(weight)) weights.push(weight);
+    }
+  }
+  return weights;
+}
+
+function setPairsForRows(rows) {
+  const pairs = [];
+  for (const row of rows) {
+    for (const set of row.sets ?? []) {
+      const weight = Number(set.weight);
+      const reps = Number(set.reps);
+      if (Number.isFinite(weight) && Number.isFinite(reps)) pairs.push({ weight, reps });
+    }
+    for (const source of [row.topSet, row.comparedToPreviousSession?.previousTopSet]) {
+      const weight = Number(source?.weight);
+      const reps = Number(source?.reps);
+      if (Number.isFinite(weight) && Number.isFinite(reps)) pairs.push({ weight, reps });
+    }
+  }
+  return pairs;
+}
+
+function isEstimatedOneRepMaxWeightClaim(text, claim) {
+  const start = Math.max(0, claim.index - 40);
+  const end = Math.min(text.length, claim.index + claim.text.length + 40);
+  return /\b(?:estimated\s+)?(?:1rm|e1rm|one[-\s]?rep\s+max)\b/i.test(text.slice(start, end));
+}
+
+function isVolumeWeightClaim(text, claim) {
+  const start = Math.max(0, claim.index - 30);
+  const end = Math.min(text.length, claim.index + claim.text.length + 30);
+  return /\bvolume\b/i.test(text.slice(start, end));
+}
+
+function isBodyWeightClaim(text, claim) {
+  const start = Math.max(0, claim.index - 50);
+  const end = Math.min(text.length, claim.index + claim.text.length + 50);
+  return /\b(?:body\s*weight|bodyweight|scale\s+weight|weigh(?:ed|s|ing)?)\b/i.test(text.slice(start, end));
+}
+
+function isUnsupportedReferenceClaim(text, claim) {
+  const start = Math.max(0, claim.index - 80);
+  const end = Math.min(text.length, claim.index + String(claim.text ?? '').length + 80);
+  const window = text.slice(start, end);
+  return /\b(?:cannot|can't|couldn'?t|do not|don't|not able to|unable to|won'?t|not going to)\b.{0,60}\b(?:verify|support|confirm|say|claim|trust|use)\b/i.test(window)
+    || /\b(?:unsupported|unverified|not supported|not verified|not enough evidence|without evidence|missing evidence)\b/i.test(window)
+    || /\b(?:evidence|data|route|tools?)\b.{0,60}\b(?:does(?: not|n't)|do(?: not|n't)|did(?: not|n't)|not)\b.{0,30}\b(?:include|show|support|verify|confirm)\b/i.test(window);
+}
+
+function weightSupported(claim, rows) {
+  return weightsForRows(rows).some((weight) => Math.abs(weight - claim.value) < 0.01);
+}
+
+function setPairSupported(claim, rows) {
+  return setPairsForRows(rows).some((pair) => (
+    Math.abs(pair.weight - claim.weight) < 0.01 && pair.reps === claim.reps
+  ));
+}
+
+function claimWithinSetClaim(claim, setClaims) {
+  return setClaims.some((setClaim) => claim.index >= setClaim.index && claim.index < setClaim.end);
+}
+
+function outputHasE1rmClaim(output) {
+  return /\b(?:estimated\s+)?(?:e1rm|1rm|one[- ]rep max)\b/i.test(output);
+}
+
+function e1rmUncertaintyLanguage(output) {
+  return /\b(?:no|not enough|without|missing|lack(?:ing)?|insufficient)\b.{0,80}\b(?:e1rm|1rm|one[- ]rep max|records?|evidence|data)\b/i.test(output)
+    || /\b(?:cannot|can't|couldn'?t|do not|don't|not able to|unable to)\b.{0,80}\b(?:verify|support|confirm|see|claim|say)\b.{0,80}\b(?:e1rm|1rm|one[- ]rep max)\b/i.test(output)
+    || /\b(?:e1rm|1rm|one[- ]rep max)\b.{0,80}\b(?:not|isn'?t|wasn'?t)\b.{0,80}\b(?:in|included|shown|supported|verified)\b/i.test(output);
+}
+
+function targetHitClaims(text) {
+  return [
+    ...text.matchAll(/\b(?:you\s+)?hit(?:ting)?\s+all\s+(?:your\s+)?target(?:ed)?\s+reps?\b/gi),
+    ...text.matchAll(/\b(?:you\s+)?hit\s+all\s+(?:the\s+)?targets?\b/gi),
+    ...text.matchAll(/\b(?:you\s+)?hit\s+(?:the|your)\s+target\b(?!\s+(?:of|for|on))/gi)
+  ]
+    .filter((match) => !hasNegationBefore(text, match.index ?? 0, /\b(?:not|didn'?t|don'?t|failed to|missed|never)\b[\s\w'-]*$/i))
+    .map((match) => ({ text: match[0] }));
+}
+
+function cleanConsistencyClaims(text) {
+  return [
+    ...text.matchAll(/\bclean,\s+consistent\b/gi),
+    ...text.matchAll(/\bclean\s+and\s+consistent\b/gi),
+    ...text.matchAll(/\bconsistent\s+set\s+of\s+work\b/gi),
+    ...text.matchAll(/\bacross\s+the\s+board\b/gi)
+  ]
+    .filter((match) => !hasNegationBefore(text, match.index ?? 0, /\b(?:not|wasn'?t|weren'?t|isn'?t|hardly|not a)\b[\s\w'-]*$/i))
+    .map((match) => ({ text: match[0] }));
+}
+
+function recentSessionMisses(snapshot, { today = new Date(), lookbackDays = 7, exerciseNames = [] } = {}) {
+  const todayMs = Date.parse(`${dateOnlyString(today)}T00:00:00.000Z`);
+  const cutoff = Number.isFinite(todayMs) ? todayMs - lookbackDays * 24 * 60 * 60 * 1000 : Date.now() - lookbackDays * 24 * 60 * 60 * 1000;
+  const scoped = exerciseNames.length > 0 ? new Set(exerciseNames) : null;
+  const misses = [];
+  for (const session of snapshot?.sessions ?? []) {
+    const completedAt = session.completedAt || session.date;
+    const completedTime = Date.parse(completedAt);
+    if (!Number.isFinite(completedTime) || completedTime < cutoff) continue;
+    const targetByExercise = new Map();
+    for (const planned of session.prescriptionSnapshot?.exercises ?? []) {
+      const target = Number(planned.targetReps);
+      if (Number.isFinite(target) && target > 0) {
+        targetByExercise.set(normalizeExerciseName(planned.exerciseName), target);
+      }
+    }
+    for (const exercise of session.exercises ?? []) {
+      const normalizedName = normalizeExerciseName(exercise.name);
+      if (scoped && !scoped.has(normalizedName)) continue;
+      const target = targetByExercise.get(normalizedName);
+      if (!Number.isFinite(target)) continue;
+      for (const set of exercise.sets ?? []) {
+        const reps = Number(set.reps);
+        if (set.isComplete && Number.isFinite(reps) && reps < target) {
+          misses.push({ sessionId: session.id, exerciseName: exercise.name, reps, target });
+        }
+      }
+    }
+  }
+  return misses;
+}
+
+function fatigueLanguage(output) {
+  return /\b(fatigue|fatigued|underrecovered|under[-\s]?recovery|poor recovery|low recovery|incomplete recovery|recovery debt|fatigue ceiling|limited by recovery|limited by fatigue|accumulated fatigue)\b/i.test(output);
+}
+
+function fatigueUncertaintyLanguage(output) {
+  return /\b(?:no|not enough|without|missing|lack(?:ing)?|insufficient)\s+(?:\w+\s+){0,4}?(?:recovery|readiness|vitals?|sleep|hrv|heart rate|data|info|signals?|metrics?)\b/i.test(output)
+    || /\b(?:cannot|can't|do not|don't|not enough|isn't enough|no basis to|hard to)\s+(?:\w+\s+){0,12}?(?:infer|tie|connect|attribute|blame|claim|say|show|prove|know|call)\s+(?:\w+\s+){0,12}?(?:fatigue|recovery|readiness|why)\b/i.test(output);
+}
+
+function fatigueSupport(snapshot, {
+  today = new Date(),
+  lookbackDays = 7,
+  exclude = [],
+  allowRecoveryMetrics = false,
+  allowSessionDropoff = false
+} = {}) {
+  const todayMs = Date.parse(`${dateOnlyString(today)}T00:00:00.000Z`);
+  const cutoff = Number.isFinite(todayMs) ? todayMs - lookbackDays * 24 * 60 * 60 * 1000 : Date.now() - lookbackDays * 24 * 60 * 60 * 1000;
+  const excluded = new Set(normalizeExcludeList(exclude));
+  const withinCutoff = (dateValue) => {
+    const ms = Date.parse(dateValue);
+    return Number.isFinite(ms) && ms >= cutoff;
+  };
+
+  if (allowRecoveryMetrics && !excluded.has('recovery')) {
+    if ((snapshot?.vitalsSummaries ?? []).some((entry) => withinCutoff(entry.date))) return true;
+    const metrics = snapshot?.healthMetrics ?? {};
+    for (const key of ['restingHR', 'hrv', 'sleep']) {
+      if ((Array.isArray(metrics[key]) ? metrics[key] : []).some((reading) => withinCutoff(reading.date))) return true;
+    }
+  }
+
+  if (allowSessionDropoff) {
+    for (const session of snapshot?.sessions ?? []) {
+      if (!withinCutoff(session.completedAt || session.date)) continue;
+      for (const exercise of session.exercises ?? []) {
+        const reps = (exercise.sets ?? []).map((set) => Number(set.reps)).filter((value) => Number.isFinite(value) && value > 0);
+        if (reps.length >= 2 && reps[0] > 0 && (reps[0] - reps.at(-1)) / reps[0] >= 0.3) return true;
+      }
+    }
+  }
+  return false;
+}
+
+function declineLanguage(window) {
+  const text = normalizeText(window);
+  const decline = /\b(drop(?:ped|ping|s)?(?: off)?|drop-off|declin(?:e|ed|ing)|regress(?:ed|ion|ing)?|fell|fall(?:ing)?|decreas(?:e|ed|ing)|lower|worse|slid|slipped)\b/i;
+  if (!decline.test(text)) return false;
+  if (/\b(?:no|not|isn'?t|wasn'?t|without|rather than)\b.{0,45}\b(drop(?:ped|ping|s)?(?: off)?|drop-off|declin(?:e|ed|ing)?|decreas(?:e|ed|ing)?|regress(?:ed|ion|ing)?|fall(?:ing)?|fell|lower|worse|slid|slipped)\b/i.test(text)) return false;
+  if (/\b(?:rep|reps)\b.{0,20}\b(drop(?:ped|ping|s)?(?: off)?|drop-off|slip(?:ped|ping)?|fell|fall(?:ing)?|lower|declin(?:e|ed|ing)?|decreas(?:e|ed|ing)?|worse)\b/i.test(text)) return false;
+  return true;
+}
+
+function improvementLanguage(window) {
+  const text = normalizeText(window);
+  const improvement = /\b(improv(?:e|ed|ing|ement)|progress(?:ed|ing)?|stronger|increas(?:e|ed|ing)|moving up|went up|up from|load jump|jumped)\b/i;
+  if (!improvement.test(text)) return false;
+  if (/\b(?:no|not|isn'?t|wasn'?t|without|rather than)\b.{0,35}\b(improv(?:e|ed|ing|ement)?|progress(?:ed|ing)?|stronger|increas(?:e|ed|ing)?|moving up|went up|up from|load jump|jump(?:ed|ing)?)\b/i.test(text)) return false;
+  if (/\b(?:rep|reps)\b.{0,20}\b(improv(?:e|ed|ing|ement)?|increas(?:e|ed|ing)?|better|moving up|went up|up from|load jump|jump(?:ed|ing)?)\b/i.test(text)) return false;
+  return true;
+}
+
+function directionWindows(outputText, exerciseName, exerciseNames = []) {
+  const normalizedExercise = normalizeExerciseName(exerciseName);
+  const otherExercises = [...new Set(exerciseNames.map(normalizeExerciseName))]
+    .filter((name) => name && name !== normalizedExercise);
+  const sentences = outputText.split(/(?<=[.!?])\s+/).map((sentence) => sentence.trim()).filter(Boolean);
+  if (!normalizedExercise) return sentences;
+  const windows = [];
+  for (let index = 0; index < sentences.length; index += 1) {
+    if (!normalizeExerciseName(sentences[index]).includes(normalizedExercise)) continue;
+    const clauses = sentences[index]
+      .split(/\s*(?:[;:]|,\s+|\bwhile\b|\bbut\b)\s*/i)
+      .map((clause) => clause.trim())
+      .filter(Boolean);
+    const scopedClauses = clauses.filter((clause) => normalizeExerciseName(clause).includes(normalizedExercise));
+    windows.push(...(scopedClauses.length > 0 ? scopedClauses : [sentences[index]]));
+    for (let nextIndex = index + 1; nextIndex < sentences.length; nextIndex += 1) {
+      const normalizedNext = normalizeExerciseName(sentences[nextIndex]);
+      if (otherExercises.some((name) => normalizedNext.includes(name))) break;
+      if (!/^(?:that|this|it|there|still|the\s+(?:latest|top)|top\s+set|same\s+load)\b/i.test(sentences[nextIndex])) break;
+      windows.push(sentences[nextIndex]);
+    }
+  }
+  return windows.length > 0 ? [...new Set(windows)] : [outputText];
+}
+
+function newestComparableRow(rows = []) {
+  return rows
+    .filter((row) => row.comparedToPreviousSession?.loadDirection)
+    .sort((lhs, rhs) => {
+      const lhsDays = Number(lhs.daysAgo);
+      const rhsDays = Number(rhs.daysAgo);
+      if (Number.isFinite(lhsDays) && Number.isFinite(rhsDays)) return lhsDays - rhsDays;
+      return String(rhs.date ?? '').localeCompare(String(lhs.date ?? ''));
+    })[0] ?? null;
+}
+
+function checkSnapshotClaims(answer, snapshot, routingMetadata, { today = new Date(), exclude = [] } = {}) {
+  const failures = [];
+  const mentions = findAskAnswerExerciseMentions(answer, snapshot);
+  const scopedExerciseNames = uniqueStrings(mentions.map((mention) => mention.normalizedName));
+  const normalized = normalizeText(answer);
+  const toolNames = routedToolNames(routingMetadata);
+  const hasSessionEvidence = [
+    'get_recent_sessions',
+    'get_exercise_history',
+    'get_next_session',
+    'get_exercise_progress_summary',
+    'get_program_progress',
+    'compare_session_to_observations'
+  ].some((toolName) => toolNames.has(toolName));
+  const hasRecoveryEvidence = [
+    'get_readiness_snapshot',
+    'get_program_progress'
+  ].some((toolName) => toolNames.has(toolName));
+  const misses = hasSessionEvidence
+    ? recentSessionMisses(snapshot, { today, exerciseNames: scopedExerciseNames })
+    : [];
+
+  if (targetHitClaims(normalized).length > 0) {
+    if (!hasSessionEvidence) {
+      failures.push({
+        key: 'target_hit_without_session_evidence',
+        severity: 'blocking',
+        reason: 'Draft claims target reps were hit, but routed evidence did not include session performance.'
+      });
+    } else if (misses.length > 0) {
+      const sample = misses[0];
+      failures.push({
+        key: 'target_hit_contradiction',
+        severity: 'blocking',
+        reason: `Draft claims targets were hit, but ${sample.exerciseName} has ${sample.reps} reps below target ${sample.target}.`
+      });
+    }
+  }
+
+  if (cleanConsistencyClaims(normalized).length > 0 && misses.length > 0) {
+    const sample = misses[0];
+    failures.push({
+      key: 'clean_consistency_contradiction',
+      severity: 'blocking',
+      reason: `Draft frames missed target reps as clean consistency, but ${sample.exerciseName} has ${sample.reps} reps below target ${sample.target}.`
+    });
+  }
+
+  if (fatigueLanguage(normalized) && !fatigueUncertaintyLanguage(normalized) && !fatigueSupport(snapshot, {
+    today,
+    exclude,
+    allowRecoveryMetrics: hasRecoveryEvidence,
+    allowSessionDropoff: hasSessionEvidence
+  })) {
+    failures.push({
+      key: 'unsupported_fatigue_recovery',
+      severity: 'blocking',
+      reason: 'Draft uses fatigue/recovery attribution without recent vitals, sleep, or rep-dropoff support.'
+    });
+  }
+
+  return failures;
+}
+
+function checkToolProvenance(answer, snapshot, routingMetadata, {
+  today = new Date(),
+  exclude = [],
+  strictMentionProvenance = false,
+  executeTool = executeCoachReadTool
+} = {}) {
+  const failures = [];
+  const { toolResults, replayFailures } = replayAskToolResults(snapshot, routingMetadata, { today, exclude, executeTool });
+  failures.push(...replayFailures);
+
+  const rows = evidenceRows(toolResults);
+  const mentions = findAskAnswerExerciseMentions(answer, snapshot);
+  const toolsUsed = routedToolNames(routingMetadata);
+  const normalized = normalizeText(answer);
+
+  if (outputHasE1rmClaim(answer) && !e1rmUncertaintyLanguage(answer) && !toolsUsed.has('get_records')) {
+    failures.push({
+      key: 'e1rm_without_records',
+      severity: 'blocking',
+      reason: 'Draft mentions e1RM/1RM, but routed evidence did not use get_records.'
+    });
+  }
+
+  const setClaims = extractWeightedSetClaims(answer);
+  for (const claim of setClaims) {
+    if (isEstimatedOneRepMaxWeightClaim(answer, claim)) continue;
+    if (isUnsupportedReferenceClaim(answer, claim)) continue;
+    const mention = mentionForClaim(mentions, normalized, claim);
+    if (!mention) continue;
+    const exerciseRows = rows.filter((row) => row.normalizedName === mention.normalizedName);
+    if (exerciseRows.length === 0) {
+      failures.push({
+        key: 'unrouted_weighted_set_claim',
+        severity: 'blocking',
+        exerciseName: mention.name,
+        reason: `Draft asserts a weighted set for ${mention.name}, but that exercise was not in routed tool evidence.`
+      });
+    } else if (!setPairSupported(claim, exerciseRows)) {
+      failures.push({
+        key: 'unsupported_weighted_set_claim',
+        severity: 'blocking',
+        exerciseName: mention.name,
+        reason: `Draft asserts ${claim.text} for ${mention.name}, but routed evidence does not include that weight/reps pair.`
+      });
+    }
+  }
+
+  for (const claim of extractWeightClaims(answer)) {
+    if (claimWithinSetClaim(claim, setClaims)) continue;
+    if (isEstimatedOneRepMaxWeightClaim(answer, claim) || isVolumeWeightClaim(answer, claim) || isBodyWeightClaim(answer, claim)) continue;
+    if (isUnsupportedReferenceClaim(answer, claim)) continue;
+    const mention = mentionForClaim(mentions, normalized, claim);
+    if (!mention) continue;
+    const exerciseRows = rows.filter((row) => row.normalizedName === mention.normalizedName);
+    if (exerciseRows.length === 0) {
+      failures.push({
+        key: 'unrouted_weight_claim',
+        severity: 'blocking',
+        exerciseName: mention.name,
+        reason: `Draft asserts a load for ${mention.name}, but that exercise was not in routed tool evidence.`
+      });
+    } else if (!weightSupported(claim, exerciseRows)) {
+      failures.push({
+        key: 'unsupported_weight_claim',
+        severity: 'blocking',
+        exerciseName: mention.name,
+        reason: `Draft asserts ${claim.text} for ${mention.name}, but routed evidence does not include that load.`
+      });
+    }
+  }
+
+  const exerciseNames = rows.map((row) => row.exerciseName);
+  for (const mention of mentions) {
+    const exerciseRows = rows.filter((row) => row.normalizedName === mention.normalizedName);
+    if (exerciseRows.length === 0) {
+      if (strictMentionProvenance && toolResults.length > 0) {
+        failures.push({
+          key: 'unrouted_exercise_mention',
+          severity: 'advisory',
+          exerciseName: mention.name,
+          reason: `Draft mentions ${mention.name}, but that exercise was not in routed tool evidence.`
+        });
+      }
+      continue;
+    }
+    const comparable = newestComparableRow(exerciseRows);
+    if (!comparable) continue;
+    const direction = comparable.comparedToPreviousSession.loadDirection;
+    const exercisePattern = new RegExp(escapeRegExp(mention.name), 'gi');
+    const windows = directionWindows(normalized, mention.name, exerciseNames)
+      .map((window) => window.replace(exercisePattern, ''));
+    if (direction === 'up' && windows.some(declineLanguage)) {
+      failures.push({
+        key: 'direction_inversion',
+        severity: 'blocking',
+        exerciseName: mention.name,
+        reason: `Draft frames ${mention.name} as declining, but routed evidence says top load increased.`
+      });
+    }
+    if (direction === 'down' && windows.some(improvementLanguage)) {
+      failures.push({
+        key: 'direction_inversion',
+        severity: 'blocking',
+        exerciseName: mention.name,
+        reason: `Draft frames ${mention.name} as improving, but routed evidence says top load decreased.`
+      });
+    }
+  }
+
+  return failures;
+}
+
+const OBSERVATION_FOLLOWUP_ARTIFACT_PATTERNS = [
+  /\bi can confirm (?:the |this )?(?:coach )?observation\b/i,
+  /\b(?:the|this) (?:coach )?observation\b/i,
+  /\bcoach observation\b/i,
+  /\b(?:the|this) (?:coach )?note\b/i,
+  /\bcoach note\b/i,
+  /\b(?:the|this) (?:coach )?card\b/i,
+  /\bcoach card\b/i,
+  /\b(?:the|this) system\b/i
+];
+
+function checkObservationFollowupVoice(answer, route) {
+  if (route !== 'coach_observation_followup') return [];
+  const hits = uniqueStrings(OBSERVATION_FOLLOWUP_ARTIFACT_PATTERNS
+    .map((pattern) => answer.match(pattern)?.[0])
+    .filter(Boolean));
+  if (hits.length === 0) return [];
+  return [{
+    key: 'observation_followup_artifact_voice',
+    severity: 'blocking',
+    reason: `Observation follow-up answer talks about the coach artifact instead of speaking as the coach: ${hits.join(', ')}. Own it with first-person coaching language.`
+  }];
+}
+
+export function verifyAskAnswer({
+  answer,
+  snapshot,
+  routingMetadata = {},
+  today = new Date(),
+  exclude = [],
+  strictMentionProvenance = false,
+  executeTool = executeCoachReadTool
+} = {}) {
+  const normalized = normalizeText(answer);
+  if (!normalized || normalized === 'NO_INSIGHT') {
+    return verificationResult([]);
+  }
+
+  const route = routingMetadata?.effectiveRoute ?? routingMetadata?.route ?? routingMetadata?.evidencePlan?.effectiveRoute ?? routingMetadata?.evidencePlan?.route;
+  if (route === 'program_design') {
+    return verificationResult([], { skipped: true, skipReason: 'program_design_allows_new_exercises' });
+  }
+  const voiceFailures = checkObservationFollowupVoice(normalized, route);
+  const requestedAction = routingMetadata?.intent?.requestedAction ?? routingMetadata?.requestedAction;
+  const isPlanAdjustment = requestedAction === 'draft_changeset'
+    || routingMetadata?.observationFollowUpIntent === 'plan_adjustment'
+    || routingMetadata?.requestedCoachObservationIntent === 'plan_adjustment';
+  const isSuccessorPlan = requestedAction === 'draft_plan'
+    || routingMetadata?.observationFollowUpIntent === 'successor_plan'
+    || routingMetadata?.requestedCoachObservationIntent === 'successor_plan';
+  // Forward-looking prescriptions (successor program or plan changeset) legitimately
+  // describe future loads, which would trip the snapshot/provenance claim checks.
+  // Voice is still enforced; only the claim checks are waived.
+  if (route === 'coach_observation_followup' && (isSuccessorPlan || isPlanAdjustment)) {
+    if (voiceFailures.length > 0) return verificationResult(voiceFailures);
+    return verificationResult([], {
+      skipped: true,
+      skipReason: isPlanAdjustment
+        ? 'plan_adjustment_allows_future_prescription'
+        : 'successor_plan_allows_future_prescription'
+    });
+  }
+
+  const failures = [
+    ...voiceFailures,
+    ...checkSnapshotClaims(normalized, snapshot, routingMetadata, { today, exclude }),
+    ...checkToolProvenance(normalized, snapshot, routingMetadata, { today, exclude, strictMentionProvenance, executeTool })
+  ];
+  return verificationResult(failures);
+}
+
+function verificationResult(failures, { skipped = false, skipReason = null } = {}) {
+  const blockingFailures = failures.filter((failure) => failure.severity !== 'advisory');
+  const advisoryFailures = failures.filter((failure) => failure.severity === 'advisory');
+  const checks = [
+    {
+      key: 'ask_answer_blocking_claims',
+      passed: blockingFailures.length === 0,
+      severity: 'blocking',
+      reason: blockingFailures.length === 0
+        ? 'No blocking unsupported Ask answer claims detected.'
+        : blockingFailures.map((failure) => failure.reason).join(' ')
+    },
+    {
+      key: 'ask_answer_advisory_claims',
+      passed: advisoryFailures.length === 0,
+      severity: 'advisory',
+      reason: advisoryFailures.length === 0
+        ? 'No advisory Ask answer provenance gaps detected.'
+        : advisoryFailures.map((failure) => failure.reason).join(' ')
+    }
+  ];
+  return {
+    version: ASK_ANSWER_VERIFIER_VERSION,
+    skipped,
+    skipReason,
+    passed: blockingFailures.length === 0,
+    status: skipped ? 'skipped' : blockingFailures.length === 0 ? 'passed' : 'failed',
+    blockingFailures,
+    advisoryFailures,
+    checks,
+    blockingFailureCount: blockingFailures.length,
+    advisoryFailureCount: advisoryFailures.length,
+    failureKeys: uniqueStrings(failures.map((failure) => failure.key))
+  };
+}
+
+export function askVerificationMetadata(verification, {
+  retryCount = 0,
+  repaired = false,
+  fallback = false
+} = {}) {
+  if (!verification) return null;
+  return compactObject({
+    version: verification.version ?? ASK_ANSWER_VERIFIER_VERSION,
+    status: fallback ? 'fallback' : verification.status,
+    passed: verification.passed === true && !fallback,
+    skipped: verification.skipped === true ? true : undefined,
+    skipReason: verification.skipReason,
+    retryCount,
+    repaired: repaired ? true : undefined,
+    fallback: fallback ? true : undefined,
+    blockingFailureCount: verification.blockingFailureCount ?? 0,
+    advisoryFailureCount: verification.advisoryFailureCount ?? 0,
+    failureKeys: verification.failureKeys ?? []
+  });
+}
+
+export function shouldRepairAskAnswer(verification) {
+  return verification?.passed === false && (verification.blockingFailureCount ?? 0) > 0;
+}
+
+export function buildAskAnswerRepairContext(context, _draftAnswer, verification) {
+  const reasons = (verification?.blockingFailures ?? [])
+    .slice(0, 6)
+    .map((failure) => `- ${failure.reason}`)
+    .join('\n');
+  return [
+    context,
+    '',
+    'Ask answer verification failed. Rewrite the answer so every exercise, load, rep, direction, and target-hit claim is directly supported by the evidence above.',
+    'Do not preserve unsupported claims. If the evidence is not enough, say that plainly instead of guessing.',
+    'Verifier findings:',
+    reasons || '- Unsupported training claim detected.',
+    '',
+    'Do not reuse the failed draft. Produce a fresh answer from the evidence.'
+  ].join('\n');
+}
+
+export function safeAskVerificationFallback() {
+  return 'I can’t answer that safely from the evidence I just checked. The draft answer included training claims I could not verify, so I’m not going to guess. Ask me about a specific session or lift and I’ll re-check the data.';
+}