@burdenoff/mcp-libs 2026.627.3 → 2026.627.5

package/dist/modules/technospam/index.js

@@ -0,0 +1,1901 @@
+import { mcpToolName, errorResult, jsonResult, mcpResourceUri, mcpPromptName } from '../../chunk-H2OYWLOA.js';
+import { z } from 'zod';
+
+// src/modules/technospam/operations.ts
+var COURSE_FIELDS = `
+  id slug title summary topic level status estimatedMinutes instructorId
+  tags publishedAt workspaceId createdAt updatedAt
+  cover { id }
+`;
+var LESSON_FIELDS = `
+  id courseId title kind content position estimatedMinutes isPreview
+  file { id } workspaceId createdAt updatedAt
+`;
+var ENROLLMENT_FIELDS = `
+  id courseId learnerId status progressPct lessonsCompleted
+  startedAt lastActiveAt completedAt workspaceId createdAt updatedAt
+`;
+var CERTIFICATE_FIELDS = `
+  id courseId learnerId serial score status issuedAt revokedAt revokeReason
+  workspaceId createdAt updatedAt
+`;
+var PROBLEM_FIELDS = `
+  id slug title statement topic difficulty status points languages tags
+  publishedAt workspaceId createdAt updatedAt
+`;
+var SUBMISSION_FIELDS = `
+  id problemId learnerId code language verdict pointsAwarded runtimeMs
+  judgedAt workspaceId createdAt updatedAt
+`;
+var MENTOR_FIELDS = `
+  id userId headline bio expertise hourlyRate currency status
+  isAcceptingMentees ratingAvg sessionsCount workspaceId createdAt updatedAt
+`;
+var SESSION_FIELDS = `
+  id mentorId menteeId topic agenda status scheduledAt durationMinutes
+  meetingUrl rating feedback cancelledAt completedAt workspaceId createdAt updatedAt
+`;
+var HACKATHON_FIELDS = `
+  id slug title theme description status startAt endAt submissionDeadline
+  prizePool currency maxTeamSize tags workspaceId createdAt updatedAt
+`;
+var TEAM_FIELDS = `
+  id hackathonId name captainId memberIds status score projectName projectUrl
+  repoUrl pitch submittedAt workspaceId createdAt updatedAt
+`;
+var PAGE_INFO_FIELDS = `cursor hasMore`;
+var GET_COURSE = `
+  query TechnospamGetCourse($id: ID!) {
+    tecCourse(id: $id) {
+      ${COURSE_FIELDS}
+      lessons { ${LESSON_FIELDS} }
+      enrollments { ${ENROLLMENT_FIELDS} }
+    }
+  }
+`;
+var LIST_COURSES = `
+  query TechnospamListCourses(
+    $level: TecCourseLevel
+    $status: TecCourseStatus
+    $pagination: PaginationInput
+  ) {
+    tecListCourses(level: $level, status: $status, pagination: $pagination) {
+      items { ${COURSE_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var CREATE_COURSE = `
+  mutation TechnospamCreateCourse($input: TecCreateCourseInput!) {
+    tecCreateCourse(input: $input) {
+      ${COURSE_FIELDS}
+    }
+  }
+`;
+var UPDATE_COURSE = `
+  mutation TechnospamUpdateCourse($id: ID!, $input: TecUpdateCourseInput!) {
+    tecUpdateCourse(id: $id, input: $input) {
+      ${COURSE_FIELDS}
+    }
+  }
+`;
+var PUBLISH_COURSE = `
+  mutation TechnospamPublishCourse($id: ID!) {
+    tecPublishCourse(id: $id) {
+      ${COURSE_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_COURSE = `
+  mutation TechnospamArchiveCourse($id: ID!) {
+    tecArchiveCourse(id: $id)
+  }
+`;
+var LIST_LESSONS = `
+  query TechnospamListLessons($courseId: ID!) {
+    tecListLessons(courseId: $courseId) {
+      ${LESSON_FIELDS}
+    }
+  }
+`;
+var CREATE_LESSON = `
+  mutation TechnospamCreateLesson($input: TecCreateLessonInput!) {
+    tecCreateLesson(input: $input) {
+      ${LESSON_FIELDS}
+    }
+  }
+`;
+var UPDATE_LESSON = `
+  mutation TechnospamUpdateLesson($id: ID!, $input: TecUpdateLessonInput!) {
+    tecUpdateLesson(id: $id, input: $input) {
+      ${LESSON_FIELDS}
+    }
+  }
+`;
+var LIST_ENROLLMENTS = `
+  query TechnospamListEnrollments(
+    $courseId: ID
+    $learnerId: ID
+    $pagination: PaginationInput
+  ) {
+    tecListEnrollments(courseId: $courseId, learnerId: $learnerId, pagination: $pagination) {
+      items { ${ENROLLMENT_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var ENROLL = `
+  mutation TechnospamEnroll($input: TecEnrollInput!) {
+    tecEnroll(input: $input) {
+      ${ENROLLMENT_FIELDS}
+    }
+  }
+`;
+var UPDATE_PROGRESS = `
+  mutation TechnospamUpdateProgress($input: TecUpdateProgressInput!) {
+    tecUpdateProgress(input: $input) {
+      ${ENROLLMENT_FIELDS}
+    }
+  }
+`;
+var LIST_CERTIFICATES = `
+  query TechnospamListCertificates($courseId: ID, $learnerId: ID) {
+    tecListCertificates(courseId: $courseId, learnerId: $learnerId) {
+      ${CERTIFICATE_FIELDS}
+    }
+  }
+`;
+var ISSUE_CERTIFICATE = `
+  mutation TechnospamIssueCertificate($courseId: ID!, $learnerId: ID!, $score: Int!) {
+    tecIssueCertificate(courseId: $courseId, learnerId: $learnerId, score: $score) {
+      ${CERTIFICATE_FIELDS}
+    }
+  }
+`;
+var REVOKE_CERTIFICATE = `
+  mutation TechnospamRevokeCertificate($id: ID!, $reason: String) {
+    tecRevokeCertificate(id: $id, reason: $reason) {
+      ${CERTIFICATE_FIELDS}
+    }
+  }
+`;
+var GET_PROBLEM = `
+  query TechnospamGetProblem($id: ID!) {
+    tecProblem(id: $id) {
+      ${PROBLEM_FIELDS}
+      submissions { ${SUBMISSION_FIELDS} }
+    }
+  }
+`;
+var LIST_PROBLEMS = `
+  query TechnospamListProblems(
+    $difficulty: TecProblemDifficulty
+    $status: TecProblemStatus
+    $topic: String
+    $pagination: PaginationInput
+  ) {
+    tecListProblems(
+      difficulty: $difficulty
+      status: $status
+      topic: $topic
+      pagination: $pagination
+    ) {
+      items { ${PROBLEM_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var CREATE_PROBLEM = `
+  mutation TechnospamCreateProblem($input: TecCreateProblemInput!) {
+    tecCreateProblem(input: $input) {
+      ${PROBLEM_FIELDS}
+    }
+  }
+`;
+var UPDATE_PROBLEM = `
+  mutation TechnospamUpdateProblem($id: ID!, $input: TecUpdateProblemInput!) {
+    tecUpdateProblem(id: $id, input: $input) {
+      ${PROBLEM_FIELDS}
+    }
+  }
+`;
+var PUBLISH_PROBLEM = `
+  mutation TechnospamPublishProblem($id: ID!) {
+    tecPublishProblem(id: $id) {
+      ${PROBLEM_FIELDS}
+    }
+  }
+`;
+var LIST_SUBMISSIONS = `
+  query TechnospamListSubmissions(
+    $learnerId: ID
+    $problemId: ID
+    $pagination: PaginationInput
+  ) {
+    tecListSubmissions(learnerId: $learnerId, problemId: $problemId, pagination: $pagination) {
+      items { ${SUBMISSION_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var SUBMIT_SOLUTION = `
+  mutation TechnospamSubmitSolution($input: TecSubmitSolutionInput!) {
+    tecSubmitSolution(input: $input) {
+      ${SUBMISSION_FIELDS}
+    }
+  }
+`;
+var GRADE_SUBMISSION = `
+  mutation TechnospamGradeSubmission(
+    $id: ID!
+    $verdict: TecSubmissionVerdict!
+    $runtimeMs: Int
+  ) {
+    tecGradeSubmission(id: $id, verdict: $verdict, runtimeMs: $runtimeMs) {
+      ${SUBMISSION_FIELDS}
+    }
+  }
+`;
+var GET_MENTOR = `
+  query TechnospamGetMentor($id: ID!) {
+    tecMentor(id: $id) {
+      ${MENTOR_FIELDS}
+      sessions { ${SESSION_FIELDS} }
+    }
+  }
+`;
+var LIST_MENTORS = `
+  query TechnospamListMentors($status: TecMentorStatus, $pagination: PaginationInput) {
+    tecListMentors(status: $status, pagination: $pagination) {
+      items { ${MENTOR_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var BECOME_MENTOR = `
+  mutation TechnospamBecomeMentor($input: TecCreateMentorInput!) {
+    tecBecomeMentor(input: $input) {
+      ${MENTOR_FIELDS}
+    }
+  }
+`;
+var UPDATE_MENTOR = `
+  mutation TechnospamUpdateMentor($id: ID!, $input: TecUpdateMentorInput!) {
+    tecUpdateMentor(id: $id, input: $input) {
+      ${MENTOR_FIELDS}
+    }
+  }
+`;
+var APPROVE_MENTOR = `
+  mutation TechnospamApproveMentor($id: ID!) {
+    tecApproveMentor(id: $id) {
+      ${MENTOR_FIELDS}
+    }
+  }
+`;
+var LIST_SESSIONS = `
+  query TechnospamListSessions($mentorId: ID, $menteeId: ID, $status: TecSessionStatus) {
+    tecListSessions(mentorId: $mentorId, menteeId: $menteeId, status: $status) {
+      ${SESSION_FIELDS}
+    }
+  }
+`;
+var BOOK_SESSION = `
+  mutation TechnospamBookSession($input: TecBookSessionInput!) {
+    tecBookSession(input: $input) {
+      ${SESSION_FIELDS}
+    }
+  }
+`;
+var CONFIRM_SESSION = `
+  mutation TechnospamConfirmSession($id: ID!, $meetingUrl: String) {
+    tecConfirmSession(id: $id, meetingUrl: $meetingUrl) {
+      ${SESSION_FIELDS}
+    }
+  }
+`;
+var CANCEL_SESSION = `
+  mutation TechnospamCancelSession($id: ID!) {
+    tecCancelSession(id: $id) {
+      ${SESSION_FIELDS}
+    }
+  }
+`;
+var COMPLETE_SESSION = `
+  mutation TechnospamCompleteSession($id: ID!, $rating: Int, $feedback: String) {
+    tecCompleteSession(id: $id, rating: $rating, feedback: $feedback) {
+      ${SESSION_FIELDS}
+    }
+  }
+`;
+var GET_HACKATHON = `
+  query TechnospamGetHackathon($id: ID!) {
+    tecHackathon(id: $id) {
+      ${HACKATHON_FIELDS}
+      teams { ${TEAM_FIELDS} }
+    }
+  }
+`;
+var LIST_HACKATHONS = `
+  query TechnospamListHackathons($status: TecHackathonStatus, $pagination: PaginationInput) {
+    tecListHackathons(status: $status, pagination: $pagination) {
+      items { ${HACKATHON_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var CREATE_HACKATHON = `
+  mutation TechnospamCreateHackathon($input: TecCreateHackathonInput!) {
+    tecCreateHackathon(input: $input) {
+      ${HACKATHON_FIELDS}
+    }
+  }
+`;
+var UPDATE_HACKATHON = `
+  mutation TechnospamUpdateHackathon($id: ID!, $input: TecUpdateHackathonInput!) {
+    tecUpdateHackathon(id: $id, input: $input) {
+      ${HACKATHON_FIELDS}
+    }
+  }
+`;
+var OPEN_REGISTRATION = `
+  mutation TechnospamOpenRegistration($id: ID!) {
+    tecOpenRegistration(id: $id) {
+      ${HACKATHON_FIELDS}
+    }
+  }
+`;
+var LIST_TEAMS = `
+  query TechnospamListTeams($hackathonId: ID!) {
+    tecListTeams(hackathonId: $hackathonId) {
+      ${TEAM_FIELDS}
+    }
+  }
+`;
+var REGISTER_TEAM = `
+  mutation TechnospamRegisterTeam($input: TecRegisterTeamInput!) {
+    tecRegisterTeam(input: $input) {
+      ${TEAM_FIELDS}
+    }
+  }
+`;
+var SUBMIT_PROJECT = `
+  mutation TechnospamSubmitProject($input: TecSubmitProjectInput!) {
+    tecSubmitProject(input: $input) {
+      ${TEAM_FIELDS}
+    }
+  }
+`;
+var SCORE_TEAM = `
+  mutation TechnospamScoreTeam($id: ID!, $score: Int!, $winner: Boolean) {
+    tecScoreTeam(id: $id, score: $score, winner: $winner) {
+      ${TEAM_FIELDS}
+    }
+  }
+`;
+var HEALTH = `
+  query TechnospamHealth {
+    tecHealth
+  }
+`;
+var CourseLevelEnum = z.enum(["ADVANCED", "BEGINNER", "EXPERT", "INTERMEDIATE"]).describe("Difficulty level of a course");
+var CourseStatusEnum = z.enum(["ARCHIVED", "DRAFT", "PUBLISHED"]).describe("Lifecycle status of a course");
+var LessonKindEnum = z.enum(["ARTICLE", "INTERACTIVE", "PROJECT", "QUIZ", "VIDEO"]).describe("Content type of a lesson");
+z.enum(["COMPLETED", "DROPPED", "ENROLLED", "IN_PROGRESS"]).describe("Lifecycle status of a learner enrollment");
+var ProblemDifficultyEnum = z.enum(["EASY", "HARD", "MEDIUM"]).describe("Difficulty of a practice problem");
+var ProblemStatusEnum = z.enum(["ARCHIVED", "DRAFT", "PUBLISHED"]).describe("Lifecycle status of a practice problem");
+var SubmissionVerdictEnum = z.enum([
+  "ACCEPTED",
+  "COMPILE_ERROR",
+  "PENDING",
+  "RUNTIME_ERROR",
+  "TIME_LIMIT_EXCEEDED",
+  "WRONG_ANSWER"
+]).describe("Grader verdict for a submission");
+var MentorStatusEnum = z.enum(["ACTIVE", "INACTIVE", "PAUSED", "PENDING"]).describe("Lifecycle/moderation status of a mentor profile");
+var SessionStatusEnum = z.enum(["CANCELLED", "COMPLETED", "CONFIRMED", "NO_SHOW", "REQUESTED"]).describe("Status of a 1:1 mentor session");
+var HackathonStatusEnum = z.enum(["CANCELLED", "COMPLETED", "DRAFT", "IN_PROGRESS", "JUDGING", "REGISTRATION_OPEN"]).describe("Lifecycle status of a hackathon");
+function buildPagination(limit, offset, cursor) {
+  const pagination = {};
+  if (limit !== void 0) pagination.limit = limit;
+  if (offset !== void 0) pagination.offset = offset;
+  if (cursor !== void 0) pagination.cursor = cursor;
+  return Object.keys(pagination).length > 0 ? pagination : void 0;
+}
+
+// src/modules/technospam/tools/courses.ts
+function registerCourseTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "courses_get")),
+    {
+      title: "Get Course",
+      description: "Fetch a single Technospam course by ID, including its lessons and enrollments.",
+      inputSchema: { id: z.string().describe("Course ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_COURSE, { id });
+        if (!data.tecCourse) return errorResult(`Course ${id} not found`);
+        return jsonResult(data.tecCourse);
+      } catch (error) {
+        ctx.logger.error("technospam 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 pagination. Returns { items, pageInfo }.",
+      inputSchema: {
+        level: CourseLevelEnum.optional().describe("Filter by difficulty level"),
+        status: CourseStatusEnum.optional().describe("Filter by 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 data = await ctx.gql.workspace.request(LIST_COURSES, {
+          level,
+          status,
+          pagination: buildPagination(limit, offset, cursor)
+        });
+        return jsonResult(data.tecListCourses);
+      } catch (error) {
+        ctx.logger.error("technospam 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 course (DRAFT). `slug` must be unique within the workspace; `title` is required. Defaults level to BEGINNER.",
+      inputSchema: {
+        slug: z.string().min(1).describe("URL slug, unique within the workspace"),
+        title: z.string().min(1).describe("Course title"),
+        summary: z.string().optional().describe("Short course summary"),
+        topic: z.string().optional().describe("Primary topic/subject"),
+        level: CourseLevelEnum.optional().describe("Difficulty level (default BEGINNER)"),
+        estimatedMinutes: z.number().int().optional().describe("Estimated total completion time in minutes"),
+        instructorId: z.string().optional().describe("User ID of the instructor"),
+        coverFileId: z.string().optional().describe("wspace-files File ID for the cover image"),
+        tags: z.array(z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({
+      slug,
+      title,
+      summary,
+      topic,
+      level,
+      estimatedMinutes,
+      instructorId,
+      coverFileId,
+      tags
+    }) => {
+      try {
+        const input = { slug, title };
+        if (summary !== void 0) input.summary = summary;
+        if (topic !== void 0) input.topic = topic;
+        if (level !== void 0) input.level = level;
+        if (estimatedMinutes !== void 0) input.estimatedMinutes = estimatedMinutes;
+        if (instructorId !== void 0) input.instructorId = instructorId;
+        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.tecCreateCourse);
+      } catch (error) {
+        ctx.logger.error("technospam 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.",
+      inputSchema: {
+        id: z.string().describe("Course ID"),
+        title: z.string().optional().describe("Updated title"),
+        summary: z.string().optional().describe("Updated summary"),
+        topic: z.string().optional().describe("Updated topic"),
+        level: CourseLevelEnum.optional().describe("Updated difficulty level"),
+        estimatedMinutes: z.number().int().optional().describe("Updated estimated minutes"),
+        instructorId: z.string().optional().describe("Updated instructor user ID"),
+        coverFileId: z.string().optional().describe("Updated cover File ID"),
+        tags: z.array(z.string()).optional().describe("Updated discovery tags")
+      }
+    },
+    async ({
+      id,
+      title,
+      summary,
+      topic,
+      level,
+      estimatedMinutes,
+      instructorId,
+      coverFileId,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (summary !== void 0) input.summary = summary;
+        if (topic !== void 0) input.topic = topic;
+        if (level !== void 0) input.level = level;
+        if (estimatedMinutes !== void 0) input.estimatedMinutes = estimatedMinutes;
+        if (instructorId !== void 0) input.instructorId = instructorId;
+        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.tecUpdateCourse);
+      } catch (error) {
+        ctx.logger.error("technospam 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 (DRAFT -> PUBLISHED), making it visible to learners.",
+      inputSchema: { id: z.string().describe("Course ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PUBLISH_COURSE, { id });
+        return jsonResult(data.tecPublishCourse);
+      } catch (error) {
+        ctx.logger.error("technospam 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 (-> ARCHIVED). 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.tecArchiveCourse });
+      } catch (error) {
+        ctx.logger.error("technospam courses_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive course: ${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 all lessons for a course, ordered by position.",
+      inputSchema: { courseId: z.string().describe("Course ID") }
+    },
+    async ({ courseId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_LESSONS, { courseId });
+        return jsonResult(data.tecListLessons);
+      } catch (error) {
+        ctx.logger.error("technospam 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. Defaults kind to ARTICLE and isPreview to false. Use `fileId` to attach a video/file from wspace-files.",
+      inputSchema: {
+        courseId: z.string().min(1).describe("Owning course ID"),
+        title: z.string().min(1).describe("Lesson title"),
+        kind: LessonKindEnum.optional().describe("Lesson content type (default ARTICLE)"),
+        content: z.string().optional().describe("Lesson body / article content"),
+        position: z.number().int().optional().describe("Ordering position within the course"),
+        estimatedMinutes: z.number().int().optional().describe("Estimated completion time"),
+        isPreview: z.boolean().optional().describe("Free preview lesson (default false)"),
+        fileId: z.string().optional().describe("wspace-files File ID (video/attachment)")
+      }
+    },
+    async ({ courseId, title, kind, content, position, estimatedMinutes, isPreview, fileId }) => {
+      try {
+        const input = { courseId, title };
+        if (kind !== void 0) input.kind = kind;
+        if (content !== void 0) input.content = content;
+        if (position !== void 0) input.position = position;
+        if (estimatedMinutes !== void 0) input.estimatedMinutes = estimatedMinutes;
+        if (isPreview !== void 0) input.isPreview = isPreview;
+        if (fileId !== void 0) input.fileId = fileId;
+        const data = await ctx.gql.workspace.request(CREATE_LESSON, { input });
+        return jsonResult(data.tecCreateLesson);
+      } catch (error) {
+        ctx.logger.error("technospam lessons_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create lesson: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "lessons_update")),
+    {
+      title: "Update Lesson",
+      description: "Update a lesson. At least one mutable field must be provided.",
+      inputSchema: {
+        id: z.string().describe("Lesson ID"),
+        title: z.string().optional().describe("Updated title"),
+        kind: LessonKindEnum.optional().describe("Updated content type"),
+        content: z.string().optional().describe("Updated body content"),
+        position: z.number().int().optional().describe("Updated ordering position"),
+        estimatedMinutes: z.number().int().optional().describe("Updated estimated minutes"),
+        isPreview: z.boolean().optional().describe("Toggle free-preview flag"),
+        fileId: z.string().optional().describe("Updated attached File ID")
+      }
+    },
+    async ({ id, title, kind, content, position, estimatedMinutes, isPreview, fileId }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (kind !== void 0) input.kind = kind;
+        if (content !== void 0) input.content = content;
+        if (position !== void 0) input.position = position;
+        if (estimatedMinutes !== void 0) input.estimatedMinutes = estimatedMinutes;
+        if (isPreview !== void 0) input.isPreview = isPreview;
+        if (fileId !== void 0) input.fileId = fileId;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable lesson field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_LESSON, { id, input });
+        return jsonResult(data.tecUpdateLesson);
+      } catch (error) {
+        ctx.logger.error("technospam lessons_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update lesson: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerEnrollmentTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "enrollments_list")),
+    {
+      title: "List Enrollments",
+      description: "List enrollments, optionally filtered by course and/or learner, with pagination. Returns { items, pageInfo }.",
+      inputSchema: {
+        courseId: z.string().optional().describe("Filter by course ID"),
+        learnerId: z.string().optional().describe("Filter by learner (user) ID"),
+        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, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_ENROLLMENTS, {
+          courseId,
+          learnerId,
+          pagination: buildPagination(limit, offset, cursor)
+        });
+        return jsonResult(data.tecListEnrollments);
+      } catch (error) {
+        ctx.logger.error("technospam 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 In Course",
+      description: "Enroll the calling user in a course. The learner identity comes from the gateway-issued actor \u2014 only courseId is supplied.",
+      inputSchema: { courseId: z.string().min(1).describe("Course ID to enroll in") }
+    },
+    async ({ courseId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(ENROLL, { input: { courseId } });
+        return jsonResult(data.tecEnroll);
+      } catch (error) {
+        ctx.logger.error("technospam 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_update_progress")),
+    {
+      title: "Update Enrollment Progress",
+      description: "Update a learner's enrollment progress. Auto-completes the enrollment at progressPct 100.",
+      inputSchema: {
+        enrollmentId: z.string().min(1).describe("Enrollment ID"),
+        progressPct: z.number().int().min(0).max(100).describe("Progress percentage (0-100)"),
+        lessonsCompleted: z.number().int().optional().describe("Count of lessons completed")
+      }
+    },
+    async ({ enrollmentId, progressPct, lessonsCompleted }) => {
+      try {
+        const input = { enrollmentId, progressPct };
+        if (lessonsCompleted !== void 0) input.lessonsCompleted = lessonsCompleted;
+        const data = await ctx.gql.workspace.request(UPDATE_PROGRESS, { input });
+        return jsonResult(data.tecUpdateProgress);
+      } catch (error) {
+        ctx.logger.error("technospam enrollments_update_progress failed", { error: String(error) });
+        return errorResult(
+          `Failed to update progress: ${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.tecListCertificates);
+      } catch (error) {
+        ctx.logger.error("technospam 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 verifiable completion certificate for a learner on a course, with a score.",
+      inputSchema: {
+        courseId: z.string().min(1).describe("Course ID"),
+        learnerId: z.string().min(1).describe("Learner (user) ID"),
+        score: z.number().int().min(0).max(100).describe("Final score (0-100)")
+      }
+    },
+    async ({ courseId, learnerId, score }) => {
+      try {
+        const data = await ctx.gql.workspace.request(ISSUE_CERTIFICATE, { courseId, learnerId, score });
+        return jsonResult(data.tecIssueCertificate);
+      } catch (error) {
+        ctx.logger.error("technospam 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, with an optional reason.",
+      inputSchema: {
+        id: z.string().describe("Certificate ID"),
+        reason: z.string().optional().describe("Reason for revocation")
+      }
+    },
+    async ({ id, reason }) => {
+      try {
+        const data = await ctx.gql.workspace.request(REVOKE_CERTIFICATE, { id, reason });
+        return jsonResult(data.tecRevokeCertificate);
+      } catch (error) {
+        ctx.logger.error("technospam certificates_revoke failed", { error: String(error) });
+        return errorResult(
+          `Failed to revoke certificate: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerProblemTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "problems_get")),
+    {
+      title: "Get Problem",
+      description: "Fetch a single practice problem by ID, including its submissions.",
+      inputSchema: { id: z.string().describe("Problem ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PROBLEM, { id });
+        if (!data.tecProblem) return errorResult(`Problem ${id} not found`);
+        return jsonResult(data.tecProblem);
+      } catch (error) {
+        ctx.logger.error("technospam problems_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get problem: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "problems_list")),
+    {
+      title: "List Problems",
+      description: "List practice problems with optional difficulty/status/topic filters and pagination. Returns { items, pageInfo }.",
+      inputSchema: {
+        difficulty: ProblemDifficultyEnum.optional().describe("Filter by difficulty"),
+        status: ProblemStatusEnum.optional().describe("Filter by lifecycle status"),
+        topic: z.string().optional().describe("Filter by topic"),
+        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 ({ difficulty, status, topic, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PROBLEMS, {
+          difficulty,
+          status,
+          topic,
+          pagination: buildPagination(limit, offset, cursor)
+        });
+        return jsonResult(data.tecListProblems);
+      } catch (error) {
+        ctx.logger.error("technospam problems_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list problems: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "problems_create")),
+    {
+      title: "Create Problem",
+      description: "Create a practice problem (DRAFT). `slug` is unique within the workspace; `title` is required. Defaults difficulty to EASY.",
+      inputSchema: {
+        slug: z.string().min(1).describe("URL slug, unique within the workspace"),
+        title: z.string().min(1).describe("Problem title"),
+        statement: z.string().optional().describe("Problem statement / description"),
+        topic: z.string().optional().describe("Topic/tag area"),
+        difficulty: ProblemDifficultyEnum.optional().describe("Difficulty (default EASY)"),
+        points: z.number().int().optional().describe("Points awarded on acceptance"),
+        languages: z.array(z.string()).optional().describe("Allowed languages"),
+        starterCode: z.string().optional().describe("Starter code template"),
+        tags: z.array(z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({ slug, title, statement, topic, difficulty, points, languages, starterCode, tags }) => {
+      try {
+        const input = { slug, title };
+        if (statement !== void 0) input.statement = statement;
+        if (topic !== void 0) input.topic = topic;
+        if (difficulty !== void 0) input.difficulty = difficulty;
+        if (points !== void 0) input.points = points;
+        if (languages !== void 0) input.languages = languages;
+        if (starterCode !== void 0) input.starterCode = starterCode;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_PROBLEM, { input });
+        return jsonResult(data.tecCreateProblem);
+      } catch (error) {
+        ctx.logger.error("technospam problems_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create problem: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "problems_update")),
+    {
+      title: "Update Problem",
+      description: "Update a practice problem. At least one mutable field must be provided.",
+      inputSchema: {
+        id: z.string().describe("Problem ID"),
+        title: z.string().optional().describe("Updated title"),
+        statement: z.string().optional().describe("Updated statement"),
+        topic: z.string().optional().describe("Updated topic"),
+        difficulty: ProblemDifficultyEnum.optional().describe("Updated difficulty"),
+        points: z.number().int().optional().describe("Updated points"),
+        languages: z.array(z.string()).optional().describe("Updated allowed languages"),
+        starterCode: z.string().optional().describe("Updated starter code"),
+        tags: z.array(z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({ id, title, statement, topic, difficulty, points, languages, starterCode, tags }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (statement !== void 0) input.statement = statement;
+        if (topic !== void 0) input.topic = topic;
+        if (difficulty !== void 0) input.difficulty = difficulty;
+        if (points !== void 0) input.points = points;
+        if (languages !== void 0) input.languages = languages;
+        if (starterCode !== void 0) input.starterCode = starterCode;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable problem field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_PROBLEM, { id, input });
+        return jsonResult(data.tecUpdateProblem);
+      } catch (error) {
+        ctx.logger.error("technospam problems_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update problem: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "problems_publish")),
+    {
+      title: "Publish Problem",
+      description: "Publish a practice problem (DRAFT -> PUBLISHED).",
+      inputSchema: { id: z.string().describe("Problem ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(PUBLISH_PROBLEM, { id });
+        return jsonResult(data.tecPublishProblem);
+      } catch (error) {
+        ctx.logger.error("technospam problems_publish failed", { error: String(error) });
+        return errorResult(
+          `Failed to publish problem: ${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 problem submissions, optionally filtered by learner and/or problem, with pagination. Returns { items, pageInfo }.",
+      inputSchema: {
+        learnerId: z.string().optional().describe("Filter by learner (user) ID"),
+        problemId: z.string().optional().describe("Filter by problem ID"),
+        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 ({ learnerId, problemId, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SUBMISSIONS, {
+          learnerId,
+          problemId,
+          pagination: buildPagination(limit, offset, cursor)
+        });
+        return jsonResult(data.tecListSubmissions);
+      } catch (error) {
+        ctx.logger.error("technospam 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 Solution",
+      description: "Submit a solution to a problem. Created PENDING then graded into a verdict. The learner identity comes from the gateway-issued actor.",
+      inputSchema: {
+        problemId: z.string().min(1).describe("Problem ID"),
+        language: z.string().min(1).describe("Solution language"),
+        code: z.string().min(1).describe("Solution source code")
+      }
+    },
+    async ({ problemId, language, code }) => {
+      try {
+        const data = await ctx.gql.workspace.request(SUBMIT_SOLUTION, { input: { problemId, language, code } });
+        return jsonResult(data.tecSubmitSolution);
+      } catch (error) {
+        ctx.logger.error("technospam submissions_submit failed", { error: String(error) });
+        return errorResult(
+          `Failed to submit solution: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "submissions_grade")),
+    {
+      title: "Grade Submission",
+      description: "Record the grader verdict for a submission (awards points if ACCEPTED). Optionally record runtimeMs.",
+      inputSchema: {
+        id: z.string().describe("Submission ID"),
+        verdict: SubmissionVerdictEnum.describe("Grader verdict"),
+        runtimeMs: z.number().int().optional().describe("Execution runtime in milliseconds")
+      }
+    },
+    async ({ id, verdict, runtimeMs }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GRADE_SUBMISSION, { id, verdict, runtimeMs });
+        return jsonResult(data.tecGradeSubmission);
+      } catch (error) {
+        ctx.logger.error("technospam submissions_grade failed", { error: String(error) });
+        return errorResult(
+          `Failed to grade submission: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerMentorTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "mentors_get")),
+    {
+      title: "Get Mentor",
+      description: "Fetch a single mentor profile by ID, including its sessions.",
+      inputSchema: { id: z.string().describe("Mentor ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_MENTOR, { id });
+        if (!data.tecMentor) return errorResult(`Mentor ${id} not found`);
+        return jsonResult(data.tecMentor);
+      } catch (error) {
+        ctx.logger.error("technospam mentors_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get mentor: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "mentors_list")),
+    {
+      title: "List Mentors",
+      description: "List mentor profiles with optional status filter and pagination. Returns { items, pageInfo }.",
+      inputSchema: {
+        status: MentorStatusEnum.optional().describe("Filter by 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 ({ status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MENTORS, {
+          status,
+          pagination: buildPagination(limit, offset, cursor)
+        });
+        return jsonResult(data.tecListMentors);
+      } catch (error) {
+        ctx.logger.error("technospam mentors_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list mentors: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "mentors_become")),
+    {
+      title: "Become Mentor",
+      description: "Create the calling user's mentor profile (one per user per workspace). Starts PENDING until approved.",
+      inputSchema: {
+        headline: z.string().min(1).describe("Short professional headline"),
+        bio: z.string().optional().describe("Longer mentor bio"),
+        expertise: z.array(z.string()).optional().describe("Areas of expertise"),
+        hourlyRate: z.number().int().optional().describe("Hourly rate (minor units / whole)"),
+        currency: z.string().optional().describe("Currency code for the hourly rate")
+      }
+    },
+    async ({ headline, bio, expertise, hourlyRate, currency }) => {
+      try {
+        const input = { headline };
+        if (bio !== void 0) input.bio = bio;
+        if (expertise !== void 0) input.expertise = expertise;
+        if (hourlyRate !== void 0) input.hourlyRate = hourlyRate;
+        if (currency !== void 0) input.currency = currency;
+        const data = await ctx.gql.workspace.request(BECOME_MENTOR, { input });
+        return jsonResult(data.tecBecomeMentor);
+      } catch (error) {
+        ctx.logger.error("technospam mentors_become failed", { error: String(error) });
+        return errorResult(
+          `Failed to become mentor: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "mentors_update")),
+    {
+      title: "Update Mentor",
+      description: "Update a mentor profile. At least one mutable field must be provided. Use `isAcceptingMentees` to toggle availability.",
+      inputSchema: {
+        id: z.string().describe("Mentor ID"),
+        headline: z.string().optional().describe("Updated headline"),
+        bio: z.string().optional().describe("Updated bio"),
+        expertise: z.array(z.string()).optional().describe("Updated expertise areas"),
+        hourlyRate: z.number().int().optional().describe("Updated hourly rate"),
+        currency: z.string().optional().describe("Updated currency code"),
+        isAcceptingMentees: z.boolean().optional().describe("Toggle accepting new mentees")
+      }
+    },
+    async ({ id, headline, bio, expertise, hourlyRate, currency, isAcceptingMentees }) => {
+      try {
+        const input = {};
+        if (headline !== void 0) input.headline = headline;
+        if (bio !== void 0) input.bio = bio;
+        if (expertise !== void 0) input.expertise = expertise;
+        if (hourlyRate !== void 0) input.hourlyRate = hourlyRate;
+        if (currency !== void 0) input.currency = currency;
+        if (isAcceptingMentees !== void 0) input.isAcceptingMentees = isAcceptingMentees;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable mentor field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_MENTOR, { id, input });
+        return jsonResult(data.tecUpdateMentor);
+      } catch (error) {
+        ctx.logger.error("technospam mentors_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update mentor: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "mentors_approve")),
+    {
+      title: "Approve Mentor",
+      description: "Approve a pending mentor profile (PENDING -> ACTIVE).",
+      inputSchema: { id: z.string().describe("Mentor ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(APPROVE_MENTOR, { id });
+        return jsonResult(data.tecApproveMentor);
+      } catch (error) {
+        ctx.logger.error("technospam mentors_approve failed", { error: String(error) });
+        return errorResult(
+          `Failed to approve mentor: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerSessionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sessions_list")),
+    {
+      title: "List Sessions",
+      description: "List mentor sessions, optionally filtered by mentor, mentee, and/or status.",
+      inputSchema: {
+        mentorId: z.string().optional().describe("Filter by mentor ID"),
+        menteeId: z.string().optional().describe("Filter by mentee (user) ID"),
+        status: SessionStatusEnum.optional().describe("Filter by session status")
+      }
+    },
+    async ({ mentorId, menteeId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SESSIONS, { mentorId, menteeId, status });
+        return jsonResult(data.tecListSessions);
+      } catch (error) {
+        ctx.logger.error("technospam sessions_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list sessions: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sessions_book")),
+    {
+      title: "Book Session",
+      description: "Book a 1:1 session with a mentor as the calling mentee. `scheduledAt` is an ISO-8601 DateTime.",
+      inputSchema: {
+        mentorId: z.string().min(1).describe("Mentor ID"),
+        topic: z.string().min(1).describe("Session topic"),
+        scheduledAt: z.string().min(1).describe("ISO-8601 DateTime of the session start"),
+        agenda: z.string().optional().describe("Session agenda / goals"),
+        durationMinutes: z.number().int().optional().describe("Session duration in minutes")
+      }
+    },
+    async ({ mentorId, topic, scheduledAt, agenda, durationMinutes }) => {
+      try {
+        const input = { mentorId, topic, scheduledAt };
+        if (agenda !== void 0) input.agenda = agenda;
+        if (durationMinutes !== void 0) input.durationMinutes = durationMinutes;
+        const data = await ctx.gql.workspace.request(BOOK_SESSION, { input });
+        return jsonResult(data.tecBookSession);
+      } catch (error) {
+        ctx.logger.error("technospam sessions_book failed", { error: String(error) });
+        return errorResult(
+          `Failed to book session: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sessions_confirm")),
+    {
+      title: "Confirm Session",
+      description: "Confirm a requested session, optionally attaching a meeting URL.",
+      inputSchema: {
+        id: z.string().describe("Session ID"),
+        meetingUrl: z.string().optional().describe("Meeting/video-call URL")
+      }
+    },
+    async ({ id, meetingUrl }) => {
+      try {
+        const data = await ctx.gql.workspace.request(CONFIRM_SESSION, { id, meetingUrl });
+        return jsonResult(data.tecConfirmSession);
+      } catch (error) {
+        ctx.logger.error("technospam sessions_confirm failed", { error: String(error) });
+        return errorResult(
+          `Failed to confirm session: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sessions_cancel")),
+    {
+      title: "Cancel Session",
+      description: "Cancel a session.",
+      inputSchema: { id: z.string().describe("Session ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(CANCEL_SESSION, { id });
+        return jsonResult(data.tecCancelSession);
+      } catch (error) {
+        ctx.logger.error("technospam sessions_cancel failed", { error: String(error) });
+        return errorResult(
+          `Failed to cancel session: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sessions_complete")),
+    {
+      title: "Complete Session",
+      description: "Mark a session complete, optionally recording a rating (1-5) and feedback from the mentee.",
+      inputSchema: {
+        id: z.string().describe("Session ID"),
+        rating: z.number().int().min(1).max(5).optional().describe("Mentee rating (1-5)"),
+        feedback: z.string().optional().describe("Mentee feedback")
+      }
+    },
+    async ({ id, rating, feedback }) => {
+      try {
+        const data = await ctx.gql.workspace.request(COMPLETE_SESSION, { id, rating, feedback });
+        return jsonResult(data.tecCompleteSession);
+      } catch (error) {
+        ctx.logger.error("technospam sessions_complete failed", { error: String(error) });
+        return errorResult(
+          `Failed to complete session: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerHackathonTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "hackathons_get")),
+    {
+      title: "Get Hackathon",
+      description: "Fetch a single hackathon by ID, including its registered teams.",
+      inputSchema: { id: z.string().describe("Hackathon ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_HACKATHON, { id });
+        if (!data.tecHackathon) return errorResult(`Hackathon ${id} not found`);
+        return jsonResult(data.tecHackathon);
+      } catch (error) {
+        ctx.logger.error("technospam hackathons_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get hackathon: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "hackathons_list")),
+    {
+      title: "List Hackathons",
+      description: "List hackathons with optional status filter and pagination. Returns { items, pageInfo }.",
+      inputSchema: {
+        status: HackathonStatusEnum.optional().describe("Filter by 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 ({ status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_HACKATHONS, {
+          status,
+          pagination: buildPagination(limit, offset, cursor)
+        });
+        return jsonResult(data.tecListHackathons);
+      } catch (error) {
+        ctx.logger.error("technospam hackathons_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list hackathons: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "hackathons_create")),
+    {
+      title: "Create Hackathon",
+      description: "Create a hackathon (DRAFT). `slug`/`title` required; `startAt`/`endAt` are ISO-8601 DateTimes.",
+      inputSchema: {
+        slug: z.string().min(1).describe("URL slug, unique within the workspace"),
+        title: z.string().min(1).describe("Hackathon title"),
+        startAt: z.string().min(1).describe("ISO-8601 DateTime start"),
+        endAt: z.string().min(1).describe("ISO-8601 DateTime end"),
+        theme: z.string().optional().describe("Hackathon theme"),
+        description: z.string().optional().describe("Hackathon description"),
+        submissionDeadline: z.string().optional().describe("ISO-8601 DateTime submission deadline"),
+        prizePool: z.number().int().optional().describe("Total prize pool amount"),
+        currency: z.string().optional().describe("Prize-pool currency code"),
+        maxTeamSize: z.number().int().optional().describe("Maximum team size"),
+        tags: z.array(z.string()).optional().describe("Discovery tags")
+      }
+    },
+    async ({
+      slug,
+      title,
+      startAt,
+      endAt,
+      theme,
+      description,
+      submissionDeadline,
+      prizePool,
+      currency,
+      maxTeamSize,
+      tags
+    }) => {
+      try {
+        const input = { slug, title, startAt, endAt };
+        if (theme !== void 0) input.theme = theme;
+        if (description !== void 0) input.description = description;
+        if (submissionDeadline !== void 0) input.submissionDeadline = submissionDeadline;
+        if (prizePool !== void 0) input.prizePool = prizePool;
+        if (currency !== void 0) input.currency = currency;
+        if (maxTeamSize !== void 0) input.maxTeamSize = maxTeamSize;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_HACKATHON, { input });
+        return jsonResult(data.tecCreateHackathon);
+      } catch (error) {
+        ctx.logger.error("technospam hackathons_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create hackathon: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "hackathons_update")),
+    {
+      title: "Update Hackathon",
+      description: "Update a hackathon. At least one mutable field must be provided.",
+      inputSchema: {
+        id: z.string().describe("Hackathon ID"),
+        title: z.string().optional().describe("Updated title"),
+        theme: z.string().optional().describe("Updated theme"),
+        description: z.string().optional().describe("Updated description"),
+        startAt: z.string().optional().describe("Updated ISO-8601 DateTime start"),
+        endAt: z.string().optional().describe("Updated ISO-8601 DateTime end"),
+        submissionDeadline: z.string().optional().describe("Updated submission deadline"),
+        prizePool: z.number().int().optional().describe("Updated prize pool"),
+        currency: z.string().optional().describe("Updated currency code"),
+        maxTeamSize: z.number().int().optional().describe("Updated max team size"),
+        tags: z.array(z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      title,
+      theme,
+      description,
+      startAt,
+      endAt,
+      submissionDeadline,
+      prizePool,
+      currency,
+      maxTeamSize,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (theme !== void 0) input.theme = theme;
+        if (description !== void 0) input.description = description;
+        if (startAt !== void 0) input.startAt = startAt;
+        if (endAt !== void 0) input.endAt = endAt;
+        if (submissionDeadline !== void 0) input.submissionDeadline = submissionDeadline;
+        if (prizePool !== void 0) input.prizePool = prizePool;
+        if (currency !== void 0) input.currency = currency;
+        if (maxTeamSize !== void 0) input.maxTeamSize = maxTeamSize;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult("No updates specified \u2014 provide at least one mutable hackathon field");
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_HACKATHON, { id, input });
+        return jsonResult(data.tecUpdateHackathon);
+      } catch (error) {
+        ctx.logger.error("technospam hackathons_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update hackathon: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "hackathons_open_registration")),
+    {
+      title: "Open Hackathon Registration",
+      description: "Open registration for a hackathon (DRAFT -> REGISTRATION_OPEN).",
+      inputSchema: { id: z.string().describe("Hackathon ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(OPEN_REGISTRATION, { id });
+        return jsonResult(data.tecOpenRegistration);
+      } catch (error) {
+        ctx.logger.error("technospam hackathons_open_registration failed", {
+          error: String(error)
+        });
+        return errorResult(
+          `Failed to open registration: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerTeamTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "teams_list")),
+    {
+      title: "List Teams",
+      description: "List all teams registered for a hackathon.",
+      inputSchema: { hackathonId: z.string().describe("Hackathon ID") }
+    },
+    async ({ hackathonId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_TEAMS, { hackathonId });
+        return jsonResult(data.tecListTeams);
+      } catch (error) {
+        ctx.logger.error("technospam teams_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list teams: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "teams_register")),
+    {
+      title: "Register Team",
+      description: "Register a team for a hackathon with the calling user as captain. `memberIds` are additional team member user IDs.",
+      inputSchema: {
+        hackathonId: z.string().min(1).describe("Hackathon ID"),
+        name: z.string().min(1).describe("Team name"),
+        memberIds: z.array(z.string()).optional().describe("Additional member user IDs")
+      }
+    },
+    async ({ hackathonId, name, memberIds }) => {
+      try {
+        const input = { hackathonId, name };
+        if (memberIds !== void 0) input.memberIds = memberIds;
+        const data = await ctx.gql.workspace.request(REGISTER_TEAM, { input });
+        return jsonResult(data.tecRegisterTeam);
+      } catch (error) {
+        ctx.logger.error("technospam teams_register failed", { error: String(error) });
+        return errorResult(
+          `Failed to register team: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "teams_submit_project")),
+    {
+      title: "Submit Team Project",
+      description: "Submit a team's project for judging (sets status SUBMITTED).",
+      inputSchema: {
+        teamId: z.string().min(1).describe("Team ID"),
+        projectName: z.string().min(1).describe("Project name"),
+        projectUrl: z.string().optional().describe("Live project / demo URL"),
+        repoUrl: z.string().optional().describe("Source repository URL"),
+        pitch: z.string().optional().describe("Project pitch / description")
+      }
+    },
+    async ({ teamId, projectName, projectUrl, repoUrl, pitch }) => {
+      try {
+        const input = { teamId, projectName };
+        if (projectUrl !== void 0) input.projectUrl = projectUrl;
+        if (repoUrl !== void 0) input.repoUrl = repoUrl;
+        if (pitch !== void 0) input.pitch = pitch;
+        const data = await ctx.gql.workspace.request(SUBMIT_PROJECT, { input });
+        return jsonResult(data.tecSubmitProject);
+      } catch (error) {
+        ctx.logger.error("technospam teams_submit_project failed", { error: String(error) });
+        return errorResult(
+          `Failed to submit project: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "teams_score")),
+    {
+      title: "Score Team",
+      description: "Record a judge score for a team and optionally mark it WINNER.",
+      inputSchema: {
+        id: z.string().describe("Team ID"),
+        score: z.number().int().describe("Judge score"),
+        winner: z.boolean().optional().describe("Mark the team as a WINNER")
+      }
+    },
+    async ({ id, score, winner }) => {
+      try {
+        const data = await ctx.gql.workspace.request(SCORE_TEAM, { id, score, winner });
+        return jsonResult(data.tecScoreTeam);
+      } catch (error) {
+        ctx.logger.error("technospam teams_score failed", { error: String(error) });
+        return errorResult(
+          `Failed to score team: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/technospam/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "Technospam Health Check",
+      description: "Public health probe for the Technospam subgraph (tecHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.tecHealth });
+      } catch (error) {
+        ctx.logger.error("technospam health failed", { error: String(error) });
+        return errorResult(
+          `Technospam health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/technospam/resources.ts
+function registerTechnospamResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const coursesUri = track(mcpResourceUri(ctx.productName, "courses"));
+  const hackathonsUri = track(mcpResourceUri(ctx.productName, "hackathons"));
+  const mentorsUri = track(mcpResourceUri(ctx.productName, "mentors"));
+  server.registerResource(
+    "technospam-schema",
+    schemaUri,
+    {
+      title: "Technospam Domain Schema",
+      description: "Overview of the Technospam learning-platform domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# Technospam Domain (Overview)
+
+Technical-learning platform: courses, competitive-programming practice,
+1:1 mentorship, and hackathons.
+
+## Entities
+- TecCourse (+TecLesson) \u2014 a course and its ordered lessons
+- TecEnrollment \u2014 a learner's progress through a course
+- TecCertificate \u2014 a verifiable completion certificate
+- TecProblem (+TecSubmission) \u2014 a practice problem and its graded submissions
+- TecMentor (+TecMentorSession) \u2014 a mentor profile and its 1:1 sessions
+- TecHackathon (+TecHackathonTeam) \u2014 a hackathon event and its teams
+
+## Enums
+- TecCourseLevel: BEGINNER, INTERMEDIATE, ADVANCED, EXPERT
+- TecCourseStatus: DRAFT, PUBLISHED, ARCHIVED
+- TecLessonKind: ARTICLE, VIDEO, QUIZ, PROJECT, INTERACTIVE
+- TecEnrollmentStatus: ENROLLED, IN_PROGRESS, COMPLETED, DROPPED
+- TecCertificateStatus: ISSUED, REVOKED
+- TecProblemDifficulty: EASY, MEDIUM, HARD
+- TecProblemStatus: DRAFT, PUBLISHED, ARCHIVED
+- TecSubmissionVerdict: PENDING, ACCEPTED, WRONG_ANSWER, TIME_LIMIT_EXCEEDED, RUNTIME_ERROR, COMPILE_ERROR
+- TecMentorStatus: PENDING, ACTIVE, PAUSED, INACTIVE
+- TecSessionStatus: REQUESTED, CONFIRMED, COMPLETED, CANCELLED, NO_SHOW
+- TecHackathonStatus: DRAFT, REGISTRATION_OPEN, IN_PROGRESS, JUDGING, COMPLETED, CANCELLED
+- TecTeamSubmissionStatus: DRAFT, SUBMITTED, WINNER, DISQUALIFIED
+
+## Tool groups
+courses, lessons, enrollments, certificates, problems, submissions, mentors,
+sessions, hackathons, teams. All run against the WORKSPACE gateway
+(workspace-scoped) except the public health probe.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "technospam-courses",
+    coursesUri,
+    {
+      title: "Technospam 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.tecListCourses, 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(
+    "technospam-hackathons",
+    hackathonsUri,
+    {
+      title: "Technospam Hackathon Directory",
+      description: "The first 50 hackathons in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${hackathonsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          LIST_HACKATHONS,
+          { pagination: { limit: 50, offset: 0 } }
+        );
+        return {
+          contents: [
+            {
+              uri: hackathonsUri,
+              text: JSON.stringify(data.tecListHackathons, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: hackathonsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "technospam-mentors",
+    mentorsUri,
+    {
+      title: "Technospam Mentor Directory",
+      description: "The first 50 mentor profiles in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${mentorsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MENTORS, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: mentorsUri,
+              text: JSON.stringify(data.tecListMentors, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: mentorsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerTechnospamPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const authoringName = track(mcpPromptName(p, "course-authoring"));
+  const opsName = track(mcpPromptName(p, "learning-ops"));
+  server.registerPrompt(
+    authoringName,
+    {
+      title: "Course Authoring",
+      description: "Guide for authoring a new Technospam course end to end: create the course, add lessons, publish it, and (optionally) issue completion certificates.",
+      argsSchema: {
+        title: z.string().optional().describe("Course title"),
+        topic: z.string().optional().describe("Course topic/subject")
+      }
+    },
+    ({ title, topic }) => {
+      ctx.logger.debug(`Prompt ${authoringName} called`, { title, topic });
+      const titleNote = title ? `Use the title "${title}".` : "Ask the user for the course title.";
+      const topicNote = topic ? `Use topic "${topic}".` : "Help the user pick a topic.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me author a new Technospam course.
+
+1. **Create Course**: Use ${p}_courses_create. ${titleNote} ${topicNote} Provide a unique slug, a level (BEGINNER/INTERMEDIATE/ADVANCED/EXPERT), and optional estimatedMinutes.
+2. **Add Lessons**: Use ${p}_lessons_create for each lesson \u2014 set kind (ARTICLE/VIDEO/QUIZ/PROJECT/INTERACTIVE), position, and optional content or a fileId (video/attachment).
+3. **Verify Outline**: Use ${p}_lessons_list for the new courseId to confirm ordering.
+4. **Publish**: Use ${p}_courses_publish when the outline is complete (DRAFT -> PUBLISHED).
+5. **(Optional) Certificates**: After learners finish, use ${p}_certificates_issue (courseId, learnerId, score).
+
+Show results at each step and confirm before publishing.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    opsName,
+    {
+      title: "Learning Operations",
+      description: "Operations workflow across the Technospam learning surfaces: triage practice submissions, manage mentor sessions, and run hackathon judging.",
+      argsSchema: {
+        problemId: z.string().optional().describe("Problem ID to triage submissions for"),
+        hackathonId: z.string().optional().describe("Hackathon ID to operate")
+      }
+    },
+    ({ problemId, hackathonId }) => {
+      ctx.logger.debug(`Prompt ${opsName} called`, { problemId, hackathonId });
+      const problemNote = problemId ? `Triage submissions for problem "${problemId}".` : `First list problems with ${p}_problems_list and pick one.`;
+      const hackathonNote = hackathonId ? `Operate hackathon "${hackathonId}".` : `List hackathons with ${p}_hackathons_list and pick one.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run Technospam learning operations.
+
+1. **Practice Queue**: ${problemNote} Use ${p}_submissions_list filtered by problemId and grade PENDING ones with ${p}_submissions_grade (verdict + runtimeMs).
+2. **Mentorship**: Use ${p}_mentors_list (status=PENDING) and approve qualified mentors with ${p}_mentors_approve. Use ${p}_sessions_list (status=REQUESTED) and confirm them with ${p}_sessions_confirm; complete finished sessions with ${p}_sessions_complete.
+3. **Hackathon Judging**: ${hackathonNote} Use ${p}_teams_list for the hackathon; for each SUBMITTED team record a score with ${p}_teams_score (set winner=true for the winner). Move the hackathon through its lifecycle with ${p}_hackathons_update / ${p}_hackathons_open_registration as needed.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/technospam/index.ts
+var technospamModule = {
+  id: "technospam",
+  version: "0.0.1",
+  displayName: "Technospam",
+  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);
+    registerLessonTools(server, ctx, trackTool);
+    registerEnrollmentTools(server, ctx, trackTool);
+    registerCertificateTools(server, ctx, trackTool);
+    registerProblemTools(server, ctx, trackTool);
+    registerSubmissionTools(server, ctx, trackTool);
+    registerMentorTools(server, ctx, trackTool);
+    registerSessionTools(server, ctx, trackTool);
+    registerHackathonTools(server, ctx, trackTool);
+    registerTeamTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerTechnospamResources(server, ctx, trackResource);
+    registerTechnospamPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var technospam_default = technospamModule;
+
+export { technospam_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map