@burdenoff/mcp-libs 2026.627.2 → 2026.627.4

package/dist/modules/buildmyiq/index.js

@@ -0,0 +1,1501 @@
+import { mcpToolName, errorResult, jsonResult, mcpResourceUri, mcpPromptName } from '../../chunk-H2OYWLOA.js';
+import { z } from 'zod';
+
+// src/modules/buildmyiq/operations.ts
+var PAGE_INFO_FIELDS = `cursor hasMore`;
+var COURSE_FIELDS = `
+  id title slug summary description level status language tags estimatedHours
+  isPublic instructorId skillId publishedAt workspaceId createdAt updatedAt
+  cover { id }
+`;
+var MODULE_FIELDS = `
+  id courseId title description position workspaceId createdAt updatedAt
+`;
+var LESSON_FIELDS = `
+  id courseId moduleId title type content durationMin isPreview position
+  workspaceId createdAt updatedAt media { id }
+`;
+var SKILL_FIELDS = `
+  id name description category isActive workspaceId createdAt updatedAt
+`;
+var ENROLLMENT_FIELDS = `
+  id courseId learnerId cohortId status progressPct enrolledAt startedAt
+  completedAt lastActiveAt expiresAt workspaceId createdAt updatedAt
+`;
+var LESSON_PROGRESS_FIELDS = `
+  id enrollmentId lessonId status secondsSpent completedAt workspaceId
+  createdAt updatedAt
+`;
+var COHORT_FIELDS = `
+  id courseId name status capacity facilitatorId startDate endDate
+  workspaceId createdAt updatedAt
+`;
+var CERTIFICATE_FIELDS = `
+  id courseId enrollmentId learnerId serial status finalScore issuedAt
+  expiresAt revokedAt workspaceId createdAt updatedAt file { id }
+`;
+var ASSESSMENT_FIELDS = `
+  id courseId title description type status passingScore maxAttempts
+  timeLimitMin isGraded workspaceId createdAt updatedAt
+`;
+var QUESTION_FIELDS = `
+  id assessmentId type prompt options points position explanation
+  workspaceId createdAt updatedAt
+`;
+var SUBMISSION_FIELDS = `
+  id assessmentId enrollmentId learnerId attempt status answers score passed
+  feedback gradedById gradedAt submittedAt workspaceId createdAt updatedAt
+`;
+var GET_COURSE = `
+  query BuildmyiqGetCourse($id: ID!) {
+    buiCourse(id: $id) {
+      ${COURSE_FIELDS}
+      skill { ${SKILL_FIELDS} }
+      modules { ${MODULE_FIELDS} lessons { ${LESSON_FIELDS} } }
+      lessons { ${LESSON_FIELDS} }
+    }
+  }
+`;
+var LIST_COURSES = `
+  query BuildmyiqListCourses(
+    $level: BuiCourseLevel
+    $status: BuiCourseStatus
+    $pagination: PaginationInput
+  ) {
+    buiListCourses(level: $level, status: $status, pagination: $pagination) {
+      items { ${COURSE_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var CREATE_COURSE = `
+  mutation BuildmyiqCreateCourse($input: BuiCreateCourseInput!) {
+    buiCreateCourse(input: $input) {
+      ${COURSE_FIELDS}
+    }
+  }
+`;
+var UPDATE_COURSE = `
+  mutation BuildmyiqUpdateCourse($id: ID!, $input: BuiUpdateCourseInput!) {
+    buiUpdateCourse(id: $id, input: $input) {
+      ${COURSE_FIELDS}
+    }
+  }
+`;
+var PUBLISH_COURSE = `
+  mutation BuildmyiqPublishCourse($id: ID!) {
+    buiPublishCourse(id: $id) {
+      ${COURSE_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_COURSE = `
+  mutation BuildmyiqArchiveCourse($id: ID!) {
+    buiArchiveCourse(id: $id)
+  }
+`;
+var LIST_MODULES = `
+  query BuildmyiqListModules($courseId: ID!) {
+    buiListModules(courseId: $courseId) {
+      ${MODULE_FIELDS}
+      lessons { ${LESSON_FIELDS} }
+    }
+  }
+`;
+var CREATE_MODULE = `
+  mutation BuildmyiqCreateModule($input: BuiCreateModuleInput!) {
+    buiCreateModule(input: $input) {
+      ${MODULE_FIELDS}
+    }
+  }
+`;
+var LIST_LESSONS = `
+  query BuildmyiqListLessons($courseId: ID!, $moduleId: ID) {
+    buiListLessons(courseId: $courseId, moduleId: $moduleId) {
+      ${LESSON_FIELDS}
+    }
+  }
+`;
+var CREATE_LESSON = `
+  mutation BuildmyiqCreateLesson($input: BuiCreateLessonInput!) {
+    buiCreateLesson(input: $input) {
+      ${LESSON_FIELDS}
+    }
+  }
+`;
+var LIST_SKILLS = `
+  query BuildmyiqListSkills($category: BuiSkillCategory) {
+    buiListSkills(category: $category) {
+      ${SKILL_FIELDS}
+    }
+  }
+`;
+var CREATE_SKILL = `
+  mutation BuildmyiqCreateSkill($input: BuiCreateSkillInput!) {
+    buiCreateSkill(input: $input) {
+      ${SKILL_FIELDS}
+    }
+  }
+`;
+var GET_ENROLLMENT = `
+  query BuildmyiqGetEnrollment($id: ID!) {
+    buiEnrollment(id: $id) {
+      ${ENROLLMENT_FIELDS}
+      cohort { ${COHORT_FIELDS} }
+      lessonProgress { ${LESSON_PROGRESS_FIELDS} }
+    }
+  }
+`;
+var LIST_ENROLLMENTS = `
+  query BuildmyiqListEnrollments(
+    $courseId: ID
+    $learnerId: ID
+    $status: BuiEnrollmentStatus
+    $pagination: PaginationInput
+  ) {
+    buiListEnrollments(
+      courseId: $courseId
+      learnerId: $learnerId
+      status: $status
+      pagination: $pagination
+    ) {
+      items { ${ENROLLMENT_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var ENROLL = `
+  mutation BuildmyiqEnroll($input: BuiEnrollInput!) {
+    buiEnroll(input: $input) {
+      ${ENROLLMENT_FIELDS}
+    }
+  }
+`;
+var TRANSITION_ENROLLMENT = `
+  mutation BuildmyiqTransitionEnrollment($id: ID!, $status: BuiEnrollmentStatus!) {
+    buiTransitionEnrollment(id: $id, status: $status) {
+      ${ENROLLMENT_FIELDS}
+    }
+  }
+`;
+var RECORD_LESSON_PROGRESS = `
+  mutation BuildmyiqRecordLessonProgress($input: BuiRecordLessonProgressInput!) {
+    buiRecordLessonProgress(input: $input) {
+      ${LESSON_PROGRESS_FIELDS}
+    }
+  }
+`;
+var LIST_COHORTS = `
+  query BuildmyiqListCohorts($courseId: ID, $status: BuiCohortStatus) {
+    buiListCohorts(courseId: $courseId, status: $status) {
+      ${COHORT_FIELDS}
+    }
+  }
+`;
+var CREATE_COHORT = `
+  mutation BuildmyiqCreateCohort($input: BuiCreateCohortInput!) {
+    buiCreateCohort(input: $input) {
+      ${COHORT_FIELDS}
+    }
+  }
+`;
+var LIST_CERTIFICATES = `
+  query BuildmyiqListCertificates($courseId: ID, $learnerId: ID) {
+    buiListCertificates(courseId: $courseId, learnerId: $learnerId) {
+      ${CERTIFICATE_FIELDS}
+    }
+  }
+`;
+var ISSUE_CERTIFICATE = `
+  mutation BuildmyiqIssueCertificate($input: BuiIssueCertificateInput!) {
+    buiIssueCertificate(input: $input) {
+      ${CERTIFICATE_FIELDS}
+    }
+  }
+`;
+var REVOKE_CERTIFICATE = `
+  mutation BuildmyiqRevokeCertificate($id: ID!) {
+    buiRevokeCertificate(id: $id) {
+      ${CERTIFICATE_FIELDS}
+    }
+  }
+`;
+var GET_ASSESSMENT = `
+  query BuildmyiqGetAssessment($id: ID!) {
+    buiAssessment(id: $id) {
+      ${ASSESSMENT_FIELDS}
+      questions { ${QUESTION_FIELDS} }
+    }
+  }
+`;
+var LIST_ASSESSMENTS = `
+  query BuildmyiqListAssessments($courseId: ID!, $status: BuiAssessmentStatus) {
+    buiListAssessments(courseId: $courseId, status: $status) {
+      ${ASSESSMENT_FIELDS}
+    }
+  }
+`;
+var CREATE_ASSESSMENT = `
+  mutation BuildmyiqCreateAssessment($input: BuiCreateAssessmentInput!) {
+    buiCreateAssessment(input: $input) {
+      ${ASSESSMENT_FIELDS}
+    }
+  }
+`;
+var PUBLISH_ASSESSMENT = `
+  mutation BuildmyiqPublishAssessment($id: ID!) {
+    buiPublishAssessment(id: $id) {
+      ${ASSESSMENT_FIELDS}
+    }
+  }
+`;
+var CREATE_QUESTION = `
+  mutation BuildmyiqCreateQuestion($input: BuiCreateQuestionInput!) {
+    buiCreateQuestion(input: $input) {
+      ${QUESTION_FIELDS}
+    }
+  }
+`;
+var LIST_SUBMISSIONS = `
+  query BuildmyiqListSubmissions(
+    $assessmentId: ID
+    $learnerId: ID
+    $status: BuiSubmissionStatus
+    $pagination: PaginationInput
+  ) {
+    buiListSubmissions(
+      assessmentId: $assessmentId
+      learnerId: $learnerId
+      status: $status
+      pagination: $pagination
+    ) {
+      items { ${SUBMISSION_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var SUBMIT_ASSESSMENT = `
+  mutation BuildmyiqSubmitAssessment($input: BuiSubmitAssessmentInput!) {
+    buiSubmitAssessment(input: $input) {
+      ${SUBMISSION_FIELDS}
+    }
+  }
+`;
+var GRADE_SUBMISSION = `
+  mutation BuildmyiqGradeSubmission($id: ID!, $input: BuiGradeSubmissionInput!) {
+    buiGradeSubmission(id: $id, input: $input) {
+      ${SUBMISSION_FIELDS}
+    }
+  }
+`;
+var HEALTH = `
+  query BuildmyiqHealth {
+    buiHealth
+  }
+`;
+var CourseLevelEnum = z.enum(["BEGINNER", "INTERMEDIATE", "ADVANCED", "EXPERT"]).describe("Difficulty level of a course");
+var CourseStatusEnum = z.enum(["DRAFT", "IN_REVIEW", "PUBLISHED", "ARCHIVED"]).describe("Authoring lifecycle status of a course");
+var SkillCategoryEnum = z.enum(["BUSINESS", "COGNITIVE", "CREATIVE", "LANGUAGE", "SOCIAL", "TECHNICAL"]).describe("Category of a skill/competency");
+var LessonTypeEnum = z.enum(["ARTICLE", "ASSIGNMENT", "INTERACTIVE", "LIVE_SESSION", "QUIZ", "VIDEO"]).describe("Delivery type of a lesson");
+var EnrollmentStatusEnum = z.enum(["ENROLLED", "IN_PROGRESS", "COMPLETED", "DROPPED", "EXPIRED"]).describe("Lifecycle status of a learner enrollment");
+var ProgressStatusEnum = z.enum(["NOT_STARTED", "IN_PROGRESS", "COMPLETED"]).describe("Per-lesson progress status within an enrollment");
+var CohortStatusEnum = z.enum(["SCHEDULED", "ENROLLING", "ACTIVE", "COMPLETED", "CANCELLED"]).describe("Lifecycle status of a cohort");
+var AssessmentTypeEnum = z.enum(["ASSIGNMENT", "EXAM", "PRACTICAL", "QUIZ", "SURVEY"]).describe("Type of an assessment");
+var AssessmentStatusEnum = z.enum(["DRAFT", "PUBLISHED", "ARCHIVED"]).describe("Lifecycle status of an assessment");
+var QuestionTypeEnum = z.enum(["CODE", "ESSAY", "MULTIPLE_CHOICE", "SHORT_ANSWER", "SINGLE_CHOICE", "TRUE_FALSE"]).describe("Type of an assessment question");
+var SubmissionStatusEnum = z.enum(["IN_PROGRESS", "SUBMITTED", "GRADING", "GRADED", "RETURNED"]).describe("Lifecycle status of an assessment submission");
+var JsonObject = z.record(z.string(), z.unknown());
+var JsonValue = z.union([JsonObject, z.array(z.unknown())]).describe("Arbitrary JSON value (object or array)");
+
+// src/modules/buildmyiq/tools/courses.ts
+function registerCourseTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "courses_get")),
+    {
+      title: "Get Course",
+      description: "Fetch a single BuildMyIQ course by ID, including its skill, modules (with lessons), and flat lesson list.",
+      inputSchema: { id: z.string().describe("Course ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_COURSE, { id });
+        if (!data.buiCourse) return errorResult(`Course ${id} not found`);
+        return jsonResult(data.buiCourse);
+      } catch (error) {
+        ctx.logger.error("buildmyiq courses_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get course: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "courses_list")),
+    {
+      title: "List Courses",
+      description: "List courses in the bound workspace with optional level/status filters and cursor/limit/offset pagination. Returns { items, pageInfo }.",
+      inputSchema: {
+        level: CourseLevelEnum.optional().describe("Filter by difficulty level"),
+        status: CourseStatusEnum.optional().describe("Filter by authoring lifecycle status"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ level, status, limit, offset, cursor }) => {
+      try {
+        const pagination = {};
+        if (limit !== void 0) pagination.limit = limit;
+        if (offset !== void 0) pagination.offset = offset;
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(LIST_COURSES, {
+          level,
+          status,
+          pagination: Object.keys(pagination).length > 0 ? pagination : void 0
+        });
+        return jsonResult(data.buiListCourses);
+      } catch (error) {
+        ctx.logger.error("buildmyiq courses_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list courses: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "courses_create")),
+    {
+      title: "Create Course",
+      description: "Create a draft course. `slug` must be unique within the workspace. Reference a cover image by `coverFileId` (a wspace-files-svc File) rather than uploading a blob.",
+      inputSchema: {
+        title: z.string().min(1).describe("Course title"),
+        slug: z.string().min(1).describe("URL slug, unique within the workspace"),
+        summary: z.string().optional().describe("Short marketing summary"),
+        description: z.string().optional().describe("Full course description"),
+        level: CourseLevelEnum.optional().describe("Difficulty level (default BEGINNER)"),
+        language: z.string().optional().describe('Primary language (e.g. "en")'),
+        estimatedHours: z.number().int().optional().describe("Estimated completion hours"),
+        isPublic: z.boolean().optional().describe("Whether the course is publicly discoverable"),
+        instructorId: z.string().optional().describe("User ID of the primary instructor"),
+        skillId: z.string().optional().describe("Linked skill ID"),
+        coverFileId: z.string().optional().describe("wspace-files-svc File ID for the cover image"),
+        tags: z.array(z.string()).optional().describe("Discovery tags (default [])")
+      }
+    },
+    async ({
+      title,
+      slug,
+      summary,
+      description,
+      level,
+      language,
+      estimatedHours,
+      isPublic,
+      instructorId,
+      skillId,
+      coverFileId,
+      tags
+    }) => {
+      try {
+        const input = { title, slug };
+        if (summary !== void 0) input.summary = summary;
+        if (description !== void 0) input.description = description;
+        if (level !== void 0) input.level = level;
+        if (language !== void 0) input.language = language;
+        if (estimatedHours !== void 0) input.estimatedHours = estimatedHours;
+        if (isPublic !== void 0) input.isPublic = isPublic;
+        if (instructorId !== void 0) input.instructorId = instructorId;
+        if (skillId !== void 0) input.skillId = skillId;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_COURSE, { input });
+        return jsonResult(data.buiCreateCourse);
+      } catch (error) {
+        ctx.logger.error("buildmyiq courses_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create course: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "courses_update")),
+    {
+      title: "Update Course",
+      description: "Update a course. At least one mutable field must be provided. Use courses_publish/courses_archive for lifecycle transitions rather than setting status here.",
+      inputSchema: {
+        id: z.string().describe("Course ID"),
+        title: z.string().optional().describe("Updated title"),
+        summary: z.string().optional().describe("Updated summary"),
+        description: z.string().optional().describe("Updated description"),
+        level: CourseLevelEnum.optional().describe("Updated difficulty level"),
+        language: z.string().optional().describe("Updated language"),
+        estimatedHours: z.number().int().optional().describe("Updated estimated hours"),
+        isPublic: z.boolean().optional().describe("Updated public visibility"),
+        instructorId: z.string().optional().describe("Updated instructor user ID"),
+        skillId: z.string().optional().describe("Updated linked skill ID"),
+        coverFileId: z.string().optional().describe("Updated cover File ID"),
+        tags: z.array(z.string()).optional().describe("Updated discovery tags")
+      }
+    },
+    async ({
+      id,
+      title,
+      summary,
+      description,
+      level,
+      language,
+      estimatedHours,
+      isPublic,
+      instructorId,
+      skillId,
+      coverFileId,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (summary !== void 0) input.summary = summary;
+        if (description !== void 0) input.description = description;
+        if (level !== void 0) input.level = level;
+        if (language !== void 0) input.language = language;
+        if (estimatedHours !== void 0) input.estimatedHours = estimatedHours;
+        if (isPublic !== void 0) input.isPublic = isPublic;
+        if (instructorId !== void 0) input.instructorId = instructorId;
+        if (skillId !== void 0) input.skillId = skillId;
+        if (coverFileId !== void 0) input.coverFileId = coverFileId;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable course field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_COURSE, { id, input });
+        return jsonResult(data.buiUpdateCourse);
+      } catch (error) {
+        ctx.logger.error("buildmyiq courses_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update course: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "courses_publish")),
+    {
+      title: "Publish Course",
+      description: "Publish a course through its authoring lifecycle (validated DRAFT \u2192 IN_REVIEW \u2192 PUBLISHED transitions).",
+      inputSchema: { id: z.string().describe("Course ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PUBLISH_COURSE, { id });
+        return jsonResult(data.buiPublishCourse);
+      } catch (error) {
+        ctx.logger.error("buildmyiq courses_publish failed", { error: String(error) });
+        return errorResult(
+          `Failed to publish course: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "courses_archive")),
+    {
+      title: "Archive Course",
+      description: "Archive a course (soft-retire). Returns true on success.",
+      inputSchema: { id: z.string().describe("Course ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_COURSE,
+          { id }
+        );
+        return jsonResult({ archived: data.buiArchiveCourse });
+      } catch (error) {
+        ctx.logger.error("buildmyiq courses_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive course: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerModuleTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "modules_list")),
+    {
+      title: "List Course Modules",
+      description: "List the modules (sections) of a course in position order, each with its lessons.",
+      inputSchema: { courseId: z.string().describe("Course ID") }
+    },
+    async ({ courseId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MODULES, { courseId });
+        return jsonResult(data.buiListModules);
+      } catch (error) {
+        ctx.logger.error("buildmyiq modules_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list modules: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "modules_create")),
+    {
+      title: "Create Course Module",
+      description: "Add a module (section) to a course. `position` orders it within the course.",
+      inputSchema: {
+        courseId: z.string().min(1).describe("Owning course ID"),
+        title: z.string().min(1).describe("Module title"),
+        description: z.string().optional().describe("Module description"),
+        position: z.number().int().optional().describe("Ordering position within the course")
+      }
+    },
+    async ({ courseId, title, description, position }) => {
+      try {
+        const input = { courseId, title };
+        if (description !== void 0) input.description = description;
+        if (position !== void 0) input.position = position;
+        const data = await ctx.gql.workspace.request(CREATE_MODULE, { input });
+        return jsonResult(data.buiCreateModule);
+      } catch (error) {
+        ctx.logger.error("buildmyiq modules_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create module: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerLessonTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "lessons_list")),
+    {
+      title: "List Lessons",
+      description: "List the lessons of a course in position order, optionally narrowed to a single module.",
+      inputSchema: {
+        courseId: z.string().describe("Course ID"),
+        moduleId: z.string().optional().describe("Filter to a single module")
+      }
+    },
+    async ({ courseId, moduleId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_LESSONS, { courseId, moduleId });
+        return jsonResult(data.buiListLessons);
+      } catch (error) {
+        ctx.logger.error("buildmyiq lessons_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list lessons: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "lessons_create")),
+    {
+      title: "Create Lesson",
+      description: "Add a lesson to a course (optionally within a module). Reference media (video/asset) by `mediaFileId` (a wspace-files-svc File) rather than uploading a blob.",
+      inputSchema: {
+        courseId: z.string().min(1).describe("Owning course ID"),
+        title: z.string().min(1).describe("Lesson title"),
+        type: LessonTypeEnum.optional().describe("Lesson delivery type (default ARTICLE)"),
+        moduleId: z.string().optional().describe("Owning module ID (optional)"),
+        content: z.string().optional().describe("Lesson body content (markdown/HTML/text)"),
+        durationMin: z.number().int().optional().describe("Estimated duration in minutes"),
+        isPreview: z.boolean().optional().describe("Whether the lesson is a free preview"),
+        position: z.number().int().optional().describe("Ordering position within the course/module"),
+        mediaFileId: z.string().optional().describe("wspace-files-svc File ID for the lesson media")
+      }
+    },
+    async ({
+      courseId,
+      title,
+      type,
+      moduleId,
+      content,
+      durationMin,
+      isPreview,
+      position,
+      mediaFileId
+    }) => {
+      try {
+        const input = { courseId, title };
+        if (type !== void 0) input.type = type;
+        if (moduleId !== void 0) input.moduleId = moduleId;
+        if (content !== void 0) input.content = content;
+        if (durationMin !== void 0) input.durationMin = durationMin;
+        if (isPreview !== void 0) input.isPreview = isPreview;
+        if (position !== void 0) input.position = position;
+        if (mediaFileId !== void 0) input.mediaFileId = mediaFileId;
+        const data = await ctx.gql.workspace.request(CREATE_LESSON, { input });
+        return jsonResult(data.buiCreateLesson);
+      } catch (error) {
+        ctx.logger.error("buildmyiq lessons_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create lesson: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerSkillTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "skills_list")),
+    {
+      title: "List Skills",
+      description: "List skills in the bound workspace, optionally filtered by category.",
+      inputSchema: {
+        category: SkillCategoryEnum.optional().describe("Filter by skill category")
+      }
+    },
+    async ({ category }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SKILLS, { category });
+        return jsonResult(data.buiListSkills);
+      } catch (error) {
+        ctx.logger.error("buildmyiq skills_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list skills: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "skills_create")),
+    {
+      title: "Create Skill",
+      description: "Create a skill/competency that courses can be tagged against.",
+      inputSchema: {
+        name: z.string().min(1).describe("Skill name"),
+        category: SkillCategoryEnum.optional().describe("Skill category (default TECHNICAL)"),
+        description: z.string().optional().describe("Skill description")
+      }
+    },
+    async ({ name, category, description }) => {
+      try {
+        const input = { name };
+        if (category !== void 0) input.category = category;
+        if (description !== void 0) input.description = description;
+        const data = await ctx.gql.workspace.request(CREATE_SKILL, { input });
+        return jsonResult(data.buiCreateSkill);
+      } catch (error) {
+        ctx.logger.error("buildmyiq skills_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create skill: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerEnrollmentTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "enrollments_get")),
+    {
+      title: "Get Enrollment",
+      description: "Fetch a single enrollment by ID, including its cohort and per-lesson progress records.",
+      inputSchema: { id: z.string().describe("Enrollment ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_ENROLLMENT, { id });
+        if (!data.buiEnrollment) return errorResult(`Enrollment ${id} not found`);
+        return jsonResult(data.buiEnrollment);
+      } catch (error) {
+        ctx.logger.error("buildmyiq enrollments_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get enrollment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "enrollments_list")),
+    {
+      title: "List Enrollments",
+      description: "List enrollments, optionally filtered by course, learner, and/or status, with cursor/limit/offset pagination. Returns { items, pageInfo }.",
+      inputSchema: {
+        courseId: z.string().optional().describe("Filter by course ID"),
+        learnerId: z.string().optional().describe("Filter by learner user ID"),
+        status: EnrollmentStatusEnum.optional().describe("Filter by enrollment status"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ courseId, learnerId, status, limit, offset, cursor }) => {
+      try {
+        const pagination = {};
+        if (limit !== void 0) pagination.limit = limit;
+        if (offset !== void 0) pagination.offset = offset;
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(LIST_ENROLLMENTS, {
+          courseId,
+          learnerId,
+          status,
+          pagination: Object.keys(pagination).length > 0 ? pagination : void 0
+        });
+        return jsonResult(data.buiListEnrollments);
+      } catch (error) {
+        ctx.logger.error("buildmyiq enrollments_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list enrollments: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "enrollments_enroll")),
+    {
+      title: "Enroll Learner",
+      description: "Enroll a learner in a course (optionally within a cohort). If `learnerId` is omitted the calling actor is enrolled. `expiresAt` is an optional access-expiry timestamp.",
+      inputSchema: {
+        courseId: z.string().min(1).describe("Course to enroll into"),
+        learnerId: z.string().optional().describe("Learner user ID (defaults to the caller)"),
+        cohortId: z.string().optional().describe("Cohort to enroll within"),
+        expiresAt: z.string().optional().describe("Access-expiry timestamp (ISO-8601 DateTime)")
+      }
+    },
+    async ({ courseId, learnerId, cohortId, expiresAt }) => {
+      try {
+        const input = { courseId };
+        if (learnerId !== void 0) input.learnerId = learnerId;
+        if (cohortId !== void 0) input.cohortId = cohortId;
+        if (expiresAt !== void 0) input.expiresAt = expiresAt;
+        const data = await ctx.gql.workspace.request(ENROLL, { input });
+        return jsonResult(data.buiEnroll);
+      } catch (error) {
+        ctx.logger.error("buildmyiq enrollments_enroll failed", { error: String(error) });
+        return errorResult(
+          `Failed to enroll: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "enrollments_transition")),
+    {
+      title: "Transition Enrollment",
+      description: "Advance an enrollment through its lifecycle via validated transitions (ENROLLED \u2192 IN_PROGRESS \u2192 COMPLETED, or DROPPED/EXPIRED).",
+      inputSchema: {
+        id: z.string().describe("Enrollment ID"),
+        status: EnrollmentStatusEnum.describe("Target enrollment status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_ENROLLMENT, { id, status });
+        return jsonResult(data.buiTransitionEnrollment);
+      } catch (error) {
+        ctx.logger.error("buildmyiq enrollments_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition enrollment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "enrollments_record_progress")),
+    {
+      title: "Record Lesson Progress",
+      description: "Record (upsert) a learner\u2019s progress on a lesson within an enrollment \u2014 sets status and accumulates time spent.",
+      inputSchema: {
+        enrollmentId: z.string().min(1).describe("Enrollment ID"),
+        lessonId: z.string().min(1).describe("Lesson ID"),
+        status: ProgressStatusEnum.optional().describe("Progress status (default IN_PROGRESS)"),
+        secondsSpent: z.number().int().optional().describe("Seconds spent to add to the total")
+      }
+    },
+    async ({ enrollmentId, lessonId, status, secondsSpent }) => {
+      try {
+        const input = { enrollmentId, lessonId };
+        if (status !== void 0) input.status = status;
+        if (secondsSpent !== void 0) input.secondsSpent = secondsSpent;
+        const data = await ctx.gql.workspace.request(RECORD_LESSON_PROGRESS, { input });
+        return jsonResult(data.buiRecordLessonProgress);
+      } catch (error) {
+        ctx.logger.error("buildmyiq enrollments_record_progress failed", { error: String(error) });
+        return errorResult(
+          `Failed to record lesson progress: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerCohortTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "cohorts_list")),
+    {
+      title: "List Cohorts",
+      description: "List cohorts, optionally filtered by course and/or status.",
+      inputSchema: {
+        courseId: z.string().optional().describe("Filter by course ID"),
+        status: CohortStatusEnum.optional().describe("Filter by cohort status")
+      }
+    },
+    async ({ courseId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_COHORTS, { courseId, status });
+        return jsonResult(data.buiListCohorts);
+      } catch (error) {
+        ctx.logger.error("buildmyiq cohorts_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list cohorts: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "cohorts_create")),
+    {
+      title: "Create Cohort",
+      description: "Create a scheduled cohort for a course with an optional facilitator, capacity, and start/end dates.",
+      inputSchema: {
+        courseId: z.string().min(1).describe("Owning course ID"),
+        name: z.string().min(1).describe("Cohort name"),
+        capacity: z.number().int().optional().describe("Maximum number of learners"),
+        facilitatorId: z.string().optional().describe("Facilitator user ID"),
+        startDate: z.string().optional().describe("Start date (ISO-8601 DateTime)"),
+        endDate: z.string().optional().describe("End date (ISO-8601 DateTime)")
+      }
+    },
+    async ({ courseId, name, capacity, facilitatorId, startDate, endDate }) => {
+      try {
+        const input = { courseId, name };
+        if (capacity !== void 0) input.capacity = capacity;
+        if (facilitatorId !== void 0) input.facilitatorId = facilitatorId;
+        if (startDate !== void 0) input.startDate = startDate;
+        if (endDate !== void 0) input.endDate = endDate;
+        const data = await ctx.gql.workspace.request(CREATE_COHORT, { input });
+        return jsonResult(data.buiCreateCohort);
+      } catch (error) {
+        ctx.logger.error("buildmyiq cohorts_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create cohort: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerCertificateTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "certificates_list")),
+    {
+      title: "List Certificates",
+      description: "List issued certificates, optionally filtered by course and/or learner.",
+      inputSchema: {
+        courseId: z.string().optional().describe("Filter by course ID"),
+        learnerId: z.string().optional().describe("Filter by learner user ID")
+      }
+    },
+    async ({ courseId, learnerId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_CERTIFICATES, { courseId, learnerId });
+        return jsonResult(data.buiListCertificates);
+      } catch (error) {
+        ctx.logger.error("buildmyiq certificates_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list certificates: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "certificates_issue")),
+    {
+      title: "Issue Certificate",
+      description: "Issue a completion certificate to a learner for a course. `serial` must be unique. Reference the rendered PDF by `fileId` (a wspace-files-svc File).",
+      inputSchema: {
+        courseId: z.string().min(1).describe("Course the certificate is for"),
+        learnerId: z.string().min(1).describe("Recipient learner user ID"),
+        serial: z.string().min(1).describe("Unique certificate serial number"),
+        enrollmentId: z.string().optional().describe("Source enrollment ID"),
+        finalScore: z.number().optional().describe("Final score recorded on the certificate"),
+        fileId: z.string().optional().describe("wspace-files-svc File ID for the rendered PDF"),
+        expiresAt: z.string().optional().describe("Expiry timestamp (ISO-8601 DateTime)")
+      }
+    },
+    async ({ courseId, learnerId, serial, enrollmentId, finalScore, fileId, expiresAt }) => {
+      try {
+        const input = { courseId, learnerId, serial };
+        if (enrollmentId !== void 0) input.enrollmentId = enrollmentId;
+        if (finalScore !== void 0) input.finalScore = finalScore;
+        if (fileId !== void 0) input.fileId = fileId;
+        if (expiresAt !== void 0) input.expiresAt = expiresAt;
+        const data = await ctx.gql.workspace.request(ISSUE_CERTIFICATE, { input });
+        return jsonResult(data.buiIssueCertificate);
+      } catch (error) {
+        ctx.logger.error("buildmyiq certificates_issue failed", { error: String(error) });
+        return errorResult(
+          `Failed to issue certificate: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "certificates_revoke")),
+    {
+      title: "Revoke Certificate",
+      description: "Revoke a previously issued certificate (sets status REVOKED).",
+      inputSchema: { id: z.string().describe("Certificate ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(REVOKE_CERTIFICATE, { id });
+        return jsonResult(data.buiRevokeCertificate);
+      } catch (error) {
+        ctx.logger.error("buildmyiq certificates_revoke failed", { error: String(error) });
+        return errorResult(
+          `Failed to revoke certificate: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerAssessmentTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "assessments_get")),
+    {
+      title: "Get Assessment",
+      description: "Fetch a single assessment by ID, including its ordered questions (with options and points).",
+      inputSchema: { id: z.string().describe("Assessment ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_ASSESSMENT, { id });
+        if (!data.buiAssessment) return errorResult(`Assessment ${id} not found`);
+        return jsonResult(data.buiAssessment);
+      } catch (error) {
+        ctx.logger.error("buildmyiq assessments_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get assessment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "assessments_list")),
+    {
+      title: "List Assessments",
+      description: "List the assessments of a course, optionally filtered by status.",
+      inputSchema: {
+        courseId: z.string().describe("Course ID"),
+        status: AssessmentStatusEnum.optional().describe("Filter by assessment status")
+      }
+    },
+    async ({ courseId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ASSESSMENTS, { courseId, status });
+        return jsonResult(data.buiListAssessments);
+      } catch (error) {
+        ctx.logger.error("buildmyiq assessments_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list assessments: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "assessments_create")),
+    {
+      title: "Create Assessment",
+      description: "Create a draft assessment (quiz/exam/assignment/practical/survey) for a course. Add questions with questions_create, then publish with assessments_publish.",
+      inputSchema: {
+        courseId: z.string().min(1).describe("Owning course ID"),
+        title: z.string().min(1).describe("Assessment title"),
+        type: AssessmentTypeEnum.optional().describe("Assessment type (default QUIZ)"),
+        description: z.string().optional().describe("Assessment description/instructions"),
+        passingScore: z.number().optional().describe("Passing score threshold"),
+        maxAttempts: z.number().int().optional().describe("Maximum allowed attempts"),
+        timeLimitMin: z.number().int().optional().describe("Time limit in minutes"),
+        isGraded: z.boolean().optional().describe("Whether the assessment is graded")
+      }
+    },
+    async ({
+      courseId,
+      title,
+      type,
+      description,
+      passingScore,
+      maxAttempts,
+      timeLimitMin,
+      isGraded
+    }) => {
+      try {
+        const input = { courseId, title };
+        if (type !== void 0) input.type = type;
+        if (description !== void 0) input.description = description;
+        if (passingScore !== void 0) input.passingScore = passingScore;
+        if (maxAttempts !== void 0) input.maxAttempts = maxAttempts;
+        if (timeLimitMin !== void 0) input.timeLimitMin = timeLimitMin;
+        if (isGraded !== void 0) input.isGraded = isGraded;
+        const data = await ctx.gql.workspace.request(CREATE_ASSESSMENT, { input });
+        return jsonResult(data.buiCreateAssessment);
+      } catch (error) {
+        ctx.logger.error("buildmyiq assessments_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create assessment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "assessments_publish")),
+    {
+      title: "Publish Assessment",
+      description: "Publish a draft assessment so learners can take it (sets status PUBLISHED).",
+      inputSchema: { id: z.string().describe("Assessment ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PUBLISH_ASSESSMENT, { id });
+        return jsonResult(data.buiPublishAssessment);
+      } catch (error) {
+        ctx.logger.error("buildmyiq assessments_publish failed", { error: String(error) });
+        return errorResult(
+          `Failed to publish assessment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "questions_create")),
+    {
+      title: "Create Question",
+      description: "Add a question to an assessment. `options` and `answerKey` are JSON (e.g. choices array + correct-answer key); `points` weights grading.",
+      inputSchema: {
+        assessmentId: z.string().min(1).describe("Owning assessment ID"),
+        prompt: z.string().min(1).describe("Question prompt/text"),
+        type: QuestionTypeEnum.optional().describe("Question type (default SINGLE_CHOICE)"),
+        options: JsonValue.optional().describe("Answer options JSON (choices array/object)"),
+        answerKey: JsonValue.optional().describe("Correct-answer key JSON"),
+        points: z.number().optional().describe("Points the question is worth"),
+        position: z.number().int().optional().describe("Ordering position within the assessment"),
+        explanation: z.string().optional().describe("Post-answer explanation/rationale")
+      }
+    },
+    async ({ assessmentId, prompt, type, options, answerKey, points, position, explanation }) => {
+      try {
+        const input = { assessmentId, prompt };
+        if (type !== void 0) input.type = type;
+        if (options !== void 0) input.options = options;
+        if (answerKey !== void 0) input.answerKey = answerKey;
+        if (points !== void 0) input.points = points;
+        if (position !== void 0) input.position = position;
+        if (explanation !== void 0) input.explanation = explanation;
+        const data = await ctx.gql.workspace.request(CREATE_QUESTION, { input });
+        return jsonResult(data.buiCreateQuestion);
+      } catch (error) {
+        ctx.logger.error("buildmyiq questions_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create question: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerSubmissionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "submissions_list")),
+    {
+      title: "List Submissions",
+      description: "List assessment submissions, optionally filtered by assessment, learner, and/or status, with cursor/limit/offset pagination. Returns { items, pageInfo }.",
+      inputSchema: {
+        assessmentId: z.string().optional().describe("Filter by assessment ID"),
+        learnerId: z.string().optional().describe("Filter by learner user ID"),
+        status: SubmissionStatusEnum.optional().describe("Filter by submission status"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ assessmentId, learnerId, status, limit, offset, cursor }) => {
+      try {
+        const pagination = {};
+        if (limit !== void 0) pagination.limit = limit;
+        if (offset !== void 0) pagination.offset = offset;
+        if (cursor !== void 0) pagination.cursor = cursor;
+        const data = await ctx.gql.workspace.request(LIST_SUBMISSIONS, {
+          assessmentId,
+          learnerId,
+          status,
+          pagination: Object.keys(pagination).length > 0 ? pagination : void 0
+        });
+        return jsonResult(data.buiListSubmissions);
+      } catch (error) {
+        ctx.logger.error("buildmyiq submissions_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list submissions: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "submissions_submit")),
+    {
+      title: "Submit Assessment",
+      description: "Submit a learner\u2019s answers to an assessment. `answers` is JSON keyed by question. If `learnerId` is omitted the calling actor is used; `attempt` defaults to the next attempt number.",
+      inputSchema: {
+        assessmentId: z.string().min(1).describe("Assessment being submitted"),
+        answers: JsonValue.optional().describe("Answers JSON (keyed by question)"),
+        learnerId: z.string().optional().describe("Learner user ID (defaults to the caller)"),
+        enrollmentId: z.string().optional().describe("Source enrollment ID"),
+        attempt: z.number().int().optional().describe("Attempt number")
+      }
+    },
+    async ({ assessmentId, answers, learnerId, enrollmentId, attempt }) => {
+      try {
+        const input = { assessmentId };
+        if (answers !== void 0) input.answers = answers;
+        if (learnerId !== void 0) input.learnerId = learnerId;
+        if (enrollmentId !== void 0) input.enrollmentId = enrollmentId;
+        if (attempt !== void 0) input.attempt = attempt;
+        const data = await ctx.gql.workspace.request(SUBMIT_ASSESSMENT, { input });
+        return jsonResult(data.buiSubmitAssessment);
+      } catch (error) {
+        ctx.logger.error("buildmyiq submissions_submit failed", { error: String(error) });
+        return errorResult(
+          `Failed to submit assessment: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "submissions_grade")),
+    {
+      title: "Grade Submission",
+      description: "Grade a submission: record a score, an optional pass/fail flag, and optional feedback. Moves the submission to GRADED.",
+      inputSchema: {
+        id: z.string().describe("Submission ID"),
+        score: z.number().describe("Awarded score"),
+        passed: z.boolean().optional().describe("Whether the learner passed"),
+        feedback: z.string().optional().describe("Grader feedback")
+      }
+    },
+    async ({ id, score, passed, feedback }) => {
+      try {
+        const input = { score };
+        if (passed !== void 0) input.passed = passed;
+        if (feedback !== void 0) input.feedback = feedback;
+        const data = await ctx.gql.workspace.request(GRADE_SUBMISSION, { id, input });
+        return jsonResult(data.buiGradeSubmission);
+      } catch (error) {
+        ctx.logger.error("buildmyiq submissions_grade failed", { error: String(error) });
+        return errorResult(
+          `Failed to grade submission: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/buildmyiq/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "BuildMyIQ Health Check",
+      description: "Public liveness/identity probe for the BuildMyIQ subgraph (buiHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.buiHealth });
+      } catch (error) {
+        ctx.logger.error("buildmyiq health failed", { error: String(error) });
+        return errorResult(
+          `BuildMyIQ health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/buildmyiq/resources.ts
+function registerBuildmyiqResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const coursesUri = track(mcpResourceUri(ctx.productName, "courses"));
+  const skillsUri = track(mcpResourceUri(ctx.productName, "skills"));
+  const healthUri = track(mcpResourceUri(ctx.productName, "health"));
+  server.registerResource(
+    "buildmyiq-schema",
+    schemaUri,
+    {
+      title: "BuildMyIQ Domain Schema",
+      description: "Overview of the BuildMyIQ learning-platform domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# BuildMyIQ Domain (Overview)
+
+AI-native Education, Learning & Development platform \u2014 courses, learning,
+and assessment for schools, universities, and teams.
+
+## Entities
+- BuiCourse (+BuiCourseConnection) \u2014 a course (modules, lessons, skill, cover File)
+- BuiModule \u2014 a structural section of a course (has lessons)
+- BuiLesson \u2014 a learning unit (ARTICLE/VIDEO/QUIZ/... , media File)
+- BuiSkill \u2014 a competency a course maps to
+- BuiEnrollment (+BuiEnrollmentConnection) \u2014 a learner's enrollment (cohort, progress)
+- BuiLessonProgress \u2014 per-lesson progress within an enrollment
+- BuiCohort \u2014 a scheduled, facilitated group of a course
+- BuiCertificate \u2014 a completion certificate (rendered PDF File)
+- BuiAssessment \u2014 a quiz/exam/assignment (has questions)
+- BuiQuestion \u2014 a question within an assessment
+- BuiSubmission (+BuiSubmissionConnection) \u2014 a learner attempt + grading
+
+## Enums
+- BuiCourseLevel: BEGINNER, INTERMEDIATE, ADVANCED, EXPERT
+- BuiCourseStatus: DRAFT, IN_REVIEW, PUBLISHED, ARCHIVED
+- BuiSkillCategory: BUSINESS, COGNITIVE, CREATIVE, LANGUAGE, SOCIAL, TECHNICAL
+- BuiLessonType: ARTICLE, ASSIGNMENT, INTERACTIVE, LIVE_SESSION, QUIZ, VIDEO
+- BuiEnrollmentStatus: ENROLLED, IN_PROGRESS, COMPLETED, DROPPED, EXPIRED
+- BuiProgressStatus: NOT_STARTED, IN_PROGRESS, COMPLETED
+- BuiCohortStatus: SCHEDULED, ENROLLING, ACTIVE, COMPLETED, CANCELLED
+- BuiAssessmentType: ASSIGNMENT, EXAM, PRACTICAL, QUIZ, SURVEY
+- BuiAssessmentStatus: DRAFT, PUBLISHED, ARCHIVED
+- BuiQuestionType: CODE, ESSAY, MULTIPLE_CHOICE, SHORT_ANSWER, SINGLE_CHOICE, TRUE_FALSE
+- BuiSubmissionStatus: IN_PROGRESS, SUBMITTED, GRADING, GRADED, RETURNED
+
+## Tool groups
+courses, modules, lessons, skills, enrollments, cohorts, certificates,
+assessments (+questions), submissions, health.
+All run against the WORKSPACE gateway (workspace-scoped) except the public
+buiHealth probe.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "buildmyiq-courses",
+    coursesUri,
+    {
+      title: "BuildMyIQ Course Catalog",
+      description: "The first 50 courses in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${coursesUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_COURSES, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: coursesUri,
+              text: JSON.stringify(data.buiListCourses, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: coursesUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "buildmyiq-skills",
+    skillsUri,
+    {
+      title: "BuildMyIQ Skill Taxonomy",
+      description: "The skills/competencies defined in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${skillsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SKILLS, {});
+        return {
+          contents: [
+            {
+              uri: skillsUri,
+              text: JSON.stringify(data.buiListSkills, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: skillsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "buildmyiq-health",
+    healthUri,
+    {
+      title: "BuildMyIQ Health",
+      description: "Live liveness/identity probe for the BuildMyIQ subgraph (buiHealth).",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${healthUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return {
+          contents: [
+            {
+              uri: healthUri,
+              text: JSON.stringify({ ok: true, status: data.buiHealth }, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: healthUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerBuildmyiqPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const authoringName = track(mcpPromptName(p, "course-authoring"));
+  const opsName = track(mcpPromptName(p, "cohort-operations"));
+  server.registerPrompt(
+    authoringName,
+    {
+      title: "Course Authoring",
+      description: "Guide for authoring a BuildMyIQ course end to end: create the course, structure it into modules and lessons, add an assessment with questions, and publish.",
+      argsSchema: {
+        title: z.string().optional().describe("Course title"),
+        level: z.string().optional().describe("Course level (BEGINNER/INTERMEDIATE/ADVANCED/EXPERT)")
+      }
+    },
+    ({ title, level }) => {
+      ctx.logger.debug(`Prompt ${authoringName} called`, { title, level });
+      const titleNote = title ? `Use the title "${title}".` : "Ask the user for the course title.";
+      const levelNote = level ? `Use level ${level}.` : "Help the user pick a BuiCourseLevel.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me author a new BuildMyIQ course.
+
+1. **Create Course**: Use ${p}_courses_create. ${titleNote} ${levelNote} Provide a unique slug; optionally link a skill (${p}_skills_list / ${p}_skills_create) and a cover File.
+2. **Structure**: Use ${p}_modules_create to add sections, then ${p}_lessons_create for each lesson (set type=ARTICLE/VIDEO/QUIZ/... and position).
+3. **Assess**: Use ${p}_assessments_create to add a quiz/exam, then ${p}_questions_create for each question. Publish it with ${p}_assessments_publish.
+4. **Review Structure**: Use ${p}_courses_get to verify modules + lessons, and ${p}_assessments_list for the course.
+5. **Publish**: Use ${p}_courses_publish to move the course through DRAFT \u2192 IN_REVIEW \u2192 PUBLISHED.
+
+Show results at each step and confirm before publishing.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    opsName,
+    {
+      title: "Cohort Operations",
+      description: "Operations workflow for running a course cohort: enroll learners, track progress, grade submissions, and issue certificates.",
+      argsSchema: {
+        courseId: z.string().optional().describe("Course ID to operate")
+      }
+    },
+    ({ courseId }) => {
+      ctx.logger.debug(`Prompt ${opsName} called`, { courseId });
+      const courseNote = courseId ? `Operate course "${courseId}".` : `First list courses with ${p}_courses_list and pick one.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run BuildMyIQ cohort operations. ${courseNote}
+
+1. **Cohort**: Use ${p}_cohorts_list (or ${p}_cohorts_create) to find/open a cohort for the course.
+2. **Enroll**: Use ${p}_enrollments_enroll for each learner (optionally within the cohort).
+3. **Progress**: Use ${p}_enrollments_list filtered by courseId/status to see who is IN_PROGRESS vs COMPLETED; drill in with ${p}_enrollments_get.
+4. **Grade**: Use ${p}_submissions_list filtered by status=SUBMITTED, then ${p}_submissions_grade (score, passed, feedback) for each.
+5. **Advance**: Use ${p}_enrollments_transition to mark finished learners COMPLETED.
+6. **Certify**: For passing learners use ${p}_certificates_issue (unique serial), and ${p}_certificates_list to confirm.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/buildmyiq/index.ts
+var buildmyiqModule = {
+  id: "buildmyiq",
+  version: "0.0.1",
+  displayName: "BuildMyIQ",
+  dependsOn: ["auth"],
+  capabilities: { tools: {}, resources: {}, prompts: {} },
+  register(server, ctx) {
+    const tools = [];
+    const resources = [];
+    const prompts = [];
+    const trackTool = (n) => {
+      tools.push(n);
+      return n;
+    };
+    const trackResource = (uri) => {
+      resources.push(uri);
+      return uri;
+    };
+    const trackPrompt = (n) => {
+      prompts.push(n);
+      return n;
+    };
+    registerCourseTools(server, ctx, trackTool);
+    registerModuleTools(server, ctx, trackTool);
+    registerLessonTools(server, ctx, trackTool);
+    registerSkillTools(server, ctx, trackTool);
+    registerEnrollmentTools(server, ctx, trackTool);
+    registerCohortTools(server, ctx, trackTool);
+    registerCertificateTools(server, ctx, trackTool);
+    registerAssessmentTools(server, ctx, trackTool);
+    registerSubmissionTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerBuildmyiqResources(server, ctx, trackResource);
+    registerBuildmyiqPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var buildmyiq_default = buildmyiqModule;
+
+export { buildmyiq_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map