incremnt 0.3.0 → 0.5.0

package/src/sync-service.js

@@ -1,11 +1,13 @@
 import { createHash, randomUUID, timingSafeEqual } from 'node:crypto';
+import { anonymizeAccountId } from './anonymize.js';
 import { capabilities as cliCapabilities, contractVersion, officialCommands } from './contract.js';
 import { executeReadCommand } from './queries.js';
-import { fenceContent, sanitizeHistory, detectSystemPromptLeak } from './prompt-security.js';
+import { sanitizeHistory, detectSystemPromptLeak, stripXMLTagBlocks } from './prompt-security.js';
 
 const MAX_BODY_BYTES = 10 * 1024 * 1024; // 10 MB
 const DEFAULT_RATE_LIMIT_WINDOW_MS = 60_000;
-const MAX_ASK_USER_TURNS = 3;
+const WEEKLY_CHECKIN_COMPLETION_USER_TURNS = 3;
+const WEEKLY_CHECKIN_RECAP_LOCAL_HOUR = 16;
 const DEFAULT_RATE_LIMIT_RULES = {
   'workout-summary-ai': 3,
   'cycle-summary-ai': 3,
@@ -14,6 +16,10 @@ const DEFAULT_RATE_LIMIT_RULES = {
   'ask-ai': 5,
   'ai-feedback': 60,
   'coach-memory': 30,
+  'weekly-checkin-enroll': 10,
+  'weekly-checkin-current': 30,
+  'weekly-checkin-ack': 30,
+  'weekly-checkin-start': 10,
   'dev-login': 10,
   'device-start': 20,
   'device-poll': 300,
@@ -25,11 +31,20 @@ const DEFAULT_RATE_LIMIT_RULES = {
   'web-auth-start': 20,
   'web-auth-callback': 20,
   'session-login': 60,
+  'anonymous-start': 60,
   'session-refresh': 30,
   'delete-account': 1,
   'sync-account-preferences': 30,
   'proposals': 30,
   'proposal-update': 30,
+  'program-share-create': 30,
+  'program-share-list': 60,
+  'program-share-public': 120,
+  'program-share-revoke': 30,
+  'mobile-sync-bootstrap': 60,
+  'mobile-sync-pull': 120,
+  'mobile-sync-push': 60,
+  'score-snapshots': 60,
   'social-invite': 20,
   'social-groups': 60,
   'social-group-create': 20,
@@ -52,6 +67,8 @@ const DEFAULT_RATE_LIMIT_RULES = {
   'social-user-suggestions': 60,
   'social-user-report': 60,
   'social-user-exercise-history': 60,
+  'social-user-activities': 60,
+  'social-user-best-efforts': 60,
   'social-user-mute': 20,
   'social-user-block': 20,
   'social-report': 20,
@@ -90,6 +107,292 @@ export function isNoInsightResponse(text) {
   return normalized === 'NO_INSIGHT' || normalized.startsWith('NO_INSIGHT\n');
 }
 
+function isValidTimeZone(timeZoneId) {
+  if (!timeZoneId || typeof timeZoneId !== 'string') return false;
+  try {
+    new Intl.DateTimeFormat('en-US', { timeZone: timeZoneId }).format(new Date());
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function zonedParts(date, timeZoneId) {
+  const parts = new Intl.DateTimeFormat('en-US', {
+    timeZone: timeZoneId,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    hour12: false,
+    hourCycle: 'h23',
+    weekday: 'short'
+  }).formatToParts(date);
+  const byType = Object.fromEntries(parts.map((part) => [part.type, part.value]));
+  const weekdayIndex = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].indexOf(byType.weekday);
+  return {
+    year: Number(byType.year),
+    month: Number(byType.month),
+    day: Number(byType.day),
+    hour: Number(byType.hour),
+    minute: Number(byType.minute),
+    second: Number(byType.second),
+    weekday: weekdayIndex >= 0 ? weekdayIndex : 0
+  };
+}
+
+function zonedDateTimeToUtc(timeZoneId, { year, month, day, hour, minute = 0, second = 0 }) {
+  let utc = Date.UTC(year, month - 1, day, hour, minute, second);
+  for (let index = 0; index < 4; index += 1) {
+    const parts = zonedParts(new Date(utc), timeZoneId);
+    const asIfUtc = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
+    const wanted = Date.UTC(year, month - 1, day, hour, minute, second);
+    const delta = wanted - asIfUtc;
+    if (delta === 0) break;
+    utc += delta;
+  }
+  return new Date(utc);
+}
+
+function addCalendarDays({ year, month, day }, days) {
+  const date = new Date(Date.UTC(year, month - 1, day + days, 12, 0, 0));
+  return {
+    year: date.getUTCFullYear(),
+    month: date.getUTCMonth() + 1,
+    day: date.getUTCDate()
+  };
+}
+
+function isoDateFromParts({ year, month, day }) {
+  return [
+    String(year).padStart(4, '0'),
+    String(month).padStart(2, '0'),
+    String(day).padStart(2, '0')
+  ].join('-');
+}
+
+export function nextWeeklyCheckinSchedule(timeZoneId, now = new Date()) {
+  if (!isValidTimeZone(timeZoneId)) {
+    const err = new Error('Invalid timezoneId');
+    err.code = 'invalid_timezone';
+    throw err;
+  }
+  const local = zonedParts(now, timeZoneId);
+  const daysUntilSunday = (7 - local.weekday) % 7;
+  let target = addCalendarDays(local, daysUntilSunday);
+  let dueAt = zonedDateTimeToUtc(timeZoneId, {
+    ...target,
+    hour: WEEKLY_CHECKIN_RECAP_LOCAL_HOUR,
+    minute: 0,
+    second: 0
+  });
+  if (dueAt <= now) {
+    target = addCalendarDays(target, 7);
+    dueAt = zonedDateTimeToUtc(timeZoneId, {
+      ...target,
+      hour: WEEKLY_CHECKIN_RECAP_LOCAL_HOUR,
+      minute: 0,
+      second: 0
+    });
+  }
+  return {
+    weekStartDate: isoDateFromParts(target),
+    nextRecapDueAt: dueAt.toISOString()
+  };
+}
+
+const PROGRAM_DRAFT_VERSION = 1;
+const VALID_PROGRAM_DRAFT_EQUIPMENT_TIERS = new Set(['fullGym', 'benchDumbbells', 'dumbbellsOnly', 'bodyweightOnly']);
+const VALID_PROGRAM_DRAFT_VOLUME_LEVELS = new Set(['minimum', 'moderate', 'high']);
+
+const PROGRAM_DRAFT_LIMITS = {
+  nameMaxLen: 120,
+  muscleGroupMaxLen: 60,
+  dayLabelMaxLen: 60,
+  dayTitleMaxLen: 120,
+  daySubtitleMaxLen: 120,
+  noteMaxLen: 1000,
+  minWeight: 0,
+  maxWeight: 600,
+  minReps: 1,
+  maxReps: 30,
+  minRir: 0,
+  maxRir: 5,
+  minSetsPerExercise: 1,
+  maxSetsPerExercise: 12,
+  minExercisesPerDay: 1,
+  maxExercisesPerDay: 24,
+  minDaysPerWeek: 1,
+  maxDaysPerWeek: 7,
+  minDays: 1,
+  maxDays: 14
+};
+
+function collapseBlankLines(text) {
+  return String(text ?? '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+function titleCaseExerciseName(name) {
+  return String(name ?? '')
+    .split(' ')
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ');
+}
+
+function normalizedExerciseDisplayName(name, canonicalizeExerciseName) {
+  const trimmed = String(name ?? '').trim();
+  if (!trimmed) return '';
+  const canonical = canonicalizeExerciseName ? canonicalizeExerciseName(trimmed) : trimmed.toLowerCase();
+  return titleCaseExerciseName(canonical);
+}
+
+function normalizeProgramDraftSet(set) {
+  const weight = Number(set?.weight);
+  const reps = Number(set?.reps);
+  if (!Number.isFinite(weight) || !Number.isInteger(reps)) return null;
+  if (
+    weight < PROGRAM_DRAFT_LIMITS.minWeight ||
+    weight > PROGRAM_DRAFT_LIMITS.maxWeight ||
+    reps < PROGRAM_DRAFT_LIMITS.minReps ||
+    reps > PROGRAM_DRAFT_LIMITS.maxReps
+  ) return null;
+  return {
+    weight,
+    reps,
+    isComplete: false,
+    isWarmup: set?.isWarmup === true
+  };
+}
+
+function normalizeProgramDraftExercise(exercise, canonicalizeExerciseName) {
+  const name = normalizedExerciseDisplayName(exercise?.name, canonicalizeExerciseName);
+  const muscleGroup = String(exercise?.muscleGroup ?? '').trim();
+  const sets = Array.isArray(exercise?.sets)
+    ? exercise.sets.map(normalizeProgramDraftSet).filter(Boolean)
+    : [];
+
+  if (!name || name.length > PROGRAM_DRAFT_LIMITS.nameMaxLen) return null;
+  if (!muscleGroup || muscleGroup.length > PROGRAM_DRAFT_LIMITS.muscleGroupMaxLen) return null;
+  if (
+    sets.length < PROGRAM_DRAFT_LIMITS.minSetsPerExercise ||
+    sets.length > PROGRAM_DRAFT_LIMITS.maxSetsPerExercise
+  ) return null;
+
+  const rir = exercise?.rir == null ? null : Number(exercise.rir);
+  if (rir != null && (
+    !Number.isInteger(rir) ||
+    rir < PROGRAM_DRAFT_LIMITS.minRir ||
+    rir > PROGRAM_DRAFT_LIMITS.maxRir
+  )) return null;
+
+  const note = exercise?.note == null ? null : String(exercise.note);
+  if (note && note.length > PROGRAM_DRAFT_LIMITS.noteMaxLen) return null;
+
+  return {
+    name,
+    muscleGroup,
+    lastSuggestion: '',
+    nextSuggestion: '',
+    sets,
+    ...(note ? { note } : {}),
+    ...(rir != null ? { rir } : {})
+  };
+}
+
+function normalizeProgramDraftDay(day, canonicalizeExerciseName) {
+  const dayLabel = String(day?.dayLabel ?? '').trim();
+  const title = String(day?.title ?? '').trim();
+  const subtitle = String(day?.subtitle ?? '').trim();
+  const exercises = Array.isArray(day?.exercises)
+    ? day.exercises.map((exercise) => normalizeProgramDraftExercise(exercise, canonicalizeExerciseName)).filter(Boolean)
+    : [];
+
+  if (!dayLabel || dayLabel.length > PROGRAM_DRAFT_LIMITS.dayLabelMaxLen) return null;
+  if (!title || title.length > PROGRAM_DRAFT_LIMITS.dayTitleMaxLen) return null;
+  if (subtitle.length > PROGRAM_DRAFT_LIMITS.daySubtitleMaxLen) return null;
+  if (
+    exercises.length < PROGRAM_DRAFT_LIMITS.minExercisesPerDay ||
+    exercises.length > PROGRAM_DRAFT_LIMITS.maxExercisesPerDay
+  ) return null;
+
+  return { dayLabel, title, subtitle, exercises };
+}
+
+function normalizeProgramDraft(rawProgram, { canonicalizeExerciseName } = {}) {
+  if (!rawProgram || typeof rawProgram !== 'object' || Array.isArray(rawProgram)) return null;
+
+  const name = String(rawProgram.name ?? '').trim();
+  const days = Array.isArray(rawProgram.days)
+    ? rawProgram.days.map((day) => normalizeProgramDraftDay(day, canonicalizeExerciseName)).filter(Boolean)
+    : [];
+  const daysPerWeek = Number(rawProgram.daysPerWeek);
+  const currentDayIndex = rawProgram.currentDayIndex == null ? 0 : Number(rawProgram.currentDayIndex);
+  const equipmentTier = String(rawProgram.equipmentTier ?? 'fullGym').trim();
+  const volumeLevel = String(rawProgram.volumeLevel ?? 'moderate').trim();
+
+  if (!name || name.length > PROGRAM_DRAFT_LIMITS.nameMaxLen) return null;
+  if (days.length < PROGRAM_DRAFT_LIMITS.minDays || days.length > PROGRAM_DRAFT_LIMITS.maxDays) return null;
+  if (
+    !Number.isInteger(daysPerWeek) ||
+    daysPerWeek < PROGRAM_DRAFT_LIMITS.minDaysPerWeek ||
+    daysPerWeek > PROGRAM_DRAFT_LIMITS.maxDaysPerWeek
+  ) return null;
+  if (!Number.isInteger(currentDayIndex) || currentDayIndex < 0 || currentDayIndex >= days.length) return null;
+  if (!VALID_PROGRAM_DRAFT_EQUIPMENT_TIERS.has(equipmentTier) || !VALID_PROGRAM_DRAFT_VOLUME_LEVELS.has(volumeLevel)) return null;
+
+  return {
+    name,
+    daysPerWeek,
+    equipmentTier,
+    volumeLevel,
+    source: 'guided',
+    days,
+    currentDayIndex
+  };
+}
+
+function extractAskProgramDraft(rawText, { canonicalizeExerciseName } = {}) {
+  const text = String(rawText ?? '');
+  const match = text.match(/<program_draft>\s*([\s\S]*?)\s*<\/program_draft>/i);
+  if (!match) {
+    return { answerText: text.trim(), programDraft: null };
+  }
+
+  const answerText = collapseBlankLines(text.replace(match[0], ''));
+  let parsed;
+  try {
+    parsed = JSON.parse(match[1]);
+  } catch (err) {
+    console.warn('askCoach: <program_draft> JSON parse failed — dropping draft:', err.message);
+    return { answerText, programDraft: null };
+  }
+
+  const program = normalizeProgramDraft(parsed, { canonicalizeExerciseName });
+  if (!program) {
+    console.warn('askCoach: <program_draft> payload failed validation — dropping draft');
+    return { answerText, programDraft: null };
+  }
+
+  return {
+    answerText,
+    programDraft: {
+      program,
+      provenance: {
+        source: 'ai-coach',
+        type: 'program',
+        version: PROGRAM_DRAFT_VERSION,
+        createdAt: new Date().toISOString(),
+        tokenHint: null
+      }
+    }
+  };
+}
+
 function json(response, statusCode, payload) {
   response.writeHead(statusCode, { 'content-type': 'application/json' });
   response.end(JSON.stringify(payload));
@@ -111,17 +414,6 @@ function logRequest(request, statusCode, extra = '') {
   console.log(`${method} ${path} ${statusCode}${suffix}`);
 }
 
-function anonymizeAccountId(accountId) {
-  if (typeof accountId !== 'string' || !accountId.trim()) {
-    return 'anon:unknown';
-  }
-  const digest = createHash('sha256')
-    .update(`account:${accountId}`)
-    .digest('hex')
-    .slice(0, 12);
-  return `anon:${digest}`;
-}
-
 function anonymizeSessionToken(sessionToken) {
   if (typeof sessionToken !== 'string' || !sessionToken.trim()) {
     return 'sess:unknown';
@@ -133,6 +425,30 @@ function anonymizeSessionToken(sessionToken) {
   return `sess:${digest}`;
 }
 
+function resolveConfiguredPublicOrigin(candidate) {
+  if (typeof candidate !== 'string' || !candidate.trim()) {
+    return null;
+  }
+
+  let parsed;
+  try {
+    parsed = new URL(candidate);
+  } catch {
+    return null;
+  }
+
+  if ((parsed.protocol !== 'https:' && parsed.protocol !== 'http:') ||
+      parsed.username ||
+      parsed.password ||
+      parsed.pathname !== '/' ||
+      parsed.search ||
+      parsed.hash) {
+    return null;
+  }
+
+  return parsed.origin;
+}
+
 function sanitizeSocialLogValue(value) {
   if (typeof value === 'string') return value;
   if (typeof value === 'number' || typeof value === 'boolean') return value;
@@ -185,6 +501,71 @@ function anonymizeRelationIds(items, { max = 5 } = {}) {
     .join(',');
 }
 
+function currentAIGitSha() {
+  return process.env.RENDER_GIT_COMMIT
+    ?? process.env.GIT_SHA
+    ?? process.env.COMMIT_SHA
+    ?? process.env.VERCEL_GIT_COMMIT_SHA
+    ?? null;
+}
+
+function buildAIGenerationMetadata(surface, model, promptVersion, generation = {}) {
+  return {
+    surface,
+    generatedAt: new Date().toISOString(),
+    model: model ?? null,
+    promptVersion: promptVersion ?? null,
+    gitSha: currentAIGitSha(),
+    langfuseTraceId: generation.langfuseTraceId ?? null,
+    langfuseObservationId: generation.langfuseObservationId ?? null
+  };
+}
+
+function transcriptForCoachFactExtraction(messages, { maxChars = 4000 } = {}) {
+  const text = (Array.isArray(messages) ? messages : [])
+    .filter((message) => message?.role === 'user')
+    .slice(-8)
+    .map((message) => `user: ${String(message.content ?? '').trim()}`)
+    .join('\n')
+    .slice(-maxChars);
+  return text.trim();
+}
+
+async function extractAndSaveCoachFacts({
+  account,
+  sourceSurface,
+  sourceSessionId,
+  transcript,
+  openrouterKey,
+  aiUser,
+  saveCoachFactsForAccount,
+  generateCoachFactCandidatesImpl,
+  onError
+}) {
+  if (!saveCoachFactsForAccount || !transcript || !openrouterKey) return [];
+  try {
+    const { generateCoachFactCandidates } = await import('./openrouter.js');
+    const generateFacts = generateCoachFactCandidatesImpl ?? generateCoachFactCandidates;
+    const factResult = await generateFacts(transcript, {
+      apiKey: openrouterKey,
+      user: aiUser,
+      sessionId: `coach-facts:${sourceSessionId ?? sourceSurface}`,
+      contextMetadata: {
+        sourceSurface,
+        sourceSessionId
+      }
+    });
+    return saveCoachFactsForAccount(account, factResult.facts ?? [], {
+      sourceSurface,
+      sourceSessionId
+    });
+  } catch (factErr) {
+    console.error('Coach fact extraction failed:', factErr.message);
+    onError?.(factErr, { feature: 'coach-fact-extraction', sourceSurface });
+    return [];
+  }
+}
+
 function unauthorized(response, request) {
   if (request) logRequest(request, 401);
   json(response, 401, { error: 'Unauthorized' });
@@ -212,6 +593,13 @@ function internalError(response, error, onError) {
   json(response, 500, { error: 'Internal server error' });
 }
 
+function reportAuthFailure(onError, error, context = {}) {
+  onError?.(error, {
+    feature: 'auth-callback',
+    ...context
+  });
+}
+
 function constantTimeEqual(a, b) {
   if (!a || !b) return false;
   // Hash both values to fixed length to avoid leaking length information
@@ -311,6 +699,10 @@ function routeRequest(url, method) {
     return { command: 'session-login', options: {} };
   }
 
+  if (pathname === '/auth/anonymous/start') {
+    return { command: 'anonymous-start', options: {} };
+  }
+
   if (pathname === '/auth/refresh') {
     return { command: 'session-refresh', options: {} };
   }
@@ -335,6 +727,10 @@ function routeRequest(url, method) {
     return { command: 'google-callback', options: {} };
   }
 
+  if (pathname === '/auth/google/mobile') {
+    return { command: 'google-mobile', options: {} };
+  }
+
   if (pathname === '/auth/apple/start') {
     return { command: 'apple-start', options: {} };
   }
@@ -359,6 +755,34 @@ function routeRequest(url, method) {
     return { command: 'sync-upload', options: {} };
   }
 
+  if (pathname === '/mobile/sync/bootstrap') {
+    return { command: 'mobile-sync-bootstrap', options: {} };
+  }
+
+  if (pathname === '/mobile/sync/pull') {
+    return {
+      command: 'mobile-sync-pull',
+      options: {
+        since: url.searchParams.get('since') ?? undefined
+      }
+    };
+  }
+
+  if (pathname === '/mobile/sync/push') {
+    return { command: 'mobile-sync-push', options: {} };
+  }
+
+  if (pathname === '/mobile/score-snapshots') {
+    return {
+      command: 'score-snapshots',
+      options: {
+        from: url.searchParams.get('from') ?? undefined,
+        to: url.searchParams.get('to') ?? undefined,
+        limit: url.searchParams.get('limit') ?? undefined
+      }
+    };
+  }
+
   if (pathname === '/cli/account') {
     return { command: 'delete-account', options: {} };
   }
@@ -400,6 +824,46 @@ function routeRequest(url, method) {
     return { command: 'proposals', options: { status: url.searchParams.get('status') ?? undefined } };
   }
 
+  {
+    const programShareCreateMatch = pathname.match(/^\/cli\/programs\/([^/]+)\/share$/);
+    if (programShareCreateMatch) {
+      return {
+        command: 'program-share-create',
+        options: { programId: decodeURIComponent(programShareCreateMatch[1]) }
+      };
+    }
+  }
+
+  {
+    const programShareListMatch = pathname.match(/^\/cli\/programs\/([^/]+)\/shares$/);
+    if (programShareListMatch) {
+      return {
+        command: 'program-share-list',
+        options: { programId: decodeURIComponent(programShareListMatch[1]) }
+      };
+    }
+  }
+
+  {
+    const programSharePublicMatch = pathname.match(/^\/program-share\/([^/]+)$/);
+    if (programSharePublicMatch) {
+      return {
+        command: 'program-share-public',
+        options: { token: decodeURIComponent(programSharePublicMatch[1]) }
+      };
+    }
+  }
+
+  {
+    const programShareRevokeMatch = pathname.match(/^\/cli\/program-share\/([^/]+)\/revoke$/);
+    if (programShareRevokeMatch) {
+      return {
+        command: 'program-share-revoke',
+        options: { shareId: decodeURIComponent(programShareRevokeMatch[1]) }
+      };
+    }
+  }
+
   const proposalUpdateMatch = pathname.match(/^\/cli\/programs\/proposals\/([^/]+)$/);
   if (proposalUpdateMatch) {
     return { command: 'proposal-update', options: { id: proposalUpdateMatch[1] } };
@@ -548,6 +1012,22 @@ function routeRequest(url, method) {
     return { command: 'ai-feedback', options: {} };
   }
 
+  if (pathname === '/cli/weekly-checkin/current') {
+    return { command: 'weekly-checkin-current', options: {} };
+  }
+
+  if (pathname === '/cli/weekly-checkin/enroll') {
+    return { command: 'weekly-checkin-enroll', options: {} };
+  }
+
+  if (pathname === '/cli/weekly-checkin/ack') {
+    return { command: 'weekly-checkin-ack', options: {} };
+  }
+
+  if (pathname === '/cli/weekly-checkin/start') {
+    return { command: 'weekly-checkin-start', options: {} };
+  }
+
   if (pathname === '/cli/health/ai') {
     return {
       command: 'health-ai',
@@ -605,6 +1085,30 @@ function routeRequest(url, method) {
     }
   }
 
+  {
+    const userActivitiesMatch = pathname.match(/^\/cli\/social\/users\/([^/]+)\/activities$/);
+    if (userActivitiesMatch) {
+      return {
+        command: 'social-user-activities',
+        options: {
+          accountId: decodeURIComponent(userActivitiesMatch[1]),
+          limit: url.searchParams.get('limit') ?? undefined,
+          before: url.searchParams.get('before') ?? undefined
+        }
+      };
+    }
+  }
+
+  {
+    const userBestEffortsMatch = pathname.match(/^\/cli\/social\/users\/([^/]+)\/best-efforts$/);
+    if (userBestEffortsMatch) {
+      return {
+        command: 'social-user-best-efforts',
+        options: { accountId: decodeURIComponent(userBestEffortsMatch[1]) }
+      };
+    }
+  }
+
   {
     const userReportMatch = pathname.match(/^\/cli\/social\/users\/([^/]+)\/report$/);
     if (userReportMatch) {
@@ -908,6 +1412,91 @@ function routeRequest(url, method) {
   return null;
 }
 
+/// Formats a `ProgramPhaseWindowContext` (sent by iOS in the request body) as
+/// a short text prelude prepended to the AI context. Without this the model
+/// would have to infer "is this a deload week / was last week deload?" from
+/// session prose; with it the structured phase facts are explicit.
+function formatProgramPhasePrelude(programPhase) {
+  if (!programPhase || typeof programPhase !== 'object') return null;
+  const current = programPhase.current;
+  const previous = programPhase.previousWeek;
+  const next = programPhase.nextWeek;
+  if (!current?.phase || typeof current.displayWeek !== 'number') return null;
+  const describe = (phase) => {
+    if (!phase?.phase) return null;
+    const week = typeof phase.displayWeek === 'number' ? `week ${phase.displayWeek}` : 'week ?';
+    return `${week} (${phase.phase})${phase.isDeload ? ' · deload week' : ''}`;
+  };
+  const describeList = (phases) => {
+    if (!Array.isArray(phases) || phases.length === 0) return null;
+    return phases.map(describe).filter(Boolean).join(', ');
+  };
+  const lines = [
+    '[Program phase]',
+    `- Current: ${describe(current)}`
+  ];
+  if (previous?.phase) lines.push(`- Previous: ${describe(previous)}`);
+  if (next?.phase) lines.push(`- Next: ${describe(next)}`);
+  if (programPhase.isPostDeloadReturn === true) {
+    lines.push('- Post-deload return: yes (last week was deload, this week is build)');
+  }
+  const range = describeList(programPhase.phasesInRange);
+  if (range) lines.push(`- Range phases: ${range}`);
+  const previousRange = describeList(programPhase.previousRangePhases);
+  if (previousRange) lines.push(`- Previous range phases: ${previousRange}`);
+  return lines.join('\n');
+}
+
+export function formatIncrementScorePrelude(snapshots) {
+  if (!Array.isArray(snapshots) || snapshots.length === 0) return null;
+  const latest = snapshots[0];
+  if (latest == null || typeof latest.score !== 'number') return null;
+
+  const lines = ['[Increment Score]'];
+  const tier = latest.dataTier ? ` · ${latest.dataTier}` : '';
+  lines.push(`- Current: ${latest.score}/100${tier}`);
+
+  if (latest.components && typeof latest.components === 'object') {
+    const parts = [];
+    for (const [name, value] of Object.entries(latest.components)) {
+      const num = typeof value === 'number' ? value : value?.score;
+      if (typeof num === 'number') parts.push(`${name} ${num}`);
+    }
+    if (parts.length > 0) lines.push(`- Components: ${parts.join(', ')}`);
+  }
+
+  const driverLabels = (list) => {
+    if (!Array.isArray(list) || list.length === 0) return null;
+    return list
+      .slice(0, 3)
+      .map((d) => d?.label ?? d?.id ?? d?.driver)
+      .filter(Boolean)
+      .join('; ');
+  };
+  const positives = driverLabels(latest.topPositiveDrivers);
+  if (positives) lines.push(`- Top positive drivers: ${positives}`);
+  const negatives = driverLabels(latest.topNegativeDrivers);
+  if (negatives) lines.push(`- Top negative drivers: ${negatives}`);
+
+  if (snapshots.length > 1) {
+    const prior = snapshots[1];
+    if (typeof prior?.score === 'number') {
+      const delta = latest.score - prior.score;
+      const sign = delta > 0 ? '+' : '';
+      lines.push(`- Day-over-day delta: ${sign}${delta}`);
+    }
+    const recent = snapshots
+      .slice(0, 7)
+      .map((s) => (typeof s?.score === 'number' ? s.score : null))
+      .filter((s) => s != null);
+    if (recent.length >= 3) {
+      lines.push(`- Last ${recent.length} days: ${recent.join(', ')}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
 async function readJsonBody(request) {
   const chunks = [];
   let totalSize = 0;
@@ -961,7 +1550,7 @@ function deviceApprovalPage({
   userCode = '',
   email = '',
   userId = '',
-  includeManualForm = true,
+  includeManualForm = false,
   appleStartPath = null,
   googleStartPath = null,
   isError = false
@@ -973,6 +1562,7 @@ function deviceApprovalPage({
   const escapedUserId = escapeHtml(userId);
   const badgeBg = isError ? 'rgba(255,69,58,0.15)' : 'rgba(0,255,163,0.1)';
   const badgeColor = isError ? '#FF453A' : '#00ffa3';
+  const hasProviderActions = Boolean(appleStartPath || googleStartPath);
 
   return `<!doctype html>
 <html lang="en">
@@ -1139,7 +1729,9 @@ function deviceApprovalPage({
       </form>
       <small>Enter the code shown by <code>incremnt login</code>. Provide either the email or user ID for the account that should own this session.</small>
       ` : `
-      <small>Continue with a configured identity provider to approve the code shown by <code>incremnt login</code>.</small>
+      <small>${hasProviderActions
+        ? 'Continue with a configured identity provider to approve the code shown by <code>incremnt login</code>.'
+        : 'No hosted identity provider is available for this login flow.'}</small>
       `}
     </main>
   </body>
@@ -1346,6 +1938,7 @@ export function createSyncServiceRequestHandler({
   writeSnapshotForAccount,
   issueDevLogin,
   issueSession,
+  issueAnonymousWriteAccess,
   issueDeviceChallenge,
   consumeDeviceChallenge,
   readDeviceChallengeByUserCode,
@@ -1368,22 +1961,44 @@ export function createSyncServiceRequestHandler({
   buildGoogleWebAuthUrl = null,
   completeAppleWebAuth = null,
   completeGoogleWebAuth = null,
+  completeGoogleMobileAuth = null,
   refreshSession,
+  authenticateConnectedWriteToken,
   allowManualDeviceApproval = false,
   rateLimitConfig = null,
+  publicOrigin = null,
   corsOrigins = [],
   createProposalForAccount = null,
   listProposalsForAccount = null,
   updateProposalForAccount = null,
+  createProgramShareForAccount = null,
+  listProgramSharesForAccount = null,
+  readPublicProgramShare = null,
+  revokeProgramShareForAccount = null,
   updateAnalysisConsentForAccount = null,
   updateDisplayNameForAccount = null,
   saveAskConversationForAccount = null,
   listAskConversationsForAccount = null,
   getAskConversationForAccount = null,
   readCoachMemoryForAccount = null,
-  writeCoachMemoryForAccount = null,
+  saveCoachFactsForAccount = null,
+  listCoachFactsForAccount = null,
+  saveCoachCommitmentsForAccount = null,
+  listActiveCoachCommitmentsForAccount = null,
+  getCurrentWeeklyCheckinForAccount = null,
+  upsertScheduledWeeklyCheckinForAccount = null,
+  transitionWeeklyCheckinForAccount = null,
+  generateWeeklyCheckinRecapImpl = null,
+  generateCheckinQuestionsImpl = null,
   saveAIFeedbackForAccount = null,
+  generateAskAnswerImpl = null,
+  generateCoachFactCandidatesImpl = null,
   deleteAccountForUser = null,
+  loadMobileSyncStateForAccount = null,
+  pullMobileSyncStateForAccount = null,
+  pushMobileSyncChangesForAccount = null,
+  insertScoreSnapshotsForAccount = null,
+  listScoreSnapshotsForAccount = null,
   // Social
   social = null,
   onError = null
@@ -1412,6 +2027,8 @@ export function createSyncServiceRequestHandler({
       }
 
       const url = new URL(request.url ?? '/', `http://${request.headers.host ?? '127.0.0.1'}`);
+      const resolvedPublicOrigin = resolveConfiguredPublicOrigin(publicOrigin)
+        ?? `${url.protocol}//${url.host}`;
       const route = routeRequest(url, request.method);
       if (!route) {
         notFound(response);
@@ -1449,8 +2066,7 @@ export function createSyncServiceRequestHandler({
 
       logRequest(request, '-', rateLimitCommand);
 
-      const providerApprovalAvailable = Boolean(appleAuth?.configured || googleAuth?.configured);
-      const manualDeviceApprovalEnabled = allowManualDeviceApproval || !providerApprovalAvailable;
+      const manualDeviceApprovalEnabled = allowManualDeviceApproval;
 
       if (route.command === 'auth-config') {
         json(response, 200, {
@@ -1648,6 +2264,12 @@ export function createSyncServiceRequestHandler({
             response.end();
             return;
           } catch (error) {
+            reportAuthFailure(onError, error, {
+              route: 'google-callback',
+              provider: 'google',
+              authFlow: 'web',
+              statusCode: 400
+            });
             html(response, 400, deviceApprovalPage({
               title: 'Login failed',
               message: error.message,
@@ -1670,6 +2292,12 @@ export function createSyncServiceRequestHandler({
           }));
           return;
         } catch (error) {
+          reportAuthFailure(onError, error, {
+            route: 'google-callback',
+            provider: 'google',
+            authFlow: 'device',
+            statusCode: 400
+          });
           html(response, 400, deviceApprovalPage({
             title: 'Approval failed',
             message: error.message,
@@ -1715,10 +2343,12 @@ export function createSyncServiceRequestHandler({
 
         let code = url.searchParams.get('code') ?? '';
         let state = url.searchParams.get('state') ?? '';
+        let user = null;
         if (request.method === 'POST') {
           const body = await readUrlEncodedBody(request);
           code = body.code ?? code;
           state = body.state ?? state;
+          user = body.user ?? null;
         }
 
         if (!code || !state) {
@@ -1741,13 +2371,19 @@ export function createSyncServiceRequestHandler({
           }
 
           try {
-            const result = await completeAppleWebAuth({ code, state });
+            const result = await completeAppleWebAuth({ code, state, user });
             const returnUrl = new URL(result.returnUrl);
             returnUrl.hash = `token=${result.session.accessToken}&expires=${result.session.expiresAt}`;
             response.writeHead(302, { location: returnUrl.toString() });
             response.end();
             return;
           } catch (error) {
+            reportAuthFailure(onError, error, {
+              route: 'apple-callback',
+              provider: 'apple',
+              authFlow: 'web',
+              statusCode: 400
+            });
             html(response, 400, deviceApprovalPage({
               title: 'Login failed',
               message: error.message,
@@ -1763,7 +2399,7 @@ export function createSyncServiceRequestHandler({
         }
 
         try {
-          const result = await completeAppleDeviceApproval({ code, state });
+          const result = await completeAppleDeviceApproval({ code, state, user });
           html(response, 200, deviceApprovalSuccessPage({
             email: result.account.email ?? '',
             userId: result.account.id
@@ -1776,6 +2412,12 @@ export function createSyncServiceRequestHandler({
             hasCode: Boolean(code),
             hasState: Boolean(state)
           });
+          reportAuthFailure(onError, error, {
+            route: 'apple-callback',
+            provider: 'apple',
+            authFlow: 'device',
+            statusCode: 400
+          });
           html(response, 400, deviceApprovalPage({
             title: 'Approval failed',
             message: error.message,
@@ -1849,19 +2491,25 @@ export function createSyncServiceRequestHandler({
         }
 
         if (request.method === 'GET') {
+          const appleStartPath = appleAuth?.configured
+            ? `/auth/apple/start?userCode=${encodeURIComponent(url.searchParams.get('userCode') ?? '')}`
+            : null;
+          const googleStartPath = googleAuth?.configured
+            ? `/auth/google/start?userCode=${encodeURIComponent(url.searchParams.get('userCode') ?? '')}`
+            : null;
+          const hasHostedProvider = Boolean(appleStartPath || googleStartPath);
           html(response, 200, deviceApprovalPage({
-            title: 'Approve incremnt login',
-            message: 'Enter the approval code shown by the CLI and the account identity that should own the session.',
+            title: hasHostedProvider ? 'Approve incremnt login' : 'Cloud Sync unavailable',
+            message: hasHostedProvider
+              ? 'Continue with a configured identity provider to approve the code shown by incremnt login.'
+              : 'Cloud Sync sign-in is temporarily unavailable. Try again later.',
             userCode: url.searchParams.get('userCode') ?? '',
             email: url.searchParams.get('email') ?? '',
             userId: url.searchParams.get('userId') ?? '',
-            includeManualForm: manualDeviceApprovalEnabled,
-            appleStartPath: appleAuth?.configured
-              ? `/auth/apple/start?userCode=${encodeURIComponent(url.searchParams.get('userCode') ?? '')}`
-              : null,
-            googleStartPath: googleAuth?.configured
-              ? `/auth/google/start?userCode=${encodeURIComponent(url.searchParams.get('userCode') ?? '')}`
-              : null
+            includeManualForm: false,
+            appleStartPath,
+            googleStartPath,
+            isError: !hasHostedProvider
           }));
           return;
         }
@@ -1878,9 +2526,11 @@ export function createSyncServiceRequestHandler({
 
         try {
           const contentType = request.headers['content-type'] ?? '';
-          const body = contentType.includes('application/json')
-            ? await readJsonBody(request)
-            : await readUrlEncodedBody(request);
+          if (!contentType.includes('application/json')) {
+            methodNotAllowed(response, 'Manual device approval only accepts application/json.');
+            return;
+          }
+          const body = await readJsonBody(request);
           const result = await approveDeviceChallenge({
             deviceCode: body.deviceCode ?? null,
             userCode: body.userCode ?? body.user_code ?? null,
@@ -1888,24 +2538,13 @@ export function createSyncServiceRequestHandler({
             email: body.email ?? null
           });
 
-          if (contentType.includes('application/json')) {
-            json(response, 200, {
-              ok: true,
-              deviceCode: result.deviceCode,
-              userCode: result.userCode,
-              account: result.account,
-              expiresAt: result.expiresAt
-            });
-            return;
-          }
-
-          html(response, 200, deviceApprovalPage({
-            title: 'Login approved',
-            message: `The session for ${result.account.email ?? result.account.id} is ready. Return to the CLI to finish login.`,
+          json(response, 200, {
+            ok: true,
+            deviceCode: result.deviceCode,
             userCode: result.userCode,
-            email: result.account.email ?? '',
-            userId: result.account.id
-          }));
+            account: result.account,
+            expiresAt: result.expiresAt
+          });
           return;
         } catch (error) {
           html(response, 400, deviceApprovalPage({
@@ -1967,6 +2606,87 @@ export function createSyncServiceRequestHandler({
         }
       }
 
+      if (route.command === 'program-share-public') {
+        if (request.method !== 'GET') {
+          methodNotAllowed(response, 'Use GET for /program-share/:token.');
+          return;
+        }
+        if (!readPublicProgramShare) {
+          methodNotAllowed(response, 'Program sharing is not enabled for this service mode.');
+          return;
+        }
+        try {
+          const shared = await readPublicProgramShare(route.options.token);
+          if (shared.status === 'not_found') {
+            notFound(response, 'Program share not found.');
+            return;
+          }
+          if (shared.status === 'revoked' || shared.status === 'expired') {
+            json(response, 410, { error: 'Program share is no longer available.' });
+            return;
+          }
+          json(response, 200, {
+            ok: true,
+            token: route.options.token,
+            version: shared.share.version,
+            programId: shared.share.programId,
+            programName: shared.share.programPayload?.name ?? null,
+            programPayload: shared.share.programPayload,
+            createdAt: shared.share.createdAt,
+            expiresAt: shared.share.expiresAt
+          });
+          return;
+        } catch (error) {
+          if (error?.message === 'Invalid program share token.') {
+            badRequest(response, error.message);
+            return;
+          }
+          internalError(response, error, onError);
+          return;
+        }
+      }
+
+      if (route.command === 'google-mobile') {
+        if (request.method !== 'POST') {
+          methodNotAllowed(response, 'Use POST for /auth/google/mobile.');
+          return;
+        }
+
+        if (!googleAuth?.configured || !completeGoogleMobileAuth) {
+          methodNotAllowed(response, 'Google mobile auth is not enabled for this service mode.');
+          return;
+        }
+
+        try {
+          const body = await readJsonBody(request);
+          const idToken = typeof body?.idToken === 'string' ? body.idToken.trim() : '';
+          if (!idToken) {
+            badRequest(response, 'idToken is required.');
+            return;
+          }
+
+          const result = await completeGoogleMobileAuth({ idToken });
+          json(response, 200, {
+            ok: true,
+            session: {
+              accessToken: result.session.accessToken,
+              expiresAt: result.session.expiresAt
+            },
+            account: result.account
+          });
+          return;
+        } catch (error) {
+          reportAuthFailure(onError, error, {
+            route: 'google-mobile',
+            provider: 'google',
+            authFlow: 'mobile',
+            statusCode: 400
+          });
+          badRequest(response, error.message);
+          return;
+        }
+      }
+
       const requestToken = bearerToken(request);
       if (route.command === 'session-login') {
         if (request.method !== 'POST') {
@@ -2005,18 +2725,55 @@ export function createSyncServiceRequestHandler({
         return;
       }
 
-      if (route.command === 'session-refresh') {
+      if (route.command === 'anonymous-start') {
         if (request.method !== 'POST') {
-          methodNotAllowed(response, 'Use POST for /auth/refresh.');
+          methodNotAllowed(response, 'Use POST for /auth/anonymous/start.');
           return;
         }
 
-        if (!requestToken) {
-          unauthorized(response, request);
+        if (!issueAnonymousWriteAccess) {
+          methodNotAllowed(response, 'Anonymous hosted persistence is not enabled for this service mode.');
           return;
         }
 
-        if (!refreshSession) {
+        try {
+          const body = await readJsonBody(request);
+          const installId = typeof body?.installId === 'string' ? body.installId.trim() : '';
+          if (!installId) {
+            badRequest(response, 'installId is required.');
+            return;
+          }
+
+          const issued = await issueAnonymousWriteAccess({ installId });
+          // Return only the minimal account shape. `issued.account` also carries
+          // internal fields (identities, consent timestamps, capabilities) that
+          // the client doesn't need and shouldn't receive on an anon endpoint.
+          json(response, 200, {
+            ok: true,
+            account: { id: issued.account.id, email: issued.account.email ?? null },
+            anonymous: {
+              accessToken: issued.accessToken
+            }
+          });
+          return;
+        } catch (error) {
+          badRequest(response, error.message);
+          return;
+        }
+      }
+
+      if (route.command === 'session-refresh') {
+        if (request.method !== 'POST') {
+          methodNotAllowed(response, 'Use POST for /auth/refresh.');
+          return;
+        }
+
+        if (!requestToken) {
+          unauthorized(response, request);
+          return;
+        }
+
+        if (!refreshSession) {
           methodNotAllowed(response, 'Session refresh is not enabled for this service mode.');
           return;
         }
@@ -2040,6 +2797,132 @@ export function createSyncServiceRequestHandler({
 
       const readAuthenticator = authenticateReadToken ?? authenticateToken;
       const writeAuthenticator = authenticateWriteToken ?? authenticateToken;
+      const connectedWriteAuthenticator = authenticateConnectedWriteToken ?? readAuthenticator;
+      const mobileSyncAuthenticator = writeAuthenticator;
+
+      if (route.command === 'mobile-sync-bootstrap') {
+        if (request.method !== 'GET') {
+          methodNotAllowed(response, 'Use GET for /mobile/sync/bootstrap.');
+          return;
+        }
+        if (!loadMobileSyncStateForAccount) {
+          methodNotAllowed(response, 'Mobile sync bootstrap is not enabled for this service mode.');
+          return;
+        }
+
+        const account = mobileSyncAuthenticator
+          ? await mobileSyncAuthenticator(requestToken)
+          : null;
+        if (!account) {
+          unauthorized(response, request);
+          return;
+        }
+
+        json(response, 200, await loadMobileSyncStateForAccount(account));
+        return;
+      }
+
+      if (route.command === 'mobile-sync-pull') {
+        if (request.method !== 'GET') {
+          methodNotAllowed(response, 'Use GET for /mobile/sync/pull.');
+          return;
+        }
+        if (!pullMobileSyncStateForAccount) {
+          methodNotAllowed(response, 'Mobile sync pull is not enabled for this service mode.');
+          return;
+        }
+
+        const account = mobileSyncAuthenticator
+          ? await mobileSyncAuthenticator(requestToken)
+          : null;
+        if (!account) {
+          unauthorized(response, request);
+          return;
+        }
+
+        json(response, 200, await pullMobileSyncStateForAccount(account, route.options.since));
+        return;
+      }
+
+      if (route.command === 'score-snapshots') {
+        const account = connectedWriteAuthenticator
+          ? await connectedWriteAuthenticator(requestToken)
+          : null;
+        if (!account) {
+          unauthorized(response, request);
+          return;
+        }
+
+        if (request.method === 'POST') {
+          if (!insertScoreSnapshotsForAccount) {
+            methodNotAllowed(response, 'Score snapshot upload is not enabled for this service mode.');
+            return;
+          }
+          try {
+            const body = await readJsonBody(request);
+            if (!body || typeof body !== 'object' || !Array.isArray(body.snapshots)) {
+              badRequest(response, 'Invalid score snapshots body: expected an object with a snapshots array.');
+              return;
+            }
+            const result = await insertScoreSnapshotsForAccount(account, body.snapshots);
+            json(response, 200, result);
+            return;
+          } catch (error) {
+            badRequest(response, error.message);
+            return;
+          }
+        }
+
+        if (request.method === 'GET') {
+          if (!listScoreSnapshotsForAccount) {
+            methodNotAllowed(response, 'Score snapshot history is not enabled for this service mode.');
+            return;
+          }
+          try {
+            const snapshots = await listScoreSnapshotsForAccount(account, route.options ?? {});
+            json(response, 200, { snapshots });
+            return;
+          } catch (error) {
+            badRequest(response, error.message);
+            return;
+          }
+        }
+
+        methodNotAllowed(response, 'Use POST to upload or GET to list score snapshots.');
+        return;
+      }
+
+      if (route.command === 'mobile-sync-push') {
+        if (request.method !== 'POST') {
+          methodNotAllowed(response, 'Use POST for /mobile/sync/push.');
+          return;
+        }
+        if (!pushMobileSyncChangesForAccount) {
+          methodNotAllowed(response, 'Mobile sync push is not enabled for this service mode.');
+          return;
+        }
+
+        const account = mobileSyncAuthenticator
+          ? await mobileSyncAuthenticator(requestToken)
+          : null;
+        if (!account) {
+          unauthorized(response, request);
+          return;
+        }
+
+        try {
+          const body = await readJsonBody(request);
+          if (!body || typeof body !== 'object' || !Array.isArray(body.changes)) {
+            badRequest(response, 'Invalid mobile sync push body: expected an object with a changes array.');
+            return;
+          }
+          json(response, 200, await pushMobileSyncChangesForAccount(account, body));
+          return;
+        } catch (error) {
+          badRequest(response, error.message);
+          return;
+        }
+      }
 
       if (route.command === 'delete-account') {
         if (request.method !== 'DELETE') {
@@ -2078,8 +2961,8 @@ export function createSyncServiceRequestHandler({
             return;
           }
 
-          const proposalAccount = writeAuthenticator
-            ? await writeAuthenticator(requestToken)
+          const proposalAccount = connectedWriteAuthenticator
+            ? await connectedWriteAuthenticator(requestToken)
             : requestToken === token
               ? { id: 'remote-user', email: null }
               : null;
@@ -2146,8 +3029,8 @@ export function createSyncServiceRequestHandler({
           return;
         }
 
-        const proposalAccount = writeAuthenticator
-          ? await writeAuthenticator(requestToken)
+        const proposalAccount = connectedWriteAuthenticator
+          ? await connectedWriteAuthenticator(requestToken)
           : requestToken === token
             ? { id: 'remote-user', email: null }
             : null;
@@ -2177,6 +3060,129 @@ export function createSyncServiceRequestHandler({
         }
       }
 
+      if (route.command === 'program-share-create') {
+        if (request.method !== 'POST') {
+          methodNotAllowed(response, 'Use POST for /cli/programs/:programId/share.');
+          return;
+        }
+        if (!createProgramShareForAccount) {
+          methodNotAllowed(response, 'Program sharing is not enabled for this service mode.');
+          return;
+        }
+        const account = connectedWriteAuthenticator
+          ? await connectedWriteAuthenticator(requestToken)
+          : null;
+        if (!account) {
+          unauthorized(response, request);
+          return;
+        }
+        try {
+          const share = await createProgramShareForAccount(account, route.options.programId);
+          json(response, 201, {
+            ok: true,
+            shareId: share.id,
+            tokenHint: share.tokenHint,
+            token: share.token,
+            programId: share.programId,
+            createdAt: share.createdAt,
+            expiresAt: share.expiresAt,
+            revokedAt: share.revokedAt,
+            version: share.version,
+            link: `${resolvedPublicOrigin}/program-share/${share.token}`,
+            deepLink: `incremnt://plan-share/${share.token}?base=${encodeURIComponent(resolvedPublicOrigin)}`
+          });
+          return;
+        } catch (error) {
+          if (error?.message === 'programId is required.' || error?.message === 'Program not found.') {
+            const code = error.message === 'Program not found.' ? 404 : 400;
+            json(response, code, { error: error.message });
+            return;
+          }
+          internalError(response, error, onError);
+          return;
+        }
+      }
+
+      if (route.command === 'program-share-list') {
+        if (request.method !== 'GET') {
+          methodNotAllowed(response, 'Use GET for /cli/programs/:programId/shares.');
+          return;
+        }
+        if (!listProgramSharesForAccount) {
+          methodNotAllowed(response, 'Program sharing is not enabled for this service mode.');
+          return;
+        }
+        const account = readAuthenticator
+          ? await readAuthenticator(requestToken)
+          : null;
+        if (!account) {
+          unauthorized(response, request);
+          return;
+        }
+        try {
+          const rows = await listProgramSharesForAccount(account, route.options.programId);
+          json(response, 200, {
+            ok: true,
+            shares: rows.map((share) => ({
+              shareId: share.id,
+              tokenHint: share.tokenHint,
+              programId: share.programId,
+              createdAt: share.createdAt,
+              expiresAt: share.expiresAt,
+              revokedAt: share.revokedAt,
+              version: share.version
+            }))
+          });
+          return;
+        } catch (error) {
+          if (error?.message === 'programId is required.') {
+            badRequest(response, error.message);
+            return;
+          }
+          internalError(response, error, onError);
+          return;
+        }
+      }
+
+      if (route.command === 'program-share-revoke') {
+        if (request.method !== 'POST') {
+          methodNotAllowed(response, 'Use POST for /cli/program-share/:token/revoke.');
+          return;
+        }
+        if (!revokeProgramShareForAccount) {
+          methodNotAllowed(response, 'Program sharing is not enabled for this service mode.');
+          return;
+        }
+        const account = connectedWriteAuthenticator
+          ? await connectedWriteAuthenticator(requestToken)
+          : null;
+        if (!account) {
+          unauthorized(response, request);
+          return;
+        }
+        try {
+          const share = await revokeProgramShareForAccount(account, route.options.shareId);
+          if (!share) {
+            notFound(response, 'Program share not found.');
+            return;
+          }
+          json(response, 200, {
+            ok: true,
+            shareId: share.id,
+            tokenHint: share.tokenHint,
+            revokedAt: share.revokedAt
+          });
+          return;
+        } catch (error) {
+          if (error?.message === 'Invalid program share id.') {
+            badRequest(response, error.message);
+            return;
+          }
+          internalError(response, error, onError);
+          return;
+        }
+      }
+
       if (route.command === 'contract') {
         const account = readAuthenticator
           ? await readAuthenticator(requestToken)
@@ -2281,8 +3287,8 @@ export function createSyncServiceRequestHandler({
           return;
         }
 
-        const account = writeAuthenticator
-          ? await writeAuthenticator(requestToken)
+        const account = connectedWriteAuthenticator
+          ? await connectedWriteAuthenticator(requestToken)
           : requestToken === token
             ? { id: 'remote-user', email: null }
             : null;
@@ -2359,8 +3365,8 @@ export function createSyncServiceRequestHandler({
           return;
         }
 
-        const writeAccount = writeAuthenticator
-          ? await writeAuthenticator(requestToken)
+        const writeAccount = connectedWriteAuthenticator
+          ? await connectedWriteAuthenticator(requestToken)
           : requestToken === token
             ? { id: 'remote-user', email: null }
             : null;
@@ -2420,8 +3426,8 @@ export function createSyncServiceRequestHandler({
           return;
         }
 
-        const writeAccount = writeAuthenticator
-          ? await writeAuthenticator(requestToken)
+        const writeAccount = connectedWriteAuthenticator
+          ? await connectedWriteAuthenticator(requestToken)
           : requestToken === token
             ? { id: 'remote-user', email: null }
             : null;
@@ -2469,6 +3475,7 @@ export function createSyncServiceRequestHandler({
       }
       // Parse comma-separated exclude param into a Set for AI context builders
       const parseExclude = (raw) => new Set((raw ?? '').split(',').map((s) => s.trim()).filter(Boolean));
+      const aiUser = anonymizeAccountId(account.id);
 
       if (route.command === 'workout-summary-ai') {
         const sessionId = route.options['session-id'];
@@ -2478,7 +3485,8 @@ export function createSyncServiceRequestHandler({
         }
 
         const { workoutSummaryContext } = await import('./queries.js');
-        const ctx = workoutSummaryContext(snapshot, sessionId, { exclude: parseExclude(route.options['exclude']) });
+        const exclude = parseExclude(route.options['exclude']);
+        const ctx = workoutSummaryContext(snapshot, sessionId, { exclude });
         if (!ctx) {
           notFound(response, `Session not found: ${sessionId}`);
           return;
@@ -2491,8 +3499,17 @@ export function createSyncServiceRequestHandler({
         }
 
         try {
-          const { generateWorkoutCoachingSummary } = await import('./openrouter.js');
-          const result = await generateWorkoutCoachingSummary(ctx, { apiKey: openrouterKey, tone: route.options['tone'] });
+          const { AI_PROMPT_VERSIONS, generateWorkoutCoachingSummary } = await import('./openrouter.js');
+          const result = await generateWorkoutCoachingSummary(ctx, {
+            apiKey: openrouterKey,
+            tone: route.options['tone'],
+            user: aiUser,
+            sessionId: `workout:${sessionId}`,
+            contextMetadata: {
+              excludedSections: [...exclude],
+              sessionId
+            }
+          });
           if (isNoInsightResponse(result.text)) {
             response.writeHead(204).end();
             return;
@@ -2514,7 +3531,11 @@ export function createSyncServiceRequestHandler({
             json(response, 200, { summary: null, model: result.model, filtered: true });
             return;
           }
-          json(response, 200, { summary: result.text, model: result.model });
+          json(response, 200, {
+            summary: stripXMLTagBlocks(result.text),
+            model: result.model,
+            metadata: buildAIGenerationMetadata('workout', result.model, AI_PROMPT_VERSIONS.workout, result)
+          });
         } catch (err) {
           console.error('AI workout summary error:', err.message);
           onError?.(err, {
@@ -2551,6 +3572,245 @@ export function createSyncServiceRequestHandler({
         return;
       }
 
+      if (route.command === 'weekly-checkin-enroll') {
+        if (request.method !== 'POST') {
+          methodNotAllowed(response, 'Use POST for /cli/weekly-checkin/enroll.');
+          return;
+        }
+        if (!upsertScheduledWeeklyCheckinForAccount) {
+          json(response, 503, { error: 'Weekly check-in not available' });
+          return;
+        }
+        let body;
+        try { body = await readJsonBody(request); } catch { badRequest(response, 'Invalid JSON body.'); return; }
+        const timezoneId = body?.timezoneId;
+        if (!isValidTimeZone(timezoneId)) {
+          badRequest(response, 'timezoneId must be a valid IANA timezone identifier.');
+          return;
+        }
+        const schedule = nextWeeklyCheckinSchedule(timezoneId);
+        try {
+          const row = await upsertScheduledWeeklyCheckinForAccount(account, {
+            id: `weekly-checkin:${account.id}:${schedule.weekStartDate}:${randomUUID()}`,
+            weekStartDate: schedule.weekStartDate,
+            nextRecapDueAt: schedule.nextRecapDueAt,
+            timezoneId
+          });
+          json(response, 200, {
+            id: row.id,
+            weekStartDate: row.weekStartDate,
+            status: row.status,
+            nextRecapDueAt: row.nextRecapDueAt,
+            timezoneId: row.timezoneId
+          });
+        } catch (err) {
+          console.error('Weekly check-in enroll error:', err.message);
+          json(response, 500, { error: 'Failed to enroll weekly check-in' });
+        }
+        return;
+      }
+
+      if (route.command === 'weekly-checkin-current') {
+        if (request.method !== 'GET') {
+          methodNotAllowed(response, 'Use GET for /cli/weekly-checkin/current.');
+          return;
+        }
+        if (!getCurrentWeeklyCheckinForAccount) {
+          json(response, 503, { error: 'Weekly check-in not available' });
+          return;
+        }
+        try {
+          const row = await getCurrentWeeklyCheckinForAccount(account);
+          if (!row) {
+            notFound(response, 'No weekly check-in scheduled yet.');
+            return;
+          }
+          // Lazy-gen path: if scheduled and overdue, attempt to generate now.
+          if (row.status === 'scheduled' && row.nextRecapDueAt && new Date(row.nextRecapDueAt) <= new Date()) {
+            const openrouterKey = process.env.OPENROUTER_API_KEY;
+            let recap = null;
+            if (openrouterKey && generateWeeklyCheckinRecapImpl && generateCheckinQuestionsImpl) {
+              try {
+                const { weeklyCheckinContext } = await import('./queries.js');
+                const ctx = weeklyCheckinContext(snapshot, account.id, {});
+                if (ctx) {
+                  let priorCommitmentRow = null;
+                  if (listActiveCoachCommitmentsForAccount) {
+                    try {
+                      const activeCommitments = await listActiveCoachCommitmentsForAccount(account, {
+                        limit: 1,
+                        weekStartDate: ctx.weekRangeIso?.start
+                      });
+                      priorCommitmentRow = activeCommitments[0] ?? null;
+                    } catch (commitmentErr) {
+                      console.error('Lazy weekly-checkin commitment read failed:', commitmentErr.message);
+                    }
+                  }
+                  const recapResult = await generateWeeklyCheckinRecapImpl(ctx, {
+                    apiKey: openrouterKey,
+                    user: aiUser,
+                    sessionId: `weekly-checkin:${row.id}:recap`,
+                    priorCommitment: priorCommitmentRow?.commitment ?? null,
+                    contextMetadata: {
+                      coachCommitmentIds: priorCommitmentRow?.id ? [priorCommitmentRow.id] : []
+                    }
+                  });
+                  const questionsResult = await generateCheckinQuestionsImpl(ctx, recapResult.text, {
+                    apiKey: openrouterKey,
+                    user: aiUser,
+                    sessionId: `weekly-checkin:${row.id}:questions`
+                  });
+                  recap = {
+                    recapText: recapResult.text,
+                    questions: questionsResult.questions,
+                    model: recapResult.model,
+                    generatedAt: new Date().toISOString()
+                  };
+                }
+              } catch (genErr) {
+                console.error('Lazy weekly-checkin gen failed:', genErr.message);
+              }
+            }
+            if (!recap) {
+              recap = { recapText: 'Your recap is being prepared.', questions: [], placeholder: true, generatedAt: new Date().toISOString() };
+            }
+            if (transitionWeeklyCheckinForAccount) {
+              try {
+                const updated = await transitionWeeklyCheckinForAccount(account, row.id, { toStatus: 'generated', recap });
+                if (updated) Object.assign(row, updated);
+              } catch (tErr) {
+                console.error('Lazy weekly-checkin transition failed:', tErr.message);
+                const latest = await getCurrentWeeklyCheckinForAccount(account);
+                if (latest?.id === row.id) {
+                  Object.assign(row, latest);
+                }
+              }
+            }
+          }
+          json(response, 200, {
+            id: row.id,
+            weekStartDate: row.weekStartDate,
+            status: row.status,
+            recap: row.recap,
+            conversationId: row.conversationId
+          });
+        } catch (err) {
+          console.error('Weekly check-in current error:', err.message);
+          json(response, 500, { error: 'Failed to load weekly check-in' });
+        }
+        return;
+      }
+
+      if (route.command === 'weekly-checkin-ack') {
+        if (request.method !== 'POST') {
+          methodNotAllowed(response, 'Use POST for /cli/weekly-checkin/ack.');
+          return;
+        }
+        if (!getCurrentWeeklyCheckinForAccount || !transitionWeeklyCheckinForAccount) {
+          json(response, 503, { error: 'Weekly check-in not available' });
+          return;
+        }
+        let body;
+        try { body = await readJsonBody(request); } catch { badRequest(response, 'Invalid JSON body.'); return; }
+        const action = body?.action;
+        if (action !== 'opened' && action !== 'dismissed') {
+          badRequest(response, 'action must be "opened" or "dismissed".');
+          return;
+        }
+        const row = await getCurrentWeeklyCheckinForAccount(account);
+        if (!row) {
+          notFound(response, 'No weekly check-in.');
+          return;
+        }
+        try {
+          const updated = await transitionWeeklyCheckinForAccount(account, row.id, { toStatus: action });
+          if (!updated) {
+            badRequest(response, `Cannot transition from ${row.status} to ${action}.`);
+            return;
+          }
+          json(response, 200, { id: updated.id, status: updated.status });
+        } catch (err) {
+          console.error('Weekly check-in ack error:', err.message);
+          if (err.code === 'invalid_transition') {
+            badRequest(response, err.message);
+            return;
+          }
+          json(response, 500, { error: 'Failed to ack weekly check-in' });
+        }
+        return;
+      }
+
+      if (route.command === 'weekly-checkin-start') {
+        if (request.method !== 'POST') {
+          methodNotAllowed(response, 'Use POST for /cli/weekly-checkin/start.');
+          return;
+        }
+        if (!getCurrentWeeklyCheckinForAccount || !transitionWeeklyCheckinForAccount || !saveAskConversationForAccount) {
+          json(response, 503, { error: 'Weekly check-in not available' });
+          return;
+        }
+        const row = await getCurrentWeeklyCheckinForAccount(account);
+        if (!row) {
+          notFound(response, 'No weekly check-in scheduled.');
+          return;
+        }
+        if (!row.recap || row.recap.placeholder) {
+          json(response, 409, { error: 'Weekly check-in recap not ready yet.', code: 'recap_not_ready' });
+          return;
+        }
+        const conversationId = `weekly-checkin:${row.id}`;
+        const recapText = String(row.recap.recapText ?? '').trim();
+        const questions = Array.isArray(row.recap.questions) ? row.recap.questions : [];
+        const firstAssistantMessage = [recapText, ...(questions.length ? [questions.map((q, i) => `${i + 1}. ${q}`).join('\n')] : [])].filter(Boolean).join('\n\n');
+        try {
+          const { AI_PROMPT_VERSIONS } = await import('./openrouter.js');
+          const existingConversation = getAskConversationForAccount
+            ? await getAskConversationForAccount(account, conversationId)
+            : null;
+          if (Array.isArray(existingConversation?.messages) && existingConversation.messages.length > 0) {
+            const existingFirstAssistant = existingConversation.messages.find((m) => m.role === 'assistant')?.content;
+            json(response, 200, {
+              conversationId,
+              firstAssistantMessage: existingFirstAssistant || firstAssistantMessage,
+              questions,
+              resumed: true
+            });
+            return;
+          }
+          if (row.status !== 'in_progress') {
+            let openedRow = row;
+            if (openedRow.status === 'generated' || openedRow.status === 'delivered') {
+              openedRow = await transitionWeeklyCheckinForAccount(account, row.id, { toStatus: 'opened' });
+            }
+            if (!openedRow || openedRow.status !== 'opened') {
+              json(response, 409, { error: `Cannot start weekly check-in from ${row.status}.`, code: 'invalid_state' });
+              return;
+            }
+            const inProgress = await transitionWeeklyCheckinForAccount(account, row.id, { toStatus: 'in_progress', conversationId });
+            if (!inProgress || inProgress.status !== 'in_progress') {
+              json(response, 409, { error: 'Weekly check-in state was not updated.', code: 'state_update_failed' });
+              return;
+            }
+          }
+          await saveAskConversationForAccount(account, {
+            id: conversationId,
+            messages: [{ role: 'assistant', content: firstAssistantMessage }],
+            model: row.recap.model ?? null,
+            metadata: buildAIGenerationMetadata('weekly-checkin', row.recap.model ?? null, AI_PROMPT_VERSIONS.weeklyCheckin, row.recap),
+            kind: 'weekly-checkin'
+          });
+          json(response, 200, { conversationId, firstAssistantMessage, questions });
+        } catch (err) {
+          console.error('Weekly check-in start error:', err.message);
+          if (err.code === 'invalid_transition') {
+            json(response, 409, { error: err.message, code: 'invalid_transition' });
+            return;
+          }
+          json(response, 500, { error: 'Failed to start weekly check-in' });
+        }
+        return;
+      }
+
       if (route.command === 'cycle-summary-ai') {
         const programId = route.options['program-id'];
         if (!programId) {
@@ -2559,22 +3819,13 @@ export function createSyncServiceRequestHandler({
         }
 
         const { cycleSummaryContext } = await import('./queries.js');
-        const ctx = cycleSummaryContext(snapshot, programId, { exclude: parseExclude(route.options['exclude']) });
+        const exclude = parseExclude(route.options['exclude']);
+        const ctx = cycleSummaryContext(snapshot, programId, { exclude });
         if (!ctx) {
           notFound(response, `No completed cycle found for program: ${programId}`);
           return;
         }
 
-        // Inject coach memory into cycle summary context if available
-        let coachMemory = null;
-        if (readCoachMemoryForAccount) {
-          try {
-            coachMemory = await readCoachMemoryForAccount(account);
-          } catch (memErr) {
-            console.error('Coach memory read error (cycle-summary):', memErr.message);
-          }
-        }
-
         const openrouterKey = process.env.OPENROUTER_API_KEY;
         if (!openrouterKey) {
           json(response, 503, { error: 'AI summaries not configured', code: 'not_configured' });
@@ -2582,11 +3833,17 @@ export function createSyncServiceRequestHandler({
         }
 
         try {
-          const { generateCoachingSummary } = await import('./openrouter.js');
-          if (coachMemory?.content) {
-            ctx.coachMemory = coachMemory.content;
-          }
-          const result = await generateCoachingSummary(ctx, { apiKey: openrouterKey, tone: route.options['tone'] });
+          const { AI_PROMPT_VERSIONS, generateCoachingSummary } = await import('./openrouter.js');
+          const result = await generateCoachingSummary(ctx, {
+            apiKey: openrouterKey,
+            tone: route.options['tone'],
+            user: aiUser,
+            sessionId: `cycle:${programId}:${ctx.cycleNumber}`,
+            contextMetadata: {
+              excludedSections: [...exclude],
+              programId
+            }
+          });
           if (result.fallback && onError) {
             const warning = new Error(`AI cycle-summary used fallback model ${result.model}`);
             warning.level = 'warning';
@@ -2604,32 +3861,11 @@ export function createSyncServiceRequestHandler({
             json(response, 200, { summary: null, model: result.model, filtered: true });
             return;
           }
-          json(response, 200, { summary: result.text, model: result.model });
-
-          // Background: update coach memory after responding
-          if (writeCoachMemoryForAccount && readCoachMemoryForAccount) {
-            setImmediate(async () => {
-              try {
-                const { generateMemoryUpdate } = await import('./openrouter.js');
-                // Build recent context from previous cycle summaries
-                const recentLines = (ctx.previousCycles || [])
-                  .filter((pc) => pc.previousAISummary)
-                  .map((pc) => `Week ${pc.weekNumber}: ${pc.previousAISummary.split('\n')[0].slice(0, 200)}`)
-                  .join('\n');
-                const memResult = await generateMemoryUpdate(
-                  coachMemory?.content || '',
-                  result.text,
-                  recentLines || null,
-                  { apiKey: openrouterKey }
-                );
-                await writeCoachMemoryForAccount(account, memResult.text);
-                console.log(`Coach memory updated for account (v${(coachMemory?.version ?? 0) + 1})`);
-              } catch (memErr) {
-                console.error('Background coach memory update failed:', memErr.message);
-                onError?.(memErr, { feature: 'coach-memory-update' });
-              }
-            });
-          }
+          json(response, 200, {
+            summary: stripXMLTagBlocks(result.text),
+            model: result.model,
+            metadata: buildAIGenerationMetadata('cycle', result.model, AI_PROMPT_VERSIONS.cycle, result)
+          });
         } catch (err) {
           console.error('AI cycle summary error:', err.message);
           onError?.(err, {
@@ -2650,11 +3886,21 @@ export function createSyncServiceRequestHandler({
         }
 
         const { vitalsSummaryContext } = await import('./queries.js');
-        const ctx = vitalsSummaryContext(snapshot, { exclude: parseExclude(route.options['exclude']) });
+        const exclude = parseExclude(route.options['exclude']);
+        const ctx = vitalsSummaryContext(snapshot, { exclude });
 
         try {
-          const { generateVitalsSummary } = await import('./openrouter.js');
-          const result = await generateVitalsSummary(ctx, { apiKey: openrouterKey, tone: route.options['tone'] });
+          const { AI_PROMPT_VERSIONS, generateVitalsSummary } = await import('./openrouter.js');
+          const result = await generateVitalsSummary(ctx, {
+            apiKey: openrouterKey,
+            tone: route.options['tone'],
+            user: aiUser,
+            sessionId: `vitals:${new Date().toISOString().slice(0, 10)}`,
+            contextMetadata: {
+              excludedSections: [...exclude],
+              recentDays: 14
+            }
+          });
           if (result.fallback && onError) {
             const warning = new Error(`AI vitals-summary used fallback model ${result.model}`);
             warning.level = 'warning';
@@ -2672,7 +3918,11 @@ export function createSyncServiceRequestHandler({
             json(response, 200, { summary: null, model: result.model, filtered: true });
             return;
           }
-          json(response, 200, { summary: result.text, model: result.model });
+          json(response, 200, {
+            summary: stripXMLTagBlocks(result.text),
+            model: result.model,
+            metadata: buildAIGenerationMetadata('vitals', result.model, AI_PROMPT_VERSIONS.vitals, result)
+          });
         } catch (err) {
           console.error('AI vitals summary error:', err.message);
           onError?.(err, {
@@ -2698,24 +3948,13 @@ export function createSyncServiceRequestHandler({
         }
 
         const { checkpointContext } = await import('./queries.js');
-        const ctx = checkpointContext(snapshot, programId, checkpointWeek, { exclude: parseExclude(route.options['exclude']) });
+        const exclude = parseExclude(route.options['exclude']);
+        const ctx = checkpointContext(snapshot, programId, checkpointWeek, { exclude });
         if (!ctx) {
           notFound(response, 'No strength plan found for program');
           return;
         }
 
-        // Inject coach memory into checkpoint context
-        if (readCoachMemoryForAccount) {
-          try {
-            const mem = await readCoachMemoryForAccount(account);
-            if (mem?.content) {
-              ctx.coachMemory = mem.content;
-            }
-          } catch (memErr) {
-            console.error('Coach memory read error (checkpoint):', memErr.message);
-          }
-        }
-
         const openrouterKey = process.env.OPENROUTER_API_KEY;
         if (!openrouterKey) {
           json(response, 503, { error: 'AI summaries not configured', code: 'not_configured' });
@@ -2723,8 +3962,18 @@ export function createSyncServiceRequestHandler({
         }
 
         try {
-          const { generateCheckpointSummary } = await import('./openrouter.js');
-          const result = await generateCheckpointSummary(ctx, { apiKey: openrouterKey, tone: route.options['tone'] });
+          const { AI_PROMPT_VERSIONS, generateCheckpointSummary } = await import('./openrouter.js');
+          const result = await generateCheckpointSummary(ctx, {
+            apiKey: openrouterKey,
+            tone: route.options['tone'],
+            user: aiUser,
+            sessionId: `checkpoint:${programId}:${checkpointWeek}`,
+            contextMetadata: {
+              excludedSections: [...exclude],
+              programId,
+              checkpointWeek
+            }
+          });
           if (result.fallback && onError) {
             const warning = new Error(`AI checkpoint-summary used fallback model ${result.model}`);
             warning.level = 'warning';
@@ -2742,7 +3991,11 @@ export function createSyncServiceRequestHandler({
             json(response, 200, { summary: null, model: result.model, filtered: true });
             return;
           }
-          json(response, 200, { summary: result.text, model: result.model });
+          json(response, 200, {
+            summary: stripXMLTagBlocks(result.text),
+            model: result.model,
+            metadata: buildAIGenerationMetadata('checkpoint', result.model, AI_PROMPT_VERSIONS.checkpoint, result)
+          });
         } catch (err) {
           console.error('AI checkpoint summary error:', err.message);
           onError?.(err, {
@@ -2793,12 +4046,6 @@ export function createSyncServiceRequestHandler({
           ? sanitizeHistory(persistedConversation.messages)
           : null;
         const canonicalHistory = (persistedMessages?.length ? persistedMessages : null) ?? history;
-        const priorUserTurns = canonicalHistory.filter((m) => m.role === 'user').length;
-        if (priorUserTurns >= MAX_ASK_USER_TURNS) {
-          json(response, 400, { error: `Ask Coach supports up to ${MAX_ASK_USER_TURNS} questions per conversation. Start a new conversation.`, code: 'conversation_limit' });
-          return;
-        }
-
         const openrouterKey = process.env.OPENROUTER_API_KEY;
         if (!openrouterKey) {
           json(response, 503, { error: 'AI not configured', code: 'not_configured' });
@@ -2807,55 +4054,158 @@ export function createSyncServiceRequestHandler({
 
         const queries = await import('./queries.js');
         const exclude = parseExclude(body?.exclude);
-        let ctx = queries.askContext(snapshot, { exclude });
-
-        // Inject coach memory into ask context
-        if (readCoachMemoryForAccount) {
+        let coachFacts = [];
+        if (listCoachFactsForAccount) {
           try {
-            const mem = await readCoachMemoryForAccount(account);
-            if (mem?.content) {
-              ctx = ctx + '\n\n' + fenceContent('coach_memory', mem.content);
-            }
-          } catch (memErr) {
-            console.error('Coach memory read error (ask):', memErr.message);
+            const kinds = queries.coachFactKindsForAskQuestion
+              ? queries.coachFactKindsForAskQuestion(snapshot, question)
+              : [];
+            coachFacts = await listCoachFactsForAccount(account, { kinds, limit: 30 });
+          } catch (factErr) {
+            console.error('Coach facts read error (ask):', factErr.message);
+          }
+        }
+        let scoreSnapshots = [];
+        if (listScoreSnapshotsForAccount) {
+          try {
+            scoreSnapshots = await listScoreSnapshotsForAccount(account, { limit: 14 }) ?? [];
+          } catch (scoreErr) {
+            console.error('Increment Score read error (ask):', scoreErr.message);
           }
         }
+        if (scoreSnapshots.length > 0) {
+          snapshot.incrementScore = {
+            latest: scoreSnapshots[0],
+            history: scoreSnapshots
+          };
+        }
+
+        const routedContext = queries.askRoutedContext
+          ? queries.askRoutedContext(snapshot, question, { exclude, coachFacts })
+          : { context: queries.askContext(snapshot, { exclude }), metadata: { route: 'legacy' } };
+        const persistedKind = persistedConversation?.kind ?? (conversationId?.startsWith('weekly-checkin:') ? 'weekly-checkin' : 'ask');
+        const serverProgramPhase = persistedKind === 'weekly-checkin'
+          ? queries.weeklyCheckinContext?.(snapshot, account.id)?.programPhase
+          : null;
+        const programPhasePrelude = formatProgramPhasePrelude(body?.programPhase ?? serverProgramPhase);
+        const incrementScorePrelude = formatIncrementScorePrelude(scoreSnapshots);
+
+        const preludes = [programPhasePrelude, incrementScorePrelude].filter(Boolean);
+        const ctx = preludes.length > 0
+          ? `${preludes.join('\n\n')}\n\n${routedContext.context}`
+          : routedContext.context;
 
         const askTone = ['default', 'hype', 'numbers-only'].includes(body?.tone) ? body.tone : undefined;
 
         try {
-          const { generateAskAnswer } = await import('./openrouter.js');
-
-          const askResult = await generateAskAnswer(ctx, question, {
-            apiKey: openrouterKey, history: canonicalHistory, tone: askTone
+          const { AI_PROMPT_VERSIONS, generateAskAnswer, WEEKLY_CHECKIN_PROMPT } = await import('./openrouter.js');
+          const generateAsk = generateAskAnswerImpl ?? generateAskAnswer;
+          const systemPromptOverride = persistedKind === 'weekly-checkin' ? WEEKLY_CHECKIN_PROMPT : undefined;
+
+          const askResult = await generateAsk(ctx, question, {
+            apiKey: openrouterKey,
+            history: canonicalHistory,
+            tone: askTone,
+            user: aiUser,
+            sessionId: `ask:${conversationId}`,
+            systemPrompt: systemPromptOverride,
+            routingMetadata: {
+              ...routedContext.metadata,
+              contextCharCount: ctx.length,
+              historyTurnCount: canonicalHistory.filter((m) => m.role === 'user').length,
+              coachFactsIncluded: (routedContext.metadata?.includedCoachFactIds ?? []).length > 0,
+              coachFactIds: routedContext.metadata?.includedCoachFactIds ?? [],
+              coachFactKinds: routedContext.metadata?.coachFactKinds ?? []
+            }
           });
 
-          // Check for system prompt leakage BEFORE persisting — a leaked
-          // response must never be saved to the conversation history.
+          const parsedAsk = extractAskProgramDraft(askResult.text, {
+            canonicalizeExerciseName: queries.canonicalExerciseName
+          });
+          const assistantAnswer = stripXMLTagBlocks(parsedAsk.answerText);
+          // Check for system prompt leakage before persisting. We inspect only
+          // the user-visible prose, not the structured draft payload, so valid
+          // <program_draft> output does not false-positive as a prompt leak.
           const { SYSTEM_PROMPTS_FOR_LEAK_CHECK } = await import('./openrouter.js');
-          if (detectSystemPromptLeak(askResult.text, SYSTEM_PROMPTS_FOR_LEAK_CHECK)) {
+          if (detectSystemPromptLeak(assistantAnswer, SYSTEM_PROMPTS_FOR_LEAK_CHECK)) {
             console.error('SECURITY: System prompt leak detected in ask-ai response, blocking');
             onError?.(new Error('System prompt leak detected in AI response'), { feature: 'ask-coach', security: true });
             json(response, 200, { answer: 'I can only answer questions about your training. Could you rephrase?', model: askResult.model, filtered: true });
             return;
           }
 
+          const promptSurface = persistedKind === 'weekly-checkin' ? 'weekly-checkin' : 'ask';
+          const promptVersion = persistedKind === 'weekly-checkin' ? AI_PROMPT_VERSIONS.weeklyCheckin : AI_PROMPT_VERSIONS.ask;
+          const metadata = buildAIGenerationMetadata(promptSurface, askResult.model, promptVersion, askResult);
           const updatedMessages = [
             ...canonicalHistory,
             { role: 'user', content: question },
-            { role: 'assistant', content: askResult.text }
+            { role: 'assistant', content: assistantAnswer }
           ];
           if (saveAskConversationForAccount) {
             try {
               await saveAskConversationForAccount(account, {
                 id: conversationId,
                 messages: updatedMessages,
-                model: askResult.model
+                model: askResult.model,
+                metadata,
+                kind: persistedKind
               });
             } catch (saveErr) {
               console.error('Failed to save ask conversation:', saveErr.message);
             }
           }
+          if (saveCoachFactsForAccount) {
+            const transcript = transcriptForCoachFactExtraction(updatedMessages);
+            const sourceSessionId = conversationId;
+            setImmediate(() => {
+              extractAndSaveCoachFacts({
+                account,
+                sourceSurface: promptSurface,
+                sourceSessionId,
+                transcript,
+                openrouterKey,
+                aiUser,
+                saveCoachFactsForAccount,
+                generateCoachFactCandidatesImpl,
+                onError
+              });
+            });
+          }
+          const updatedUserTurns = updatedMessages.filter((m) => m.role === 'user').length;
+          if (
+            persistedKind === 'weekly-checkin' &&
+            updatedUserTurns >= WEEKLY_CHECKIN_COMPLETION_USER_TURNS &&
+            conversationId.startsWith('weekly-checkin:') &&
+            transitionWeeklyCheckinForAccount
+          ) {
+            const weeklyCheckinId = conversationId.slice('weekly-checkin:'.length);
+            let completedCheckin = null;
+            try {
+              completedCheckin = await transitionWeeklyCheckinForAccount(account, weeklyCheckinId, { toStatus: 'completed' });
+            } catch (completeErr) {
+              if (completeErr.code !== 'invalid_transition') {
+                console.error('Weekly check-in completion transition failed:', completeErr.message);
+              }
+            }
+            if (saveCoachCommitmentsForAccount) {
+              setImmediate(async () => {
+                try {
+                  const { extractCoachCommitmentsFromUserTurns } = await import('./openrouter.js');
+                  const commitments = extractCoachCommitmentsFromUserTurns(updatedMessages);
+                  if (commitments.length === 0) return;
+                  await saveCoachCommitmentsForAccount(account, commitments, {
+                    weekStartDate: completedCheckin?.weekStartDate ?? new Date().toISOString().slice(0, 10),
+                    sourceSurface: 'weekly-checkin',
+                    sourceConversationId: conversationId
+                  });
+                } catch (commitmentErr) {
+                  console.error('Background weekly check-in commitment save failed:', commitmentErr.message);
+                  onError?.(commitmentErr, { feature: 'weekly-checkin-commitment-save' });
+                }
+              });
+            }
+          }
           if (askResult.fallback && onError) {
             const warning = new Error(`AI ask-coach used fallback model ${askResult.model}`);
             warning.level = 'warning';
@@ -2866,7 +4216,12 @@ export function createSyncServiceRequestHandler({
               fallbackModel: askResult.model
             });
           }
-          json(response, 200, { answer: askResult.text, model: askResult.model });
+          json(response, 200, {
+            answer: assistantAnswer,
+            model: askResult.model,
+            metadata,
+            programDraft: parsedAsk.programDraft
+          });
         } catch (err) {
           console.error('AI ask error:', err.message);
           onError?.(err, {
@@ -2945,7 +4300,10 @@ export function createSyncServiceRequestHandler({
               id: c.id,
               preview: (firstUserMsg?.content ?? '').slice(0, 120),
               messageCount: c.messages?.length ?? 0,
-              createdAt: c.createdAt
+              createdAt: c.createdAt,
+              model: c.model ?? null,
+              kind: c.kind ?? 'ask',
+              metadata: c.metadata ?? null
             };
           });
           json(response, 200, { conversations: summaries });
@@ -2976,7 +4334,7 @@ export function createSyncServiceRequestHandler({
             const conversations = await listAskConversationsForAccount(account);
             conversation = conversations.find((c) => c.id === route.options.id);
           }
-          if (!conversation) {
+          if (!conversation || (conversation.kind ?? 'ask') !== 'ask') {
             notFound(response, `Conversation not found: ${route.options.id}`);
             return;
           }
@@ -3142,6 +4500,47 @@ export function createSyncServiceRequestHandler({
         return;
       }
 
+      if (social && route.command === 'social-user-activities') {
+        if (request.method !== 'GET') {
+          methodNotAllowed(response, 'Use GET for /cli/social/users/:accountId/activities.');
+          return;
+        }
+        const parsedLimit = route.options.limit ? parseInt(route.options.limit, 10) : 20;
+        const limit = Number.isFinite(parsedLimit) && parsedLimit > 0 ? Math.min(parsedLimit, 100) : 20;
+        const before = route.options.before ?? null;
+        const result = await social.getUserActivities(account.id, route.options.accountId, { limit, before });
+        if (result.error === 'forbidden') {
+          json(response, 403, { ok: false, error: 'Access denied' });
+          return;
+        }
+        logRequest(request, 200, socialLogSuffix(request, account.id, {
+          cmd: route.command,
+          count: result.items?.length ?? 0,
+          limit,
+          hasBefore: Boolean(before)
+        }));
+        json(response, 200, result);
+        return;
+      }
+
+      if (social && route.command === 'social-user-best-efforts') {
+        if (request.method !== 'GET') {
+          methodNotAllowed(response, 'Use GET for /cli/social/users/:accountId/best-efforts.');
+          return;
+        }
+        const result = await social.getUserBestEfforts(account.id, route.options.accountId);
+        if (result.error === 'forbidden') {
+          json(response, 403, { ok: false, error: 'Access denied' });
+          return;
+        }
+        logRequest(request, 200, socialLogSuffix(request, account.id, {
+          cmd: route.command,
+          count: result.efforts?.length ?? 0
+        }));
+        json(response, 200, result);
+        return;
+      }
+
       if (social && route.command === 'social-invite') {
         if (request.method !== 'POST') {
           methodNotAllowed(response, 'Use POST for /cli/social/invite.');