fix(exercise): persist completion policy and improve dev build workflow (#754)

* fix(exercise): persist completion policy and pass threshold on save

buildExerciseUpdateFields accepted completionPolicy and passThreshold in
the validation schema but never mapped them to the database update, so
exercise settings appeared to save while reverting on refresh.

Co-authored-by: Rotimi Best <[email protected]>

* fix(db): build workspace deps before compiling

@cio/db imports @cio/utils/notifications, which only exists after
@cio/utils is built. Building db in isolation failed when utils dist
was missing or stale.

- Add a db prebuild step for question-types, utils, and email
- Clean dist and tsbuildinfo before utils and email builds so
  incremental tsc cannot skip emission after dist was removed

Co-authored-by: Rotimi Best <[email protected]>

* chore(dev): build api workspace deps before api:dev

Run turbo build for @cio/api and @cio/jobs-worker dependencies before
starting the dev servers, so missing dist/ folders do not break startup.

Co-authored-by: Rotimi Best <[email protected]>

* feat(course): improve exercise progression grading UX

---------

Co-authored-by: Rotimi Best <[email protected]>

apps/api/src/services/course/completion.ts

@@ -15,7 +15,11 @@ import {
   getCourseProgress as getCourseProgressQuery,
   type TCourseCertificationRow
 } from '@cio/db/queries/course/course';
+import { claimMemberCertificateEarned } from '@cio/db/queries/course/people';
+import { getActiveOrganizationPlan } from '@cio/db/queries/organization';
 import { ROLE } from '@cio/utils/constants';
+import { PLAN } from '@cio/utils/plans';
+import { env } from '@cio/core/config/env';
 import { trackServerEvent, SERVER_EVENTS } from '@cio/analytics';
 
 export type CertificationBlocker = {
@@ -230,38 +234,58 @@ export async function evaluateCourseCertification(
   let isNewCompletion = false;
 
   if (evaluation.eligibleForCertificate && !certificateEarnedAt && progress.groupMemberId) {
-    const earnedAt = new Date().toISOString();
-    certificateEarnedAt = earnedAt;
-    isNewCompletion = true;
+    const certificatesEnabled = await orgHasCertificatesEnabled(courseRow.orgId);
 
-    scheduleCertificationCompletionWork({
-      courseId,
-      profileId,
-      groupMemberId: progress.groupMemberId,
-      courseRow,
-      earnedAt
-    });
+    if (certificatesEnabled) {
+      const earnedAt = new Date().toISOString();
+      const didClaimCertificate = await claimMemberCertificateEarned(progress.groupMemberId, earnedAt);
+      certificateEarnedAt = earnedAt;
 
-    trackServerEvent({
-      eventType: SERVER_EVENTS.COURSE_COMPLETED,
-      userId: profileId,
-      courseId,
-      props: { path: 'standard', earnedAt }
-    });
+      if (didClaimCertificate) {
+        isNewCompletion = true;
 
-    if (courseRow.certificate?.isDownloadable) {
-      trackServerEvent({
-        eventType: SERVER_EVENTS.CERTIFICATE_ISSUED,
-        userId: profileId,
-        courseId,
-        props: { path: 'standard', earnedAt }
-      });
+        scheduleCertificationCompletionWork({
+          courseId,
+          profileId,
+          groupMemberId: progress.groupMemberId,
+          courseRow,
+          earnedAt
+        });
+
+        trackServerEvent({
+          eventType: SERVER_EVENTS.COURSE_COMPLETED,
+          userId: profileId,
+          courseId,
+          props: { path: 'standard', earnedAt }
+        });
+
+        if (courseRow.certificate?.isDownloadable) {
+          trackServerEvent({
+            eventType: SERVER_EVENTS.CERTIFICATE_ISSUED,
+            userId: profileId,
+            courseId,
+            props: { path: 'standard', earnedAt }
+          });
+        }
+      }
     }
   }
 
   return { ...evaluation, certificateEarnedAt, isNewCompletion };
 }
 
+/**
+ * Free-plan orgs do not get certificates: no earned record, no completion email.
+ * Self-hosted deployments always have certificates enabled.
+ */
+async function orgHasCertificatesEnabled(orgId: string): Promise<boolean> {
+  if (env.PUBLIC_IS_SELFHOSTED === 'true') return true;
+
+  const activePlan = await getActiveOrganizationPlan(orgId);
+
+  return Boolean(activePlan && activePlan.planName !== PLAN.BASIC);
+}
+
 /**
  * Server-side guard for PDF certificate download (must match dashboard eligibility).
  */

apps/api/src/services/exercise/utils.ts

@@ -12,11 +12,19 @@ import {
   updateQuestions
 } from '@cio/db/queries/exercise';
 
+import {
+  QUESTION_TYPE_IDS,
+  QUESTION_TYPE_KEY,
+  resolveTrueFalseCorrectValue,
+  syncTrueFalseOptions,
+  type TrueFalseAnswerOption
+} from '@cio/question-types';
 import type { DbOrTxClient } from '@cio/db/drizzle';
 import type { TExerciseUpdate } from '@cio/utils/validation/exercise';
 
 type CurrentQuestion = TNewQuestion & { options?: TNewOption[] };
 type CurrentOption = TNewOption;
+type ExerciseUpdateQuestion = NonNullable<TExerciseUpdate['questions']>[number];
 
 type ExerciseAnswer = Pick<
   TQuestionAnswer,
@@ -68,6 +76,26 @@ function areSettingsEqual(left: unknown, right: unknown): boolean {
   return JSON.stringify(leftNormalized) === JSON.stringify(rightNormalized);
 }
 
+const TRUE_FALSE_QUESTION_TYPE_ID = QUESTION_TYPE_IDS[QUESTION_TYPE_KEY.TRUE_FALSE];
+
+function normalizeTrueFalseQuestion(
+  question: ExerciseUpdateQuestion,
+  currentQuestion?: CurrentQuestion
+): ExerciseUpdateQuestion {
+  const questionTypeId = question.questionTypeId ?? currentQuestion?.questionTypeId;
+  if (questionTypeId !== TRUE_FALSE_QUESTION_TYPE_ID) return question;
+
+  const settings = normalizeSettings(question.settings ?? currentQuestion?.settings);
+  const options = question.options ?? currentQuestion?.options ?? [];
+  const correctValue = resolveTrueFalseCorrectValue(settings, options as TrueFalseAnswerOption[]);
+
+  return {
+    ...question,
+    settings: { ...settings, correctValue },
+    options: question.options ? syncTrueFalseOptions(question.options, correctValue) : question.options
+  };
+}
+
 /**
  * Extracts exercise-level fields from the update payload
  */
@@ -81,6 +109,8 @@ export function buildExerciseUpdateFields(data: TExerciseUpdate): Partial<TExerc
   if (data.isUnlocked !== undefined) exerciseUpdate.isUnlocked = data.isUnlocked;
   if (data.dueBy !== undefined) exerciseUpdate.dueBy = data.dueBy || null;
   if (data.allowMultipleAttempts !== undefined) exerciseUpdate.allowMultipleAttempts = data.allowMultipleAttempts;
+  if (data.completionPolicy !== undefined) exerciseUpdate.completionPolicy = data.completionPolicy;
+  if (data.passThreshold !== undefined) exerciseUpdate.passThreshold = data.passThreshold;
   if (data.sectionDisplayMode !== undefined) exerciseUpdate.sectionDisplayMode = data.sectionDisplayMode;
   if (data.slug !== undefined) exerciseUpdate.slug = data.slug;
   return exerciseUpdate;
@@ -95,7 +125,9 @@ export function categorizeQuestions(questions: NonNullable<TExerciseUpdate['ques
   const newQuestions: typeof questions = [];
   const questionUpdates: Array<{ id: number; data: Partial<TNewQuestion> }> = [];
 
-  for (const q of questions) {
+  for (const rawQuestion of questions) {
+    const q = normalizeTrueFalseQuestion(rawQuestion);
+
     if (q.deletedAt && q.id) {
       deletedIds.push(q.id);
     } else if (q.id) {
@@ -230,13 +262,16 @@ export function computeExerciseDiff(
   incomingQuestions: NonNullable<TExerciseUpdate['questions']>
 ) {
   const questionMap = new Map(currentQuestions.map((q) => [q.id, q]));
+  const normalizedIncomingQuestions = incomingQuestions.map((incoming) =>
+    normalizeTrueFalseQuestion(incoming, incoming.id ? questionMap.get(incoming.id) : undefined)
+  );
 
   const deletedQuestionIds: number[] = [];
   const questionUpdates: Array<{ id: number; data: Partial<TNewQuestion> }> = [];
   const newQuestions: NonNullable<TExerciseUpdate['questions']> = [];
 
   // Process incoming questions
-  for (const incoming of incomingQuestions) {
+  for (const incoming of normalizedIncomingQuestions) {
     if (incoming.deletedAt && incoming.id) {
       deletedQuestionIds.push(incoming.id);
     } else if (incoming.id) {
@@ -260,7 +295,7 @@ export function computeExerciseDiff(
   const optionUpdates: Array<{ id: number; data: Partial<TNewOption> }> = [];
   const optionCreates: TNewOption[] = [];
 
-  for (const incoming of incomingQuestions) {
+  for (const incoming of normalizedIncomingQuestions) {
     if (!incoming.id || incoming.deletedAt) continue;
 
     const current = questionMap.get(incoming.id);
@@ -336,8 +371,9 @@ export async function createNewQuestionsWithOptions(
   newQuestions: NonNullable<TExerciseUpdate['questions']>,
   txClient: DbOrTxClient
 ): Promise<void> {
+  const normalizedQuestions = newQuestions.map((question) => normalizeTrueFalseQuestion(question));
   const createdQuestions = await createQuestions(
-    newQuestions.map((q) => ({
+    normalizedQuestions.map((q) => ({
       exerciseId,
       title: q.question,
       questionTypeId: q.questionTypeId || 1,
@@ -351,7 +387,7 @@ export async function createNewQuestionsWithOptions(
 
   const newOptions: TNewOption[] = [];
   createdQuestions.forEach((newQuestion, index) => {
-    const questionData = newQuestions[index];
+    const questionData = normalizedQuestions[index];
     if (newQuestion && questionData?.options && questionData.options.length > 0) {
       // Only include non-deleted options for new questions
       for (const opt of questionData.options) {