@playcademy/sandbox 0.4.2-beta.2 → 0.4.2-beta.3

package/dist/cli.js

@@ -1078,7 +1078,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@playcademy/sandbox",
-    version: "0.4.2-beta.2",
+    version: "0.4.2-beta.3",
     description: "Local development server for Playcademy game development",
     type: "module",
     exports: {
@@ -11320,10 +11320,11 @@ var init_table6 = __esm(() => {
 });
 
 // ../data/src/domains/timeback/table.ts
-var gameTimebackIntegrations, gameTimebackAssessmentTests;
+var gameTimebackIntegrations, gameTimebackAssessmentTests, gameTimebackMetricDiscrepancyVerifications;
 var init_table7 = __esm(() => {
   init_pg_core();
   init_table5();
+  init_table3();
   gameTimebackIntegrations = pgTable("game_timeback_integrations", {
     id: uuid("id").primaryKey().defaultRandom(),
     gameId: uuid("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
@@ -11348,6 +11349,21 @@ var init_table7 = __esm(() => {
   }, (table3) => [
     uniqueIndex("game_timeback_assessment_tests_integration_qti_idx").on(table3.integrationId, table3.qtiTestIdentifier)
   ]);
+  gameTimebackMetricDiscrepancyVerifications = pgTable("game_timeback_metric_discrepancy_verifications", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    gameId: uuid("game_id").notNull().references(() => games.id, { onDelete: "cascade" }),
+    courseId: text("course_id").notNull(),
+    studentId: text("student_id").notNull(),
+    runId: uuid("run_id").notNull(),
+    activityId: text("activity_id"),
+    verifiedByUserId: text("verified_by_user_id").references(() => users.id, {
+      onDelete: "set null"
+    }),
+    verifiedAt: timestamp("verified_at", { withTimezone: true }).notNull().defaultNow()
+  }, (table3) => [
+    uniqueIndex("game_timeback_metric_discrepancy_verifications_run_idx").on(table3.gameId, table3.courseId, table3.studentId, table3.runId),
+    index("game_timeback_metric_discrepancy_verifications_course_idx").on(table3.gameId, table3.courseId, table3.verifiedAt)
+  ]);
 });
 
 // ../data/src/tables.index.ts
@@ -11361,6 +11377,7 @@ __export(exports_tables_index, {
   games: () => games,
   gameVisibilityEnum: () => gameVisibilityEnum,
   gameTypeEnum: () => gameTypeEnum,
+  gameTimebackMetricDiscrepancyVerifications: () => gameTimebackMetricDiscrepancyVerifications,
   gameTimebackIntegrations: () => gameTimebackIntegrations,
   gameTimebackAssessmentTests: () => gameTimebackAssessmentTests,
   gameScoresRelations: () => gameScoresRelations,
@@ -29364,6 +29381,75 @@ function formatDateYMDInTimezone(timeZone, date3 = new Date) {
   const d = parts2.find((p) => p.type === "day").value;
   return `${y}-${m}-${d}`;
 }
+function getUtcInstantForMidnight(date3, timeZone) {
+  const parts2 = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  }).formatToParts(date3).reduce((acc, p) => {
+    if (p.type !== "literal") {
+      acc[p.type] = p.value;
+    }
+    return acc;
+  }, {});
+  const year = Number(parts2.year);
+  const month = Number(parts2.month);
+  const day = Number(parts2.day);
+  for (let dayOffset = -1;dayOffset <= 1; dayOffset++) {
+    const testYear = year;
+    const testMonth = month;
+    const testDay = day + dayOffset;
+    for (let utcHour = 0;utcHour < 24; utcHour++) {
+      const testDate = new Date(Date.UTC(testYear, testMonth - 1, testDay, utcHour, 0, 0, 0));
+      const testParts = new Intl.DateTimeFormat("en-US", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hour12: false
+      }).formatToParts(testDate).reduce((acc, p) => {
+        if (p.type !== "literal") {
+          acc[p.type] = p.value;
+        }
+        return acc;
+      }, {});
+      const yearMatch = Number(testParts.year) === year;
+      const monthMatch = Number(testParts.month) === month;
+      const dayMatch = Number(testParts.day) === day;
+      const hourValue = Number(testParts.hour);
+      const hourMatch = hourValue === 0 || hourValue === 24;
+      const minuteMatch = Number(testParts.minute) === 0;
+      if (yearMatch && monthMatch && dayMatch && hourMatch && minuteMatch) {
+        return testDate;
+      }
+    }
+  }
+  throw new Error(`Could not find midnight for ${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")} in timezone ${timeZone}`);
+}
+function getDayBoundariesInTimezone(date3, timezone) {
+  const startOfDay = getUtcInstantForMidnight(date3, timezone);
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+  const parts2 = formatter.formatToParts(date3).reduce((acc, p) => {
+    if (p.type !== "literal") {
+      acc[p.type] = p.value;
+    }
+    return acc;
+  }, {});
+  const year = Number(parts2.year);
+  const month = Number(parts2.month);
+  const day = Number(parts2.day);
+  const nextDayNoon = new Date(Date.UTC(year, month - 1, day + 1, 12, 0, 0, 0));
+  const endOfDay = getUtcInstantForMidnight(nextDayNoon, timezone);
+  return { startOfDay, endOfDay };
+}
 // ../utils/src/url.ts
 function buildPath(path, params) {
   const url = new URL(path, "http://n");
@@ -29407,6 +29493,42 @@ function formatGradeLabel(grade) {
     }
   }
 }
+function isTimebackDiscrepancyQueueWindow(value) {
+  return typeof value === "string" && TIMEBACK_DISCREPANCY_QUEUE_WINDOW_VALUES.has(value);
+}
+function isTimebackDiscrepancyQueueMetric(value) {
+  return typeof value === "string" && TIMEBACK_DISCREPANCY_QUEUE_METRIC_VALUES.has(value);
+}
+function parseTimebackDiscrepancyQueueWindow(value) {
+  const window2 = value?.trim();
+  return isTimebackDiscrepancyQueueWindow(window2) ? window2 : DEFAULT_TIMEBACK_DISCREPANCY_QUEUE_WINDOW;
+}
+function parseTimebackDiscrepancyQueueMetrics(values) {
+  const metrics = [];
+  const seen = new Set;
+  for (const value of values) {
+    const metric = value.trim();
+    if (isTimebackDiscrepancyQueueMetric(metric) && !seen.has(metric)) {
+      seen.add(metric);
+      metrics.push(metric);
+    }
+  }
+  return metrics;
+}
+var TIMEBACK_DISCREPANCY_QUEUE_WINDOWS, TIMEBACK_DISCREPANCY_QUEUE_METRICS, DEFAULT_TIMEBACK_DISCREPANCY_QUEUE_WINDOW = "this-week", TIMEBACK_DISCREPANCY_QUEUE_WINDOW_VALUES, TIMEBACK_DISCREPANCY_QUEUE_METRIC_VALUES;
+var init_timeback3 = __esm(() => {
+  TIMEBACK_DISCREPANCY_QUEUE_WINDOWS = [
+    "today",
+    "yesterday",
+    "this-week",
+    "last-week",
+    "all",
+    "custom"
+  ];
+  TIMEBACK_DISCREPANCY_QUEUE_METRICS = ["xp", "mastery", "time", "score"];
+  TIMEBACK_DISCREPANCY_QUEUE_WINDOW_VALUES = new Set(TIMEBACK_DISCREPANCY_QUEUE_WINDOWS);
+  TIMEBACK_DISCREPANCY_QUEUE_METRIC_VALUES = new Set(TIMEBACK_DISCREPANCY_QUEUE_METRICS);
+});
 
 // ../../node_modules/.bun/drizzle-zod@0.7.1+e9f18f9688af15ce/node_modules/drizzle-zod/index.mjs
 function isColumnType(column2, columnTypes) {
@@ -29907,7 +30029,7 @@ function isValidAdminAttributionDate(value) {
   const date3 = new Date(Date.UTC(year, month - 1, day, 12, 0, 0));
   return date3.getUTCFullYear() === year && date3.getUTCMonth() + 1 === month && date3.getUTCDate() === day;
 }
-var TIMEBACK_GRADES, TIMEBACK_SUBJECTS4, TimebackGradeSchema, TimebackSubjectSchema, CourseGoalsSchema, UpdateGameTimebackIntegrationRequestSchema, TimebackActivityDataSchema, EndActivityRequestSchema, GameRunMetricsSchema, GameCourseMetricsSchema, GameMetricsResponseSchema, AdvanceCourseRequestSchema, UnenrollCourseRequestSchema, HeartbeatRequestSchema, PopulateStudentRequestSchema, DerivedPlatformCourseConfigSchema, TimebackBaseConfigSchema, PlatformTimebackSetupRequestSchema, AdminTimebackMutationBaseSchema, AdminAttributionDateSchema, ADMIN_GRANT_XP_MIN = -1e5, ADMIN_GRANT_XP_MAX = 1e5, ADMIN_GRANT_XP_AMOUNT_RANGE_MESSAGE, GrantTimebackXpRequestSchema, AdjustTimebackTimeRequestSchema, AdjustTimebackMasteryRequestSchema, ReconcileMasteryForConfigChangeSchema, EnrollStudentRequestSchema, UnenrollStudentRequestSchema, ReactivateEnrollmentRequestSchema, InsertAssessmentTestSchema, CreateAssessmentRequestSchema, ReorderAssessmentsRequestSchema, ReorderQuestionsRequestSchema;
+var TIMEBACK_GRADES, TIMEBACK_SUBJECTS4, TimebackGradeSchema, TimebackSubjectSchema, CourseGoalsSchema, UpdateGameTimebackIntegrationRequestSchema, TimebackActivityDataSchema, EndActivityRequestSchema, GameRunMetricsSchema, GameCourseMetricsSchema, GameMetricsResponseSchema, AdvanceCourseRequestSchema, UnenrollCourseRequestSchema, HeartbeatRequestSchema, PopulateStudentRequestSchema, DerivedPlatformCourseConfigSchema, TimebackBaseConfigSchema, PlatformTimebackSetupRequestSchema, AdminTimebackMutationBaseSchema, AdminAttributionDateSchema, ADMIN_GRANT_XP_MIN = -1e5, ADMIN_GRANT_XP_MAX = 1e5, ADMIN_GRANT_XP_AMOUNT_RANGE_MESSAGE, GrantTimebackXpRequestSchema, AdjustTimebackTimeRequestSchema, AdjustTimebackMasteryRequestSchema, ReconcileMasteryForConfigChangeSchema, EnrollStudentRequestSchema, UnenrollStudentRequestSchema, ReactivateEnrollmentRequestSchema, VerifyTimebackMetricDiscrepancyRequestSchema, InsertAssessmentTestSchema, CreateAssessmentRequestSchema, ReorderAssessmentsRequestSchema, ReorderQuestionsRequestSchema;
 var init_schemas4 = __esm(() => {
   init_drizzle_zod();
   init_esm();
@@ -30148,6 +30270,11 @@ var init_schemas4 = __esm(() => {
     studentId: exports_external.string().min(1),
     enrollmentId: exports_external.string().min(1)
   });
+  VerifyTimebackMetricDiscrepancyRequestSchema = exports_external.object({
+    studentId: exports_external.string().min(1),
+    runId: exports_external.string().uuid(),
+    activityId: exports_external.string().min(1).optional()
+  });
   InsertAssessmentTestSchema = createInsertSchema(gameTimebackAssessmentTests).omit({
     id: true,
     createdAt: true
@@ -30280,183 +30407,6 @@ var init_timeback_admin_util = __esm(() => {
   init_errors();
 });
 
-// ../api-core/src/utils/timeback-game-metrics-comparison.util.ts
-function createMetricRow(definition) {
-  const { gameValue, kind, metric, timebackValue, tolerance } = definition;
-  if (timebackValue === undefined && gameValue === undefined) {
-    return null;
-  }
-  if (gameValue === undefined) {
-    return {
-      metric,
-      kind,
-      status: "not_reported_by_game",
-      ...timebackValue !== undefined ? { timebackValue } : {}
-    };
-  }
-  if (timebackValue === undefined) {
-    return {
-      metric,
-      kind,
-      status: "not_recorded_by_timeback",
-      gameValue
-    };
-  }
-  const delta = gameValue - timebackValue;
-  const isDiscrepant = tolerance === 0 ? delta !== 0 : Math.abs(delta) >= tolerance;
-  return {
-    metric,
-    kind,
-    status: isDiscrepant ? "discrepant" : "matched",
-    timebackValue,
-    gameValue,
-    delta
-  };
-}
-function createRunComparison(activity, gameRun) {
-  const runId = activity.runId ?? "";
-  if (!gameRun) {
-    return {
-      runId,
-      status: "not_reported",
-      discrepancyCount: 0,
-      rows: []
-    };
-  }
-  const rows = [
-    createMetricRow({
-      metric: "xp",
-      kind: "number",
-      timebackValue: activity.xpDelta,
-      gameValue: gameRun.totalXp,
-      tolerance: TIMEBACK_GAME_METRIC_COMPARISON_TOLERANCE.xp
-    }),
-    createMetricRow({
-      metric: "mastery",
-      kind: "number",
-      timebackValue: activity.masteredUnitsDelta,
-      gameValue: gameRun.masteredUnits,
-      tolerance: TIMEBACK_GAME_METRIC_COMPARISON_TOLERANCE.mastery
-    }),
-    createMetricRow({
-      metric: "time",
-      kind: "time",
-      timebackValue: activity.timeDeltaSeconds,
-      gameValue: gameRun.activeTimeSeconds,
-      tolerance: TIMEBACK_GAME_METRIC_COMPARISON_TOLERANCE.time
-    }),
-    createMetricRow({
-      metric: "score",
-      kind: "percent",
-      timebackValue: activity.score,
-      gameValue: gameRun.score,
-      tolerance: TIMEBACK_GAME_METRIC_COMPARISON_TOLERANCE.score
-    })
-  ].filter((row) => row !== null);
-  const discrepancyCount = rows.filter((row) => row.status === "discrepant").length;
-  return {
-    runId,
-    status: discrepancyCount > 0 ? "discrepant" : "matched",
-    discrepancyCount,
-    rows
-  };
-}
-function summarizeGameRunMetricsComparison(comparison) {
-  return {
-    runId: comparison.runId,
-    status: comparison.status,
-    discrepancyCount: comparison.discrepancyCount,
-    ...comparison.reason ? { reason: comparison.reason } : {}
-  };
-}
-function buildGameRunMetricComparisons(activities, course, response) {
-  const activitiesWithRunIds = activities.filter((activity) => typeof activity.runId === "string" && activity.runId.length > 0);
-  const comparisons = new Map;
-  if (activitiesWithRunIds.length === 0) {
-    return comparisons;
-  }
-  if (!response.supported) {
-    for (const activity of activitiesWithRunIds) {
-      comparisons.set(activity.runId, {
-        runId: activity.runId,
-        status: "unavailable",
-        discrepancyCount: 0,
-        reason: response.reason,
-        rows: []
-      });
-    }
-    return comparisons;
-  }
-  const gameCourseMetrics = response.metrics.courses.find((gameCourse) => gameCourse.grade === course.grade && gameCourse.subject === course.subject);
-  const gameRunsById = new Map(gameCourseMetrics?.activities?.map((gameRun) => [gameRun.runId.toLowerCase(), gameRun]));
-  for (const activity of activitiesWithRunIds) {
-    comparisons.set(activity.runId, createRunComparison(activity, gameRunsById.get(activity.runId.toLowerCase())));
-  }
-  return comparisons;
-}
-var init_timeback_game_metrics_comparison_util = __esm(() => {
-  init_src();
-});
-
-// ../api-core/src/utils/timeback-mastery-completion.util.ts
-async function upsertMasteryCompletionEntry(params) {
-  const { client, courseId, studentId, appName, action } = params;
-  const ids = deriveSourcedIds(courseId);
-  const lineItemId = `${ids.course}-mastery-completion-assessment`;
-  const resultId = `${lineItemId}:${studentId}:completion`;
-  if (action === "complete") {
-    await client.oneroster.assessmentLineItems.findOrCreate(lineItemId, {
-      sourcedId: lineItemId,
-      title: "Mastery Completion",
-      status: ONEROSTER_STATUS.active,
-      course: { sourcedId: ids.course },
-      ...ids.componentResource ? { componentResource: { sourcedId: ids.componentResource } } : {}
-    });
-    await client.oneroster.assessmentResults.upsert(resultId, {
-      sourcedId: resultId,
-      status: ONEROSTER_STATUS.active,
-      assessmentLineItem: { sourcedId: lineItemId },
-      student: { sourcedId: studentId },
-      score: 100,
-      scoreDate: new Date().toISOString(),
-      scoreStatus: SCORE_STATUS.fullyGraded,
-      inProgress: "false",
-      metadata: {
-        isMasteryCompletion: true,
-        adminAction: true,
-        appName
-      }
-    });
-  } else {
-    try {
-      await client.oneroster.assessmentResults.upsert(resultId, {
-        sourcedId: resultId,
-        status: ONEROSTER_STATUS.active,
-        assessmentLineItem: { sourcedId: lineItemId },
-        student: { sourcedId: studentId },
-        score: 0,
-        scoreDate: new Date().toISOString(),
-        scoreStatus: SCORE_STATUS.notSubmitted,
-        inProgress: "true",
-        metadata: {
-          isMasteryCompletion: true,
-          adminAction: true,
-          appName
-        }
-      });
-    } catch {
-      logger16.debug("No completion entry to revoke", { studentId, courseId });
-    }
-  }
-}
-var logger16;
-var init_timeback_mastery_completion_util = __esm(() => {
-  init_src2();
-  init_constants4();
-  init_utils6();
-  logger16 = log.scope("timeback-mastery-completion");
-});
-
 // ../api-core/src/utils/timeback.util.ts
 function isRecord2(value) {
   return typeof value === "object" && value !== null;
@@ -30604,6 +30554,13 @@ function groupCaliperEventsByRun(events) {
   }
   return groups;
 }
+function findCaliperEventGroupContainingExternalId(events, externalId) {
+  const targetExternalId = externalId.trim();
+  if (!targetExternalId) {
+    return;
+  }
+  return [...groupCaliperEventsByRun(events).values()].find((group) => group.some((event) => event.externalId === targetExternalId));
+}
 function mapCaliperEventGroupToActivity(events, relevantCourseIds) {
   if (events.length === 0) {
     return null;
@@ -30777,6 +30734,371 @@ var init_timeback_util = __esm(() => {
   ]);
 });
 
+// ../api-core/src/utils/timeback-discrepancy-queue.util.ts
+function parseDateInputParts(value) {
+  const parts2 = value.split("-");
+  return {
+    year: Number(parts2[0]),
+    month: Number(parts2[1]),
+    day: Number(parts2[2])
+  };
+}
+function addDateInputDays(value, days) {
+  const { year, month, day } = parseDateInputParts(value);
+  const date3 = new Date(Date.UTC(year, month - 1, day + days, 12));
+  return [
+    String(date3.getUTCFullYear()),
+    String(date3.getUTCMonth() + 1).padStart(2, "0"),
+    String(date3.getUTCDate()).padStart(2, "0")
+  ].join("-");
+}
+function getDateInputDayOfWeek(value) {
+  const { year, month, day } = parseDateInputParts(value);
+  return new Date(Date.UTC(year, month - 1, day, 12)).getUTCDay();
+}
+function getDateInputBoundary(value, boundary, timezone2) {
+  const { year, month, day } = parseDateInputParts(value);
+  const anchor = new Date(Date.UTC(year, month - 1, day, 12));
+  const { startOfDay, endOfDay } = getDayBoundariesInTimezone(anchor, timezone2);
+  return boundary === "end" ? new Date(endOfDay.getTime() - 1) : startOfDay;
+}
+function getWeekStartDateInput(date3, timezone2) {
+  const today = formatDateYMDInTimezone(timezone2, date3);
+  const dayOfWeek = getDateInputDayOfWeek(today);
+  return addDateInputDays(today, -dayOfWeek);
+}
+function parseDateBoundary(value, boundary, timezone2) {
+  if (!value) {
+    return null;
+  }
+  if (DATE_INPUT_RE.test(value)) {
+    return getDateInputBoundary(value, boundary, timezone2);
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function getTimebackDiscrepancyQueueDateRange(options) {
+  const now2 = options.now ?? new Date;
+  const timezone2 = options.timezone ?? "UTC";
+  if (options.window === "all") {
+    return {};
+  }
+  if (options.window === "today") {
+    return { startDate: getDayBoundariesInTimezone(now2, timezone2).startOfDay.toISOString() };
+  }
+  if (options.window === "yesterday") {
+    const yesterdayInput = addDateInputDays(formatDateYMDInTimezone(timezone2, now2), -1);
+    return {
+      startDate: getDateInputBoundary(yesterdayInput, "start", timezone2).toISOString(),
+      endDate: getDateInputBoundary(yesterdayInput, "end", timezone2).toISOString()
+    };
+  }
+  if (options.window === "this-week") {
+    return {
+      startDate: getDateInputBoundary(getWeekStartDateInput(now2, timezone2), "start", timezone2).toISOString()
+    };
+  }
+  if (options.window === "last-week") {
+    const thisWeekStartInput = getWeekStartDateInput(now2, timezone2);
+    const lastWeekStartInput = addDateInputDays(thisWeekStartInput, -7);
+    const lastWeekEndInput = addDateInputDays(thisWeekStartInput, -1);
+    return {
+      startDate: getDateInputBoundary(lastWeekStartInput, "start", timezone2).toISOString(),
+      endDate: getDateInputBoundary(lastWeekEndInput, "end", timezone2).toISOString()
+    };
+  }
+  const startDate = parseDateBoundary(options.startDate, "start", timezone2);
+  const endDate = parseDateBoundary(options.endDate, "end", timezone2);
+  return {
+    ...startDate ? { startDate: startDate.toISOString() } : {},
+    ...endDate ? { endDate: endDate.toISOString() } : {}
+  };
+}
+function getCaliperActorSourcedId(event) {
+  const actorId = typeof event.actor.id === "string" ? event.actor.id.trim() : "";
+  if (!actorId) {
+    return;
+  }
+  const normalized = actorId.replace(/\/$/, "");
+  const segment = normalized.split("/").at(-1);
+  if (!segment) {
+    return;
+  }
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+function getTimebackDiscrepancyVerificationKey(params) {
+  return `${params.studentId}:${params.runId.toLowerCase()}`;
+}
+function getTimebackMetricDiscrepancyVerificationForActivity(params) {
+  if (params.comparison?.status !== "discrepant" || !params.activity.runId) {
+    return;
+  }
+  return params.verificationsByKey.get(getTimebackDiscrepancyVerificationKey({
+    studentId: params.studentId,
+    runId: params.activity.runId
+  }));
+}
+function mapCaliperEventsToStudentGameplayActivities(events, relevantCourseIds) {
+  if (relevantCourseIds.size === 0) {
+    return [];
+  }
+  const gameplayEventsByStudent = new Map;
+  for (const event of events) {
+    const isGameplayEvent = event.type === "ActivityEvent" || event.type === "TimeSpentEvent";
+    const studentId = isGameplayEvent && !isCaliperRemediationOrCompletionEvent(event) ? getCaliperActorSourcedId(event) : undefined;
+    if (studentId) {
+      const existing = gameplayEventsByStudent.get(studentId);
+      if (existing) {
+        existing.push(event);
+      } else {
+        gameplayEventsByStudent.set(studentId, [event]);
+      }
+    }
+  }
+  const groups = [];
+  for (const [studentId, studentEvents] of gameplayEventsByStudent) {
+    const activities = [...groupCaliperEventsByRun(studentEvents).values()].map((group) => mapCaliperEventGroupToActivity(group, relevantCourseIds)).filter((activity) => Boolean(activity)).toSorted((a, b) => b.occurredAt.localeCompare(a.occurredAt));
+    if (activities.length > 0) {
+      groups.push({ studentId, activities });
+    }
+  }
+  return groups.toSorted((a, b) => {
+    const aLatest = a.activities[0]?.occurredAt ?? "";
+    const bLatest = b.activities[0]?.occurredAt ?? "";
+    return bLatest.localeCompare(aLatest);
+  });
+}
+function mapCaliperEventsToCompletedStudentGameplayActivities(events, relevantCourseIds, options = {}) {
+  const runIds = options.runIds ? new Set([...options.runIds].map((runId) => runId.toLowerCase())) : undefined;
+  return mapCaliperEventsToStudentGameplayActivities(events, relevantCourseIds).filter((group) => !options.studentId || group.studentId === options.studentId).map((group) => ({
+    studentId: group.studentId,
+    activities: group.activities.filter((activity) => {
+      const runId = activity.runId?.toLowerCase();
+      return activity.kind === "activity" && runId !== undefined && isValidUUID(runId) && (!runIds || runIds.has(runId));
+    })
+  })).filter((group) => group.activities.length > 0);
+}
+function getTimebackActivityRunIds(groups) {
+  const runIds = [];
+  const seen = new Set;
+  for (const group of groups) {
+    for (const activity of group.activities) {
+      const runId = activity.runId?.toLowerCase();
+      if (runId && isValidUUID(runId) && !seen.has(runId)) {
+        seen.add(runId);
+        runIds.push(runId);
+      }
+    }
+  }
+  return runIds;
+}
+function mergeHydratedMetricDiscrepancyQueueItems(options) {
+  const hydratedRunIds = new Set([...options.hydratedRunIds].map((runId) => runId.toLowerCase()));
+  const hydratedItems = options.hydratedItems.map((item) => ({
+    ...item,
+    comparisonSource: "hydrated"
+  }));
+  const preliminaryFallbackItems = options.preliminaryItems.filter((item) => {
+    const runId = item.activity.runId?.toLowerCase();
+    return runId === undefined || !hydratedRunIds.has(runId);
+  }).map((item) => ({
+    ...item,
+    comparisonSource: "preliminary"
+  }));
+  return [...hydratedItems, ...preliminaryFallbackItems].toSorted((a, b) => b.activity.occurredAt.localeCompare(a.activity.occurredAt));
+}
+function selectTimebackMetricDiscrepancyQueueItems(candidates, options) {
+  const discrepancyMetricScopesSet = new Set(options.discrepancyMetricScopes);
+  return candidates.filter((candidate) => candidate.activity.kind === "activity").filter((candidate) => candidate.gameMetricsComparison.status === "discrepant").filter((candidate) => !options.studentId || candidate.student.studentId === options.studentId).filter((candidate) => discrepancyMetricScopesSet.size === 0 || candidate.gameMetricsComparison.rows.some((row) => row.status === "discrepant" && discrepancyMetricScopesSet.has(row.metric))).filter((candidate) => options.includeVerified || !candidate.verification).toSorted((a, b) => b.activity.occurredAt.localeCompare(a.activity.occurredAt));
+}
+var DATE_INPUT_RE;
+var init_timeback_discrepancy_queue_util = __esm(() => {
+  init_src4();
+  init_timeback_util();
+  DATE_INPUT_RE = /^\d{4}-\d{2}-\d{2}$/;
+});
+
+// ../api-core/src/utils/timeback-game-metrics-comparison.util.ts
+function createMetricRow(definition) {
+  const { gameValue, kind, metric, timebackValue, tolerance } = definition;
+  if (timebackValue === undefined && gameValue === undefined) {
+    return null;
+  }
+  if (gameValue === undefined) {
+    return {
+      metric,
+      kind,
+      status: "not_reported_by_game",
+      ...timebackValue !== undefined ? { timebackValue } : {}
+    };
+  }
+  if (timebackValue === undefined) {
+    return {
+      metric,
+      kind,
+      status: "not_recorded_by_timeback",
+      gameValue
+    };
+  }
+  const delta = gameValue - timebackValue;
+  const isDiscrepant = tolerance === 0 ? delta !== 0 : Math.abs(delta) >= tolerance;
+  return {
+    metric,
+    kind,
+    status: isDiscrepant ? "discrepant" : "matched",
+    timebackValue,
+    gameValue,
+    delta
+  };
+}
+function createRunComparison(activity, gameRun) {
+  const runId = activity.runId ?? "";
+  if (!gameRun) {
+    return {
+      runId,
+      status: "not_reported",
+      discrepancyCount: 0,
+      rows: []
+    };
+  }
+  const rows = [
+    createMetricRow({
+      metric: "xp",
+      kind: "number",
+      timebackValue: activity.xpDelta,
+      gameValue: gameRun.totalXp,
+      tolerance: TIMEBACK_GAME_METRIC_COMPARISON_TOLERANCE.xp
+    }),
+    createMetricRow({
+      metric: "time",
+      kind: "time",
+      timebackValue: activity.timeDeltaSeconds,
+      gameValue: gameRun.activeTimeSeconds,
+      tolerance: TIMEBACK_GAME_METRIC_COMPARISON_TOLERANCE.time
+    }),
+    createMetricRow({
+      metric: "score",
+      kind: "percent",
+      timebackValue: activity.score,
+      gameValue: gameRun.score,
+      tolerance: TIMEBACK_GAME_METRIC_COMPARISON_TOLERANCE.score
+    }),
+    createMetricRow({
+      metric: "mastery",
+      kind: "number",
+      timebackValue: activity.masteredUnitsDelta ?? 0,
+      gameValue: gameRun.masteredUnits,
+      tolerance: TIMEBACK_GAME_METRIC_COMPARISON_TOLERANCE.mastery
+    })
+  ].filter((row) => row !== null);
+  const discrepancyCount = rows.filter((row) => row.status === "discrepant").length;
+  return {
+    runId,
+    status: discrepancyCount > 0 ? "discrepant" : "matched",
+    discrepancyCount,
+    rows
+  };
+}
+function summarizeGameRunMetricsComparison(comparison) {
+  return {
+    runId: comparison.runId,
+    status: comparison.status,
+    discrepancyCount: comparison.discrepancyCount,
+    ...comparison.reason ? { reason: comparison.reason } : {}
+  };
+}
+function buildGameRunMetricComparisons(activities, course, response) {
+  const activitiesWithRunIds = activities.filter((activity) => typeof activity.runId === "string" && activity.runId.length > 0);
+  const comparisons = new Map;
+  if (activitiesWithRunIds.length === 0) {
+    return comparisons;
+  }
+  if (!response.supported) {
+    for (const activity of activitiesWithRunIds) {
+      comparisons.set(activity.runId, {
+        runId: activity.runId,
+        status: "unavailable",
+        discrepancyCount: 0,
+        reason: response.reason,
+        rows: []
+      });
+    }
+    return comparisons;
+  }
+  const gameCourseMetrics = response.metrics.courses.find((gameCourse) => gameCourse.grade === course.grade && gameCourse.subject === course.subject);
+  const gameRunsById = new Map(gameCourseMetrics?.activities?.map((gameRun) => [gameRun.runId.toLowerCase(), gameRun]));
+  for (const activity of activitiesWithRunIds) {
+    comparisons.set(activity.runId, createRunComparison(activity, gameRunsById.get(activity.runId.toLowerCase())));
+  }
+  return comparisons;
+}
+var init_timeback_game_metrics_comparison_util = __esm(() => {
+  init_src();
+});
+
+// ../api-core/src/utils/timeback-mastery-completion.util.ts
+async function upsertMasteryCompletionEntry(params) {
+  const { client, courseId, studentId, appName, action } = params;
+  const ids = deriveSourcedIds(courseId);
+  const lineItemId = `${ids.course}-mastery-completion-assessment`;
+  const resultId = `${lineItemId}:${studentId}:completion`;
+  if (action === "complete") {
+    await client.oneroster.assessmentLineItems.findOrCreate(lineItemId, {
+      sourcedId: lineItemId,
+      title: "Mastery Completion",
+      status: ONEROSTER_STATUS.active,
+      course: { sourcedId: ids.course },
+      ...ids.componentResource ? { componentResource: { sourcedId: ids.componentResource } } : {}
+    });
+    await client.oneroster.assessmentResults.upsert(resultId, {
+      sourcedId: resultId,
+      status: ONEROSTER_STATUS.active,
+      assessmentLineItem: { sourcedId: lineItemId },
+      student: { sourcedId: studentId },
+      score: 100,
+      scoreDate: new Date().toISOString(),
+      scoreStatus: SCORE_STATUS.fullyGraded,
+      inProgress: "false",
+      metadata: {
+        isMasteryCompletion: true,
+        adminAction: true,
+        appName
+      }
+    });
+  } else {
+    try {
+      await client.oneroster.assessmentResults.upsert(resultId, {
+        sourcedId: resultId,
+        status: ONEROSTER_STATUS.active,
+        assessmentLineItem: { sourcedId: lineItemId },
+        student: { sourcedId: studentId },
+        score: 0,
+        scoreDate: new Date().toISOString(),
+        scoreStatus: SCORE_STATUS.notSubmitted,
+        inProgress: "true",
+        metadata: {
+          isMasteryCompletion: true,
+          adminAction: true,
+          appName
+        }
+      });
+    } catch {
+      logger16.debug("No completion entry to revoke", { studentId, courseId });
+    }
+  }
+}
+var logger16;
+var init_timeback_mastery_completion_util = __esm(() => {
+  init_src2();
+  init_constants4();
+  init_utils6();
+  logger16 = log.scope("timeback-mastery-completion");
+});
+
 // ../api-core/src/services/timeback-admin.service.ts
 class TimebackAdminService {
   deps;
@@ -30785,6 +31107,10 @@ class TimebackAdminService {
   static MAX_STUDENT_ACTIVITY_LIMIT = 200;
   static MAX_STUDENT_ACTIVITY_OFFSET = 1000;
   static MAX_RECENT_ACTIVITY_EVENT_FETCH = 4000;
+  static DISCREPANCY_QUEUE_EVENT_FETCH_LIMIT = 4000;
+  static DISCREPANCY_QUEUE_RUN_EVENT_FETCH_LIMIT = 4000;
+  static DISCREPANCY_QUEUE_RUN_HYDRATION_CONCURRENCY = 4;
+  static DISCREPANCY_QUEUE_COMPARISON_CONCURRENCY = 4;
   static ANALYTICS_CONCURRENCY = 8;
   static MASTERABLE_UNITS_CONCURRENCY = 4;
   static GAME_METRICS_FETCH_TIMEOUT_MS = 1e4;
@@ -31032,16 +31358,53 @@ class TimebackAdminService {
     }));
     return comparisons;
   }
+  async getMetricDiscrepancyVerificationsByKey(options) {
+    const runIds = TimebackAdminService.normalizeRunIds(options.runIds);
+    if (runIds.length === 0) {
+      return new Map;
+    }
+    const conditions2 = [
+      eq(gameTimebackMetricDiscrepancyVerifications.gameId, options.gameId),
+      eq(gameTimebackMetricDiscrepancyVerifications.courseId, options.courseId),
+      inArray(gameTimebackMetricDiscrepancyVerifications.runId, runIds)
+    ];
+    if (options.studentId) {
+      conditions2.push(eq(gameTimebackMetricDiscrepancyVerifications.studentId, options.studentId));
+    }
+    const rows = await this.deps.db.query.gameTimebackMetricDiscrepancyVerifications.findMany({
+      where: and(...conditions2)
+    });
+    return new Map(rows.map((row) => [
+      getTimebackDiscrepancyVerificationKey({
+        studentId: row.studentId,
+        runId: row.runId
+      }),
+      TimebackAdminService.mapMetricDiscrepancyVerification(row)
+    ]));
+  }
   async attachGameMetricSummariesToActivities(user, options) {
     const comparisons = await this.getGameMetricComparisonsForActivities(user, options);
     if (comparisons.size === 0) {
       return [...options.activities];
     }
+    const verificationsByKey = await this.getMetricDiscrepancyVerificationsByKey({
+      gameId: options.gameId,
+      courseId: options.courseId,
+      studentId: options.studentId,
+      runIds: [...comparisons.values()].filter((comparison) => comparison.status === "discrepant").map((comparison) => comparison.runId)
+    });
     return options.activities.map((activity) => {
       const comparison = activity.runId ? comparisons.get(activity.runId) : undefined;
+      const verification2 = getTimebackMetricDiscrepancyVerificationForActivity({
+        studentId: options.studentId,
+        activity,
+        comparison,
+        verificationsByKey
+      });
       return comparison ? {
         ...activity,
-        gameMetricsComparison: summarizeGameRunMetricsComparison(comparison)
+        gameMetricsComparison: summarizeGameRunMetricsComparison(comparison),
+        ...verification2 ? { gameMetricsVerification: verification2 } : {}
       } : activity;
     });
   }
@@ -31132,6 +31495,165 @@ class TimebackAdminService {
     });
     return events;
   }
+  async fetchCaliperEventsForGame(client, source, options) {
+    const actorId = options.studentId ? `${client.getBaseUrl().replace(/\/$/, "")}/ims/oneroster/rostering/v1p2/users/${options.studentId}` : undefined;
+    return client.caliper.events.list({
+      limit: options.limit,
+      offset: options.offset,
+      ...actorId ? { actorId } : {},
+      ...options.startDate ? { startDate: options.startDate } : {},
+      ...options.endDate ? { endDate: options.endDate } : {},
+      ...options.sessionId ? { sessionId: options.sessionId } : {},
+      ...source.sourceMode === "production" ? { sensor: source.sensorUrl } : {},
+      extensions: {
+        gameId: source.gameId
+      }
+    });
+  }
+  static getActivityRunOwners(activityGroups) {
+    const runOwnersById = new Map;
+    for (const group of activityGroups) {
+      for (const activity of group.activities) {
+        const runId = activity.runId?.toLowerCase();
+        if (runId && !runOwnersById.has(runId)) {
+          runOwnersById.set(runId, group.studentId);
+        }
+      }
+    }
+    return runOwnersById;
+  }
+  static dedupeCaliperEvents(events) {
+    const deduped = [];
+    const seen = new Set;
+    for (const event of events) {
+      const key = `${event.id}:${event.externalId}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        deduped.push(event);
+      }
+    }
+    return deduped;
+  }
+  async fetchCaliperEventsForRun(client, source, options) {
+    const runId = options.runId.toLowerCase();
+    const events = [];
+    let offset = 0;
+    while (true) {
+      const result = await this.fetchCaliperEventsForGame(client, source, {
+        limit: TimebackAdminService.DISCREPANCY_QUEUE_RUN_EVENT_FETCH_LIMIT,
+        offset,
+        studentId: options.studentId
+      });
+      const runEvents = result.events.filter((event) => getCanonicalRunId(event.session)?.toLowerCase() === runId);
+      events.push(...runEvents);
+      const pageStep = result.pagination.limit > 0 ? result.pagination.limit : result.events.length;
+      const nextOffset = offset + pageStep;
+      if (pageStep === 0 || result.events.length === 0 || nextOffset >= result.pagination.total) {
+        break;
+      }
+      offset = nextOffset;
+    }
+    return TimebackAdminService.dedupeCaliperEvents(events);
+  }
+  async hydrateDiscrepancyQueueRunEvents(client, source, options) {
+    if (options.runOwnersById.size === 0) {
+      return { events: [], runIds: new Set };
+    }
+    const hydratedRuns = await TimebackAdminService.runWithConcurrency([...options.runOwnersById.entries()], TimebackAdminService.DISCREPANCY_QUEUE_RUN_HYDRATION_CONCURRENCY, async ([runId, studentId]) => {
+      try {
+        return {
+          runId,
+          events: await this.fetchCaliperEventsForRun(client, source, {
+            runId,
+            studentId
+          })
+        };
+      } catch (error) {
+        logger17.warn("Failed to hydrate Caliper events for discrepancy queue run", {
+          runId,
+          studentId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return { runId, events: [] };
+      }
+    });
+    const hydratedRunIds = new Set(hydratedRuns.filter((result) => result.events.length > 0).map((result) => result.runId.toLowerCase()));
+    const baseEventsForHydratedRuns = options.baseEvents.filter((event) => {
+      const runId = getCanonicalRunId(event.session)?.toLowerCase();
+      return runId !== undefined && hydratedRunIds.has(runId);
+    });
+    return {
+      events: TimebackAdminService.dedupeCaliperEvents([
+        ...baseEventsForHydratedRuns,
+        ...hydratedRuns.flatMap((result) => result.events)
+      ]),
+      runIds: hydratedRunIds
+    };
+  }
+  async buildMetricDiscrepancyQueueCandidates(user, options) {
+    const comparisonResults = await TimebackAdminService.runWithConcurrency(options.activityGroups, TimebackAdminService.DISCREPANCY_QUEUE_COMPARISON_CONCURRENCY, async (group) => {
+      try {
+        return {
+          group,
+          comparisons: await this.getGameMetricComparisonsForActivities(user, {
+            gameId: options.gameId,
+            studentId: group.studentId,
+            course: options.course,
+            activities: group.activities,
+            timeoutMs: TimebackAdminService.GAME_METRICS_LIST_FETCH_TIMEOUT_MS
+          })
+        };
+      } catch (error) {
+        logger17.warn("Failed to compare game metrics for discrepancy queue student", {
+          gameId: options.gameId,
+          courseId: options.courseId,
+          studentId: group.studentId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        return { group, comparisons: new Map };
+      }
+    });
+    return comparisonResults.flatMap(({ group, comparisons }) => {
+      const student = options.studentsById.get(group.studentId) ?? {
+        studentId: group.studentId,
+        name: "No name specified",
+        email: null
+      };
+      return group.activities.flatMap((activity) => {
+        const runId = activity.runId;
+        if (!runId) {
+          return [];
+        }
+        const gameMetricsComparison = comparisons.get(runId);
+        if (!gameMetricsComparison) {
+          return [];
+        }
+        const verification2 = options.verificationsByKey.get(getTimebackDiscrepancyVerificationKey({
+          studentId: group.studentId,
+          runId
+        }));
+        return [
+          {
+            student,
+            activity,
+            gameMetricsComparison,
+            ...verification2 ? { verification: verification2 } : {}
+          }
+        ];
+      });
+    });
+  }
+  static mapMetricDiscrepancyVerification(row) {
+    return {
+      gameId: row.gameId,
+      courseId: row.courseId,
+      studentId: row.studentId,
+      runId: row.runId,
+      activityId: row.activityId,
+      verifiedAt: row.verifiedAt.toISOString(),
+      verifiedByUserId: row.verifiedByUserId
+    };
+  }
   async listRecentActivityForStudent(client, studentId, source, relevantCourseIds, maxResults = TimebackAdminService.RECENT_ACTIVITY_LIMIT) {
     if (relevantCourseIds.size === 0) {
       return [];
@@ -31381,12 +31903,215 @@ class TimebackAdminService {
     const activitiesWithGameMetrics = await this.attachGameMetricSummariesToActivities(user, {
       gameId,
       studentId,
+      courseId,
       course: { grade: integration.grade, subject: integration.subject },
       activities,
       timeoutMs: TimebackAdminService.GAME_METRICS_LIST_FETCH_TIMEOUT_MS
     });
     return { activities: activitiesWithGameMetrics, hasMore };
   }
+  async listMetricDiscrepancies(user, options) {
+    const { gameId, courseId, window: window2, includeVerified } = options;
+    const selectedStudentId = options.studentId?.trim() || undefined;
+    const client = this.requireClient();
+    const dateRange = getTimebackDiscrepancyQueueDateRange({
+      window: window2,
+      startDate: options.startDate,
+      endDate: options.endDate,
+      timezone: PLATFORM_TIMEZONE
+    });
+    const safeEventOffset = Math.max(0, Math.trunc(options.eventOffset));
+    await this.deps.validateGameManagementAccess(user, gameId);
+    const [integration, gameSource, roster] = await Promise.all([
+      this.deps.db.query.gameTimebackIntegrations.findFirst({
+        where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.courseId, courseId))
+      }),
+      this.getGameActivitySource(gameId),
+      client.oneroster.enrollments.listByCourse(courseId, {
+        role: "student",
+        includeInactive: true
+      })
+    ]);
+    if (!integration) {
+      throw new NotFoundError("Timeback integration", `${gameId}:${courseId}`);
+    }
+    const studentsById = new Map;
+    for (const entry of roster) {
+      const studentId = entry.enrollment.user.sourcedId;
+      if (studentId && !studentsById.has(studentId)) {
+        const name3 = entry.user ? `${entry.user.givenName} ${entry.user.familyName}`.trim() || "No name specified" : "No name specified";
+        studentsById.set(studentId, {
+          studentId,
+          name: name3,
+          email: entry.user?.email || null
+        });
+      }
+    }
+    const students = [...studentsById.values()].toSorted((a, b) => a.name.localeCompare(b.name) || a.studentId.localeCompare(b.studentId));
+    if (selectedStudentId && !studentsById.has(selectedStudentId)) {
+      students.push({
+        studentId: selectedStudentId,
+        name: selectedStudentId,
+        email: null
+      });
+    }
+    const eventResult = await this.fetchCaliperEventsForGame(client, gameSource, {
+      limit: TimebackAdminService.DISCREPANCY_QUEUE_EVENT_FETCH_LIMIT,
+      offset: safeEventOffset,
+      ...selectedStudentId ? { studentId: selectedStudentId } : {},
+      ...dateRange
+    });
+    const { events, pagination } = eventResult;
+    let effectiveEventPageLimit = pagination.limit;
+    if (effectiveEventPageLimit <= 0) {
+      effectiveEventPageLimit = events.length > 0 ? events.length : TimebackAdminService.DISCREPANCY_QUEUE_EVENT_FETCH_LIMIT;
+    }
+    const relevantCourseIds = new Set([courseId]);
+    const preliminaryActivityGroups = mapCaliperEventsToCompletedStudentGameplayActivities(events, relevantCourseIds, selectedStudentId ? { studentId: selectedStudentId } : {});
+    const preliminaryRunIds = getTimebackActivityRunIds(preliminaryActivityGroups);
+    const verificationsByKey = await this.getMetricDiscrepancyVerificationsByKey({
+      gameId,
+      courseId,
+      runIds: preliminaryRunIds
+    });
+    const queueFilterOptions = {
+      ...selectedStudentId ? { studentId: selectedStudentId } : {},
+      discrepancyMetricScopes: options.discrepancyMetricScopes,
+      includeVerified
+    };
+    const preliminaryCandidates = await this.buildMetricDiscrepancyQueueCandidates(user, {
+      gameId,
+      courseId,
+      course: { grade: integration.grade, subject: integration.subject },
+      activityGroups: preliminaryActivityGroups,
+      studentsById,
+      verificationsByKey
+    });
+    const preliminaryItems = selectTimebackMetricDiscrepancyQueueItems(preliminaryCandidates, queueFilterOptions);
+    const runOwnersById = TimebackAdminService.getActivityRunOwners(preliminaryItems.map((item) => ({
+      studentId: item.student.studentId,
+      activities: [item.activity]
+    })));
+    const hydratedRunEvents = await this.hydrateDiscrepancyQueueRunEvents(client, gameSource, {
+      baseEvents: events,
+      runOwnersById
+    });
+    const finalActivityGroups = mapCaliperEventsToCompletedStudentGameplayActivities(hydratedRunEvents.events, relevantCourseIds, {
+      ...selectedStudentId ? { studentId: selectedStudentId } : {},
+      runIds: hydratedRunEvents.runIds
+    });
+    const finalCandidates = await this.buildMetricDiscrepancyQueueCandidates(user, {
+      gameId,
+      courseId,
+      course: { grade: integration.grade, subject: integration.subject },
+      activityGroups: finalActivityGroups,
+      studentsById,
+      verificationsByKey
+    });
+    const hydratedItems = selectTimebackMetricDiscrepancyQueueItems(finalCandidates, queueFilterOptions);
+    const items = mergeHydratedMetricDiscrepancyQueueItems({
+      preliminaryItems,
+      hydratedItems,
+      hydratedRunIds: hydratedRunEvents.runIds
+    });
+    const eventPage = {
+      offset: safeEventOffset,
+      limit: effectiveEventPageLimit,
+      total: pagination.total,
+      hasPrevious: safeEventOffset > 0,
+      hasNext: safeEventOffset + effectiveEventPageLimit < pagination.total
+    };
+    return {
+      gameId,
+      courseId,
+      window: window2,
+      dateRange,
+      ...selectedStudentId ? { studentId: selectedStudentId } : {},
+      students,
+      discrepancyMetricScopes: [...options.discrepancyMetricScopes ?? []],
+      eventPage,
+      includeVerified,
+      items
+    };
+  }
+  async verifyMetricDiscrepancy(user, options) {
+    const { gameId, courseId, data } = options;
+    const client = this.requireClient();
+    await this.deps.validateDeveloperAccess(user, gameId);
+    const [integration, gameSource] = await Promise.all([
+      this.deps.db.query.gameTimebackIntegrations.findFirst({
+        where: and(eq(gameTimebackIntegrations.gameId, gameId), eq(gameTimebackIntegrations.courseId, courseId))
+      }),
+      this.getGameActivitySource(gameId)
+    ]);
+    if (!integration) {
+      throw new NotFoundError("Timeback integration", `${gameId}:${courseId}`);
+    }
+    await this.assertStudentHasEnrollmentInCourse(client, data.studentId, courseId);
+    const runId = data.runId.toLowerCase();
+    let runEvents;
+    try {
+      runEvents = await this.fetchCaliperEventsForRun(client, gameSource, {
+        runId,
+        studentId: data.studentId
+      });
+    } catch (error) {
+      logger17.warn("Failed to hydrate Caliper events for discrepancy verification", {
+        gameId,
+        courseId,
+        studentId: data.studentId,
+        runId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw new ValidationError("Cannot verify discrepancy until full run data is available");
+    }
+    const activity = mapCaliperEventsToCompletedStudentGameplayActivities(runEvents, new Set([courseId]), {
+      studentId: data.studentId,
+      runIds: new Set([runId])
+    }).flatMap((group) => group.activities).find((runActivity) => runActivity.runId?.toLowerCase() === runId);
+    if (!activity) {
+      throw new ValidationError("Cannot verify discrepancy until full run data is available");
+    }
+    const comparisons = await this.getGameMetricComparisonsForActivities(user, {
+      gameId,
+      studentId: data.studentId,
+      course: { grade: integration.grade, subject: integration.subject },
+      activities: [activity]
+    });
+    const comparison = comparisons.get(activity.runId ?? runId);
+    if (comparison?.status !== "discrepant") {
+      throw new ValidationError("Cannot verify discrepancy because the hydrated run is not discrepant");
+    }
+    const verifiedAt = new Date;
+    const [row] = await this.deps.db.insert(gameTimebackMetricDiscrepancyVerifications).values({
+      gameId,
+      courseId,
+      studentId: data.studentId,
+      runId,
+      activityId: data.activityId ?? null,
+      verifiedByUserId: user.id,
+      verifiedAt
+    }).onConflictDoUpdate({
+      target: [
+        gameTimebackMetricDiscrepancyVerifications.gameId,
+        gameTimebackMetricDiscrepancyVerifications.courseId,
+        gameTimebackMetricDiscrepancyVerifications.studentId,
+        gameTimebackMetricDiscrepancyVerifications.runId
+      ],
+      set: {
+        activityId: data.activityId ?? null,
+        verifiedByUserId: user.id,
+        verifiedAt
+      }
+    }).returning();
+    if (!row) {
+      throw new ValidationError("Failed to verify metric discrepancy");
+    }
+    return {
+      status: "ok",
+      verification: TimebackAdminService.mapMetricDiscrepancyVerification(row)
+    };
+  }
   async getActivityDetail(user, options) {
     const { gameId, studentId, courseId, activityId, runId } = options;
     const client = this.requireClient();
@@ -31401,16 +32126,37 @@ class TimebackAdminService {
       throw new NotFoundError("Timeback integration", `${gameId}:${courseId}`);
     }
     await this.assertStudentHasEnrollmentInCourse(client, studentId, courseId);
-    const events = await this.fetchCaliperEventsForStudent(client, studentId, gameSource, TimebackAdminService.MAX_RECENT_ACTIVITY_EVENT_FETCH);
     const relevantCourseIds = new Set([courseId]);
     let matchedEvents;
     let activity;
     if (runId) {
-      const gameplayEvents = events.filter((event) => (event.type === "ActivityEvent" || event.type === "TimeSpentEvent") && !isCaliperRemediationOrCompletionEvent(event));
-      const groups = groupCaliperEventsByRun(gameplayEvents);
-      matchedEvents = [...groups.values()].find((group) => group.some((event) => getCanonicalRunId(event.session) === runId && event.externalId === activityId)) ?? [];
-      activity = mapCaliperEventGroupToActivity(matchedEvents, relevantCourseIds);
+      const normalizedRunId = TimebackAdminService.normalizeRunIds([runId], 1)[0];
+      if (!normalizedRunId) {
+        matchedEvents = [];
+        activity = null;
+      } else {
+        let runEvents;
+        try {
+          runEvents = await this.fetchCaliperEventsForRun(client, gameSource, {
+            runId: normalizedRunId,
+            studentId
+          });
+        } catch (error) {
+          logger17.warn("Failed to load Caliper events for activity detail run", {
+            runId: normalizedRunId,
+            studentId,
+            activityId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          runEvents = [];
+        }
+        const gameplayEvents = runEvents.filter((event) => (event.type === "ActivityEvent" || event.type === "TimeSpentEvent") && !isCaliperRemediationOrCompletionEvent(event));
+        const matchingActivityEvents = findCaliperEventGroupContainingExternalId(gameplayEvents, activityId);
+        matchedEvents = matchingActivityEvents ?? [];
+        activity = mapCaliperEventGroupToActivity(matchedEvents, relevantCourseIds);
+      }
     } else {
+      const events = await this.fetchCaliperEventsForStudent(client, studentId, gameSource, TimebackAdminService.MAX_RECENT_ACTIVITY_EVENT_FETCH);
       matchedEvents = events.filter((event) => event.externalId === activityId);
       if (matchedEvents.length > 0) {
         activity = mapCaliperEventToRemediationActivity(matchedEvents[0], relevantCourseIds) ?? mapCaliperEventGroupToActivity(matchedEvents, relevantCourseIds);
@@ -31428,9 +32174,22 @@ class TimebackAdminService {
       activities: [activity]
     });
     const gameMetricsComparison = activity.runId ? comparisons.get(activity.runId) : undefined;
+    const verificationsByKey = gameMetricsComparison?.status === "discrepant" && activity.runId ? await this.getMetricDiscrepancyVerificationsByKey({
+      gameId,
+      courseId,
+      studentId,
+      runIds: [activity.runId]
+    }) : new Map;
+    const verification2 = getTimebackMetricDiscrepancyVerificationForActivity({
+      studentId,
+      activity,
+      comparison: gameMetricsComparison,
+      verificationsByKey
+    });
     const activityWithGameMetrics = gameMetricsComparison ? {
       ...activity,
-      gameMetricsComparison: summarizeGameRunMetricsComparison(gameMetricsComparison)
+      gameMetricsComparison: summarizeGameRunMetricsComparison(gameMetricsComparison),
+      ...verification2 ? { gameMetricsVerification: verification2 } : {}
     } : activity;
     return {
       activity: activityWithGameMetrics,
@@ -31721,9 +32480,11 @@ var init_timeback_admin_service = __esm(() => {
   init_types4();
   init_utils6();
   init_src4();
+  init_timeback3();
   init_errors();
   init_timeback_admin_metrics_util();
   init_timeback_admin_util();
+  init_timeback_discrepancy_queue_util();
   init_timeback_game_metrics_comparison_util();
   init_timeback_mastery_completion_util();
   init_timeback_util();
@@ -34996,6 +35757,9 @@ function createCaliperNamespace(client) {
         if (params.actorEmail) {
           query.set("actorEmail", params.actorEmail);
         }
+        if (params.sessionId) {
+          query.set("sessionId", params.sessionId);
+        }
         if (params.extensions) {
           for (const [key, value] of Object.entries(params.extensions)) {
             query.set(`extensions.${key}`, value);
@@ -37364,7 +38128,7 @@ function buildTimebackClient() {
   }
   return;
 }
-var init_timeback3 = __esm(() => {
+var init_timeback4 = __esm(() => {
   init_src2();
   init_dist3();
   init_config();
@@ -37372,7 +38136,7 @@ var init_timeback3 = __esm(() => {
 
 // src/infrastructure/api/clients/index.ts
 var init_clients = __esm(() => {
-  init_timeback3();
+  init_timeback4();
 });
 
 // src/infrastructure/api/providers/auth.provider.ts
@@ -92418,7 +93182,7 @@ async function seedTimebackIntegrations(db2, gameId, courses) {
   }
   return seededCount;
 }
-var init_timeback4 = __esm(() => {
+var init_timeback5 = __esm(() => {
   init_tables_index();
   init_config();
 });
@@ -92509,7 +93273,7 @@ var init_games = __esm(() => {
   init_tables_index();
   init_constants();
   init_logging();
-  init_timeback4();
+  init_timeback5();
 });
 
 // src/database/seed/index.ts
@@ -92535,7 +93299,7 @@ var init_seed = __esm(() => {
   init_tables_index();
   init_constants();
   init_games();
-  init_timeback4();
+  init_timeback5();
   init_games();
 });
 
@@ -94238,12 +95002,13 @@ var init_session_controller = __esm(() => {
 });
 
 // ../api-core/src/controllers/timeback.controller.ts
-var logger45, populateStudent, getUser, getUserEnrollments, getUserById, setupIntegration, getIntegrations, updateIntegration, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getActivityDetail, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, deleteAssessment, reorderAssessments, reorderQuestions, activateAssessment, deactivateAssessment, listQuestions, createQuestion, updateQuestion, deleteQuestion, getAssessmentBankStatus, destroyAssessmentBank, timeback2;
+var logger45, populateStudent, getUser, getUserEnrollments, getUserById, setupIntegration, getIntegrations, updateIntegration, getIntegrationConfig, verifyIntegration, getConfig, deleteIntegrations, endActivity, heartbeat, advanceCourse, unenrollCourse, getStudentXp, getStudentMastery, getStudentHighestGradeMastered, getRoster, getStudentOverview, getGameMetrics, getStudentActivity, getActivityDetail, listMetricDiscrepancies, verifyMetricDiscrepancy, grantXp, adjustTime, adjustMastery, reconcileMasteryForConfigChange, searchStudents, enrollStudent, unenrollStudent, reactivateEnrollment, listAssessments, createAssessment, deleteAssessment, reorderAssessments, reorderQuestions, activateAssessment, deactivateAssessment, listQuestions, createQuestion, updateQuestion, deleteQuestion, getAssessmentBankStatus, destroyAssessmentBank, timeback2;
 var init_timeback_controller = __esm(() => {
   init_esm();
   init_schemas_index();
   init_src2();
   init_src4();
+  init_timeback3();
   init_errors();
   init_utils11();
   logger45 = log.scope("TimebackController");
@@ -94710,6 +95475,65 @@ var init_timeback_controller = __esm(() => {
       runId
     });
   });
+  listMetricDiscrepancies = requireGameManagementAccess(async (ctx) => {
+    const gameId = ctx.params.gameId;
+    const courseId = ctx.params.courseId;
+    const requestedEventOffset = Number(ctx.url.searchParams.get("eventOffset"));
+    const requestedWindow = ctx.url.searchParams.get("window");
+    const startDate = ctx.url.searchParams.get("startDate") ?? undefined;
+    const endDate = ctx.url.searchParams.get("endDate") ?? undefined;
+    const studentId = ctx.url.searchParams.get("studentId")?.trim() || undefined;
+    const discrepancyMetricScopes = parseTimebackDiscrepancyQueueMetrics(ctx.url.searchParams.getAll("discrepancyMetric"));
+    const eventOffset = Number.isFinite(requestedEventOffset) && requestedEventOffset > 0 ? Math.trunc(requestedEventOffset) : 0;
+    const window2 = parseTimebackDiscrepancyQueueWindow(requestedWindow);
+    const includeVerified = ctx.url.searchParams.get("includeVerified") === "true";
+    if (!gameId || !courseId) {
+      throw ApiError.badRequest("Missing gameId or courseId path parameter");
+    }
+    logger45.debug("Listing metric discrepancies", {
+      requesterId: ctx.user.id,
+      gameId,
+      courseId,
+      window: window2,
+      startDate,
+      endDate,
+      studentId,
+      discrepancyMetricScopes,
+      includeVerified,
+      eventOffset
+    });
+    return ctx.services.timebackAdmin.listMetricDiscrepancies(ctx.user, {
+      gameId,
+      courseId,
+      window: window2,
+      startDate,
+      endDate,
+      studentId,
+      discrepancyMetricScopes,
+      includeVerified,
+      eventOffset
+    });
+  });
+  verifyMetricDiscrepancy = requireDeveloper(async (ctx) => {
+    const gameId = ctx.params.gameId;
+    const courseId = ctx.params.courseId;
+    const body2 = await parseRequestBody(ctx.request, VerifyTimebackMetricDiscrepancyRequestSchema);
+    if (!gameId || !courseId) {
+      throw ApiError.badRequest("Missing gameId or courseId path parameter");
+    }
+    logger45.debug("Verifying metric discrepancy", {
+      requesterId: ctx.user.id,
+      gameId,
+      courseId,
+      studentId: body2.studentId,
+      runId: body2.runId
+    });
+    return ctx.services.timebackAdmin.verifyMetricDiscrepancy(ctx.user, {
+      gameId,
+      courseId,
+      data: body2
+    });
+  });
   grantXp = requireDeveloper(async (ctx) => {
     const body2 = await parseRequestBody(ctx.request, GrantTimebackXpRequestSchema);
     logger45.debug("Granting manual XP", {
@@ -94953,6 +95777,8 @@ var init_timeback_controller = __esm(() => {
     getGameMetrics,
     getStudentActivity,
     getActivityDetail,
+    listMetricDiscrepancies,
+    verifyMetricDiscrepancy,
     grantXp,
     adjustTime,
     adjustMastery,
@@ -95190,7 +96016,7 @@ async function buildMockUserResponse(db2, user, gameId) {
     timeback: timeback3
   };
 }
-var init_timeback5 = __esm(() => {
+var init_timeback6 = __esm(() => {
   init_drizzle_orm();
   init_utils11();
   init_tables_index();
@@ -95208,7 +96034,7 @@ var init_users = __esm(() => {
   init_tables_index();
   init_api();
   init_error_handler();
-  init_timeback5();
+  init_timeback6();
   usersRouter = new Hono2;
   usersRouter.get("/me", async (c2) => {
     const user = c2.get("user");
@@ -95833,15 +96659,16 @@ function hashCode(str) {
   return Math.abs(hash);
 }
 var timebackRouter;
-var init_timeback6 = __esm(() => {
+var init_timeback7 = __esm(() => {
   init_dist4();
   init_controllers();
   init_errors();
   init_utils11();
   init_schemas_index();
+  init_timeback3();
   init_api();
   init_error_handler();
-  init_timeback5();
+  init_timeback6();
   timebackRouter = new Hono2;
   timebackRouter.post("/populate-student", async (c2) => c2.json({
     status: "no_record"
@@ -96164,7 +96991,7 @@ var init_routes = __esm(() => {
   init_users();
   init_games2();
   init_leaderboard();
-  init_timeback6();
+  init_timeback7();
   init_lti();
 });