@burdenoff/mcp-libs 2026.627.6 → 2026.629.1

package/dist/modules/atheletebridge/index.js

@@ -0,0 +1,1646 @@
+import { mcpToolName, errorResult, jsonResult, mcpResourceUri, mcpPromptName } from '../../chunk-H2OYWLOA.js';
+import { z } from 'zod';
+
+// src/modules/atheletebridge/operations.ts
+var MEMBER_FIELDS = `
+  id teamId userId displayName role status position jerseyNumber
+  dominantSide height weight joinedAt notes workspaceId createdAt updatedAt
+`;
+var TEAM_FIELDS = `
+  id name sport status season ageGroup homeVenue headCoachId description
+  tags workspaceId createdAt updatedAt
+`;
+var DRILL_FIELDS = `
+  id programId name description weekNumber orderIndex sets reps
+  durationSec restSec video { id } workspaceId createdAt updatedAt
+`;
+var PROGRAM_FIELDS = `
+  id coachId name sport level status summary weeks isTemplate tags
+  workspaceId createdAt updatedAt
+`;
+var SESSION_FIELDS = `
+  id coachId athleteId programId title type status scheduledAt durationMin
+  location meetingUrl rating feedback completedAt workspaceId createdAt updatedAt
+`;
+var FIXTURE_FIELDS = `
+  id homeTeamId awayTeamId type status competition round venue
+  scheduledAt kickoffAt homeScore awayScore notes workspaceId createdAt updatedAt
+`;
+var STANDING_FIELDS = `
+  id teamId competition played won drawn lost goalsFor goalsAgainst
+  points rank workspaceId createdAt updatedAt
+`;
+var WORKOUT_LOG_FIELDS = `
+  id athleteId programId title status performedAt durationMin rpe totalLoad
+  metrics notes workspaceId createdAt updatedAt
+`;
+var METRIC_FIELDS = `
+  id athleteId type label value unit source recordedAt workspaceId createdAt updatedAt
+`;
+var GET_TEAM = `
+  query AtheletebridgeGetTeam($id: ID!) {
+    athTeam(id: $id) {
+      ${TEAM_FIELDS}
+      members { ${MEMBER_FIELDS} }
+      fixtures { id type status scheduledAt homeTeamId awayTeamId homeScore awayScore }
+    }
+  }
+`;
+var LIST_TEAMS = `
+  query AtheletebridgeListTeams(
+    $pagination: PaginationInput
+    $sport: AthSport
+    $status: AthTeamStatus
+  ) {
+    athListTeams(pagination: $pagination, sport: $sport, status: $status) {
+      items { ${TEAM_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_TEAM = `
+  mutation AtheletebridgeCreateTeam($input: AthCreateTeamInput!) {
+    athCreateTeam(input: $input) {
+      ${TEAM_FIELDS}
+    }
+  }
+`;
+var UPDATE_TEAM = `
+  mutation AtheletebridgeUpdateTeam($id: ID!, $input: AthUpdateTeamInput!) {
+    athUpdateTeam(id: $id, input: $input) {
+      ${TEAM_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_TEAM = `
+  mutation AtheletebridgeArchiveTeam($id: ID!) {
+    athArchiveTeam(id: $id)
+  }
+`;
+var LIST_MEMBERS = `
+  query AtheletebridgeListMembers($teamId: ID!, $status: AthMemberStatus) {
+    athListMembers(teamId: $teamId, status: $status) {
+      ${MEMBER_FIELDS}
+    }
+  }
+`;
+var ADD_MEMBER = `
+  mutation AtheletebridgeAddMember($input: AthAddMemberInput!) {
+    athAddMember(input: $input) {
+      ${MEMBER_FIELDS}
+    }
+  }
+`;
+var UPDATE_MEMBER = `
+  mutation AtheletebridgeUpdateMember($id: ID!, $input: AthUpdateMemberInput!) {
+    athUpdateMember(id: $id, input: $input) {
+      ${MEMBER_FIELDS}
+    }
+  }
+`;
+var REMOVE_MEMBER = `
+  mutation AtheletebridgeRemoveMember($id: ID!) {
+    athRemoveMember(id: $id)
+  }
+`;
+var GET_PROGRAM = `
+  query AtheletebridgeGetProgram($id: ID!) {
+    athProgram(id: $id) {
+      ${PROGRAM_FIELDS}
+      drills { ${DRILL_FIELDS} }
+    }
+  }
+`;
+var LIST_PROGRAMS = `
+  query AtheletebridgeListPrograms(
+    $pagination: PaginationInput
+    $sport: AthSport
+    $level: AthProgramLevel
+    $status: AthProgramStatus
+  ) {
+    athListPrograms(
+      pagination: $pagination
+      sport: $sport
+      level: $level
+      status: $status
+    ) {
+      items { ${PROGRAM_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var CREATE_PROGRAM = `
+  mutation AtheletebridgeCreateProgram($input: AthCreateProgramInput!) {
+    athCreateProgram(input: $input) {
+      ${PROGRAM_FIELDS}
+    }
+  }
+`;
+var UPDATE_PROGRAM = `
+  mutation AtheletebridgeUpdateProgram($id: ID!, $input: AthUpdateProgramInput!) {
+    athUpdateProgram(id: $id, input: $input) {
+      ${PROGRAM_FIELDS}
+    }
+  }
+`;
+var TRANSITION_PROGRAM = `
+  mutation AtheletebridgeTransitionProgram($id: ID!, $status: AthProgramStatus!) {
+    athTransitionProgram(id: $id, status: $status) {
+      ${PROGRAM_FIELDS}
+    }
+  }
+`;
+var ARCHIVE_PROGRAM = `
+  mutation AtheletebridgeArchiveProgram($id: ID!) {
+    athArchiveProgram(id: $id)
+  }
+`;
+var ADD_DRILL = `
+  mutation AtheletebridgeAddDrill($input: AthAddDrillInput!) {
+    athAddDrill(input: $input) {
+      ${DRILL_FIELDS}
+    }
+  }
+`;
+var REMOVE_DRILL = `
+  mutation AtheletebridgeRemoveDrill($id: ID!) {
+    athRemoveDrill(id: $id)
+  }
+`;
+var GET_SESSION = `
+  query AtheletebridgeGetSession($id: ID!) {
+    athSession(id: $id) {
+      ${SESSION_FIELDS}
+    }
+  }
+`;
+var LIST_SESSIONS = `
+  query AtheletebridgeListSessions(
+    $pagination: PaginationInput
+    $coachId: ID
+    $athleteId: ID
+    $status: AthSessionStatus
+  ) {
+    athListSessions(
+      pagination: $pagination
+      coachId: $coachId
+      athleteId: $athleteId
+      status: $status
+    ) {
+      items { ${SESSION_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var BOOK_SESSION = `
+  mutation AtheletebridgeBookSession($input: AthBookSessionInput!) {
+    athBookSession(input: $input) {
+      ${SESSION_FIELDS}
+    }
+  }
+`;
+var CONFIRM_SESSION = `
+  mutation AtheletebridgeConfirmSession($id: ID!) {
+    athConfirmSession(id: $id) {
+      ${SESSION_FIELDS}
+    }
+  }
+`;
+var COMPLETE_SESSION = `
+  mutation AtheletebridgeCompleteSession($id: ID!, $input: AthCompleteSessionInput) {
+    athCompleteSession(id: $id, input: $input) {
+      ${SESSION_FIELDS}
+    }
+  }
+`;
+var CANCEL_SESSION = `
+  mutation AtheletebridgeCancelSession($id: ID!) {
+    athCancelSession(id: $id) {
+      ${SESSION_FIELDS}
+    }
+  }
+`;
+var GET_FIXTURE = `
+  query AtheletebridgeGetFixture($id: ID!) {
+    athFixture(id: $id) {
+      ${FIXTURE_FIELDS}
+      homeTeam { id name }
+      awayTeam { id name }
+    }
+  }
+`;
+var LIST_FIXTURES = `
+  query AtheletebridgeListFixtures(
+    $pagination: PaginationInput
+    $teamId: ID
+    $status: AthFixtureStatus
+  ) {
+    athListFixtures(pagination: $pagination, teamId: $teamId, status: $status) {
+      items { ${FIXTURE_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var SCHEDULE_FIXTURE = `
+  mutation AtheletebridgeScheduleFixture($input: AthCreateFixtureInput!) {
+    athScheduleFixture(input: $input) {
+      ${FIXTURE_FIELDS}
+    }
+  }
+`;
+var RECORD_FIXTURE_RESULT = `
+  mutation AtheletebridgeRecordFixtureResult($id: ID!, $input: AthRecordResultInput!) {
+    athRecordFixtureResult(id: $id, input: $input) {
+      ${FIXTURE_FIELDS}
+    }
+  }
+`;
+var LIST_STANDINGS = `
+  query AtheletebridgeStandings($competition: String!) {
+    athStandings(competition: $competition) {
+      ${STANDING_FIELDS}
+      team { id name }
+    }
+  }
+`;
+var LIST_WORKOUT_LOGS = `
+  query AtheletebridgeListWorkoutLogs(
+    $pagination: PaginationInput
+    $athleteId: ID
+    $programId: ID
+  ) {
+    athListWorkoutLogs(pagination: $pagination, athleteId: $athleteId, programId: $programId) {
+      items { ${WORKOUT_LOG_FIELDS} }
+      pageInfo { cursor hasMore }
+    }
+  }
+`;
+var LOG_WORKOUT = `
+  mutation AtheletebridgeLogWorkout($input: AthLogWorkoutInput!) {
+    athLogWorkout(input: $input) {
+      ${WORKOUT_LOG_FIELDS}
+    }
+  }
+`;
+var LIST_PERFORMANCE_METRICS = `
+  query AtheletebridgePerformanceMetrics($athleteId: ID!, $type: AthMetricType) {
+    athPerformanceMetrics(athleteId: $athleteId, type: $type) {
+      ${METRIC_FIELDS}
+    }
+  }
+`;
+var RECORD_METRIC = `
+  mutation AtheletebridgeRecordMetric($input: AthRecordMetricInput!) {
+    athRecordMetric(input: $input) {
+      ${METRIC_FIELDS}
+    }
+  }
+`;
+var HEALTH = `
+  query AtheletebridgeHealth {
+    athHealth
+  }
+`;
+var SportEnum = z.enum([
+  "ATHLETICS",
+  "BASKETBALL",
+  "CRICKET",
+  "ESPORTS",
+  "FOOTBALL",
+  "OTHER",
+  "SWIMMING",
+  "TENNIS"
+]).describe("Sport a team or program is organised around");
+var TeamStatusEnum = z.enum(["ACTIVE", "ARCHIVED", "FORMING", "INACTIVE"]).describe("Lifecycle status of a team");
+var MemberRoleEnum = z.enum(["ASSISTANT_COACH", "CAPTAIN", "COACH", "MANAGER", "PHYSIO", "PLAYER"]).describe("Role of a member within a team");
+var MemberStatusEnum = z.enum(["ACTIVE", "INJURED", "RELEASED", "SUSPENDED", "TRIAL"]).describe("Roster status of a team member");
+var ProgramLevelEnum = z.enum(["ADVANCED", "BEGINNER", "ELITE", "INTERMEDIATE"]).describe("Difficulty level of a training program");
+var ProgramStatusEnum = z.enum(["ARCHIVED", "DRAFT", "PUBLISHED"]).describe("Publish lifecycle status of a training program");
+var SessionTypeEnum = z.enum(["HYBRID", "IN_PERSON", "ONLINE"]).describe("Delivery format of a coaching session");
+var SessionStatusEnum = z.enum(["CANCELLED", "COMPLETED", "CONFIRMED", "NO_SHOW", "REQUESTED"]).describe("Lifecycle status of a coaching session");
+var FixtureTypeEnum = z.enum(["CUP", "FRIENDLY", "LEAGUE", "SCRIMMAGE", "TOURNAMENT"]).describe("Competition type of a fixture");
+var FixtureStatusEnum = z.enum(["CANCELLED", "COMPLETED", "LIVE", "POSTPONED", "SCHEDULED"]).describe("Lifecycle status of a fixture");
+var WorkoutStatusEnum = z.enum(["COMPLETED", "PLANNED", "SKIPPED"]).describe("Status of a logged workout");
+var MetricTypeEnum = z.enum(["ACCURACY", "AGILITY", "CUSTOM", "ENDURANCE", "HEART_RATE", "SPEED", "STRENGTH", "WEIGHT"]).describe("Category of a performance metric");
+var JsonObject = z.record(z.string(), z.unknown());
+
+// src/modules/atheletebridge/tools/teams.ts
+function registerTeamTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "teams_get")),
+    {
+      title: "Get Team",
+      description: "Fetch a single AtheleteBridge team by ID, including its roster (members) and fixtures.",
+      inputSchema: { id: z.string().describe("Team ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_TEAM, { id });
+        if (!data.athTeam) return errorResult(`Team ${id} not found`);
+        return jsonResult(data.athTeam);
+      } catch (error) {
+        ctx.logger.error("atheletebridge teams_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get team: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "teams_list")),
+    {
+      title: "List Teams",
+      description: "List teams in the bound workspace with optional sport/status filters and pagination.",
+      inputSchema: {
+        sport: SportEnum.optional().describe("Filter by sport"),
+        status: TeamStatusEnum.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)")
+      }
+    },
+    async ({ sport, status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_TEAMS, {
+          pagination: { limit: limit ?? 50, offset: offset ?? 0 },
+          sport,
+          status
+        });
+        return jsonResult(data.athListTeams);
+      } catch (error) {
+        ctx.logger.error("atheletebridge 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_create")),
+    {
+      title: "Create Team",
+      description: "Create a new team. `name` is required; sport and status default server-side.",
+      inputSchema: {
+        name: z.string().min(1).describe("Team display name"),
+        sport: SportEnum.optional().describe("Sport (default OTHER)"),
+        status: TeamStatusEnum.optional().describe("Initial status (default FORMING)"),
+        season: z.string().optional().describe('Season label (e.g. "2026")'),
+        ageGroup: z.string().optional().describe('Age group (e.g. "U18")'),
+        homeVenue: z.string().optional().describe("Home venue / ground"),
+        headCoachId: z.string().optional().describe("User ID of the head coach"),
+        description: z.string().optional().describe("Team description"),
+        tags: z.array(z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({
+      name,
+      sport,
+      status,
+      season,
+      ageGroup,
+      homeVenue,
+      headCoachId,
+      description,
+      tags
+    }) => {
+      try {
+        const input = { name };
+        if (sport !== void 0) input.sport = sport;
+        if (status !== void 0) input.status = status;
+        if (season !== void 0) input.season = season;
+        if (ageGroup !== void 0) input.ageGroup = ageGroup;
+        if (homeVenue !== void 0) input.homeVenue = homeVenue;
+        if (headCoachId !== void 0) input.headCoachId = headCoachId;
+        if (description !== void 0) input.description = description;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(
+          CREATE_TEAM,
+          { input }
+        );
+        return jsonResult(data.athCreateTeam);
+      } catch (error) {
+        ctx.logger.error("atheletebridge teams_create failed", { error: String(error) });
+        return errorResult(
+          `Failed to create team: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "teams_update")),
+    {
+      title: "Update Team",
+      description: "Update a team. At least one mutable field must be provided.",
+      inputSchema: {
+        id: z.string().describe("Team ID"),
+        name: z.string().optional().describe("Updated name"),
+        sport: SportEnum.optional().describe("Updated sport"),
+        status: TeamStatusEnum.optional().describe("Updated status"),
+        season: z.string().optional().describe("Updated season"),
+        ageGroup: z.string().optional().describe("Updated age group"),
+        homeVenue: z.string().optional().describe("Updated home venue"),
+        headCoachId: z.string().optional().describe("Updated head-coach user ID"),
+        description: z.string().optional().describe("Updated description"),
+        tags: z.array(z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({
+      id,
+      name,
+      sport,
+      status,
+      season,
+      ageGroup,
+      homeVenue,
+      headCoachId,
+      description,
+      tags
+    }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (sport !== void 0) input.sport = sport;
+        if (status !== void 0) input.status = status;
+        if (season !== void 0) input.season = season;
+        if (ageGroup !== void 0) input.ageGroup = ageGroup;
+        if (homeVenue !== void 0) input.homeVenue = homeVenue;
+        if (headCoachId !== void 0) input.headCoachId = headCoachId;
+        if (description !== void 0) input.description = description;
+        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/sport/status/season/ageGroup/homeVenue/headCoachId/description/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(
+          UPDATE_TEAM,
+          { id, input }
+        );
+        return jsonResult(data.athUpdateTeam);
+      } catch (error) {
+        ctx.logger.error("atheletebridge teams_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update team: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "teams_archive")),
+    {
+      title: "Archive Team",
+      description: "Archive (soft-delete) a team by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Team ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_TEAM,
+          {
+            id
+          }
+        );
+        return jsonResult({ archived: data.athArchiveTeam, id });
+      } catch (error) {
+        ctx.logger.error("atheletebridge teams_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive team: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "members_list")),
+    {
+      title: "List Team Members",
+      description: "List the members (roster) of a team, optionally filtered by member status.",
+      inputSchema: {
+        teamId: z.string().describe("Team ID"),
+        status: MemberStatusEnum.optional().describe("Filter by roster status")
+      }
+    },
+    async ({ teamId, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_MEMBERS, { teamId, status });
+        return jsonResult(data.athListMembers);
+      } catch (error) {
+        ctx.logger.error("atheletebridge members_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list members: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "members_add")),
+    {
+      title: "Add Team Member",
+      description: "Add a member to a team roster. `teamId`, `userId`, and `displayName` are required.",
+      inputSchema: {
+        teamId: z.string().min(1).describe("Team ID"),
+        userId: z.string().min(1).describe("User ID of the member"),
+        displayName: z.string().min(1).describe("Display name on the roster"),
+        role: MemberRoleEnum.optional().describe("Role (default PLAYER)"),
+        status: MemberStatusEnum.optional().describe("Initial status (default ACTIVE)"),
+        position: z.string().optional().describe("Playing position"),
+        jerseyNumber: z.number().int().optional().describe("Jersey number"),
+        dominantSide: z.string().optional().describe("Dominant side/hand/foot"),
+        height: z.number().optional().describe("Height (units per workspace convention)"),
+        weight: z.number().optional().describe("Weight (units per workspace convention)"),
+        joinedAt: z.string().optional().describe("Join date (ISO 8601 DateTime)"),
+        notes: z.string().optional().describe("Free-form notes")
+      }
+    },
+    async ({
+      teamId,
+      userId,
+      displayName,
+      role,
+      status,
+      position,
+      jerseyNumber,
+      dominantSide,
+      height,
+      weight,
+      joinedAt,
+      notes
+    }) => {
+      try {
+        const input = { teamId, userId, displayName };
+        if (role !== void 0) input.role = role;
+        if (status !== void 0) input.status = status;
+        if (position !== void 0) input.position = position;
+        if (jerseyNumber !== void 0) input.jerseyNumber = jerseyNumber;
+        if (dominantSide !== void 0) input.dominantSide = dominantSide;
+        if (height !== void 0) input.height = height;
+        if (weight !== void 0) input.weight = weight;
+        if (joinedAt !== void 0) input.joinedAt = joinedAt;
+        if (notes !== void 0) input.notes = notes;
+        const data = await ctx.gql.workspace.request(
+          ADD_MEMBER,
+          { input }
+        );
+        return jsonResult(data.athAddMember);
+      } catch (error) {
+        ctx.logger.error("atheletebridge members_add failed", { error: String(error) });
+        return errorResult(
+          `Failed to add member: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "members_update")),
+    {
+      title: "Update Team Member",
+      description: "Update a roster member. At least one mutable field must be provided.",
+      inputSchema: {
+        id: z.string().describe("Member ID"),
+        displayName: z.string().optional().describe("Updated display name"),
+        role: MemberRoleEnum.optional().describe("Updated role"),
+        status: MemberStatusEnum.optional().describe("Updated roster status"),
+        position: z.string().optional().describe("Updated position"),
+        jerseyNumber: z.number().int().optional().describe("Updated jersey number"),
+        dominantSide: z.string().optional().describe("Updated dominant side"),
+        height: z.number().optional().describe("Updated height"),
+        weight: z.number().optional().describe("Updated weight"),
+        notes: z.string().optional().describe("Updated notes")
+      }
+    },
+    async ({
+      id,
+      displayName,
+      role,
+      status,
+      position,
+      jerseyNumber,
+      dominantSide,
+      height,
+      weight,
+      notes
+    }) => {
+      try {
+        const input = {};
+        if (displayName !== void 0) input.displayName = displayName;
+        if (role !== void 0) input.role = role;
+        if (status !== void 0) input.status = status;
+        if (position !== void 0) input.position = position;
+        if (jerseyNumber !== void 0) input.jerseyNumber = jerseyNumber;
+        if (dominantSide !== void 0) input.dominantSide = dominantSide;
+        if (height !== void 0) input.height = height;
+        if (weight !== void 0) input.weight = weight;
+        if (notes !== void 0) input.notes = notes;
+        if (Object.keys(input).length === 0) {
+          return errorResult(
+            "No updates specified \u2014 provide at least one of displayName/role/status/position/jerseyNumber/dominantSide/height/weight/notes"
+          );
+        }
+        const data = await ctx.gql.workspace.request(
+          UPDATE_MEMBER,
+          { id, input }
+        );
+        return jsonResult(data.athUpdateMember);
+      } catch (error) {
+        ctx.logger.error("atheletebridge members_update failed", { error: String(error) });
+        return errorResult(
+          `Failed to update member: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "members_remove")),
+    {
+      title: "Remove Team Member",
+      description: "Remove a member from the roster by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Member ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          REMOVE_MEMBER,
+          { id }
+        );
+        return jsonResult({ removed: data.athRemoveMember, id });
+      } catch (error) {
+        ctx.logger.error("atheletebridge members_remove failed", { error: String(error) });
+        return errorResult(
+          `Failed to remove member: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerProgramTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "programs_get")),
+    {
+      title: "Get Training Program",
+      description: "Fetch a single training program by ID, including its drills.",
+      inputSchema: { id: z.string().describe("Program ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_PROGRAM, { id });
+        if (!data.athProgram) return errorResult(`Program ${id} not found`);
+        return jsonResult(data.athProgram);
+      } catch (error) {
+        ctx.logger.error("atheletebridge 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 with optional sport/level/status filters and pagination.",
+      inputSchema: {
+        sport: SportEnum.optional().describe("Filter by sport"),
+        level: ProgramLevelEnum.optional().describe("Filter by difficulty level"),
+        status: ProgramStatusEnum.optional().describe("Filter by publish status"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ sport, level, status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PROGRAMS, {
+          pagination: { limit: limit ?? 50, offset: offset ?? 0 },
+          sport,
+          level,
+          status
+        });
+        return jsonResult(data.athListPrograms);
+      } catch (error) {
+        ctx.logger.error("atheletebridge 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 new training program. `name` is required.",
+      inputSchema: {
+        name: z.string().min(1).describe("Program name"),
+        sport: SportEnum.optional().describe("Sport (default OTHER)"),
+        level: ProgramLevelEnum.optional().describe("Difficulty level (default BEGINNER)"),
+        summary: z.string().optional().describe("Short summary"),
+        weeks: z.number().int().optional().describe("Number of weeks the program spans"),
+        isTemplate: z.boolean().optional().describe("Mark as a reusable template (default false)"),
+        tags: z.array(z.string()).optional().describe("Free-form tags")
+      }
+    },
+    async ({ name, sport, level, summary, weeks, isTemplate, tags }) => {
+      try {
+        const input = { name };
+        if (sport !== void 0) input.sport = sport;
+        if (level !== void 0) input.level = level;
+        if (summary !== void 0) input.summary = summary;
+        if (weeks !== void 0) input.weeks = weeks;
+        if (isTemplate !== void 0) input.isTemplate = isTemplate;
+        if (tags !== void 0) input.tags = tags;
+        const data = await ctx.gql.workspace.request(
+          CREATE_PROGRAM,
+          { input }
+        );
+        return jsonResult(data.athCreateProgram);
+      } catch (error) {
+        ctx.logger.error("atheletebridge 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.",
+      inputSchema: {
+        id: z.string().describe("Program ID"),
+        name: z.string().optional().describe("Updated name"),
+        sport: SportEnum.optional().describe("Updated sport"),
+        level: ProgramLevelEnum.optional().describe("Updated level"),
+        summary: z.string().optional().describe("Updated summary"),
+        weeks: z.number().int().optional().describe("Updated week count"),
+        isTemplate: z.boolean().optional().describe("Updated template flag"),
+        tags: z.array(z.string()).optional().describe("Updated tags")
+      }
+    },
+    async ({ id, name, sport, level, summary, weeks, isTemplate, tags }) => {
+      try {
+        const input = {};
+        if (name !== void 0) input.name = name;
+        if (sport !== void 0) input.sport = sport;
+        if (level !== void 0) input.level = level;
+        if (summary !== void 0) input.summary = summary;
+        if (weeks !== void 0) input.weeks = weeks;
+        if (isTemplate !== void 0) input.isTemplate = isTemplate;
+        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/sport/level/summary/weeks/isTemplate/tags"
+          );
+        }
+        const data = await ctx.gql.workspace.request(
+          UPDATE_PROGRAM,
+          { id, input }
+        );
+        return jsonResult(data.athUpdateProgram);
+      } catch (error) {
+        ctx.logger.error("atheletebridge 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 Program Status",
+      description: "Advance a program through its publish lifecycle (validated transitions: DRAFT -> PUBLISHED -> ARCHIVED).",
+      inputSchema: {
+        id: z.string().describe("Program ID"),
+        status: ProgramStatusEnum.describe("Target status")
+      }
+    },
+    async ({ id, status }) => {
+      try {
+        const data = await ctx.gql.workspace.request(TRANSITION_PROGRAM, { id, status });
+        return jsonResult(data.athTransitionProgram);
+      } catch (error) {
+        ctx.logger.error("atheletebridge 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 (soft-delete) a program by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Program ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          ARCHIVE_PROGRAM,
+          { id }
+        );
+        return jsonResult({ archived: data.athArchiveProgram, id });
+      } catch (error) {
+        ctx.logger.error("atheletebridge programs_archive failed", { error: String(error) });
+        return errorResult(
+          `Failed to archive program: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "drills_add")),
+    {
+      title: "Add Drill",
+      description: "Add a drill to a training program. `programId` and `name` are required. `videoFileId` references a wspace-files-svc File (demo video).",
+      inputSchema: {
+        programId: z.string().min(1).describe("Program ID the drill belongs to"),
+        name: z.string().min(1).describe("Drill name"),
+        description: z.string().optional().describe("Drill description / instructions"),
+        weekNumber: z.number().int().optional().describe("Program week (default 1)"),
+        orderIndex: z.number().int().optional().describe("Ordering within the week (default 0)"),
+        sets: z.number().int().optional().describe("Number of sets"),
+        reps: z.number().int().optional().describe("Reps per set"),
+        durationSec: z.number().int().optional().describe("Duration in seconds"),
+        restSec: z.number().int().optional().describe("Rest between sets in seconds"),
+        videoFileId: z.string().optional().describe("wspace-files-svc File ID for a demo video")
+      }
+    },
+    async ({
+      programId,
+      name,
+      description,
+      weekNumber,
+      orderIndex,
+      sets,
+      reps,
+      durationSec,
+      restSec,
+      videoFileId
+    }) => {
+      try {
+        const input = { programId, name };
+        if (description !== void 0) input.description = description;
+        if (weekNumber !== void 0) input.weekNumber = weekNumber;
+        if (orderIndex !== void 0) input.orderIndex = orderIndex;
+        if (sets !== void 0) input.sets = sets;
+        if (reps !== void 0) input.reps = reps;
+        if (durationSec !== void 0) input.durationSec = durationSec;
+        if (restSec !== void 0) input.restSec = restSec;
+        if (videoFileId !== void 0) input.videoFileId = videoFileId;
+        const data = await ctx.gql.workspace.request(
+          ADD_DRILL,
+          { input }
+        );
+        return jsonResult(data.athAddDrill);
+      } catch (error) {
+        ctx.logger.error("atheletebridge drills_add failed", { error: String(error) });
+        return errorResult(
+          `Failed to add drill: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "drills_remove")),
+    {
+      title: "Remove Drill",
+      description: "Remove a drill from its program by ID. Returns true on success.",
+      inputSchema: { id: z.string().describe("Drill ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          REMOVE_DRILL,
+          {
+            id
+          }
+        );
+        return jsonResult({ removed: data.athRemoveDrill, id });
+      } catch (error) {
+        ctx.logger.error("atheletebridge drills_remove failed", { error: String(error) });
+        return errorResult(
+          `Failed to remove drill: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerSessionTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "sessions_get")),
+    {
+      title: "Get Coaching Session",
+      description: "Fetch a single coaching session by ID.",
+      inputSchema: { id: z.string().describe("Session ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_SESSION, { id });
+        if (!data.athSession) return errorResult(`Session ${id} not found`);
+        return jsonResult(data.athSession);
+      } catch (error) {
+        ctx.logger.error("atheletebridge 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 Coaching Sessions",
+      description: "List coaching sessions with optional coach/athlete/status filters and pagination.",
+      inputSchema: {
+        coachId: z.string().optional().describe("Filter by coach user ID"),
+        athleteId: z.string().optional().describe("Filter by athlete user ID"),
+        status: SessionStatusEnum.optional().describe("Filter by session status"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ coachId, athleteId, status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_SESSIONS, {
+          pagination: { limit: limit ?? 50, offset: offset ?? 0 },
+          coachId,
+          athleteId,
+          status
+        });
+        return jsonResult(data.athListSessions);
+      } catch (error) {
+        ctx.logger.error("atheletebridge 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 Coaching Session",
+      description: "Book a coaching session. `coachId`, `athleteId`, `title`, and `scheduledAt` are required.",
+      inputSchema: {
+        coachId: z.string().min(1).describe("Coach user ID"),
+        athleteId: z.string().min(1).describe("Athlete user ID"),
+        title: z.string().min(1).describe("Session title"),
+        scheduledAt: z.string().describe("Scheduled start (ISO 8601 DateTime)"),
+        type: SessionTypeEnum.optional().describe("Delivery format (default IN_PERSON)"),
+        durationMin: z.number().int().optional().describe("Duration in minutes"),
+        location: z.string().optional().describe("Physical location"),
+        meetingUrl: z.string().optional().describe("Online meeting URL"),
+        programId: z.string().optional().describe("Linked training program ID")
+      }
+    },
+    async ({
+      coachId,
+      athleteId,
+      title,
+      scheduledAt,
+      type,
+      durationMin,
+      location,
+      meetingUrl,
+      programId
+    }) => {
+      try {
+        const input = { coachId, athleteId, title, scheduledAt };
+        if (type !== void 0) input.type = type;
+        if (durationMin !== void 0) input.durationMin = durationMin;
+        if (location !== void 0) input.location = location;
+        if (meetingUrl !== void 0) input.meetingUrl = meetingUrl;
+        if (programId !== void 0) input.programId = programId;
+        const data = await ctx.gql.workspace.request(
+          BOOK_SESSION,
+          { input }
+        );
+        return jsonResult(data.athBookSession);
+      } catch (error) {
+        ctx.logger.error("atheletebridge 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 Coaching Session",
+      description: "Confirm a requested coaching session by ID.",
+      inputSchema: { id: z.string().describe("Session ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(CONFIRM_SESSION, { id });
+        return jsonResult(data.athConfirmSession);
+      } catch (error) {
+        ctx.logger.error("atheletebridge 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_complete")),
+    {
+      title: "Complete Coaching Session",
+      description: "Mark a coaching session COMPLETED, optionally recording a rating (1-5) and feedback.",
+      inputSchema: {
+        id: z.string().describe("Session ID"),
+        rating: z.number().int().optional().describe("Rating (e.g. 1-5)"),
+        feedback: z.string().optional().describe("Coach/athlete feedback notes")
+      }
+    },
+    async ({ id, rating, feedback }) => {
+      try {
+        const input = {};
+        if (rating !== void 0) input.rating = rating;
+        if (feedback !== void 0) input.feedback = feedback;
+        const data = await ctx.gql.workspace.request(COMPLETE_SESSION, {
+          id,
+          input: Object.keys(input).length > 0 ? input : void 0
+        });
+        return jsonResult(data.athCompleteSession);
+      } catch (error) {
+        ctx.logger.error("atheletebridge 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, "sessions_cancel")),
+    {
+      title: "Cancel Coaching Session",
+      description: "Cancel a coaching session by ID.",
+      inputSchema: { id: z.string().describe("Session ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(
+          CANCEL_SESSION,
+          { id }
+        );
+        return jsonResult(data.athCancelSession);
+      } catch (error) {
+        ctx.logger.error("atheletebridge sessions_cancel failed", { error: String(error) });
+        return errorResult(
+          `Failed to cancel session: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerFixtureTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "fixtures_get")),
+    {
+      title: "Get Fixture",
+      description: "Fetch a single fixture by ID, including resolved home/away teams.",
+      inputSchema: { id: z.string().describe("Fixture ID") }
+    },
+    async ({ id }) => {
+      try {
+        const data = await ctx.gql.workspace.request(GET_FIXTURE, { id });
+        if (!data.athFixture) return errorResult(`Fixture ${id} not found`);
+        return jsonResult(data.athFixture);
+      } catch (error) {
+        ctx.logger.error("atheletebridge fixtures_get failed", { error: String(error) });
+        return errorResult(
+          `Failed to get fixture: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "fixtures_list")),
+    {
+      title: "List Fixtures",
+      description: "List fixtures with optional team/status filters and pagination.",
+      inputSchema: {
+        teamId: z.string().optional().describe("Filter by team ID (home or away)"),
+        status: FixtureStatusEnum.optional().describe("Filter by fixture status"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ teamId, status, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_FIXTURES, {
+          pagination: { limit: limit ?? 50, offset: offset ?? 0 },
+          teamId,
+          status
+        });
+        return jsonResult(data.athListFixtures);
+      } catch (error) {
+        ctx.logger.error("atheletebridge fixtures_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list fixtures: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "fixtures_schedule")),
+    {
+      title: "Schedule Fixture",
+      description: "Schedule a new fixture. `homeTeamId` and `scheduledAt` are required; `awayTeamId` is optional for solo/athletics events.",
+      inputSchema: {
+        homeTeamId: z.string().min(1).describe("Home team ID"),
+        scheduledAt: z.string().describe("Scheduled date/time (ISO 8601 DateTime)"),
+        awayTeamId: z.string().optional().describe("Away team ID"),
+        type: FixtureTypeEnum.optional().describe("Fixture type (default FRIENDLY)"),
+        competition: z.string().optional().describe("Competition name"),
+        round: z.string().optional().describe("Round / matchday label"),
+        venue: z.string().optional().describe("Venue"),
+        kickoffAt: z.string().optional().describe("Kickoff time (ISO 8601 DateTime)"),
+        notes: z.string().optional().describe("Free-form notes")
+      }
+    },
+    async ({
+      homeTeamId,
+      scheduledAt,
+      awayTeamId,
+      type,
+      competition,
+      round,
+      venue,
+      kickoffAt,
+      notes
+    }) => {
+      try {
+        const input = { homeTeamId, scheduledAt };
+        if (awayTeamId !== void 0) input.awayTeamId = awayTeamId;
+        if (type !== void 0) input.type = type;
+        if (competition !== void 0) input.competition = competition;
+        if (round !== void 0) input.round = round;
+        if (venue !== void 0) input.venue = venue;
+        if (kickoffAt !== void 0) input.kickoffAt = kickoffAt;
+        if (notes !== void 0) input.notes = notes;
+        const data = await ctx.gql.workspace.request(SCHEDULE_FIXTURE, { input });
+        return jsonResult(data.athScheduleFixture);
+      } catch (error) {
+        ctx.logger.error("atheletebridge fixtures_schedule failed", { error: String(error) });
+        return errorResult(
+          `Failed to schedule fixture: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "fixtures_record_result")),
+    {
+      title: "Record Fixture Result",
+      description: "Record a final result for a fixture, mark it COMPLETED, and recompute the competition standings for both teams.",
+      inputSchema: {
+        id: z.string().describe("Fixture ID"),
+        homeScore: z.number().int().describe("Final home score"),
+        awayScore: z.number().int().describe("Final away score")
+      }
+    },
+    async ({ id, homeScore, awayScore }) => {
+      try {
+        const data = await ctx.gql.workspace.request(RECORD_FIXTURE_RESULT, { id, input: { homeScore, awayScore } });
+        return jsonResult(data.athRecordFixtureResult);
+      } catch (error) {
+        ctx.logger.error("atheletebridge fixtures_record_result failed", { error: String(error) });
+        return errorResult(
+          `Failed to record fixture result: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "standings_list")),
+    {
+      title: "List Standings",
+      description: "List the standings table for a competition, ordered as returned by the backend.",
+      inputSchema: {
+        competition: z.string().min(1).describe("Competition name to fetch standings for")
+      }
+    },
+    async ({ competition }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_STANDINGS, { competition });
+        return jsonResult(data.athStandings);
+      } catch (error) {
+        ctx.logger.error("atheletebridge standings_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list standings: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+function registerWorkoutTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workouts_list")),
+    {
+      title: "List Workout Logs",
+      description: "List logged workouts with optional athlete/program filters and pagination.",
+      inputSchema: {
+        athleteId: z.string().optional().describe("Filter by athlete user ID"),
+        programId: z.string().optional().describe("Filter by training program ID"),
+        limit: z.number().int().optional().describe("Page size (default 50)"),
+        offset: z.number().int().optional().describe("Pagination offset (default 0)")
+      }
+    },
+    async ({ athleteId, programId, limit, offset }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_WORKOUT_LOGS, {
+          pagination: { limit: limit ?? 50, offset: offset ?? 0 },
+          athleteId,
+          programId
+        });
+        return jsonResult(data.athListWorkoutLogs);
+      } catch (error) {
+        ctx.logger.error("atheletebridge workouts_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list workout logs: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "workouts_log")),
+    {
+      title: "Log Workout",
+      description: "Log a workout. `title` and `performedAt` are required. `metrics` is arbitrary JSON (e.g. per-exercise data).",
+      inputSchema: {
+        title: z.string().min(1).describe("Workout title"),
+        performedAt: z.string().describe("When the workout was performed (ISO 8601 DateTime)"),
+        athleteId: z.string().optional().describe("Athlete user ID"),
+        programId: z.string().optional().describe("Linked training program ID"),
+        status: WorkoutStatusEnum.optional().describe("Workout status (default COMPLETED)"),
+        durationMin: z.number().int().optional().describe("Duration in minutes"),
+        rpe: z.number().int().optional().describe("Rate of perceived exertion (e.g. 1-10)"),
+        totalLoad: z.number().optional().describe("Total training load"),
+        metrics: JsonObject.optional().describe("Arbitrary metrics JSON"),
+        notes: z.string().optional().describe("Free-form notes")
+      }
+    },
+    async ({
+      title,
+      performedAt,
+      athleteId,
+      programId,
+      status,
+      durationMin,
+      rpe,
+      totalLoad,
+      metrics,
+      notes
+    }) => {
+      try {
+        const input = { title, performedAt };
+        if (athleteId !== void 0) input.athleteId = athleteId;
+        if (programId !== void 0) input.programId = programId;
+        if (status !== void 0) input.status = status;
+        if (durationMin !== void 0) input.durationMin = durationMin;
+        if (rpe !== void 0) input.rpe = rpe;
+        if (totalLoad !== void 0) input.totalLoad = totalLoad;
+        if (metrics !== void 0) input.metrics = metrics;
+        if (notes !== void 0) input.notes = notes;
+        const data = await ctx.gql.workspace.request(
+          LOG_WORKOUT,
+          { input }
+        );
+        return jsonResult(data.athLogWorkout);
+      } catch (error) {
+        ctx.logger.error("atheletebridge workouts_log failed", { error: String(error) });
+        return errorResult(
+          `Failed to log workout: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "metrics_list")),
+    {
+      title: "List Performance Metrics",
+      description: "List performance metrics for an athlete, optionally filtered by metric type.",
+      inputSchema: {
+        athleteId: z.string().describe("Athlete user ID"),
+        type: MetricTypeEnum.optional().describe("Filter by metric type")
+      }
+    },
+    async ({ athleteId, type }) => {
+      try {
+        const data = await ctx.gql.workspace.request(LIST_PERFORMANCE_METRICS, { athleteId, type });
+        return jsonResult(data.athPerformanceMetrics);
+      } catch (error) {
+        ctx.logger.error("atheletebridge metrics_list failed", { error: String(error) });
+        return errorResult(
+          `Failed to list performance metrics: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "metrics_record")),
+    {
+      title: "Record Performance Metric",
+      description: "Record a performance metric for an athlete. `label`, `value`, and `recordedAt` are required.",
+      inputSchema: {
+        label: z.string().min(1).describe("Human-readable metric label"),
+        value: z.number().describe("Recorded numeric value"),
+        recordedAt: z.string().describe("When the metric was recorded (ISO 8601 DateTime)"),
+        athleteId: z.string().optional().describe("Athlete user ID"),
+        type: MetricTypeEnum.optional().describe("Metric type (default CUSTOM)"),
+        unit: z.string().optional().describe('Unit of measure (e.g. "kg", "s", "bpm")'),
+        source: z.string().optional().describe("Source of the measurement (device/manual)")
+      }
+    },
+    async ({ label, value, recordedAt, athleteId, type, unit, source }) => {
+      try {
+        const input = { label, value, recordedAt };
+        if (athleteId !== void 0) input.athleteId = athleteId;
+        if (type !== void 0) input.type = type;
+        if (unit !== void 0) input.unit = unit;
+        if (source !== void 0) input.source = source;
+        const data = await ctx.gql.workspace.request(
+          RECORD_METRIC,
+          { input }
+        );
+        return jsonResult(data.athRecordMetric);
+      } catch (error) {
+        ctx.logger.error("atheletebridge metrics_record failed", { error: String(error) });
+        return errorResult(
+          `Failed to record performance metric: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/atheletebridge/tools/health.ts
+function registerHealthTools(server, ctx, track) {
+  server.registerTool(
+    track(mcpToolName(ctx.productName, "health")),
+    {
+      title: "AtheleteBridge Health Check",
+      description: "Public health probe for the AtheleteBridge subgraph (athHealth). Requires no authentication.",
+      inputSchema: {}
+    },
+    async () => {
+      try {
+        const data = await ctx.gql.workspace.request(HEALTH, {});
+        return jsonResult({ ok: true, status: data.athHealth });
+      } catch (error) {
+        ctx.logger.error("atheletebridge health failed", { error: String(error) });
+        return errorResult(
+          `AtheleteBridge health check failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+  );
+}
+
+// src/modules/atheletebridge/resources.ts
+function registerAtheletebridgeResources(server, ctx, track) {
+  const schemaUri = track(mcpResourceUri(ctx.productName, "schema"));
+  const teamsUri = track(mcpResourceUri(ctx.productName, "teams"));
+  const programsUri = track(mcpResourceUri(ctx.productName, "programs"));
+  server.registerResource(
+    "atheletebridge-schema",
+    schemaUri,
+    {
+      title: "AtheleteBridge Domain Schema",
+      description: "Overview of the AtheleteBridge sports domain \u2014 entities, enums, and the per-entity tool surface.",
+      mimeType: "text/plain"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${schemaUri} requested`);
+      const schema = `# AtheleteBridge Domain (Overview)
+
+Sports team management, athlete training, coaching, and performance tracking.
+
+## Entities
+- AthTeam \u2014 a squad/club (members, fixtures)
+- AthMember \u2014 a roster entry on a team (player/coach/staff)
+- AthProgram \u2014 a training program (drills)
+- AthDrill \u2014 a drill within a program (optional demo video File)
+- AthSession \u2014 a coaching session (request \u2192 confirm \u2192 complete)
+- AthFixture \u2014 a scheduled match/event (result recompute standings)
+- AthStanding \u2014 a competition standings-table row
+- AthWorkoutLog \u2014 a logged workout for an athlete
+- AthPerformanceMetric \u2014 a recorded performance metric for an athlete
+
+## Enums
+- AthSport: ATHLETICS, BASKETBALL, CRICKET, ESPORTS, FOOTBALL, OTHER, SWIMMING, TENNIS
+- AthTeamStatus: ACTIVE, ARCHIVED, FORMING, INACTIVE
+- AthMemberRole: ASSISTANT_COACH, CAPTAIN, COACH, MANAGER, PHYSIO, PLAYER
+- AthMemberStatus: ACTIVE, INJURED, RELEASED, SUSPENDED, TRIAL
+- AthProgramLevel: ADVANCED, BEGINNER, ELITE, INTERMEDIATE
+- AthProgramStatus: ARCHIVED, DRAFT, PUBLISHED
+- AthSessionType: HYBRID, IN_PERSON, ONLINE
+- AthSessionStatus: CANCELLED, COMPLETED, CONFIRMED, NO_SHOW, REQUESTED
+- AthFixtureType: CUP, FRIENDLY, LEAGUE, SCRIMMAGE, TOURNAMENT
+- AthFixtureStatus: CANCELLED, COMPLETED, LIVE, POSTPONED, SCHEDULED
+- AthWorkoutStatus: COMPLETED, PLANNED, SKIPPED
+- AthMetricType: ACCURACY, AGILITY, CUSTOM, ENDURANCE, HEART_RATE, SPEED, STRENGTH, WEIGHT
+
+## Tool groups
+teams, members, programs, drills, sessions, fixtures, standings, workouts, metrics, 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(
+    "atheletebridge-teams",
+    teamsUri,
+    {
+      title: "AtheleteBridge Team Directory",
+      description: "The first 50 teams in the bound workspace.",
+      mimeType: "application/json"
+    },
+    async () => {
+      ctx.logger.debug(`Resource ${teamsUri} requested`);
+      try {
+        const data = await ctx.gql.workspace.request(LIST_TEAMS, {
+          pagination: { limit: 50, offset: 0 }
+        });
+        return {
+          contents: [
+            {
+              uri: teamsUri,
+              text: JSON.stringify(data.athListTeams, null, 2),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: teamsUri,
+              text: JSON.stringify({
+                error: error instanceof Error ? error.message : String(error)
+              }),
+              mimeType: "application/json"
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.registerResource(
+    "atheletebridge-programs",
+    programsUri,
+    {
+      title: "AtheleteBridge Program Catalog",
+      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.athListPrograms, 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"
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerAtheletebridgePrompts(server, ctx, track) {
+  const p = ctx.productName;
+  const setupName = track(mcpPromptName(p, "team-setup"));
+  const seasonName = track(mcpPromptName(p, "season-ops"));
+  server.registerPrompt(
+    setupName,
+    {
+      title: "Team Setup",
+      description: "Guide for standing up a new AtheleteBridge team end to end: create the team, add the roster, and attach a training program with drills.",
+      argsSchema: {
+        name: z.string().optional().describe("Team name"),
+        sport: z.string().optional().describe("Sport (AthSport enum)")
+      }
+    },
+    ({ name, sport }) => {
+      ctx.logger.debug(`Prompt ${setupName} called`, { name, sport });
+      const nameNote = name ? `Use the team name "${name}".` : "Ask the user for the team name.";
+      const sportNote = sport ? `Use sport ${sport}.` : "Help the user pick an AthSport.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me set up a new AtheleteBridge team.
+
+1. **Create Team**: Use ${p}_teams_create. ${nameNote} ${sportNote} Optionally set season, ageGroup, homeVenue, and headCoachId.
+2. **Add Roster**: Use ${p}_members_add for each player/coach \u2014 set userId, displayName, role (PLAYER/COACH/...), and optional position/jerseyNumber.
+3. **Verify Roster**: Use ${p}_members_list filtered by the new teamId.
+4. **Attach Program**: Use ${p}_programs_create for a training program, then ${p}_drills_add for each drill (weekNumber, sets, reps, durationSec).
+5. **Publish Program**: Use ${p}_programs_transition with status=PUBLISHED when ready.
+
+Show results at each step and confirm before publishing.`
+            }
+          }
+        ]
+      };
+    }
+  );
+  server.registerPrompt(
+    seasonName,
+    {
+      title: "Season Operations",
+      description: "Operations workflow for running a competition season: schedule fixtures, record results, track standings, and review athlete performance.",
+      argsSchema: {
+        competition: z.string().optional().describe("Competition name"),
+        teamId: z.string().optional().describe("Team ID to operate")
+      }
+    },
+    ({ competition, teamId }) => {
+      ctx.logger.debug(`Prompt ${seasonName} called`, { competition, teamId });
+      const teamNote = teamId ? `Operate team "${teamId}".` : `First list teams with ${p}_teams_list and pick one.`;
+      const compNote = competition ? `Track the "${competition}" competition.` : "Ask the user which competition to track.";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Run AtheleteBridge season operations. ${teamNote} ${compNote}
+
+1. **Fixtures**: Use ${p}_fixtures_list filtered by teamId/status to see upcoming and past fixtures. Schedule new ones with ${p}_fixtures_schedule.
+2. **Results**: For completed matches use ${p}_fixtures_record_result (homeScore/awayScore) \u2014 this recomputes standings automatically.
+3. **Standings**: Use ${p}_standings_list for the competition to review the table.
+4. **Coaching**: Use ${p}_sessions_list to triage requested sessions; ${p}_sessions_confirm and later ${p}_sessions_complete them.
+5. **Performance**: Use ${p}_workouts_list and ${p}_metrics_list per athlete to monitor load and progress; record new measurements with ${p}_metrics_record.
+
+Summarize what needs attention after each step.`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/modules/atheletebridge/index.ts
+var atheletebridgeModule = {
+  id: "atheletebridge",
+  version: "0.0.1",
+  displayName: "AtheleteBridge",
+  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;
+    };
+    registerTeamTools(server, ctx, trackTool);
+    registerProgramTools(server, ctx, trackTool);
+    registerSessionTools(server, ctx, trackTool);
+    registerFixtureTools(server, ctx, trackTool);
+    registerWorkoutTools(server, ctx, trackTool);
+    registerHealthTools(server, ctx, trackTool);
+    registerAtheletebridgeResources(server, ctx, trackResource);
+    registerAtheletebridgePrompts(server, ctx, trackPrompt);
+    return { tools, resources, prompts };
+  }
+};
+var atheletebridge_default = atheletebridgeModule;
+
+export { atheletebridge_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map