@burdenoff/mcp-libs 2026.627.4 → 2026.627.5

package/dist/modules/mybodyshield/index.cjs

@@ -0,0 +1,1834 @@
+'use strict';
+
+var zod = require('zod');
+require('graphql-request');
+require('cross-fetch');
+require('@modelcontextprotocol/sdk/server/mcp.js');
+require('@modelcontextprotocol/sdk/types.js');
+
+// src/modules/mybodyshield/tools/programs.ts
+
+// src/core/errors.ts
+var McpInternalError = class extends Error {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "McpInternalError";
+    this.cause = cause;
+  }
+};
+
+// src/core/result.ts
+function jsonResult(data, structured) {
+  const result = {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+  return result;
+}
+function errorResult(message, hint) {
+  const text = hint ? `${message}
+
+Hint: ${hint}` : message;
+  return { content: [{ type: "text", text }], isError: true };
+}
+
+// src/core/tool-name.ts
+var MAX_TOOL_NAME_LENGTH = 63;
+function assertSafeName(name, kind) {
+  if (name.length > MAX_TOOL_NAME_LENGTH) {
+    throw new McpInternalError(
+      `Tool name '${name}' exceeds ${MAX_TOOL_NAME_LENGTH} characters (some MCP clients truncate at 64).`
+    );
+  }
+  return name;
+}
+function mcpToolName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpToolName: productName is required");
+  }
+  const name = [productName, ...parts].filter(Boolean).join("_");
+  return assertSafeName(name);
+}
+function mcpResourceUri(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpResourceUri: productName is required");
+  }
+  return `${productName}://${parts.filter(Boolean).join("/")}`;
+}
+function mcpPromptName(productName, ...parts) {
+  if (!productName) {
+    throw new McpInternalError("mcpPromptName: productName is required");
+  }
+  return [productName, ...parts].filter(Boolean).join("-");
+}
+
+// src/modules/mybodyshield/operations.ts
+var PAGE_INFO_FIELDS = `
+  cursor hasMore
+`;
+var EXERCISE_FIELDS = `
+  id workoutId name instructions muscleGroup sets reps restSeconds targetWeight
+  orderIndex demo { id } createdAt updatedAt workspaceId
+`;
+var WORKOUT_FIELDS = `
+  id programId name description type dayOfWeek weekNumber durationMin orderIndex
+  createdAt updatedAt workspaceId
+`;
+var PROGRAM_FIELDS = `
+  id name description goalType level phase status memberId coachId daysPerWeek
+  weeks startDate endDate tags createdAt updatedAt workspaceId
+`;
+var SESSION_SET_FIELDS = `
+  id sessionId exerciseName setNumber reps weight distanceM durationSec
+  isPersonalRecord createdAt updatedAt workspaceId
+`;
+var SESSION_FIELDS = `
+  id memberId programId workoutId status scheduledFor startedAt completedAt
+  caloriesBurned perceivedExertion notes createdAt updatedAt workspaceId
+`;
+var MEAL_FIELDS = `
+  id name memberId planId mealType calories proteinG carbsG fatG servings
+  isFavorite loggedAt createdAt updatedAt workspaceId
+`;
+var NUTRITION_PLAN_FIELDS = `
+  id name memberId coachId goalType calorieTarget proteinTarget carbsTarget
+  fatTarget startDate endDate isActive notes createdAt updatedAt workspaceId
+`;
+var DAILY_MACROS_FIELDS = `
+  date calories calorieTarget proteinG proteinTarget carbsG carbsTarget
+  fatG fatTarget
+`;
+var GOAL_FIELDS = `
+  id title description type status memberId baselineValue currentValue
+  targetValue unit targetDate achievedAt createdAt updatedAt workspaceId
+`;
+var BODY_METRIC_FIELDS = `
+  id memberId type value unit measuredAt notes photo { id }
+  createdAt updatedAt workspaceId
+`;
+var RECOVERY_FIELDS = `
+  id memberId metric score sleepHours notes loggedAt createdAt updatedAt workspaceId
+`;
+var COACHING_FIELDS = `
+  id coachId memberId status specialty shareWorkouts shareNutrition shareMetrics
+  notes startedAt endedAt createdAt updatedAt workspaceId
+`;
+var GET_PROGRAM = `
+  query MybodyshieldGetProgram($id: ID!) {
+    mybProgram(id: $id) {
+      ${PROGRAM_FIELDS}
+      workouts {
+        ${WORKOUT_FIELDS}
+        exercises { ${EXERCISE_FIELDS} }
+      }
+    }
+  }
+`;
+var LIST_PROGRAMS = `
+  query MybodyshieldListPrograms(
+    $memberId: ID
+    $status: MybProgramStatus
+    $pagination: PaginationInput
+  ) {
+    mybListPrograms(memberId: $memberId, status: $status, pagination: $pagination) {
+      items { ${PROGRAM_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var CREATE_PROGRAM = `
+  mutation MybodyshieldCreateProgram($input: MybCreateProgramInput!) {
+    mybCreateProgram(input: $input) { ${PROGRAM_FIELDS} }
+  }
+`;
+var UPDATE_PROGRAM = `
+  mutation MybodyshieldUpdateProgram($id: ID!, $input: MybUpdateProgramInput!) {
+    mybUpdateProgram(id: $id, input: $input) { ${PROGRAM_FIELDS} }
+  }
+`;
+var TRANSITION_PROGRAM = `
+  mutation MybodyshieldTransitionProgram($id: ID!, $status: MybProgramStatus!) {
+    mybTransitionProgram(id: $id, status: $status) { ${PROGRAM_FIELDS} }
+  }
+`;
+var ARCHIVE_PROGRAM = `
+  mutation MybodyshieldArchiveProgram($id: ID!) {
+    mybArchiveProgram(id: $id)
+  }
+`;
+var LIST_PROGRAM_WORKOUTS = `
+  query MybodyshieldListProgramWorkouts($programId: ID!) {
+    mybProgramWorkouts(programId: $programId) {
+      ${WORKOUT_FIELDS}
+      exercises { ${EXERCISE_FIELDS} }
+    }
+  }
+`;
+var ADD_WORKOUT = `
+  mutation MybodyshieldAddWorkout($input: MybCreateWorkoutInput!) {
+    mybAddWorkout(input: $input) { ${WORKOUT_FIELDS} }
+  }
+`;
+var ADD_EXERCISE = `
+  mutation MybodyshieldAddExercise($input: MybCreateExerciseInput!) {
+    mybAddExercise(input: $input) { ${EXERCISE_FIELDS} }
+  }
+`;
+var GET_SESSION = `
+  query MybodyshieldGetSession($id: ID!) {
+    mybSession(id: $id) {
+      ${SESSION_FIELDS}
+      sets { ${SESSION_SET_FIELDS} }
+    }
+  }
+`;
+var LIST_SESSIONS = `
+  query MybodyshieldListSessions(
+    $programId: ID
+    $status: MybSessionStatus
+    $pagination: PaginationInput
+  ) {
+    mybListSessions(programId: $programId, status: $status, pagination: $pagination) {
+      items {
+        ${SESSION_FIELDS}
+        sets { ${SESSION_SET_FIELDS} }
+      }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var START_SESSION = `
+  mutation MybodyshieldStartSession($input: MybStartSessionInput!) {
+    mybStartSession(input: $input) {
+      ${SESSION_FIELDS}
+      sets { ${SESSION_SET_FIELDS} }
+    }
+  }
+`;
+var COMPLETE_SESSION = `
+  mutation MybodyshieldCompleteSession($id: ID!, $input: MybCompleteSessionInput!) {
+    mybCompleteSession(id: $id, input: $input) {
+      ${SESSION_FIELDS}
+      sets { ${SESSION_SET_FIELDS} }
+    }
+  }
+`;
+var LOG_SET = `
+  mutation MybodyshieldLogSet($input: MybLogSetInput!) {
+    mybLogSet(input: $input) { ${SESSION_SET_FIELDS} }
+  }
+`;
+var GET_NUTRITION_PLAN = `
+  query MybodyshieldGetNutritionPlan($id: ID!) {
+    mybNutritionPlan(id: $id) {
+      ${NUTRITION_PLAN_FIELDS}
+      meals { ${MEAL_FIELDS} }
+    }
+  }
+`;
+var ACTIVE_NUTRITION_PLAN = `
+  query MybodyshieldActiveNutritionPlan($memberId: ID) {
+    mybActiveNutritionPlan(memberId: $memberId) {
+      ${NUTRITION_PLAN_FIELDS}
+      meals { ${MEAL_FIELDS} }
+    }
+  }
+`;
+var CREATE_NUTRITION_PLAN = `
+  mutation MybodyshieldCreateNutritionPlan($input: MybCreateNutritionPlanInput!) {
+    mybCreateNutritionPlan(input: $input) { ${NUTRITION_PLAN_FIELDS} }
+  }
+`;
+var UPDATE_NUTRITION_PLAN = `
+  mutation MybodyshieldUpdateNutritionPlan(
+    $id: ID!
+    $input: MybUpdateNutritionPlanInput!
+  ) {
+    mybUpdateNutritionPlan(id: $id, input: $input) { ${NUTRITION_PLAN_FIELDS} }
+  }
+`;
+var ACTIVATE_NUTRITION_PLAN = `
+  mutation MybodyshieldActivateNutritionPlan($id: ID!) {
+    mybActivateNutritionPlan(id: $id) { ${NUTRITION_PLAN_FIELDS} }
+  }
+`;
+var DAILY_MACROS = `
+  query MybodyshieldDailyMacros($memberId: ID, $date: DateTime) {
+    mybDailyMacros(memberId: $memberId, date: $date) { ${DAILY_MACROS_FIELDS} }
+  }
+`;
+var LIST_MEALS = `
+  query MybodyshieldListMeals(
+    $planId: ID
+    $mealType: MybMealType
+    $pagination: PaginationInput
+  ) {
+    mybListMeals(planId: $planId, mealType: $mealType, pagination: $pagination) {
+      items { ${MEAL_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var LOG_MEAL = `
+  mutation MybodyshieldLogMeal($input: MybLogMealInput!) {
+    mybLogMeal(input: $input) { ${MEAL_FIELDS} }
+  }
+`;
+var DELETE_MEAL = `
+  mutation MybodyshieldDeleteMeal($id: ID!) {
+    mybDeleteMeal(id: $id)
+  }
+`;
+var GET_GOAL = `
+  query MybodyshieldGetGoal($id: ID!) {
+    mybGoal(id: $id) { ${GOAL_FIELDS} }
+  }
+`;
+var LIST_GOALS = `
+  query MybodyshieldListGoals(
+    $memberId: ID
+    $status: MybGoalStatus
+    $pagination: PaginationInput
+  ) {
+    mybListGoals(memberId: $memberId, status: $status, pagination: $pagination) {
+      items { ${GOAL_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var CREATE_GOAL = `
+  mutation MybodyshieldCreateGoal($input: MybCreateGoalInput!) {
+    mybCreateGoal(input: $input) { ${GOAL_FIELDS} }
+  }
+`;
+var UPDATE_GOAL = `
+  mutation MybodyshieldUpdateGoal($id: ID!, $input: MybUpdateGoalInput!) {
+    mybUpdateGoal(id: $id, input: $input) { ${GOAL_FIELDS} }
+  }
+`;
+var ACHIEVE_GOAL = `
+  mutation MybodyshieldAchieveGoal($id: ID!) {
+    mybAchieveGoal(id: $id) { ${GOAL_FIELDS} }
+  }
+`;
+var LIST_BODY_METRICS = `
+  query MybodyshieldListBodyMetrics(
+    $memberId: ID
+    $type: MybBodyMetricType
+    $pagination: PaginationInput
+  ) {
+    mybListBodyMetrics(memberId: $memberId, type: $type, pagination: $pagination) {
+      items { ${BODY_METRIC_FIELDS} }
+      pageInfo { ${PAGE_INFO_FIELDS} }
+    }
+  }
+`;
+var RECORD_BODY_METRIC = `
+  mutation MybodyshieldRecordBodyMetric($input: MybRecordMetricInput!) {
+    mybRecordBodyMetric(input: $input) { ${BODY_METRIC_FIELDS} }
+  }
+`;
+var LIST_RECOVERY_LOGS = `
+  query MybodyshieldListRecoveryLogs($memberId: ID, $metric: MybRecoveryMetric) {
+    mybListRecoveryLogs(memberId: $memberId, metric: $metric) { ${RECOVERY_FIELDS} }
+  }
+`;
+var LOG_RECOVERY = `
+  mutation MybodyshieldLogRecovery($input: MybLogRecoveryInput!) {
+    mybLogRecovery(input: $input) { ${RECOVERY_FIELDS} }
+  }
+`;
+var LIST_COACHING = `
+  query MybodyshieldListCoaching($memberId: ID, $status: MybCoachingStatus) {
+    mybListCoaching(memberId: $memberId, status: $status) { ${COACHING_FIELDS} }
+  }
+`;
+var CREATE_COACHING = `
+  mutation MybodyshieldCreateCoaching($input: MybCreateCoachingInput!) {
+    mybCreateCoaching(input: $input) { ${COACHING_FIELDS} }
+  }
+`;
+var TRANSITION_COACHING = `
+  mutation MybodyshieldTransitionCoaching($id: ID!, $status: MybCoachingStatus!) {
+    mybTransitionCoaching(id: $id, status: $status) { ${COACHING_FIELDS} }
+  }
+`;
+var HEALTH = `
+  query MybodyshieldHealth {
+    mybHealth
+  }
+`;
+var GoalTypeEnum = zod.z.enum(["ENDURANCE", "GENERAL_FITNESS", "MOBILITY", "MUSCLE_GAIN", "STRENGTH", "WEIGHT_LOSS"]).describe("Training/nutrition goal type (MybGoalType)");
+var GoalStatusEnum = zod.z.enum(["ABANDONED", "ACHIEVED", "ACTIVE", "PAUSED"]).describe("Lifecycle status of a goal (MybGoalStatus)");
+var FitnessLevelEnum = zod.z.enum(["ADVANCED", "BEGINNER", "ELITE", "INTERMEDIATE"]).describe("Member fitness level for a program (MybFitnessLevel)");
+var ProgramPhaseEnum = zod.z.enum(["BUILD", "DELOAD", "MAINTENANCE", "PEAK"]).describe("Periodization phase of a program (MybProgramPhase)");
+var ProgramStatusEnum = zod.z.enum(["ACTIVE", "ARCHIVED", "COMPLETED", "DRAFT"]).describe("Lifecycle status of a training program (MybProgramStatus)");
+var WorkoutTypeEnum = zod.z.enum(["CARDIO", "HIIT", "MOBILITY", "RECOVERY", "STRENGTH", "YOGA"]).describe("Type of a workout (MybWorkoutType)");
+var MuscleGroupEnum = zod.z.enum(["ARMS", "BACK", "CHEST", "CORE", "FULL_BODY", "LEGS", "SHOULDERS"]).describe("Primary muscle group an exercise targets (MybMuscleGroup)");
+var SessionStatusEnum = zod.z.enum(["COMPLETED", "IN_PROGRESS", "SCHEDULED", "SKIPPED"]).describe("Status of a logged workout session (MybSessionStatus)");
+var MealTypeEnum = zod.z.enum(["BREAKFAST", "DINNER", "LUNCH", "SNACK"]).describe("Meal slot a meal log belongs to (MybMealType)");
+var BodyMetricTypeEnum = zod.z.enum(["ARM", "BODY_FAT", "CHEST", "HIPS", "RESTING_HEART_RATE", "THIGH", "WAIST", "WEIGHT"]).describe("Kind of body measurement (MybBodyMetricType)");
+var RecoveryMetricEnum = zod.z.enum(["MOOD", "READINESS", "SLEEP", "SORENESS", "STRESS"]).describe("Kind of recovery/wellbeing signal (MybRecoveryMetric)");
+var CoachingStatusEnum = zod.z.enum(["ACTIVE", "ENDED", "PAUSED", "PENDING"]).describe("Status of a coach\u2194member relationship (MybCoachingStatus)");
+
+// src/modules/mybodyshield/tools/programs.ts
+function registerProgramTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "programs_get")),
+    {
+      title: "Get Training Program",
+      description: "Fetch a single Mybodyshield training program by ID, including its nested workouts and exercises.",
+      inputSchema: { id: zod.z.string().describe("Program ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PROGRAM, { id });
+        if (!data.mybProgram) return errorResult(`Program ${id} not found`);
+        return jsonResult(data.mybProgram);
+      } catch (error) {
+        ctx.logger.error("mybodyshield programs_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get program: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "programs_list")),
+    {
+      title: "List Training Programs",
+      description: "List training programs in the bound workspace, optionally filtered by member and lifecycle status. Returns a paginated connection ({ items, pageInfo }).",
+      inputSchema: {
+        memberId: zod.z.string().optional().describe("Filter by member (user) ID"),
+        status: ProgramStatusEnum.optional().describe("Filter by program status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ memberId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PROGRAMS, {
+          memberId,
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.mybListPrograms);
+      } catch (error) {
+        ctx.logger.error("mybodyshield programs_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list programs: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "programs_create")),
+    {
+      title: "Create Training Program",
+      description: "Create a training program. `name` is required; goalType/level/phase default to GENERAL_FITNESS/BEGINNER/BUILD when omitted.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Program name"),
+        memberId: zod.z.string().optional().describe("Member (user) ID the program is for"),
+        coachId: zod.z.string().optional().describe("Coach (user) ID authoring the program"),
+        description: zod.z.string().optional().describe("Program description"),
+        goalType: GoalTypeEnum.optional().describe("Primary goal (default GENERAL_FITNESS)"),
+        level: FitnessLevelEnum.optional().describe("Target fitness level (default BEGINNER)"),
+        phase: ProgramPhaseEnum.optional().describe("Periodization phase (default BUILD)"),
+        daysPerWeek: zod.z.number().int().optional().describe("Training days per week"),
+        weeks: zod.z.number().int().optional().describe("Program length in weeks"),
+        startDate: zod.z.string().optional().describe("Start date (ISO-8601 DateTime)"),
+        endDate: zod.z.string().optional().describe("End date (ISO-8601 DateTime)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({
+      name,
+      memberId,
+      coachId,
+      description,
+      goalType,
+      level,
+      phase,
+      daysPerWeek,
+      weeks,
+      startDate,
+      endDate,
+      tags
+    }) => {
+      try {
+        const input = { name };
+        if (memberId !== void 0) input.memberId = memberId;
+        if (coachId !== void 0) input.coachId = coachId;
+        if (description !== void 0) input.description = description;
+        if (goalType !== void 0) input.goalType = goalType;
+        if (level !== void 0) input.level = level;
+        if (phase !== void 0) input.phase = phase;
+        if (daysPerWeek !== void 0) input.daysPerWeek = daysPerWeek;
+        if (weeks !== void 0) input.weeks = weeks;
+        if (startDate !== void 0) input.startDate = startDate;
+        if (endDate !== void 0) input.endDate = endDate;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(CREATE_PROGRAM, { input });
+        return jsonResult(data.mybCreateProgram);
+      } catch (error) {
+        ctx.logger.error("mybodyshield programs_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create program: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "programs_update")),
+    {
+      title: "Update Training Program",
+      description: "Update a training program. At least one mutable field must be provided. Use `programs_transition` for lifecycle changes.",
+      inputSchema: {
+        id: zod.z.string().describe("Program ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        description: zod.z.string().optional().describe("Updated description"),
+        coachId: zod.z.string().optional().describe("Updated coach (user) ID"),
+        goalType: GoalTypeEnum.optional().describe("Updated primary goal"),
+        level: FitnessLevelEnum.optional().describe("Updated fitness level"),
+        phase: ProgramPhaseEnum.optional().describe("Updated periodization phase"),
+        daysPerWeek: zod.z.number().int().optional().describe("Updated training days per week"),
+        weeks: zod.z.number().int().optional().describe("Updated program length in weeks"),
+        startDate: zod.z.string().optional().describe("Updated start date (ISO-8601 DateTime)"),
+        endDate: zod.z.string().optional().describe("Updated end date (ISO-8601 DateTime)"),
+        tags: zod.z.array(zod.z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      name,
+      description,
+      coachId,
+      goalType,
+      level,
+      phase,
+      daysPerWeek,
+      weeks,
+      startDate,
+      endDate,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (description !== void 0) input.description = description;
+        if (coachId !== void 0) input.coachId = coachId;
+        if (goalType !== void 0) input.goalType = goalType;
+        if (level !== void 0) input.level = level;
+        if (phase !== void 0) input.phase = phase;
+        if (daysPerWeek !== void 0) input.daysPerWeek = daysPerWeek;
+        if (weeks !== void 0) input.weeks = weeks;
+        if (startDate !== void 0) input.startDate = startDate;
+        if (endDate !== void 0) input.endDate = endDate;
+        if (tags !== void 0) input.tags = tags;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/description/coachId/goalType/level/phase/daysPerWeek/weeks/startDate/endDate/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_PROGRAM, { id, input });
+        return jsonResult(data.mybUpdateProgram);
+      } catch (error) {
+        ctx.logger.error("mybodyshield programs_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update program: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "programs_transition")),
+    {
+      title: "Transition Training Program",
+      description: "Advance a program through its lifecycle (validated transitions): DRAFT \u2192 ACTIVE \u2192 COMPLETED / ARCHIVED.",
+      inputSchema: {
+        id: zod.z.string().describe("Program ID"),
+        status: ProgramStatusEnum.describe("Target lifecycle status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_PROGRAM, { id, status });
+        return jsonResult(data.mybTransitionProgram);
+      } catch (error) {
+        ctx.logger.error("mybodyshield programs_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition program: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "programs_archive")),
+    {
+      title: "Archive Training Program",
+      description: "Archive a training program by ID. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Program ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_PROGRAM,
+          { id }
+        );
+        return jsonResult({ archived: data.mybArchiveProgram });
+      } catch (error) {
+        ctx.logger.error("mybodyshield programs_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive program: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerWorkoutTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workouts_list")),
+    {
+      title: "List Program Workouts",
+      description: "List the workouts for a program (ordered), each with its nested exercises.",
+      inputSchema: { programId: zod.z.string().describe("Program ID") }
+    },
+    async ({ programId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PROGRAM_WORKOUTS, { programId });
+        return jsonResult(data.mybProgramWorkouts);
+      } catch (error) {
+        ctx.logger.error("mybodyshield workouts_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list program workouts: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workouts_add")),
+    {
+      title: "Add Workout",
+      description: "Add a workout to a program. `programId` and `name` are required; `type` defaults to STRENGTH.",
+      inputSchema: {
+        programId: zod.z.string().describe("Parent program ID"),
+        name: zod.z.string().min(1).describe("Workout name"),
+        description: zod.z.string().optional().describe("Workout description"),
+        type: WorkoutTypeEnum.optional().describe("Workout type (default STRENGTH)"),
+        dayOfWeek: zod.z.number().int().optional().describe("Day of week (1-7)"),
+        weekNumber: zod.z.number().int().optional().describe("Program week number"),
+        durationMin: zod.z.number().int().optional().describe("Planned duration in minutes"),
+        orderIndex: zod.z.number().int().optional().describe("Ordering within the program")
+      }
+    },
+    async ({
+      programId,
+      name,
+      description,
+      type,
+      dayOfWeek,
+      weekNumber,
+      durationMin,
+      orderIndex
+    }) => {
+      try {
+        const input = { programId, name };
+        if (description !== void 0) input.description = description;
+        if (type !== void 0) input.type = type;
+        if (dayOfWeek !== void 0) input.dayOfWeek = dayOfWeek;
+        if (weekNumber !== void 0) input.weekNumber = weekNumber;
+        if (durationMin !== void 0) input.durationMin = durationMin;
+        if (orderIndex !== void 0) input.orderIndex = orderIndex;
+        const data = await ctx.gql.workspace.request(ADD_WORKOUT, { input });
+        return jsonResult(data.mybAddWorkout);
+      } catch (error) {
+        ctx.logger.error("mybodyshield workouts_add failed", { error: String(error) });
+        return errorResult(
+          `Failed to add workout: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "exercises_add")),
+    {
+      title: "Add Exercise",
+      description: "Add an exercise to a workout. `workoutId` and `name` are required; `muscleGroup` defaults to FULL_BODY. `demoFileId` references a wspace-files-svc File (demo video/image).",
+      inputSchema: {
+        workoutId: zod.z.string().describe("Parent workout ID"),
+        name: zod.z.string().min(1).describe("Exercise name"),
+        instructions: zod.z.string().optional().describe("How-to instructions"),
+        muscleGroup: MuscleGroupEnum.optional().describe("Target muscle group (default FULL_BODY)"),
+        sets: zod.z.number().int().optional().describe("Number of sets"),
+        reps: zod.z.number().int().optional().describe("Reps per set"),
+        restSeconds: zod.z.number().int().optional().describe("Rest between sets (seconds)"),
+        targetWeight: zod.z.number().optional().describe("Target working weight"),
+        orderIndex: zod.z.number().int().optional().describe("Ordering within the workout"),
+        demoFileId: zod.z.string().optional().describe("wspace-files-svc File ID for the demo media")
+      }
+    },
+    async ({
+      workoutId,
+      name,
+      instructions,
+      muscleGroup,
+      sets,
+      reps,
+      restSeconds,
+      targetWeight,
+      orderIndex,
+      demoFileId
+    }) => {
+      try {
+        const input = { workoutId, name };
+        if (instructions !== void 0) input.instructions = instructions;
+        if (muscleGroup !== void 0) input.muscleGroup = muscleGroup;
+        if (sets !== void 0) input.sets = sets;
+        if (reps !== void 0) input.reps = reps;
+        if (restSeconds !== void 0) input.restSeconds = restSeconds;
+        if (targetWeight !== void 0) input.targetWeight = targetWeight;
+        if (orderIndex !== void 0) input.orderIndex = orderIndex;
+        if (demoFileId !== void 0) input.demoFileId = demoFileId;
+        const data = await ctx.gql.workspace.request(ADD_EXERCISE, { input });
+        return jsonResult(data.mybAddExercise);
+      } catch (error) {
+        ctx.logger.error("mybodyshield exercises_add failed", { error: String(error) });
+        return errorResult(
+          `Failed to add exercise: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerSessionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sessions_get")),
+    {
+      title: "Get Workout Session",
+      description: "Fetch a single workout session by ID, including its logged sets.",
+      inputSchema: { id: zod.z.string().describe("Workout session ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_SESSION, { id });
+        if (!data.mybSession) return errorResult(`Session ${id} not found`);
+        return jsonResult(data.mybSession);
+      } catch (error) {
+        ctx.logger.error("mybodyshield sessions_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get session: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sessions_list")),
+    {
+      title: "List Workout Sessions",
+      description: "List workout sessions in the bound workspace, optionally filtered by program and status. Returns a paginated connection ({ items, pageInfo }).",
+      inputSchema: {
+        programId: zod.z.string().optional().describe("Filter by program ID"),
+        status: SessionStatusEnum.optional().describe("Filter by session status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ programId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SESSIONS, {
+          programId,
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.mybListSessions);
+      } catch (error) {
+        ctx.logger.error("mybodyshield 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_start")),
+    {
+      title: "Start Workout Session",
+      description: "Start (or schedule) a workout session. All fields are optional \u2014 supply `workoutId`/`programId` to bind the session and `scheduledFor` to plan it for later.",
+      inputSchema: {
+        workoutId: zod.z.string().optional().describe("Workout being performed"),
+        programId: zod.z.string().optional().describe("Program the session belongs to"),
+        scheduledFor: zod.z.string().optional().describe("Scheduled time (ISO-8601 DateTime)"),
+        notes: zod.z.string().optional().describe("Session notes")
+      }
+    },
+    async ({ workoutId, programId, scheduledFor, notes }) => {
+      try {
+        const input = {};
+        if (workoutId !== void 0) input.workoutId = workoutId;
+        if (programId !== void 0) input.programId = programId;
+        if (scheduledFor !== void 0) input.scheduledFor = scheduledFor;
+        if (notes !== void 0) input.notes = notes;
+        const data = await ctx.gql.workspace.request(START_SESSION, { input });
+        return jsonResult(data.mybStartSession);
+      } catch (error) {
+        ctx.logger.error("mybodyshield sessions_start failed", { error: String(error) });
+        return errorResult(
+          `Failed to start session: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sessions_complete")),
+    {
+      title: "Complete Workout Session",
+      description: "Mark a workout session complete, recording calories burned, perceived exertion (RPE), and notes.",
+      inputSchema: {
+        id: zod.z.string().describe("Workout session ID"),
+        caloriesBurned: zod.z.number().int().optional().describe("Estimated calories burned"),
+        perceivedExertion: zod.z.number().int().optional().describe("Perceived exertion / RPE"),
+        notes: zod.z.string().optional().describe("Completion notes")
+      }
+    },
+    async ({ id, caloriesBurned, perceivedExertion, notes }) => {
+      try {
+        const input = {};
+        if (caloriesBurned !== void 0) input.caloriesBurned = caloriesBurned;
+        if (perceivedExertion !== void 0) input.perceivedExertion = perceivedExertion;
+        if (notes !== void 0) input.notes = notes;
+        const data = await ctx.gql.workspace.request(COMPLETE_SESSION, { id, input });
+        return jsonResult(data.mybCompleteSession);
+      } catch (error) {
+        ctx.logger.error("mybodyshield sessions_complete failed", { error: String(error) });
+        return errorResult(
+          `Failed to complete session: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sets_log")),
+    {
+      title: "Log Session Set",
+      description: "Log a single set within a workout session. `sessionId` and `exerciseName` are required; record reps/weight (strength) or distanceM/durationSec (cardio) and flag personal records.",
+      inputSchema: {
+        sessionId: zod.z.string().describe("Parent workout session ID"),
+        exerciseName: zod.z.string().min(1).describe("Exercise name for this set"),
+        setNumber: zod.z.number().int().optional().describe("Set ordinal within the exercise"),
+        reps: zod.z.number().int().optional().describe("Repetitions performed"),
+        weight: zod.z.number().optional().describe("Weight used"),
+        distanceM: zod.z.number().optional().describe("Distance in metres (cardio)"),
+        durationSec: zod.z.number().int().optional().describe("Duration in seconds (cardio)"),
+        isPersonalRecord: zod.z.boolean().optional().describe("Mark as a personal record")
+      }
+    },
+    async ({
+      sessionId,
+      exerciseName,
+      setNumber,
+      reps,
+      weight,
+      distanceM,
+      durationSec,
+      isPersonalRecord
+    }) => {
+      try {
+        const input = { sessionId, exerciseName };
+        if (setNumber !== void 0) input.setNumber = setNumber;
+        if (reps !== void 0) input.reps = reps;
+        if (weight !== void 0) input.weight = weight;
+        if (distanceM !== void 0) input.distanceM = distanceM;
+        if (durationSec !== void 0) input.durationSec = durationSec;
+        if (isPersonalRecord !== void 0) input.isPersonalRecord = isPersonalRecord;
+        const data = await ctx.gql.workspace.request(LOG_SET, { input });
+        return jsonResult(data.mybLogSet);
+      } catch (error) {
+        ctx.logger.error("mybodyshield sets_log failed", { error: String(error) });
+        return errorResult(
+          `Failed to log set: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerNutritionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "nutrition_get")),
+    {
+      title: "Get Nutrition Plan",
+      description: "Fetch a single nutrition plan by ID, including its logged meals.",
+      inputSchema: { id: zod.z.string().describe("Nutrition plan ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_NUTRITION_PLAN, { id });
+        if (!data.mybNutritionPlan) return errorResult(`Nutrition plan ${id} not found`);
+        return jsonResult(data.mybNutritionPlan);
+      } catch (error) {
+        ctx.logger.error("mybodyshield nutrition_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get nutrition plan: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "nutrition_active")),
+    {
+      title: "Get Active Nutrition Plan",
+      description: "Fetch the active nutrition plan for a member (defaults to the calling actor when memberId is omitted). Returns null when there's no active plan.",
+      inputSchema: {
+        memberId: zod.z.string().optional().describe("Member (user) ID (default: calling actor)")
+      }
+    },
+    async ({ memberId }) => {
+      try {
+        const data = await ctx.gql.workspace.request(ACTIVE_NUTRITION_PLAN, { memberId });
+        return jsonResult(data.mybActiveNutritionPlan);
+      } catch (error) {
+        ctx.logger.error("mybodyshield nutrition_active failed", { error: String(error) });
+        return errorResult(
+          `Failed to get active nutrition plan: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "nutrition_create")),
+    {
+      title: "Create Nutrition Plan",
+      description: "Create a nutrition plan with macro targets. `name` is required; `goalType` defaults to GENERAL_FITNESS.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Plan name"),
+        memberId: zod.z.string().optional().describe("Member (user) ID the plan is for"),
+        coachId: zod.z.string().optional().describe("Coach (user) ID authoring the plan"),
+        goalType: GoalTypeEnum.optional().describe("Goal (default GENERAL_FITNESS)"),
+        calorieTarget: zod.z.number().int().optional().describe("Daily calorie target"),
+        proteinTarget: zod.z.number().int().optional().describe("Daily protein target (g)"),
+        carbsTarget: zod.z.number().int().optional().describe("Daily carbohydrate target (g)"),
+        fatTarget: zod.z.number().int().optional().describe("Daily fat target (g)"),
+        startDate: zod.z.string().optional().describe("Start date (ISO-8601 DateTime)"),
+        endDate: zod.z.string().optional().describe("End date (ISO-8601 DateTime)"),
+        notes: zod.z.string().optional().describe("Plan notes")
+      }
+    },
+    async ({
+      name,
+      memberId,
+      coachId,
+      goalType,
+      calorieTarget,
+      proteinTarget,
+      carbsTarget,
+      fatTarget,
+      startDate,
+      endDate,
+      notes
+    }) => {
+      try {
+        const input = { name };
+        if (memberId !== void 0) input.memberId = memberId;
+        if (coachId !== void 0) input.coachId = coachId;
+        if (goalType !== void 0) input.goalType = goalType;
+        if (calorieTarget !== void 0) input.calorieTarget = calorieTarget;
+        if (proteinTarget !== void 0) input.proteinTarget = proteinTarget;
+        if (carbsTarget !== void 0) input.carbsTarget = carbsTarget;
+        if (fatTarget !== void 0) input.fatTarget = fatTarget;
+        if (startDate !== void 0) input.startDate = startDate;
+        if (endDate !== void 0) input.endDate = endDate;
+        if (notes !== void 0) input.notes = notes;
+        const data = await ctx.gql.workspace.request(CREATE_NUTRITION_PLAN, { input });
+        return jsonResult(data.mybCreateNutritionPlan);
+      } catch (error) {
+        ctx.logger.error("mybodyshield nutrition_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create nutrition plan: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "nutrition_update")),
+    {
+      title: "Update Nutrition Plan",
+      description: "Update a nutrition plan. At least one mutable field must be provided. Use `nutrition_activate` to make a plan the active one.",
+      inputSchema: {
+        id: zod.z.string().describe("Nutrition plan ID"),
+        name: zod.z.string().optional().describe("Updated name"),
+        goalType: GoalTypeEnum.optional().describe("Updated goal"),
+        calorieTarget: zod.z.number().int().optional().describe("Updated calorie target"),
+        proteinTarget: zod.z.number().int().optional().describe("Updated protein target (g)"),
+        carbsTarget: zod.z.number().int().optional().describe("Updated carbohydrate target (g)"),
+        fatTarget: zod.z.number().int().optional().describe("Updated fat target (g)"),
+        startDate: zod.z.string().optional().describe("Updated start date (ISO-8601 DateTime)"),
+        endDate: zod.z.string().optional().describe("Updated end date (ISO-8601 DateTime)"),
+        notes: zod.z.string().optional().describe("Updated notes")
+      }
+    },
+    async ({
+      id,
+      name,
+      goalType,
+      calorieTarget,
+      proteinTarget,
+      carbsTarget,
+      fatTarget,
+      startDate,
+      endDate,
+      notes
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (goalType !== void 0) input.goalType = goalType;
+        if (calorieTarget !== void 0) input.calorieTarget = calorieTarget;
+        if (proteinTarget !== void 0) input.proteinTarget = proteinTarget;
+        if (carbsTarget !== void 0) input.carbsTarget = carbsTarget;
+        if (fatTarget !== void 0) input.fatTarget = fatTarget;
+        if (startDate !== void 0) input.startDate = startDate;
+        if (endDate !== void 0) input.endDate = endDate;
+        if (notes !== void 0) input.notes = notes;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of name/goalType/calorieTarget/proteinTarget/carbsTarget/fatTarget/startDate/endDate/notes"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_NUTRITION_PLAN, { id, input });
+        return jsonResult(data.mybUpdateNutritionPlan);
+      } catch (error) {
+        ctx.logger.error("mybodyshield nutrition_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update nutrition plan: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "nutrition_activate")),
+    {
+      title: "Activate Nutrition Plan",
+      description: "Make a nutrition plan the active plan for its member (deactivating any other active plan).",
+      inputSchema: { id: zod.z.string().describe("Nutrition plan ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(ACTIVATE_NUTRITION_PLAN, { id });
+        return jsonResult(data.mybActivateNutritionPlan);
+      } catch (error) {
+        ctx.logger.error("mybodyshield nutrition_activate failed", { error: String(error) });
+        return errorResult(
+          `Failed to activate nutrition plan: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "nutrition_daily_macros")),
+    {
+      title: "Daily Macros Rollup",
+      description: "Roll up a member's logged meals for a given day against the active plan's targets (calories + protein/carbs/fat consumed vs target).",
+      inputSchema: {
+        memberId: zod.z.string().optional().describe("Member (user) ID (default: calling actor)"),
+        date: zod.z.string().optional().describe("Day to roll up (ISO-8601 DateTime; default: today)")
+      }
+    },
+    async ({ memberId, date }) => {
+      try {
+        const data = await ctx.gql.workspace.request(DAILY_MACROS, { memberId, date });
+        return jsonResult(data.mybDailyMacros);
+      } catch (error) {
+        ctx.logger.error("mybodyshield nutrition_daily_macros failed", { error: String(error) });
+        return errorResult(
+          `Failed to roll up daily macros: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerMealTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "meals_list")),
+    {
+      title: "List Meal Logs",
+      description: "List logged meals in the bound workspace, optionally filtered by nutrition plan and meal type. Returns a paginated connection ({ items, pageInfo }).",
+      inputSchema: {
+        planId: zod.z.string().optional().describe("Filter by nutrition plan ID"),
+        mealType: MealTypeEnum.optional().describe("Filter by meal slot"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ planId, mealType, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MEALS, {
+          planId,
+          mealType,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.mybListMeals);
+      } catch (error) {
+        ctx.logger.error("mybodyshield meals_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list meals: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "meals_log")),
+    {
+      title: "Log Meal",
+      description: "Log a meal with its macros. `name` is required; `mealType` defaults to SNACK. Attach to a plan via `planId` to count toward daily macros.",
+      inputSchema: {
+        name: zod.z.string().min(1).describe("Meal name"),
+        mealType: MealTypeEnum.optional().describe("Meal slot (default SNACK)"),
+        planId: zod.z.string().optional().describe("Nutrition plan ID to attribute the meal to"),
+        calories: zod.z.number().int().optional().describe("Calories"),
+        proteinG: zod.z.number().int().optional().describe("Protein (g)"),
+        carbsG: zod.z.number().int().optional().describe("Carbohydrates (g)"),
+        fatG: zod.z.number().int().optional().describe("Fat (g)"),
+        servings: zod.z.number().optional().describe("Number of servings"),
+        isFavorite: zod.z.boolean().optional().describe("Flag as a favorite meal"),
+        loggedAt: zod.z.string().optional().describe("When the meal was eaten (ISO-8601 DateTime)")
+      }
+    },
+    async ({
+      name,
+      mealType,
+      planId,
+      calories,
+      proteinG,
+      carbsG,
+      fatG,
+      servings,
+      isFavorite,
+      loggedAt
+    }) => {
+      try {
+        const input = { name };
+        if (mealType !== void 0) input.mealType = mealType;
+        if (planId !== void 0) input.planId = planId;
+        if (calories !== void 0) input.calories = calories;
+        if (proteinG !== void 0) input.proteinG = proteinG;
+        if (carbsG !== void 0) input.carbsG = carbsG;
+        if (fatG !== void 0) input.fatG = fatG;
+        if (servings !== void 0) input.servings = servings;
+        if (isFavorite !== void 0) input.isFavorite = isFavorite;
+        if (loggedAt !== void 0) input.loggedAt = loggedAt;
+        const data = await ctx.gql.workspace.request(LOG_MEAL, { input });
+        return jsonResult(data.mybLogMeal);
+      } catch (error) {
+        ctx.logger.error("mybodyshield meals_log failed", { error: String(error) });
+        return errorResult(
+          `Failed to log meal: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "meals_delete")),
+    {
+      title: "Delete Meal Log",
+      description: "Delete a logged meal by ID. Returns true on success.",
+      inputSchema: { id: zod.z.string().describe("Meal log ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(DELETE_MEAL, {
+          id
+        });
+        return jsonResult({ deleted: data.mybDeleteMeal });
+      } catch (error) {
+        ctx.logger.error("mybodyshield meals_delete failed", { error: String(error) });
+        return errorResult(
+          `Failed to delete meal: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerGoalTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "goals_get")),
+    {
+      title: "Get Goal",
+      description: "Fetch a single goal by ID.",
+      inputSchema: { id: zod.z.string().describe("Goal ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_GOAL, { id });
+        if (!data.mybGoal) return errorResult(`Goal ${id} not found`);
+        return jsonResult(data.mybGoal);
+      } catch (error) {
+        ctx.logger.error("mybodyshield goals_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get goal: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "goals_list")),
+    {
+      title: "List Goals",
+      description: "List goals in the bound workspace, optionally filtered by member and status. Returns a paginated connection ({ items, pageInfo }).",
+      inputSchema: {
+        memberId: zod.z.string().optional().describe("Filter by member (user) ID"),
+        status: GoalStatusEnum.optional().describe("Filter by goal status"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ memberId, status, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_GOALS, {
+          memberId,
+          status,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.mybListGoals);
+      } catch (error) {
+        ctx.logger.error("mybodyshield goals_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list goals: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "goals_create")),
+    {
+      title: "Create Goal",
+      description: "Create a goal. `title` is required; `type` defaults to GENERAL_FITNESS. Set baseline/target values and a target date to track progress.",
+      inputSchema: {
+        title: zod.z.string().min(1).describe("Goal title"),
+        memberId: zod.z.string().optional().describe("Member (user) ID the goal is for"),
+        type: GoalTypeEnum.optional().describe("Goal type (default GENERAL_FITNESS)"),
+        description: zod.z.string().optional().describe("Goal description"),
+        baselineValue: zod.z.number().optional().describe("Starting value"),
+        targetValue: zod.z.number().optional().describe("Target value"),
+        unit: zod.z.string().optional().describe("Unit of measure (e.g. kg, reps, min)"),
+        targetDate: zod.z.string().optional().describe("Target date (ISO-8601 DateTime)")
+      }
+    },
+    async ({
+      title,
+      memberId,
+      type,
+      description,
+      baselineValue,
+      targetValue,
+      unit,
+      targetDate
+    }) => {
+      try {
+        const input = { title };
+        if (memberId !== void 0) input.memberId = memberId;
+        if (type !== void 0) input.type = type;
+        if (description !== void 0) input.description = description;
+        if (baselineValue !== void 0) input.baselineValue = baselineValue;
+        if (targetValue !== void 0) input.targetValue = targetValue;
+        if (unit !== void 0) input.unit = unit;
+        if (targetDate !== void 0) input.targetDate = targetDate;
+        const data = await ctx.gql.workspace.request(CREATE_GOAL, { input });
+        return jsonResult(data.mybCreateGoal);
+      } catch (error) {
+        ctx.logger.error("mybodyshield goals_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create goal: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "goals_update")),
+    {
+      title: "Update Goal",
+      description: "Update a goal. At least one mutable field must be provided. Use `current_value` to record progress, or `goals_achieve` to mark it achieved.",
+      inputSchema: {
+        id: zod.z.string().describe("Goal ID"),
+        title: zod.z.string().optional().describe("Updated title"),
+        type: GoalTypeEnum.optional().describe("Updated goal type"),
+        description: zod.z.string().optional().describe("Updated description"),
+        baselineValue: zod.z.number().optional().describe("Updated baseline value"),
+        currentValue: zod.z.number().optional().describe("Updated current/progress value"),
+        targetValue: zod.z.number().optional().describe("Updated target value"),
+        unit: zod.z.string().optional().describe("Updated unit of measure"),
+        targetDate: zod.z.string().optional().describe("Updated target date (ISO-8601 DateTime)")
+      }
+    },
+    async ({
+      id,
+      title,
+      type,
+      description,
+      baselineValue,
+      currentValue,
+      targetValue,
+      unit,
+      targetDate
+    }) => {
+      try {
+        const input = {};
+        if (title !== void 0) input.title = title;
+        if (type !== void 0) input.type = type;
+        if (description !== void 0) input.description = description;
+        if (baselineValue !== void 0) input.baselineValue = baselineValue;
+        if (currentValue !== void 0) input.currentValue = currentValue;
+        if (targetValue !== void 0) input.targetValue = targetValue;
+        if (unit !== void 0) input.unit = unit;
+        if (targetDate !== void 0) input.targetDate = targetDate;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of title/type/description/baselineValue/currentValue/targetValue/unit/targetDate"
+          );
+        }
+        const data = await ctx.gql.workspace.request(UPDATE_GOAL, { id, input });
+        return jsonResult(data.mybUpdateGoal);
+      } catch (error) {
+        ctx.logger.error("mybodyshield goals_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update goal: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "goals_achieve")),
+    {
+      title: "Achieve Goal",
+      description: "Mark a goal as achieved (sets status ACHIEVED + achievedAt).",
+      inputSchema: { id: zod.z.string().describe("Goal ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(ACHIEVE_GOAL, { id });
+        return jsonResult(data.mybAchieveGoal);
+      } catch (error) {
+        ctx.logger.error("mybodyshield goals_achieve failed", { error: String(error) });
+        return errorResult(
+          `Failed to achieve goal: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerMetricTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "metrics_list")),
+    {
+      title: "List Body Metrics",
+      description: "List recorded body metrics in the bound workspace, optionally filtered by member and metric type. Returns a paginated connection ({ items, pageInfo }).",
+      inputSchema: {
+        memberId: zod.z.string().optional().describe("Filter by member (user) ID"),
+        type: BodyMetricTypeEnum.optional().describe("Filter by metric type"),
+        limit: zod.z.number().int().optional().describe("Page size (default 50)"),
+        offset: zod.z.number().int().optional().describe("Pagination offset (default 0)"),
+        cursor: zod.z.string().optional().describe("Opaque pagination cursor")
+      }
+    },
+    async ({ memberId, type, limit, offset, cursor }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_BODY_METRICS, {
+          memberId,
+          type,
+          pagination: { limit: limit ?? 50, offset: offset ?? 0, cursor }
+        });
+        return jsonResult(data.mybListBodyMetrics);
+      } catch (error) {
+        ctx.logger.error("mybodyshield metrics_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list body metrics: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "metrics_record")),
+    {
+      title: "Record Body Metric",
+      description: "Record a body measurement. `type` and `value` are required; attach a progress photo via `photoFileId` (a wspace-files-svc File ID).",
+      inputSchema: {
+        type: BodyMetricTypeEnum.describe("Metric type"),
+        value: zod.z.number().describe("Measured value"),
+        unit: zod.z.string().optional().describe("Unit of measure (e.g. kg, cm, %, bpm)"),
+        memberId: zod.z.string().optional().describe("Member (user) ID (default: calling actor)"),
+        measuredAt: zod.z.string().optional().describe("When measured (ISO-8601 DateTime; default: now)"),
+        notes: zod.z.string().optional().describe("Notes"),
+        photoFileId: zod.z.string().optional().describe("wspace-files-svc File ID for a progress photo")
+      }
+    },
+    async ({ type, value, unit, memberId, measuredAt, notes, photoFileId }) => {
+      try {
+        const input = { type, value };
+        if (unit !== void 0) input.unit = unit;
+        if (memberId !== void 0) input.memberId = memberId;
+        if (measuredAt !== void 0) input.measuredAt = measuredAt;
+        if (notes !== void 0) input.notes = notes;
+        if (photoFileId !== void 0) input.photoFileId = photoFileId;
+        const data = await ctx.gql.workspace.request(RECORD_BODY_METRIC, { input });
+        return jsonResult(data.mybRecordBodyMetric);
+      } catch (error) {
+        ctx.logger.error("mybodyshield metrics_record failed", { error: String(error) });
+        return errorResult(
+          `Failed to record body metric: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerRecoveryTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "recovery_list")),
+    {
+      title: "List Recovery Logs",
+      description: "List recovery/wellbeing logs in the bound workspace, optionally filtered by member and metric. Returns a plain array.",
+      inputSchema: {
+        memberId: zod.z.string().optional().describe("Filter by member (user) ID"),
+        metric: RecoveryMetricEnum.optional().describe("Filter by recovery metric")
+      }
+    },
+    async ({ memberId, metric }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_RECOVERY_LOGS, { memberId, metric });
+        return jsonResult(data.mybListRecoveryLogs);
+      } catch (error) {
+        ctx.logger.error("mybodyshield recovery_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list recovery logs: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "recovery_log")),
+    {
+      title: "Log Recovery Signal",
+      description: "Log a recovery/wellbeing signal (sleep, soreness, readiness, mood, stress). `metric` defaults to READINESS. Record a 0\u2013100 `score` and/or `sleepHours`.",
+      inputSchema: {
+        metric: RecoveryMetricEnum.optional().describe("Recovery metric (default READINESS)"),
+        score: zod.z.number().int().optional().describe("Score (typically 0\u2013100)"),
+        sleepHours: zod.z.number().optional().describe("Hours slept"),
+        memberId: zod.z.string().optional().describe("Member (user) ID (default: calling actor)"),
+        loggedAt: zod.z.string().optional().describe("When logged (ISO-8601 DateTime; default: now)"),
+        notes: zod.z.string().optional().describe("Notes")
+      }
+    },
+    async ({ metric, score, sleepHours, memberId, loggedAt, notes }) => {
+      try {
+        const input = {};
+        if (metric !== void 0) input.metric = metric;
+        if (score !== void 0) input.score = score;
+        if (sleepHours !== void 0) input.sleepHours = sleepHours;
+        if (memberId !== void 0) input.memberId = memberId;
+        if (loggedAt !== void 0) input.loggedAt = loggedAt;
+        if (notes !== void 0) input.notes = notes;
+        const data = await ctx.gql.workspace.request(LOG_RECOVERY, { input });
+        return jsonResult(data.mybLogRecovery);
+      } catch (error) {
+        ctx.logger.error("mybodyshield recovery_log failed", { error: String(error) });
+        return errorResult(
+          `Failed to log recovery: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerCoachingTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "coaching_list")),
+    {
+      title: "List Coaching Relationships",
+      description: "List coach\u2194member coaching relationships in the bound workspace, optionally filtered by member and status. Returns a plain array.",
+      inputSchema: {
+        memberId: zod.z.string().optional().describe("Filter by member (user) ID"),
+        status: CoachingStatusEnum.optional().describe("Filter by coaching status")
+      }
+    },
+    async ({ memberId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_COACHING, { memberId, status });
+        return jsonResult(data.mybListCoaching);
+      } catch (error) {
+        ctx.logger.error("mybodyshield coaching_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list coaching relationships: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "coaching_create")),
+    {
+      title: "Create Coaching Relationship",
+      description: "Create a coaching relationship between a coach and a member (starts PENDING). Use the share flags to control what the coach can see.",
+      inputSchema: {
+        coachId: zod.z.string().describe("Coach (user) ID"),
+        memberId: zod.z.string().describe("Member (user) ID"),
+        specialty: zod.z.string().optional().describe("Coach's specialty"),
+        shareWorkouts: zod.z.boolean().optional().describe("Share workout data with the coach"),
+        shareNutrition: zod.z.boolean().optional().describe("Share nutrition data with the coach"),
+        shareMetrics: zod.z.boolean().optional().describe("Share body-metric data with the coach")
+      }
+    },
+    async ({ coachId, memberId, specialty, shareWorkouts, shareNutrition, shareMetrics }) => {
+      try {
+        const input = { coachId, memberId };
+        if (specialty !== void 0) input.specialty = specialty;
+        if (shareWorkouts !== void 0) input.shareWorkouts = shareWorkouts;
+        if (shareNutrition !== void 0) input.shareNutrition = shareNutrition;
+        if (shareMetrics !== void 0) input.shareMetrics = shareMetrics;
+        const data = await ctx.gql.workspace.request(CREATE_COACHING, { input });
+        return jsonResult(data.mybCreateCoaching);
+      } catch (error) {
+        ctx.logger.error("mybodyshield coaching_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create coaching relationship: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "coaching_transition")),
+    {
+      title: "Transition Coaching Relationship",
+      description: "Move a coaching relationship through its lifecycle: PENDING \u2192 ACTIVE \u2192 PAUSED / ENDED.",
+      inputSchema: {
+        id: zod.z.string().describe("Coaching relationship ID"),
+        status: CoachingStatusEnum.describe("Target coaching status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_COACHING, { id, status });
+        return jsonResult(data.mybTransitionCoaching);
+      } catch (error) {
+        ctx.logger.error("mybodyshield coaching_transition failed", { error: String(error) });
+        return errorResult(
+          `Failed to transition coaching relationship: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/mybodyshield/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "Mybodyshield Health Check",
+      description: "Public liveness/identity probe for the Mybodyshield subgraph (mybHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.mybHealth });
+      } catch (error) {
+        ctx.logger.error("mybodyshield health failed", { error: String(error) });
+        return errorResult(
+          `Mybodyshield health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/mybodyshield/resources.ts
+function registerMybodyshieldResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const programsUri = track(mcpResourceUri(ctx.productName, "programs"));
+  const goalsUri = track(mcpResourceUri(ctx.productName, "goals"));
+  const nutritionUri = track(mcpResourceUri(ctx.productName, "nutrition"));
+  server.registerResource(
+    "mybodyshield-schema",
+    schemaUri,
+    {
+      title: "Mybodyshield Domain Schema",
+      description: "Overview of the Mybodyshield health & fitness domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# Mybodyshield Domain (Overview)
+
+Health & fitness platform \u2014 system of record for training, nutrition, wellbeing, and coaching.
+
+## Entities
+- MybProgram \u2014 a training program (has workouts)
+- MybWorkout \u2014 a workout within a program (has exercises)
+- MybExercise \u2014 an exercise within a workout (demo File via federation)
+- MybWorkoutSession \u2014 a logged/scheduled session (has sets)
+- MybSessionSet \u2014 a single set logged in a session
+- MybNutritionPlan \u2014 a nutrition plan with macro targets (has meals)
+- MybMealLog \u2014 a logged meal with macros
+- MybGoal \u2014 a tracked fitness goal
+- MybBodyMetric \u2014 a body measurement (progress photo File via federation)
+- MybRecoveryLog \u2014 a recovery/wellbeing signal (sleep, soreness, readiness, mood, stress)
+- MybCoachingRelationship \u2014 a coach\u2194member relationship with share scopes
+
+## Enums
+- GoalType: ENDURANCE, GENERAL_FITNESS, MOBILITY, MUSCLE_GAIN, STRENGTH, WEIGHT_LOSS
+- GoalStatus: ABANDONED, ACHIEVED, ACTIVE, PAUSED
+- FitnessLevel: ADVANCED, BEGINNER, ELITE, INTERMEDIATE
+- ProgramPhase: BUILD, DELOAD, MAINTENANCE, PEAK
+- ProgramStatus: ACTIVE, ARCHIVED, COMPLETED, DRAFT
+- WorkoutType: CARDIO, HIIT, MOBILITY, RECOVERY, STRENGTH, YOGA
+- MuscleGroup: ARMS, BACK, CHEST, CORE, FULL_BODY, LEGS, SHOULDERS
+- SessionStatus: COMPLETED, IN_PROGRESS, SCHEDULED, SKIPPED
+- MealType: BREAKFAST, DINNER, LUNCH, SNACK
+- BodyMetricType: ARM, BODY_FAT, CHEST, HIPS, RESTING_HEART_RATE, THIGH, WAIST, WEIGHT
+- RecoveryMetric: MOOD, READINESS, SLEEP, SORENESS, STRESS
+- CoachingStatus: ACTIVE, ENDED, PAUSED, PENDING
+
+## Tool groups
+programs, workouts (+exercises), sessions (+sets), nutrition (+daily_macros),
+meals, goals, metrics, recovery, coaching, health.
+All run against the WORKSPACE gateway (workspace-scoped) except the public health probe.
+`;
+      return {
+        contents: [{ uri: schemaUri, text: schema, mimeType: "text/plain" }]
+      };
+    }
+  );
+  server.registerResource(
+    "mybodyshield-programs",
+    programsUri,
+    {
+      title: "Mybodyshield Programs",
+      description: "The first 50 training programs in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${programsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PROGRAMS, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: programsUri,
+              text: JSON.stringify(data.mybListPrograms, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: programsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "mybodyshield-goals",
+    goalsUri,
+    {
+      title: "Mybodyshield Goals",
+      description: "The first 50 goals in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${goalsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_GOALS, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: goalsUri,
+              text: JSON.stringify(data.mybListGoals, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: goalsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "mybodyshield-nutrition",
+    nutritionUri,
+    {
+      title: "Mybodyshield Active Nutrition Plan",
+      description: "The calling actor's active nutrition plan (with logged meals), if any.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${nutritionUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(
+          ACTIVE_NUTRITION_PLAN,
+          {}
+        );
+        return {
+          contents: [
+            {
+              uri: nutritionUri,
+              text: JSON.stringify(data.mybActiveNutritionPlan, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: nutritionUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerMybodyshieldPrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const designName = track(mcpPromptName(p, "program-design"));
+  const reviewName = track(mcpPromptName(p, "coaching-review"));
+  server.registerPrompt(
+    designName,
+    {
+      title: "Program Design",
+      description: "Guide for designing a Mybodyshield training program end to end: create the program, add workouts and exercises, optionally pair a nutrition plan, and activate.",
+      argsSchema: {
+        memberId: zod.z.string().optional().describe("Member the program is for"),
+        goalType: zod.z.string().optional().describe("Primary goal (e.g. STRENGTH, WEIGHT_LOSS)")
+      }
+    },
+    ({ memberId, goalType }) => {
+      ctx.logger.debug(`Prompt ${designName} called`, { memberId, goalType });
+      const memberNote = memberId ? `Design it for member "${memberId}".` : "Ask the user which member the program is for.";
+      const goalNote = goalType ? `Use goalType ${goalType}.` : "Help the user pick a GoalType.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me design a new Mybodyshield training program.
+
+1. **Create Program**: Use ${p}_programs_create. ${memberNote} ${goalNote} Set level, phase, daysPerWeek, and weeks.
+2. **Add Workouts**: Use ${p}_workouts_add for each session in the week (set type, dayOfWeek, weekNumber, durationMin).
+3. **Add Exercises**: Use ${p}_exercises_add for each exercise in a workout (muscleGroup, sets, reps, restSeconds, targetWeight).
+4. **(Optional) Nutrition**: Use ${p}_nutrition_create to pair a macro plan (calorieTarget, proteinTarget, carbsTarget, fatTarget) and ${p}_nutrition_activate to make it active.
+5. **Verify**: Use ${p}_programs_get to review the full program tree.
+6. **Activate**: Use ${p}_programs_transition with status=ACTIVE when ready.
+
+Show results at each step and confirm before activation.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    reviewName,
+    {
+      title: "Coaching Review",
+      description: "Periodic member-review workflow for a coach: review recent sessions, body metrics, recovery signals, daily macros, and goal progress, then adjust the program.",
+      argsSchema: {
+        memberId: zod.z.string().optional().describe("Member to review")
+      }
+    },
+    ({ memberId }) => {
+      ctx.logger.debug(`Prompt ${reviewName} called`, { memberId });
+      const memberNote = memberId ? `Review member "${memberId}".` : `First list coaching relationships with ${p}_coaching_list and pick a member.`;
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run a Mybodyshield coaching review. ${memberNote}
+
+1. **Training**: Use ${p}_sessions_list (filter by program/status) to see recent workout sessions and adherence.
+2. **Body Metrics**: Use ${p}_metrics_list (filter by memberId) to chart weight / body-fat / measurement trends.
+3. **Recovery**: Use ${p}_recovery_list (filter by memberId) to check sleep, soreness, readiness, mood, and stress.
+4. **Nutrition**: Use ${p}_nutrition_daily_macros for the member to compare consumed vs target macros, and ${p}_nutrition_active for the current plan.
+5. **Goals**: Use ${p}_goals_list (filter by memberId) \u2014 mark hit goals with ${p}_goals_achieve and update progress with ${p}_goals_update.
+6. **Adjust**: Use ${p}_programs_update / ${p}_nutrition_update to adapt the plan based on findings.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/mybodyshield/index.ts
+var mybodyshieldModule = {
+  id: "mybodyshield",
+  version: "0.0.1",
+  displayName: "Mybodyshield",
+  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;
+    };
+    registerProgramTools(server, ctx, trackTool);
+    registerWorkoutTools(server, ctx, trackTool);
+    registerSessionTools(server, ctx, trackTool);
+    registerNutritionTools(server, ctx, trackTool);
+    registerMealTools(server, ctx, trackTool);
+    registerGoalTools(server, ctx, trackTool);
+    registerMetricTools(server, ctx, trackTool);
+    registerRecoveryTools(server, ctx, trackTool);
+    registerCoachingTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerMybodyshieldResources(server, ctx, trackResource);
+    registerMybodyshieldPrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var mybodyshield_default = mybodyshieldModule;
+
+module.exports = mybodyshield_default;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map