incremnt 0.8.7 → 0.8.8

package/src/ask-coach/renderers.js

@@ -0,0 +1,4 @@
+export {
+  askRoutedContext,
+  buildAskContextBundle
+} from './orchestrator.js';

package/src/ask-coach/routing.js

@@ -0,0 +1,610 @@
+import { dateOnlyString, relativeDateString } from '../queries/common.js';
+import { canonicalExerciseName, normalizeExerciseName } from '../queries/exercise-identity.js';
+
+function allExerciseNames(snapshot) {
+  const names = new Map();
+  for (const session of snapshot.sessions ?? []) {
+    for (const exercise of session.exercises ?? []) {
+      if (!exercise.name) continue;
+      names.set(canonicalExerciseName(exercise.name), exercise.name);
+    }
+    for (const exercise of session.prescriptionSnapshot?.exercises ?? []) {
+      const name = exercise.exerciseName ?? exercise.name;
+      if (!name) continue;
+      names.set(canonicalExerciseName(name), 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;
+        names.set(canonicalExerciseName(name), name);
+      }
+    }
+  }
+  return names;
+}
+
+function namedExercisesFromQuestion(snapshot, question) {
+  const normalizedQuestion = normalizeExerciseName(question ?? '');
+  const matches = new Map();
+  const knownExercises = allExerciseNames(snapshot);
+  const knownDisplayByCanonical = new Map(knownExercises);
+  const shorthandAliases = new Map([
+    ['bench', 'bench press'],
+    ['row', 'bent over row'],
+    ['rows', 'bent over row'],
+    ['squat', 'squat'],
+    ['deadlift', 'deadlift'],
+    ['pullups', 'pull ups'],
+    ['pull ups', 'pull ups'],
+    ['pull up', 'pull ups']
+  ]);
+
+  for (const [canonical, displayName] of knownExercises) {
+    const normalizedDisplay = normalizeExerciseName(displayName);
+    if (
+      normalizedQuestion.includes(canonical) ||
+      normalizedQuestion.includes(normalizedDisplay)
+    ) {
+      matches.set(canonical, displayName);
+    }
+  }
+
+  if (matches.size === 0) {
+    for (const [canonical, displayName] of knownExercises) {
+      const displayTokens = normalizeExerciseName(displayName).split(' ').filter(Boolean);
+      const partials = [];
+      if (displayTokens.length >= 3) {
+        for (let index = 0; index < displayTokens.length; index += 1) {
+          const partial = displayTokens.filter((_, tokenIndex) => tokenIndex !== index).join(' ');
+          if (partial.split(' ').length >= 2) partials.push(partial);
+        }
+      }
+      if (partials.some((partial) => new RegExp(`(?:^| )${partial}(?: |$)`).test(normalizedQuestion))) {
+        matches.set(canonical, displayName);
+      }
+    }
+  }
+
+  for (const [alias, canonical] of shorthandAliases) {
+    if (
+      (alias === 'row' || alias === 'rows') &&
+      [...matches.keys()].some((matchedCanonical) => matchedCanonical.split(' ').includes('row'))
+    ) {
+      continue;
+    }
+    if (new RegExp(`(?:^| )${alias}(?: |$)`).test(normalizedQuestion)) {
+      const aliasCanonical = canonicalExerciseName(canonical);
+      matches.set(aliasCanonical, knownDisplayByCanonical.get(aliasCanonical) ?? canonical);
+    }
+  }
+
+  for (const [canonical, displayName] of knownExercises) {
+    if (matches.has(canonical)) continue;
+    const normalizedDisplay = normalizeExerciseName(displayName);
+    if (matches.size > 0) continue;
+    const firstToken = normalizedDisplay.split(' ')[0];
+    if (firstToken && firstToken.length >= 5 && new RegExp(`(?:^| )${firstToken}(?: |$)`).test(normalizedQuestion)) {
+      matches.set(canonical, displayName);
+    }
+  }
+
+  return [...matches.entries()].map(([canonical, displayName]) => ({ canonical, displayName }));
+}
+
+function knownSessionLabels(snapshot) {
+  const labels = new Map();
+  for (const session of snapshot.sessions ?? []) {
+    const label = String(session.dayName ?? session.programName ?? '').trim();
+    if (label) labels.set(normalizeExerciseName(label), label);
+  }
+  for (const program of snapshot.programs ?? []) {
+    for (const day of program.days ?? []) {
+      const label = String(day.title ?? '').trim();
+      if (label) labels.set(normalizeExerciseName(label), label);
+    }
+  }
+  return [...labels.entries()]
+    .filter(([normalized]) => normalized.split(' ').length > 1)
+    .sort((a, b) => b[0].length - a[0].length);
+}
+
+function referencedSessionLabelFromQuestion(snapshot, question) {
+  const normalizedQuestion = normalizeExerciseName(question ?? '');
+  if (!normalizedQuestion) return null;
+  const matched = knownSessionLabels(snapshot).find(([normalized]) => normalizedQuestion.includes(normalized));
+  return matched?.[1] ?? null;
+}
+
+function textSentenceBounds(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 referencedWeightedSets(question) {
+  const sets = [];
+  const pattern = /\b(\d+(?:\.\d+)?)\s*(?:kg|kgs|kilograms?)?\s*(?:x|×|for)\s*(\d+)\b/gi;
+  for (const match of String(question ?? '').matchAll(pattern)) {
+    sets.push({
+      weight: Number(match[1]),
+      reps: Number(match[2]),
+      index: match.index ?? -1,
+      end: (match.index ?? -1) + match[0].length
+    });
+  }
+  return sets;
+}
+
+function referencedExerciseMentions(snapshot, question) {
+  const text = String(question ?? '');
+  const normalized = normalizeExerciseName(text);
+  const mentions = [];
+  for (const [canonical, displayName] of allExerciseNames(snapshot)) {
+    const normalizedDisplay = normalizeExerciseName(displayName);
+    const normalizedIndex = normalized.indexOf(normalizedDisplay);
+    if (normalizedIndex < 0) continue;
+    const sourceIndex = text.toLowerCase().indexOf(String(displayName).toLowerCase());
+    mentions.push({
+      canonical,
+      displayName,
+      index: sourceIndex >= 0 ? sourceIndex : normalizedIndex,
+      end: (sourceIndex >= 0 ? sourceIndex : normalizedIndex) + displayName.length
+    });
+  }
+  return mentions.sort((lhs, rhs) => lhs.index - rhs.index);
+}
+
+function nearestExerciseMentionForSet(mentions, question, set) {
+  if (mentions.length === 0) return null;
+  if (mentions.length === 1) return mentions[0];
+  const bounds = textSentenceBounds(String(question ?? ''), set.index, set.end);
+  return mentions
+    .filter((mention) => mention.index >= bounds.start && mention.end <= bounds.end)
+    .map((mention) => ({
+      mention,
+      distance: mention.end <= set.index
+        ? set.index - mention.end
+        : mention.index >= set.end
+          ? mention.index - set.end
+          : 0
+    }))
+    .sort((lhs, rhs) => lhs.distance - rhs.distance)[0]?.mention ?? null;
+}
+
+function referencedSessionFromQuestion(snapshot, question) {
+  const label = referencedSessionLabelFromQuestion(snapshot, question);
+  if (!label) return null;
+  const mentions = referencedExerciseMentions(snapshot, question);
+  const setHints = referencedWeightedSets(question)
+    .map((set) => {
+      const mention = nearestExerciseMentionForSet(mentions, question, set);
+      return mention ? {
+        exerciseCanonical: mention.canonical,
+        exerciseName: mention.displayName,
+        weight: set.weight,
+        reps: set.reps
+      } : null;
+    })
+    .filter(Boolean);
+  return {
+    label,
+    setHints
+  };
+}
+
+function hasSessionReviewLanguage(question) {
+  return /\b(session|workout|you noted|tell me more|went|go|did my)\b/i.test(question ?? '');
+}
+
+function hasNamedExerciseActionLanguage(question) {
+  return /\b(should|change|swap|deload|increase|decrease|adjust|keep|load|next time)\b/i.test(question ?? '');
+}
+
+const REVIEW_WORD_NUMBERS = Object.freeze({
+  a: 1, an: 1, one: 1, couple: 2, two: 2, three: 3, four: 4, five: 5, six: 6, several: 4
+});
+
+function validDateOnlyString(value) {
+  const text = String(value ?? '').slice(0, 10);
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(text)) return null;
+  const ms = Date.parse(`${text}T00:00:00.000Z`);
+  if (!Number.isFinite(ms)) return null;
+  return new Date(ms).toISOString().slice(0, 10) === text ? text : null;
+}
+
+// Parse relative windows like "last two weeks", "past 10 days", "this month",
+// "couple of weeks", "fortnight" into a day count. Returns null when no relative
+// window is present so callers can fall back to absolute/`since` parsing.
+function inferredRelativeWindowDays(question) {
+  const text = String(question ?? '').toLowerCase();
+  if (/\bfortnight\b/.test(text)) return 14;
+  const match = text.match(
+    /\b(?:last|past|previous|recent|this)\s+(?:(\d+|a|an|one|couple|two|three|four|five|six|several)\s+)?(?:of\s+)?(day|days|week|weeks|month|months)\b/
+  );
+  if (!match) return null;
+  const rawCount = match[1];
+  const unit = match[2];
+  let count;
+  if (rawCount == null) count = 1;
+  else if (/^\d+$/.test(rawCount)) count = Number.parseInt(rawCount, 10);
+  else count = REVIEW_WORD_NUMBERS[rawCount] ?? null;
+  if (count == null || count <= 0) return null;
+  const perUnit = unit.startsWith('day') ? 1 : unit.startsWith('week') ? 7 : 30;
+  return Math.min(count * perUnit, 370);
+}
+
+function inferredSinceDate(question, today = new Date()) {
+  const text = String(question ?? '');
+  const explicitDate = text.match(/\bsince\s+(\d{4}-\d{2}-\d{2})\b/i);
+  if (explicitDate) return validDateOnlyString(explicitDate[1]);
+  const explicitYearMonth = text.match(/\bsince\s+(\d{4}-\d{2})\b/i);
+  if (explicitYearMonth) return validDateOnlyString(`${explicitYearMonth[1]}-01`);
+  const relativeWindow = inferredRelativeWindowDays(text);
+  if (relativeWindow != null) return relativeDateString(today, -relativeWindow);
+  const monthMatch = text.match(/\bsince\s+(jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:t(?:ember)?)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\b/i);
+  if (!monthMatch) return null;
+  const months = {
+    jan: 1, january: 1,
+    feb: 2, february: 2,
+    mar: 3, march: 3,
+    apr: 4, april: 4,
+    may: 5,
+    jun: 6, june: 6,
+    jul: 7, july: 7,
+    aug: 8, august: 8,
+    sep: 9, sept: 9, september: 9,
+    oct: 10, october: 10,
+    nov: 11, november: 11,
+    dec: 12, december: 12
+  };
+  const month = months[monthMatch[1].toLowerCase()];
+  if (!month) return null;
+  const year = new Date(today).getUTCFullYear();
+  const monthPart = String(month).padStart(2, '0');
+  const candidate = `${year}-${monthPart}-01`;
+  return candidate > dateOnlyString(today) ? `${year - 1}-${monthPart}-01` : candidate;
+}
+
+function deloadScheduleContextFromText(text) {
+  const raw = String(text ?? '');
+  if (!/\bd(?:e)?load\b/i.test(raw)) return null;
+  const match = raw.match(/\b(this|next|coming)\s+(?:training\s+)?week\b/i);
+  if (!match) return null;
+  return {
+    week: match[1].toLowerCase() === 'this' ? 'this' : 'next'
+  };
+}
+
+function latestDeloadScheduleContext(history = []) {
+  const messages = (Array.isArray(history) ? history : []).slice(-2);
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index];
+    if (!['user', 'assistant'].includes(message?.role) || typeof message.content !== 'string') continue;
+    const context = deloadScheduleContextFromText(message.content);
+    if (context) return context;
+  }
+  return null;
+}
+
+function isDeloadScheduleConfirmation(question) {
+  const text = String(question ?? '').trim().toLowerCase();
+  if (!text) return false;
+  if (/\b(no|don'?t|do not|cancel|undo|stop|never mind|nevermind)\b/i.test(text)) return false;
+  const wordCount = text.split(/\s+/).filter(Boolean).length;
+  if (wordCount > 8) return false;
+  return /^(yes|yeah|yep|ok|okay|sure)\b/i.test(text) ||
+    /\b(do it|schedule it|set it|make it happen|schedule that|set that)\b/i.test(text);
+}
+
+function hasProgramHistoryLanguage(question, { previousRoute = null, isFollowUp = false } = {}) {
+  const text = String(question ?? '').toLowerCase();
+  const hasProgramLanguage = /\b(program|plan|routine|split)\b/i.test(text);
+  if (/\bwhat changed\b[\s\S]{0,80}\b(program|plan|routine|split)\b/i.test(text) ||
+    /\b(program|plan|routine|split)\b[\s\S]{0,80}\bwhat changed\b/i.test(text) ||
+    /\bwhy\b[\s\S]{0,80}\b(program|plan|routine|split)\b[\s\S]{0,80}\bchang/i.test(text)) {
+    return true;
+  }
+
+  const restoreLanguage = /\b(undo that|undo it|revert that|revert it|restore that|restore it|change it back|previous version|last change)\b/i.test(text);
+  if (!restoreLanguage) return false;
+  if (hasProgramLanguage) return true;
+  return isFollowUp && ['program_history', 'program_progress', 'program_schedule_action'].includes(previousRoute);
+}
+
+function routeAskQuestion(snapshot, question, { today = new Date(), previousRoute = null, isFollowUp = false } = {}) {
+  const normalizedQuestion = normalizeExerciseName(question ?? '');
+  const namedExercises = namedExercisesFromQuestion(snapshot, question);
+  const sessionReference = referencedSessionFromQuestion(snapshot, question);
+  const sessionLabel = sessionReference?.label ?? null;
+  const since = inferredSinceDate(question, today);
+  const progressLanguage = /\b(progress|progressing|improve|improved|improvement|better|stronger|moved|moving|stalled|flat|since)\b/i.test(question ?? '');
+  const profileLanguage = /\b(know about me|about me as a lifter|me as a lifter|lifter profile|training profile)\b/i.test(question ?? '');
+  const programLanguage = /\b(program|plan|split|routine|full gym|ppl|upper lower)\b/i.test(question ?? '');
+  const deloadWord = 'd(?:e)?load';
+  const deloadScheduleContext = deloadScheduleContextFromText(question);
+  const deloadScheduleVerb = '(?:make|schedule|set|program|turn|change|adjust)';
+  const deloadScheduleLanguage = new RegExp(`\\b${deloadScheduleVerb}\\b[\\s\\S]{0,120}\\b(?:this|next|coming)\\s+(?:training\\s+)?week\\b[\\s\\S]{0,120}\\b${deloadWord}\\b`, 'i').test(question ?? '') ||
+    new RegExp(`\\b${deloadScheduleVerb}\\b[\\s\\S]{0,120}\\b${deloadWord}\\b[\\s\\S]{0,120}\\b(?:this|next|coming)\\s+(?:training\\s+)?week\\b`, 'i').test(question ?? '');
+  const windowDays = inferredRelativeWindowDays(question);
+  const reviewVerb = /\b(doing|going|look(?:s|ing|ed)?|progress\w*|train(?:s|ing)?|workouts?|fitness)\b/i.test(question ?? '');
+  const explicitReview = /\b(on (?:the )?(?:right )?track|right track|making (?:good )?progress|overall progress|review (?:my|the)\b|check (?:out\s+)?my\b|how(?:'?s| is| has| have)\s+(?:my|the)\s+(?:training|progress|fitness))\b/i.test(question ?? '');
+  const broadReviewIntent = explicitReview || (windowDays != null && reviewVerb);
+  const compositeReviewCue =
+    broadReviewIntent &&
+    /\b(include|including|along with|plus|and)\b/i.test(question ?? '') &&
+    /\b(workouts?|training|progress|overall|track)\b/i.test(question ?? '');
+  // Questions that clearly target one dedicated route should keep using it.
+  const narrowSingleTopic =
+    /\b(volume|workload|tonnage|load this week|weekly load)\b/i.test(question ?? '') ||
+    /\b(recover|recovery|readiness|hrv|sleep|resting heart|fatigue|tired|sore)\b/i.test(question ?? '') ||
+    /\b(increment(?:\s|-)?score|incremnt(?:\s|-)?score|my score|overall score|score (?:trend|trending|going)|what(?:'?s| is) my score|how(?:'?s| is) my score)\b/i.test(question ?? '') ||
+    /\b(pr|prs|record|records|max|maxes|1rm|one rep max|one-rep max|strongest)\b/i.test(question ?? '') ||
+    /\b(next|tomorrow|up next|coming session|do next|what should i do)\b/i.test(question ?? '');
+
+  if (deloadScheduleLanguage) {
+    return { route: 'program_schedule_action', namedExercises, deloadScheduleContext };
+  }
+  if (hasProgramHistoryLanguage(question, { previousRoute, isFollowUp })) {
+    return { route: 'program_history', namedExercises, deloadScheduleContext };
+  }
+
+  // Broad "how am I doing / on the right track / last N weeks" reviews fan out to
+  // sessions + volume + records + body weight rather than a single narrow route.
+  // Requires an explicit review cue, or a relative window paired with a review verb.
+  if (
+    namedExercises.length === 0 &&
+    (!narrowSingleTopic || compositeReviewCue) &&
+    broadReviewIntent
+  ) {
+    return { route: 'progress_review', namedExercises, since, deloadScheduleContext };
+  }
+  if (/\b(body ?weight|weigh|weight trends?|current weight|my weight)\b/i.test(question ?? '')) {
+    return { route: 'body_weight', namedExercises, deloadScheduleContext };
+  }
+  if (profileLanguage) {
+    return { route: 'training_profile', namedExercises, since, deloadScheduleContext };
+  }
+  if (programLanguage && progressLanguage) {
+    return { route: 'program_progress', namedExercises, since, deloadScheduleContext };
+  }
+  if (since && progressLanguage) {
+    return { route: 'exercise_progress_summary', namedExercises, since };
+  }
+  if (/\b(volume|workload|tonnage|load this week|weekly load)\b/i.test(question ?? '')) {
+    return { route: 'volume', namedExercises };
+  }
+  if (namedExercises.length > 0 && hasNamedExerciseActionLanguage(question)) {
+    return { route: 'exercise_progress', namedExercises };
+  }
+  if (sessionLabel && hasSessionReviewLanguage(question)) {
+    return { route: 'recent_session', namedExercises, sessionLabel, sessionReference };
+  }
+  if (/\b(next|tomorrow|up next|coming session|do next|what should i do)\b/i.test(question ?? '')) {
+    return { route: 'next_session', namedExercises };
+  }
+  if (/\b(recover|recovery|readiness|hrv|sleep|resting heart|fatigue|tired|sore)\b/i.test(question ?? '')) {
+    return { route: 'recovery', namedExercises };
+  }
+  if (/\b(increment(?:\s|-)?score|incremnt(?:\s|-)?score|my score|overall score|score (?:trend|trending|going)|what(?:'?s| is) my score|how(?:'?s| is) my score)\b/i.test(question ?? '')) {
+    return { route: 'score', namedExercises };
+  }
+  if (/\b(pr|prs|record|records|max|maxes|1rm|one rep max|one-rep max|strongest)\b/i.test(question ?? '')) {
+    return { route: 'records', namedExercises };
+  }
+  if (/\b(build|create|make|generate|draft|rewrite|revise|update|adjust)\b.*\b(program|plan|split|routine)\b/i.test(question ?? '')) {
+    return { route: 'program_design', namedExercises };
+  }
+  if (/\b(session|workout|today|yesterday|last time|went|go|fail|failed|miss|missed|last set|last two sets)\b/i.test(question ?? '') && namedExercises.length === 0) {
+    return { route: 'recent_session', namedExercises, sessionLabel, sessionReference };
+  }
+  if (namedExercises.length > 0 || normalizedQuestion.includes('going')) {
+    if (progressLanguage) return { route: 'exercise_progress_summary', namedExercises, since };
+    return { route: 'exercise_progress', namedExercises };
+  }
+  return { route: 'general', namedExercises };
+}
+
+function historyUserQuestions(history = []) {
+  return (Array.isArray(history) ? history : [])
+    .filter((message) => message?.role === 'user' && typeof message.content === 'string')
+    .map((message) => message.content);
+}
+
+function isTerseFollowUpQuestion(question) {
+  const text = String(question ?? '').trim().toLowerCase();
+  if (!text) return false;
+  const wordCount = text.split(/\s+/).filter(Boolean).length;
+  return wordCount <= 5 || /^(why|how come|what about|and |should i|can i|do that|make it|swap|change it)/i.test(text);
+}
+
+function requestedActionForRoute(route, question, { isFollowUp = false, carriedPreviousTopic = false } = {}) {
+  const text = String(question ?? '').toLowerCase();
+  if (route === 'program_schedule_action') return 'schedule_program_action';
+  if (route === 'program_history' && /\b(undo|revert|restore|change it back|previous version)\b/.test(text)) return 'explain_restore_status';
+  if (route === 'program_history') return 'explain_program_history';
+  if (/\b(why|how come)\b/.test(text)) return 'explain_cause';
+  if (/\b(build|create|make|generate|draft|rewrite|revise|update)\b/.test(text)) return 'draft_plan';
+  if (/\badjust\b/.test(text) && /\b(program|plan|split|routine)\b/.test(text)) return 'draft_plan';
+  if (/\b(should|change|swap|deload|increase|decrease|adjust)\b/.test(text)) return 'recommend_action';
+  if (carriedPreviousTopic) return 'compare_previous_topic';
+  if (isFollowUp) return 'continue_previous_topic';
+  const byRoute = {
+    body_weight: 'explain_body_weight',
+    training_profile: 'summarize_profile',
+    program_progress: 'explain_program_progress',
+    exercise_progress_summary: 'explain_progress',
+    exercise_progress: 'explain_exercise',
+    volume: 'explain_volume',
+    next_session: 'recommend_next_session',
+    program_history: 'explain_program_history',
+    recovery: 'explain_recovery',
+    score: 'explain_score',
+    records: 'summarize_records',
+    program_design: 'draft_plan',
+    recent_session: 'review_recent_session',
+    progress_review: 'summarize_progress',
+    general: 'answer_training_question'
+  };
+  return byRoute[route] ?? 'answer_training_question';
+}
+
+export const ASK_RESPONSE_PROFILES = Object.freeze({
+  expansive: 'expansive',
+  defensive: 'defensive',
+  structured: 'structured'
+});
+
+function responseProfileForAskIntent(route, requestedAction, question) {
+  if (route === 'program_schedule_action' || requestedAction === 'schedule_program_action') return ASK_RESPONSE_PROFILES.structured;
+  if (route === 'program_design' || requestedAction === 'draft_plan') return ASK_RESPONSE_PROFILES.structured;
+  const text = String(question ?? '').toLowerCase();
+  if (
+    requestedAction === 'recommend_action' ||
+    requestedAction === 'recommend_next_session' ||
+    requestedAction === 'explain_cause' ||
+    /\b(should|can i|safe|increase|decrease|deload|swap|change|adjust)\b/.test(text) ||
+    /\b(what should i do|do next|next session|up next)\b/.test(text) ||
+    /\b(did i hit|hit target|below target|missed?|failed?|why did i fail)\b/.test(text) ||
+    // Decision questions phrased without an imperative verb still want a crisp
+    // recommendation, not an expansive dashboard.
+    /\b(too heavy|too light|too much|too easy|ready to|time to|worth|good idea|enough|move up|add weight|bump up|push (?:harder|up)|stall(?:ing|ed)?|plateau(?:ing|ed)?|drop[- ]?off|dropping off|falling off|declining|regressing)\b/.test(text) ||
+    /\bam i ready\b/.test(text)
+  ) {
+    return ASK_RESPONSE_PROFILES.defensive;
+  }
+  return ASK_RESPONSE_PROFILES.expansive;
+}
+
+function confidenceForIntent({ rawRoute, route, namedExercises, question, previousRoute, isFollowUp }) {
+  let confidence = 0.72;
+  if (route !== 'general') confidence += 0.1;
+  if (namedExercises.length > 0) confidence += 0.06;
+  if (previousRoute && isFollowUp) confidence += 0.04;
+  if (rawRoute !== route) confidence -= 0.03;
+  if (/\b(or|maybe|not sure|confused)\b/i.test(question ?? '')) confidence -= 0.12;
+  return Math.max(0.35, Math.min(0.95, Number(confidence.toFixed(2))));
+}
+
+function ambiguityFlagsForIntent({ route, namedExercises, question, isFollowUp, previousRoute }) {
+  const flags = [];
+  const text = String(question ?? '');
+  if (route === 'general') flags.push('no_specific_route');
+  if (/\b(or|maybe|not sure|confused)\b/i.test(text)) flags.push('ambiguous_user_intent');
+  if (isFollowUp && !previousRoute) flags.push('missing_previous_context');
+  if (/\b(this|that|it)\b/i.test(text) && namedExercises.length === 0 && !previousRoute) flags.push('unresolved_reference');
+  return flags;
+}
+
+function classifyAskIntentWithPrevious(snapshot, question, { previousIntent = null, previousDeloadScheduleContext = null, today = new Date() } = {}) {
+  const previous = previousIntent
+    ? {
+        route: previousIntent.route,
+        since: previousIntent.timeframe?.since ?? null,
+        namedExercises: previousIntent.entities?.exercises ?? [],
+        sessionLabel: previousIntent.entities?.sessionLabel ?? null,
+        sessionReference: previousIntent.entities?.sessionReference ?? null,
+        deloadScheduleContext: previousIntent.deloadScheduleContext ?? null
+      }
+    : null;
+  const isFollowUp = Boolean((previous || previousDeloadScheduleContext) && isTerseFollowUpQuestion(question));
+  const current = routeAskQuestion(snapshot, question, {
+    today,
+    previousRoute: previous?.route ?? null,
+    isFollowUp
+  });
+  const currentDeloadScheduleContext = current.deloadScheduleContext ?? deloadScheduleContextFromText(question);
+  const carriedDeloadScheduleContext = currentDeloadScheduleContext ?? previousDeloadScheduleContext ?? previous?.deloadScheduleContext ?? null;
+  const isDeloadScheduleFollowUp = current.route !== 'program_schedule_action' &&
+    Boolean(carriedDeloadScheduleContext) &&
+    isDeloadScheduleConfirmation(question);
+  let route = current.route;
+  let since = current.since ?? null;
+  let carriedPreviousTopic = false;
+
+  if (isDeloadScheduleFollowUp) {
+    route = 'program_schedule_action';
+    since = null;
+  } else if (
+    isFollowUp &&
+    previous?.route &&
+    current.namedExercises.length > 0 &&
+    ['exercise_progress', 'exercise_progress_summary', 'program_progress', 'records'].includes(previous.route) &&
+    ['exercise_progress', 'general'].includes(current.route)
+  ) {
+    route = previous.route;
+    since = current.since ?? previous.since ?? null;
+    carriedPreviousTopic = true;
+  } else if (isFollowUp && current.route === 'general' && previous?.route) {
+    route = previous.route;
+    since = previous.since ?? null;
+    carriedPreviousTopic = true;
+  }
+
+  const namedExercises = carriedPreviousTopic && current.namedExercises.length === 0
+    ? previous?.namedExercises ?? []
+    : current.namedExercises;
+  const sessionLabel = current.sessionLabel ?? (carriedPreviousTopic ? previous?.sessionLabel ?? null : null);
+  const sessionReference = current.sessionReference ?? (carriedPreviousTopic ? previous?.sessionReference ?? null : null);
+  const requestedAction = requestedActionForRoute(route, question, { isFollowUp, carriedPreviousTopic });
+  const responseProfile = responseProfileForAskIntent(route, requestedAction, question);
+  return {
+    route,
+    effectiveRoute: route === 'exercise_progress' && namedExercises.length === 0 ? 'general' : route,
+    confidence: confidenceForIntent({
+      rawRoute: current.route,
+      route,
+      namedExercises,
+      question,
+      previousRoute: previous?.route ?? null,
+      isFollowUp
+    }),
+    entities: {
+      exercises: namedExercises.map((exercise) => ({
+        canonical: exercise.canonical,
+        displayName: exercise.displayName
+      })),
+      sessionLabel,
+      sessionReference
+    },
+    timeframe: since ? { since } : null,
+    requestedAction,
+    responseProfile,
+    isFollowUp,
+    previousRoute: previous?.route ?? null,
+    deloadScheduleContext: route === 'program_schedule_action'
+      ? carriedDeloadScheduleContext
+      : currentDeloadScheduleContext,
+    ambiguityFlags: ambiguityFlagsForIntent({
+      route,
+      namedExercises,
+      question,
+      isFollowUp,
+      previousRoute: previous?.route ?? null
+    })
+  };
+}
+
+export function classifyAskIntent(snapshot, question, { history = [], today = new Date() } = {}) {
+  let previousIntent = null;
+  for (const previousQuestion of historyUserQuestions(history)) {
+    previousIntent = classifyAskIntentWithPrevious(snapshot, previousQuestion, { previousIntent, today });
+  }
+  return classifyAskIntentWithPrevious(snapshot, question, {
+    previousIntent,
+    previousDeloadScheduleContext: latestDeloadScheduleContext(history),
+    today
+  });
+}

package/src/ask-coach/structured-response.js

@@ -0,0 +1,5 @@
+export {
+  buildAskStructuredResponse,
+  sanitizeCoachAdviceCandidate,
+  sanitizeAskAnswerVerificationReceipt
+} from './orchestrator.js';

package/src/ask-coach-routing.js

@@ -0,0 +1,4 @@
+export {
+  ASK_RESPONSE_PROFILES,
+  classifyAskIntent
+} from './ask-coach/routing.js';