activate_challenge
ChatGPTActivate this challenge and expose it to eligible members. Requires challenges:write and confirmation.
Business & Operations
Overview
Forj helps gym members, coaches, and owners discover gyms and classes, manage bookings and workouts, review progress, operate schedules and competitions, manage programming and automations, and perform confirmed member, messaging, and billing workflows through ChatGPT.
Tools
analyse_programming_context
ChatGPTRead recent programming history to establish context for creating a new week. Returns: the past 4 weeks of assigned workouts (movement variety, intensity patterns), active programming tracks and groups, member load indicators (average sessions/week), and available benchmarks for testing. Use this BEFORE calling create_programming_week to understand what has been programmed, avoid repeating recent movements, and align with the gym's programming philosophy. Read-only. No confirmation required. Requires OWNER or COACH role (admin:read scope).
apply_schedule_changes
ChatGPTApply capacity, time, or coach-assignment changes to one or more class sessions. IMPORTANT: You MUST call get_upcoming_classes (or list_sessions) BEFORE calling this tool to verify the current state of each session. Include the session IDs from that preview in the 'changes' array. The confirmation step shows all change types and session count — the user must review and approve before any session is modified. Supports partial application: if some changes conflict at execution time, successful changes are applied and a failure report is returned for the rest (not rolled back). Undo metadata is included for each changed session. Strong confirmation required (shows session count and change types). Requires OWNER or COACH role (admin:write scope).
archive_challenge
ChatGPTArchive this challenge. Requires challenges:write and confirmation.
cancel_class
ChatGPTCancel a future class session. Strong confirmation: shows affected booking count and notification recipients before any action. Member notifications (push + email where opted in) are sent automatically after cancellation. Irreversibility warning is shown when the session's cutoff has already passed. For recurring (template-based) sessions, only the specific occurrence is cancelled. Requires OWNER or COACH role (admin:write scope).
collect_announcement_fields
ChatGPTStart the guided announcement workflow. Call this when an admin wants to send an announcement, broadcast, or message campaign to members. This is the entry point — it prompts the admin for message content, target audience (cohort), and channel (email or SMS) before anything is sent. Do NOT call send_message_campaign directly for interactive flows; use this tool first. Accepts optional pre-filled values (body, cohortType, channel, subject) when the user has already provided some details; always returns an interaction to confirm or complete the remaining fields. Requires admin:write scope and an active gym context.
complete_challenge
ChatGPTMark this challenge completed. Requires challenges:write and confirmation.
confirm_action
ChatGPTExecute a previously approved write action. Call this tool after a
confirmation_required response when the user has approved the action. Pass the confirmationId exactly as returned in the confirmation_required envelope. Do NOT call the original write tool again — call this tool instead. Do NOT modify any arguments from the original request: the stored payload is used as-is.create_automation_policy
ChatGPTCreate a named owner-approved automation policy that ChatGPT can invoke within declared constraints. A policy defines: a name, a trigger type (e.g. 'payment_overdue', 'plan_expiring', 'attendance_gap', 'manual'), trigger configuration (e.g. { daysBefore: 3 }), and an ordered list of constituent tools to execute. Policies are created in the UNAPPROVED state — the owner must explicitly confirm to approve. Policies are automatically suspended when any constituent tool invocation fails. Every invocation of a policy is fully audit-logged. Use list_automation_policies to see existing policies. Use suspend_automation_policy to pause a policy without deleting it. Valid trigger types: payment_overdue, plan_expiring, attendance_gap, manual, new_member, failed_payment. Valid constituent tools include: get_at_risk_members, get_members_missing_attendance, draft_member_outreach, preview_message_campaign, send_message_campaign, send_payment_reminder, retry_failed_payment, get_invoices, and more. Requires OWNER role (setup:write + admin:write scopes). Strong confirmation required.
create_automation_rule
ChatGPTCreate a recurring automation rule from a previously previewed definition. Requires the confirmation_token from preview_automation_rule. The definition executed is the one stored at preview time — it cannot be swapped. The rule is created DISABLED.
create_challenge
ChatGPTCreate a challenge. Requires challenges:write and confirmation.
create_competition
ChatGPTCreate a competition. Confirm that this should be added to the authenticated gym. Requires competitions:write.
create_competition_event
ChatGPTCreate a competition event. Requires competitions:write and explicit confirmation.
create_competition_registration
ChatGPTCreate a manual competition registration. Registration and payment-sensitive workflows require explicit confirmation.
create_internal_heat
ChatGPTCreate an internal heat. Requires heats:write.
create_internal_heat_event
ChatGPTCreate an internal heat event. Requires heats:write.
create_programming_assignment
ChatGPTCreate a programming assignment after explicit confirmation. Use only with validated Forj block JSON and the existing assignment scopes; never invent a parallel programming object.
create_programming_template
ChatGPTCreate a canonical Forj programming template. Requires one explicit confirmation and uses the same validation and schema as the Forj programming UI.
create_programming_week
ChatGPTCreate a draft week of programming assignments for the active gym. Accepts a structured weekly plan: for each day, supply the date, target scope (GYM, CLASS_TYPE, or GROUP), and the workout blocks using the existing Forj block schema. ALL assignments are saved as DRAFT status — they are not published or visible to members. Publishing is a separate Phase 3 action. Returns a summary: number of sessions created, movement variety, and any progression flags. Requires explicit confirmation before any data is written. Use list_programming_templates and list_programming_tracks first to pick valid targets. Requires OWNER or COACH role (admin:write scope).
create_scheduled_action
ChatGPTCreate a one-off scheduled action (future membership pause or reinstatement) from a previously previewed definition. Requires the confirmation_token from preview_scheduled_action. The stored definition is executed — it cannot be swapped.
create_trial_offer
ChatGPTCreate a time-bounded trial or promotional membership offer. Preview shows: pricing, eligibility criteria (first-time only, per-member cap), validity window, and public visibility. Strong confirmation required due to financial and marketing impact. Backed by the existing membership plan routes (planType: TRIAL). Returns the created plan ID and a link to the member-facing sign-up page. Requires OWNER role (admin:write and billing:write scope).
delete_competition
ChatGPTDelete this competition and related operational data. This destructive change requires confirmation. Requires competitions:write.
delete_competition_event
ChatGPTDelete a competition event. Requires competitions:write and explicit confirmation.
delete_internal_heat
ChatGPTDelete this heat. This destructive change requires confirmation. Requires heats:write.
disable_automation_rule
ChatGPTDisable an automation rule so it stops running on its schedule. NOTE: pending executions already queued by past runs are NOT cancelled and will still run — tell the admin when any remain.
draft_member_outreach
ChatGPTGenerate draft message variants for a member outreach campaign WITHOUT resolving recipients or sending. Supply a cohort type (e.g. 'expiring_plans', 'inactive_members', 'new_members', 'overdue_payments', 'all_active', 'specific_members') and a campaign goal. Returns 2-3 message variants (subject + body) suitable for review before sending. No member data is accessed — this tool generates content only. Use preview_message_campaign next to resolve the actual recipient list with opt-out enforcement. Requires OWNER role (admin:write scope).
enable_automation_rule
ChatGPTEnable a disabled automation rule so it runs on its schedule. Requires user confirmation. Before calling, run preview_automation_domain on the rule's domain and show the admin what currently matches.
enroll_challenge_member
ChatGPTEnroll a member in this challenge. Requires challenges:write and confirmation.
execute_announcement
ChatGPTDispatch an announcement campaign after the admin has confirmed the preview. Only call this after preview_announcement has returned a confirmation interaction and the admin has approved. Dispatches the campaign as an async background job — returns immediately with a job_id. Opt-out is re-enforced before each message is sent. The job can be cancelled within 60 seconds via cancel_job. Requires admin:write scope and an active gym context.
execute_membership_hold
ChatGPTApply a membership hold (pause) after the user has confirmed the preview. Only call this after preview_membership_hold has returned a confirmation interaction and the user has approved. Pass memberId, startDate, and endDate from the workflow's collected arguments. Requires support:write scope and an active gym context.
explain_forj_implementation
ChatGPTVerify how the currently deployed Forj product actually behaves when existing support knowledge is insufficient or the user explicitly needs implementation verification. First use support_search_features or support_get_feature for ordinary documented how-to questions; call this only when those results do not answer the behaviour question. Returns only a sanitised explanation, confidence, uncertainty, and escalation signal. It cannot return source code or accept repository, ref, branch, SHA, path, search, shell, or provider inputs. If status is insufficient_evidence, blocked, or unavailable, do not guess; explain the uncertainty and offer human support escalation.
find_drop_in_classes
ChatGPTFind live bookable drop-in class sessions at a gym for a given week. Returns sessions with start/end times, coach, capacity, number of spots booked, and drop-in pricing. Only sessions with public drop-in booking enabled are returned. Use book_class (with confirmation) to book one of the returned sessions.
find_gyms
ChatGPTSearch the Forj platform for gyms available for membership or drop-in. Supports filtering by business type, city, suburb, postcode, or keyword search. Optionally supply caller GPS coordinates to sort results by proximity. Returns public gym profiles including slug, name, location, and booking availability. Never exposes internal gym IDs — use the returned slug with other tools.
generate_programming_workflow_guide
ChatGPTReturn the safe end-to-end workflow for generating Forj programming through MCP, including required reads, validation, confirmation and audit expectations.
get_active_gym_context
ChatGPTReturns the caller's currently active gym context: gym name, slug, ID, and your role. When no gym is selected (multi-gym account), returns null for gym fields and lists all available gyms. Use this to diagnose 'no gym selected' errors or to check which gym is currently active before using gym-scoped tools. No scope required — any authenticated caller can invoke this tool.
get_at_risk_members
ChatGPTReturn members flagged as churn-risk with structured, explainable risk reasons. Each member is scored (low / medium / high) based on one or more of these signals: • attendance_gap — no check-in in the last 14 days. • failed_payment — has an overdue invoice. • plan_expiring_soon — active membership plan ends within 30 days. • benchmark_stale — has benchmark records but none logged in 60+ days. Risk score: high (3+ signals), medium (2 signals), low (1 signal). Results include memberId, displayName, riskScore, reasons array, and dataWindowDays. Use this for targeted outreach before members cancel. Requires member:read or retention:read scope.
get_automation_action
ChatGPTGet details of a single automation action type, including its target model and payload expectations.
get_automation_rule
ChatGPTGet the full definition of one automation rule, including its domain, schedule, action payload, and run stats.
get_automation_target_model
ChatGPTGet full details of one automation target model: field allowlist with types, allowed operators and known values, available actions, and the documented date-qualification rule. Use these exact field names when building domains.
get_challenge
ChatGPTGet challenge details and stats.
get_challenge_leaderboard
ChatGPTRead challenge leaderboard.
get_coach_members
ChatGPTRetrieve the list of members assigned to the authenticated coach at their active gym. Only members explicitly assigned to this coach are returned — not all gym members. Requires COACH role or higher. Returns member profile details including name, status, and assignment counts.
get_competition
ChatGPTGet a competition with its core configuration for the authenticated gym.
get_competition_awards
ChatGPTRead competition awards/placing summaries. Tenant is derived from auth.gymId.
get_competition_leaderboard
ChatGPTRead the competition leaderboard. Tenant is derived from auth.gymId.
get_competition_readiness
ChatGPTSurface readiness blockers and status for an upcoming competition. Checks: registration count vs expected, un-seeded divisions, events missing heats, judges not assigned, waiver completion rate, and payment completion. Returns a structured readiness report with a per-area status (ready/warning/blocked). Use this to identify what needs to be resolved before competition day. Then use preview_heat_publication to draft heats and publish_competition_heats to commit. Read-only. No confirmation required. Requires competitions:read scope.
get_competition_standings
ChatGPTRead sport-specific standings for a competition event (weightlifting or bracket standings).
get_gym_briefing
ChatGPTGenerate a structured weekly operating briefing for the active gym. Composes: attendance summary (sessions run, member visits, attendance rate, average class fill rate), billing health (unpaid invoices count, overdue amount, failed payment count), active programming week (tracks with content, any missing sessions), and upcoming competition blockers (competitions in the next 30 days with readiness status). Scoped to the active gym. Owner and admin roles only. Read-only. No confirmation required. Use this at the start of a ChatGPT session to understand the gym's current state before launching into any playbook (retention outreach, schedule optimisation, etc.). Requires admin:read scope.
get_gym_profile
ChatGPTRetrieve the public profile for a specific gym by its slug. Returns the gym's name, location, contact details, and website content. Only public-facing fields are returned — no internal billing, staff data, or configuration.
get_gym_summary
ChatGPTReturns a summary of the active gym including its name, slug, timezone, member count, and today's class schedule count. Requires an active gym context — call switch_active_gym first if no gym is selected. No specific scope required beyond authentication with an active gym.
get_internal_heat_event
ChatGPTGet an internal heat event including heats and slots.
get_invoices
ChatGPTLook up invoices at the authenticated admin's active gym. Supports filtering by member ID, member name, invoice number, status, and date range (from/to). Use memberName to search by name (e.g. 'Jake') without needing a member ID — this is the preferred single-step approach. Use this to find an invoice ID before calling void_invoice — e.g. 'find Jake's March invoice'. Requires billing:read scope. Returns id, invoiceNumber, memberName, amountCents, currency, status, description, and createdAt for each match. Results are limited to 50 invoices per call. To narrow results, supply one or more filters. All filters are optional.
get_job_status
ChatGPTCheck the status of an async background job started by a previous tool call. Returns the job's current status (pending, running, succeeded, failed, cancelled), progress percentage, and — when complete — a result or failure summary. On failure, also returns safe-retry guidance so you can decide whether to retry the original operation. Use the job_id returned by the original tool call.
get_member_block_programming_coverage
ChatGPTAuthoritative read for which gym members have Block Designer programming covering a supplied date, week, or date range. Returns the complete member roster (active members by default), including explicit covered and not_covered rows. It resolves ACTIVE individual and group-assigned Block Designer days using their scheduling mode and effective dates; do not substitute the generic MEMBER programming-assignment query for this tool.
get_member_count
ChatGPTReturn gym member counts including total, active, inactive, and status breakdown for the active gym. Requires OWNER role or higher (admin:read scope). Use this to answer questions like 'how many active members do I have?'.
get_member_movement_history
ChatGPTRead every recorded performance for one member and movement over a date range with stable pagination.
get_member_personal_record_history
ChatGPTRead dated personal-record history, including superseded records, rather than only the member's current PRs.
get_member_progress
ChatGPTReturn a progress summary for a specific member at the authenticated coach's active gym. Includes recent workout logs, current personal records, and attendance summary. Requires COACH role or higher. The coach/member relationship is enforced by the backing API: if the gym uses ASSIGNED_ONLY mode, only members directly assigned to this coach are accessible. Billing and payment data is never included.
get_member_training_history
ChatGPTRead a member's completed training history over a date range with stable pagination, title search, and source-system filtering.
get_members_missing_attendance
ChatGPTReturn active members who have not attended a class in a configurable window. Default window is 14 days; maximum is 90 days. Each entry includes the member ID, display name, last attendance date (null if never attended), days since last attendance (null if never attended), and their plan status. Results are ordered: never-attended members first, then by days since last attendance descending. Use this to identify members who need proactive outreach or follow-up. Optional windowDays parameter controls the window (1–90, default 14). Optional coachId parameter allows owners and staff to filter results to members who attended sessions coached by a specific user (COACH callers are automatically scoped to their own sessions at the route layer regardless of this parameter). Requires attendance:read scope. Owner, staff, and coach roles are supported.
get_my_gyms
ChatGPTReturn the list of gyms where the authenticated user has an active membership or role. Each entry includes the gym name, slug, role, and member ID. Use this to determine which gym context the user is operating in.
get_my_mcp_auth_context
ChatGPTReturns the caller's live MCP auth context: user ID, active gym, granted scopes, token expiry, and inferred role. Use this to diagnose scope-related failures — if a tool says it requires 'programming:read' but that scope is missing from grantedScopes, re-authorize via Settings → ChatGPT Connection to obtain a fresh token with the correct scope set. No scope required — any authenticated caller can invoke this tool.
get_my_plan
ChatGPTReturn the authenticated member's active membership plan(s) at their current gym. Includes plan name, billing status (ACTIVE / PAUSED / PENDING_PAYMENT), cadence (e.g. monthly), price display, current-period end date, and whether cancellation at period end is scheduled. Also returns any active class-pack balances. If the caller has no linked member record (e.g. a staff-only account) the memberships array will be empty. Requires billing:read (for admin/owner callers) or member:read (for member callers).
get_programming_assignment
ChatGPTRead a single programming assignment with optional section filtering and a ready-to-display text summary. Use this after get_programming_week or get_programming_day to get full workout details for a specific assignmentId. Block Designer programDay IDs are hydrated from the canonical program day, including full block content and scheduled metadata. In summary mode (default) only metadata stubs are returned for sections not opted-in — call with verbosity='full' or set includeStrength/includeConditioning/includeWarmup etc. to true for the sections you need. The response always includes a displayText field that ChatGPT can quote directly.
get_programming_day
ChatGPTReturn the class sessions and programming assignments for a single date. Use this for questions like 'today\'s workout', 'tomorrow\'s WOD', or any single-day query. Never use the week tool (get_programming_week) for single-day questions — use this tool instead. Returns sessions scheduled for that date plus assignment references (assignmentId, workoutId, title, blockCount, section flags, source). Member-specific Block Designer days also include their complete blocks and day notes, including movements, prescriptions, percentages, section notes, and logging settings. For other assignments, use get_programming_assignment with the returned assignmentId for full details. Defaults to today in the gym's timezone when date is omitted. Pass memberName to look up programming assigned to a specific member (e.g. 'What is Cam\'s programming for tomorrow?'). When memberName is provided the tool performs a three-pass lookup: (1) individual Block Designer assignment (scope=MEMBER, source=\'individual\'), (2) class-type assignment (source=\'class\'), (3) gym-wide default (source=\'gym\' or source=\'track\'). Individual assignments take priority and are returned first. Each result includes a source field: individual | class | gym | track. Owners/admins (admin:read scope) see all assignments including drafts; coaches see published content only. Available to COACH, OWNER, and PLATFORM_ADMIN (coach:read or admin:read scope).
get_programming_template
ChatGPTRead one complete canonical programming template, including every block, prescription, and note.
get_programming_week
ChatGPTReturn a SUMMARY view of the gym's scheduled sessions and programming for a target week. Returns lightweight per-assignment metadata (dates, titles, block counts, section flags) — no nested block bodies. Use this for week overviews and 'what is this week's programming?' questions. The summary includes three assignment scope buckets: (1) gymAndClassAssignmentCount — GYM-wide or CLASS-scoped sessions that have a linked workout; (2) memberAssignmentCount — MEMBER-scoped individual assignments not tied to a class session; (3) totalAssignmentCount — the combined total across all three scopes (GYM + CLASS + MEMBER). For a single day use get_programming_day instead. For full workout block details use get_programming_assignment with an assignmentId. Defaults to next Monday (or current Monday if today is Monday) in the gym's timezone. If the gym has not enabled programming, programmingEnabled will be false. Available to COACH, OWNER, and PLATFORM_ADMIN (coach:read or admin:read scope).
get_public_competition_leaderboard
ChatGPTRetrieve the publicly visible leaderboard for a Forj competition. No gym membership is required — this tool is accessible to anyone with public:read scope. The competition must be configured as public by the gym; private competitions return a not-found error. The backing route also confirms the hosting gym still has the Competitions module enabled; if the module was disabled after the competition was created the route returns 404. Pass the competition slug or ID as compId (e.g. 'spring-throwdown-2026'). Optionally filter by divisionId to retrieve a specific division's leaderboard. Returns a 404-equivalent error if the competition is not found, is not publicly visible, or belongs to a gym with Competitions disabled.
get_public_schedule
ChatGPTRetrieve the public weekly class schedule (timetable) for a specific gym. Returns recurring class templates shown in the gym's public timetable, including class title, days, start/end times, duration, class type, and coach name. Only classes marked as show-in-timetable are returned. Use find_drop_in_classes to see live bookable sessions for a specific week.
get_schedule_capacity_issues
ChatGPTIdentify overbooked or underfilled class sessions in a given date range. Returns sessions that are over capacity (booking count exceeds limit), sessions that are significantly underfilled (fillRate below threshold), and sessions with no coach assigned. Default range is the current week (7 days). Maximum range is 28 days. Optional fillRateThreshold (0–1, default 0.3) controls the underfilled cutoff. Use this before calling preview_schedule_changes or apply_schedule_changes to identify which sessions need adjustments. Requires OWNER or COACH role (admin:read scope).
get_staff_coverage
ChatGPTReturn coach and staff assignment health for the active gym over a date range. Reports: total sessions, sessions with a coach assigned, sessions with no coverage, the assigned coach for each session, and a coverage health score. Read-only — no assignments are changed, no suggestions are applied. Defaults to the current week (7 days starting today) if no date range is provided. Maximum date range is 28 days. Requires OWNER or COACH role (admin:read scope).
get_upcoming_classes
ChatGPTReturn ALL class sessions scheduled at the authenticated admin's gym for a specific date. Every session is included regardless of which coach is assigned — this is the full admin day view. Defaults to today if no date is provided. Returns each session's title, start/end time, assigned coach, capacity, booking count, and a summary of the assigned workout programming. Requires OWNER role or PLATFORM_ADMIN (admin:read scope). Use get_upcoming_sessions instead if you only want sessions where you are the assigned coach.
get_upcoming_sessions
ChatGPTReturn the class sessions assigned to the authenticated coach for a specific date. Only sessions where the caller is the assigned coach are returned — not every session at the gym. Defaults to today if no date is provided. Returns each session's title, start/end time, capacity, current booking count, and a summary of the assigned workout programming. Requires COACH role or higher (coach:read scope). Use get_upcoming_classes instead if you want all sessions at the gym (admin view).
get_week_schedule
ChatGPTReturn ALL class sessions and their assigned workouts/WODs at the active gym for a given week (Monday through Sunday). Each session includes its date, title, start/end time, assigned coach, capacity, current booking count, and the resolved workout programming (workout name, block count, and source). Use this to answer questions like 'what workouts are programmed this week', 'what's the WOD for each class', or 'how many classes are running this week'. Pass weekStart (YYYY-MM-DD Monday) to see a specific week; defaults to the current week if omitted. Available to COACH, OWNER, and PLATFORM_ADMIN (coach:read or admin:read scope). For a single-day view use get_upcoming_classes instead. For a unified view that also includes programming assignments, use get_programming_week.
list_automation_actions
ChatGPTList all registered automation action types with their target model and description.
list_automation_policies
ChatGPTList all automation policies for the active gym, including their status (approved, suspended, inactive). Returns policy name, trigger type, constituent tools, approval status, suspension status, last run time, and run count. Use this to review existing policies before creating new ones, or to identify policies that need attention. Requires OWNER role (admin:read scope).
list_automation_rule_runs
ChatGPTList recent runs of an automation rule with per-run stats (matched, queued, succeeded, failed, skipped).
list_automation_rules
ChatGPTList the gym's automation rules with status, schedule, action, and last-run summary.
list_automation_target_models
ChatGPTList the Forj record types that support automated actions (member plans, program blocks, class programming), with their filterable fields, allowed operators, and available actions. Also returns the available guided templates.
list_available_tools
ChatGPTReturns the catalogue of callable Forj MCP tools grouped by domain. Call this ONLY when the user explicitly asks what tools or callable actions exist, e.g. 'what tools do you have?', 'what can you do?', 'list your tools', 'what actions are available?', or 'what Forj tools are callable from here?'. Do NOT call this for how-to questions, setup guidance, support questions, or any question where the user wants actual operational help — use support_search_features, support_list_modules, or support_resolve_feature for those. Optionally filter to a single domain (e.g. 'programming', 'bookings', 'billing', 'workouts', 'members', 'analytics') using the domainFilter argument for a focused answer. By default only fully callable (stable) tools are returned. Pass includeStubs: true to also include planned-but-not-yet-implemented tools (readinessTier 'stub') for roadmap discovery. Pass includeDisabled: true to also include tools that exist but are not enabled for this gym (readinessTier 'disabled'). Each tool entry includes a readinessTier field ('stable', 'stub', or 'disabled'). No scope required — any valid token can call this tool.
list_challenge_enrollments
ChatGPTList challenge enrollments.
list_challenge_entries
ChatGPTList challenge entries.
list_challenge_leaderboard
ChatGPTReturn the current leaderboard for a gym challenge, including member rankings and scores. Because the leaderboard contains identifiable member names, explicit confirmation is required before the ranked list is returned. Obtain challengeId from the gym's active challenges. Supports an optional anonymise mode that returns only rank + score without member names (no confirmation needed in anonymised mode). Requires OWNER or COACH role (admin:read scope).
list_challenge_tasks
ChatGPTList challenge tasks.
list_challenge_tests
ChatGPTList challenge tests.
list_challenges
ChatGPTList challenges for the authenticated gym, optionally filtered by status.
list_competition_events
ChatGPTList events/workouts in a competition. Tenant is derived from auth.gymId.
list_competition_heats
ChatGPTList heats and lane assignments for a competition event.
list_competition_registrations
ChatGPTList registrations, waiver/check-in status, and team/athlete registration details. Tenant is derived from auth.gymId.
list_competition_teams
ChatGPTList teams for a competition. Tenant is derived from auth.gymId.
list_competitions
ChatGPTList competitions for the authenticated gym. Uses the caller's gym context only; no gymId is accepted.
list_internal_heat_events
ChatGPTList internal heat events for the authenticated gym.
list_program_block_days
ChatGPTList the program days within a Block Designer block. Returns id, weekNumber, dayNumber, title, and visibility for each day. Use a programBlockId from list_program_blocks. Then pass any day's id as the assignmentId in get_programming_assignment or update_programming_assignment.
list_program_blocks
ChatGPTList Block Designer program blocks for the active gym. Returns id, name, status, durationWeeks, daysPerWeek, and assignmentType for each block. Use this to discover which blocks exist before calling list_program_block_days or get_programming_assignment with a programDayId.
list_programming_assignments
ChatGPTRead scheduled programming assignments in the active gym over a date range. Returns class, gym, group, and member assignments supported by the existing programming engine.
list_programming_groups
ChatGPTRead programming groups/cohorts for the active gym. Use this when generating or assigning group programming.
list_programming_templates
ChatGPTRead workout programming templates for the active gym. Use this before drafting new programming so generated sessions reuse the gym's existing template architecture.
list_programming_tracks
ChatGPTRead programming tracks for the active gym, including class/member default tracks where available. Use tracks to target class, gym-wide, group, or member programming correctly.
move_member_booking
ChatGPTMove a gym member from one class session to another. Requires explicit confirmation before executing — the coach must confirm the move. Call preview_member_booking_move first to review capacity impact, entitlement status, late-cancel fee implications, and waitlist effects. The move is atomic: the existing booking is cancelled and a new booking is created. If either step fails, the move is aborted. Requires OWNER or COACH role (admin:write scope).
plan_programming
ChatGPTPlan a programming session for the active gym from high-level coaching intent. Supports two modes controlled by the saveMode field: • preview_only — Returns a structured WorkoutSpec scaffold with rationale, assumptions, constraint satisfaction, and safety status. No data is written. Requires programming:read. • draft — Saves the plan as a STAFF_ONLY draft assignment (not member-visible). Requires programming:write and explicit confirmation before any write occurs. Returns the created assignment id and draft visibility. gymId is never accepted from input — always resolved from the authenticated session.
preview_announcement
ChatGPTPreview an announcement campaign with a live recipient count before dispatch. Always call collect_announcement_fields first to obtain body, cohortType, and channel. Fetches the real recipient count (after opt-out filtering) and returns a confirmation interaction that the admin must approve before the campaign is dispatched. Requires admin:write scope and an active gym context.
preview_automation_domain
ChatGPTEvaluate a domain against the gym's current data: returns the current matching record count (bounded) and a small sample of matching records with human-readable labels. Relative dates resolve using the gym timezone and week start.
preview_automation_rule
ChatGPTValidate a complete recurring automation rule definition (name, target model, schedule, domain, action, payload), run a domain preview, and issue a confirmation token. REQUIRED before create_automation_rule. The token expires in 5 minutes and is bound to this exact definition, user, and gym.
preview_heat_publication
ChatGPTPreview the heat draw for a competition event WITHOUT committing it. Returns the proposed heat structure (number of heats, athletes per heat, lane assignments) based on current registrations and the configured heat size. Surfaces blockers: un-assigned divisions, incomplete registration data, events with no registrations, and scheduling conflicts between heats. Use this to review the heat configuration BEFORE calling publish_competition_heats. Read-only — no data is written. Requires competitions:read scope.
preview_member_booking_move
ChatGPTGenerate a preview for moving a gym member from one class session to another. Returns a structured preview including: capacity impact on both sessions, whether the member has a valid entitlement for the target session, late-cancel fee implications, and whether the move affects any waitlist. Read-only — no booking changes are made. Use move_member_booking (confirmed) to execute after reviewing this preview. Requires OWNER or COACH role (admin:read scope).
preview_membership_hold
ChatGPTPreview a membership hold (pause) for a resolved member. Returns a confirmation interaction that the user must approve before the hold is applied. Always call support_resolve_member first to obtain a memberId. Pass memberId, memberName, startDate, and endDate from the workflow's collected arguments. Requires support:write scope and an active gym context.
preview_message_campaign
ChatGPTResolve the actual recipient list for a message campaign, enforcing opt-out rules. Returns: total eligible recipient count, a sample of up to 5 recipient first names (no emails/phones), and the number of members excluded due to opt-out. No message is sent. Requires explicit confirmation to acknowledge the recipient list before proceeding to Phase 3 send. Requires OWNER role (admin:write scope).
preview_schedule_changes
ChatGPTPreview the effect of capacity or coach-assignment changes on class sessions, without committing any changes. Checks: whether the new capacity would be below current booking count (conflict), whether the proposed coach user exists and has no conflicting sessions, and whether there are waitlisted members who would be affected by capacity increases. Returns a conflict-annotated list of proposed changes. Use this BEFORE calling apply_schedule_changes to identify and resolve conflicts. Read-only — no data is modified. Requires OWNER or COACH role (admin:read scope).
preview_scheduled_action
ChatGPTValidate a one-off direct action (e.g. a future membership pause or reinstatement) against a SPECIFIC record: checks the record exists, is eligible, and the payload/date are valid, then issues a confirmation token. REQUIRED before create_scheduled_action.
publish_competition_heats
ChatGPTGenerate and publish a heat draw for a competition event. Preview shows: heat count, estimated athlete slots, scheduling window, and judge assignment guidance. Idempotent: if heats already exist for the event, returns the existing draw without creating duplicates. Confirmation required. Audit-logged with event-scoped context. Requires OWNER role and competitions feature flag (competitions:write scope).
publish_programming
ChatGPTPublish one or more draft programming assignments, making them member-visible. Does NOT modify workout content — only changes the lifecycle visibility from STAFF_ONLY to MEMBER_VISIBLE. Requires explicit confirmation before any change is written. Target assignments by assignmentIds array OR by weekStartDate + optional scope filter. Returns the published assignment IDs and notification impact summary. Requires programming:write scope and explicit confirmation. gymId is never accepted from input — always resolved from the authenticated session.
publish_programming_week
ChatGPTPublish a validated draft programming week to make all DRAFT assignments member-visible. Pre-checks: validate_programming_week must return zero blocking (error) conflicts — if any errors are found the publish is blocked and conflicts are returned. Only STAFF_ONLY (draft) assignments are affected; already-published assignments are skipped. Returns a summary of published sessions, skipped sessions (already published), and any per-session failures (partial application with failure report). Undo metadata is included so the change can be described for reversal. Strong confirmation required: shows affected session count and dates. Requires OWNER or COACH role (admin:write scope).
resolve_choice
ChatGPTResolve a user-selected choice token to a usable entity reference. Call this after the user selects from the choices returned by resolve_member, resolve_session, etc. Returns an entityRef (opaque token) and entityType that you can pass to support_action_preview as the corresponding ID field. The token is validated server-side and cannot cross gym boundaries. Requires support:read scope and an active gym context.
resolve_coach
ChatGPTResolve a coach or staff member name to a structured entity reference. Accepts full or partial names. Requires support:read scope and an active gym context.
resolve_feature
ChatGPTLook up a Forj feature, page, or admin capability by natural-language query. Returns up to 3 ranked matches from the Forj feature registry, each containing the page route, breadcrumb path, and step-by-step instructions. Call this tool first whenever the user asks WHERE to find something or HOW to navigate to a feature — never hallucinate routes. Requires support:read scope.
resolve_member
ChatGPTResolve a member's name to a structured entity reference for use in support actions. Returns a single match if the name is unambiguous, up to 5 labelled choices if ambiguous, or a helpful no-match message. Never returns raw internal IDs — ambiguous results carry opaque choiceTokens. Call this before support_action_preview when you need a memberId from a natural-language name. Requires support:read scope and an active gym context.
resolve_plan
ChatGPTResolve a membership plan name to a structured entity reference. Accepts full or partial plan names. Returns a single match, up to 5 labelled choices, or a no-match message. Requires support:read scope and an active gym context.
resolve_session
ChatGPTResolve a natural-language time expression to a gym class session. Uses a tokenising parser — extracts date, time, and class-name keywords separately so any word order works. Supported phrase patterns: • Time only: '4pm', '9:30am', '17:30' • Date + time: 'Thursday 4pm', '4pm Thursday', 'tomorrow 9:30am' • Class keyword: '4pm CrossFit', 'CrossFit at 4', 'Thursday 4pm CrossFit' • Relative dates: 'today', 'tomorrow', 'yesterday', 'this Monday', 'next Wednesday', 'last Monday' • Past dates: 'yesterday 4pm CrossFit', 'last Monday 5:30pm' • Full date + time: 'next Wednesday 9:30am CrossFit' Returns a single match if unambiguous, up to 5 labelled choices if ambiguous, or a helpful no-match message. Mode parameter controls past/future handling: • 'view' (default): resolves both past and future sessions • 'book': rejects past sessions (returns a business-rule error message) • 'attendance': prefers past sessions; searches up to 7 days back • 'programming': same as view Requires support:read scope and an active gym context.
resolve_track
ChatGPTResolve a programming track name to a structured entity reference. Accepts full or partial track names. Requires support:read scope and an active gym context.
resolve_workout
ChatGPTResolve a workout name to a structured entity reference. Accepts full or partial workout names. Requires support:read scope and an active gym context.
retry_failed_payment
ChatGPTRetry the latest unpaid/failed Stripe subscription invoice for a member. Idempotent: asks the payment provider to retry collection of the latest unpaid invoice; no bank account mutation occurs. Returns the retry result from Stripe. Requires billing:write scope and OWNER role or higher. Strong confirmation required. Audit-logged. Use get_invoices to confirm the member has a failed payment before calling this.
review_programming
ChatGPTAnalyse existing programming for the active gym over a target week. Returns structured findings across movement balance, fatigue and progression, weekly stimulus distribution, equipment bottlenecks, scaling coverage, safety flags, and class logistics. No data is written. Provide a targetDate anywhere in the target week — the tool resolves the Monday start automatically. Optionally narrow to specific review categories via focusCategories. gymId is never accepted from input — always resolved from the authenticated session.
revise_programming
ChatGPTRevise an existing programming assignment using high-level coaching intent. Supports two modes: • preview_only — Returns a summary of proposed changes without writing. Requires programming:read. • draft — Applies the revision and saves as a STAFF_ONLY draft. Requires programming:write and explicit confirmation. Target the assignment by assignmentId OR by targetDate + scope. Specify sections to preserve unchanged via preserveSections. gymId is never accepted from input — always resolved from the authenticated session.
run_automation_rule_now
ChatGPTRun an automation rule immediately (outside its schedule). Honours the SKIP_IF_RUNNING concurrency policy: returns a skip message when a run is already in progress. Requires user confirmation.
send_message_campaign
ChatGPTSend a broadcast announcement or targeted outreach message to gym members. For interactive flows where the admin hasn't provided all details, call collect_announcement_fields first to guide them through content, audience, and channel selection via the guided workflow. Call this tool directly only when cohortType, channel, and body are already fully specified. Requires explicit human confirmation before dispatch: shows a live preview with the recipient count after opt-out filtering. IMPORTANT: Before calling this tool, you MUST call get_members or a filter query to verify the target cohort and estimated recipient count. Dispatches the campaign as an async background job — returns immediately with a job_id. Use get_job_status to poll for completion. The job can be cancelled within 60 seconds via cancel_job (job will not dispatch if cancelled in time). Opt-out enforcement is re-validated at send time (not only at preview) to account for any opt-outs that occurred between confirmation and dispatch. Audit-logged with recipient count, job ID, and send result. Strong confirmation required (shows live recipient count and channel). Requires OWNER role (admin:write scope).
send_payment_reminder
ChatGPTSend a payment reminder notification to all active members with failed or past-due Stripe subscriptions. Dispatched as an async background job — returns immediately with a job_id. Job can be cancelled within 60 seconds via the job cancellation window. Use get_job_status to poll for completion (result includes notified member count). Opt-out and push notification preferences are respected by the notification service. Requires billing:write scope and OWNER role or higher. Strong confirmation required.
set_active_gym
ChatGPTAlias for switch_active_gym. Sets the gym context for this ChatGPT connection.
support_action_execute
ChatGPTExecute a previewed Action Framework write operation. MUST be called after
support_action_preview — you need the confirmationToken from that call. On first call, the dispatcher fetches the live preview summary from the action framework, embeds it in a confirmation_required prompt, and waits for user approval. After user approval, re-call with _confirmationId to execute. On confirmed execution the action is performed and an audit record is written. Allowed actionIds: send-member-message, invite-member, book-member-into-class, cancel-booking, assign-membership, assign-workout-to-date, assign-staff-leave. Required fields per actionId: • send-member-message: { memberId, channel, body } — subject is optional; channel must be "email" or "sms" • invite-member: { email, memberId } — role is optional; role defaults to "MEMBER" • book-member-into-class: { memberId, sessionId, weekStartISO } — weekStartISO is YYYY-MM-DD (the Monday of the target week) and is REQUIRED • cancel-booking: { bookingId } — reason is optional • assign-membership: { memberId, planId, startAt } — endAt, billingNote are optional; startAt and endAt are YYYY-MM-DD • assign-workout-to-date: { workoutId, date } — classTypeId, scope, createdBy, visibility are optional; date is YYYY-MM-DD; scope is "GYM" or "CLASS_TYPE" • assign-staff-leave: { staffId, staffName }. Requires support:read and support:write scopes and an active gym context.support_action_preview
ChatGPTPreview an Action Framework write operation before execution. Returns a human-readable summary of what will happen, structured details, and a
confirmationToken that must be passed to support_action_execute. Always call this before support_action_execute — the token binds the preview to the execution. Allowed actionIds: send-member-message, invite-member, book-member-into-class, cancel-booking, assign-membership, assign-workout-to-date, assign-staff-leave. The input object is action-specific; gymId and userId must NOT be included (they come from your auth context). Required fields per actionId: • send-member-message: { memberId, channel, body } — subject is optional; channel must be "email" or "sms" • invite-member: { email, memberId } — role is optional; role defaults to "MEMBER" • book-member-into-class: { memberId, sessionId, weekStartISO } — weekStartISO is YYYY-MM-DD (the Monday of the target week) and is REQUIRED • cancel-booking: { bookingId } — reason is optional • assign-membership: { memberId, planId, startAt } — endAt, billingNote are optional; startAt and endAt are YYYY-MM-DD • assign-workout-to-date: { workoutId, date } — classTypeId, scope, createdBy, visibility are optional; date is YYYY-MM-DD; scope is "GYM" or "CLASS_TYPE" • assign-staff-leave: { staffId, staffName }. Requires support:read and support:write scopes and an active gym context.support_check_billing_setup
ChatGPTCheck whether billing is properly configured (payment provider connected, charges enabled, plan mappings set). Returns status, a summary of issues, and the recommended route to fix them. Use this when the user reports billing or payment problems. Requires support:read scope and an active gym context.
support_check_class_schedule_setup
ChatGPTCheck whether the class schedule is configured (class types, recurring templates, recent sessions). Returns status, a summary of issues, and the recommended route to fix them. Use this when the user reports scheduling or class setup problems. Requires support:read scope and an active gym context.
support_check_gym_setup
ChatGPTCheck whether the gym's core configuration is complete (name, timezone, branding, public site). Returns status, a summary of issues, and evidence items. Use this when the user reports setup or configuration problems with their gym profile. Requires support:read scope and an active gym context.
support_check_member_app_setup
ChatGPTCheck whether the member app / public site is configured (gym name, logo, welcome message, public site toggle). Returns status, a summary of issues, and the recommended route to fix them. Use this when the user reports problems with how their gym appears to members. Requires support:read scope and an active gym context.
support_check_programming_setup
ChatGPTCheck whether workout programming is configured (workout templates, tracks, published workouts). Returns status, a summary of issues, and evidence items. Use this when the user asks about workout programming or WOD setup problems. Requires support:read scope and an active gym context.
support_diagnose
ChatGPTRun a cross-provider diagnosis for a natural-language query about this gym's configuration or health. Returns which modules are most relevant to the query (full or partial match) and their confidence scores. Use this when the user reports a problem or asks why something is not working, e.g. 'why can't members book classes', 'billing is not processing payments', 'members can't see workouts'. Each result includes the module name, relevance (full/partial), confidence score, and a diagnostic summary. Follow up with support_get_module_setup or support_get_module_health for detailed status on a specific module. Requires support:read scope and an active gym context.
support_discover_capabilities
ChatGPTGet a compact map of all platform modules accessible to this gym, together with their dashboard navigation routes. Use this for quick orientation before deciding which diagnostic tools to call. Returns module IDs, names, and navigation routes. For detailed setup or health information on a specific module, use support_get_module_setup or support_get_module_health. Requires support:read scope and an active gym context.
support_find_navigation_path
ChatGPTResolve a natural-language intent to one or more dashboard navigation routes. Returns the matching menu items and their dashboard paths so an admin can navigate directly. Use this when the user asks 'where do I go to X', 'how do I navigate to X', or 'which page is X on'. Examples: 'where is billing', 'how do I get to member list', 'navigate to class schedule'. Results include the label, path, section, and description for each matching route. The first result is the best match and its path can be used directly in the browser. Requires support:read scope and an active gym context.
support_get_feature
ChatGPTLook up a single Forj feature by its ID and return step-by-step guidance for completing it. Feature IDs are returned in the
featureId field of support_search_features results. Use this after calling support_search_features to retrieve full step-by-step instructions for a specific feature. Example feature IDs: 'add-member', 'create-plan', 'connect-payment-provider', 'create-class-session'. Returns the feature title, description, steps, prerequisites, and related features. Requires support:read scope and an active gym context.support_get_gym_stats
ChatGPTReturn a real-time snapshot of key gym metrics: active member count, this month's revenue, classes scheduled today, and this week's attendance rate. Use when the user asks 'how is the gym doing', 'show me gym stats', or any dashboard-level health question. Requires support:read scope and an active gym context.
support_get_member_training_blocks
ChatGPTLook up a member's active training program blocks and current workout assignments. Resolves a name query to the most likely member then returns their program/track enrollments. Use when the user asks 'what program is [name] on', 'show me [name]'s training blocks', or 'list training blocks for [name]'. Requires support:read scope and an active gym context.
support_get_menu_structure
ChatGPTReturn the full navigation menu structure for the authenticated user's role. Use this when the user wants a complete list of all pages and sections available to them. Results include label, path, section, and visibility for each entry. For resolving a specific navigation intent use support_find_navigation_path instead. Requires support:read scope and an active gym context.
support_get_module_health
ChatGPTGet the runtime health status for a single named module at this gym. Returns whether the module is healthy, degraded, or unavailable at the time of the call, along with evidence items and when the health was last checked. Known module IDs: dashboard, members, memberships, billing, payments, products, schedule, bookings, attendance, check_ins, coaches, staff, programming, class_programming, personal_programming, whiteboard, challenges, competitions, member_app, website, integrations, ai, reports, settings. Pass one of these IDs directly — no need to call support_list_modules first. Use this to check if a module is currently operational (runtime health) rather than configuration completeness. Call support_get_module_setup to check whether a module is correctly configured. Requires support:read scope and an active gym context.
support_get_module_setup
ChatGPTGet the setup status for a single named module at this gym. Returns whether the module is fully configured, partially configured, or not yet set up, along with evidence items and a recommended action. Known module IDs: dashboard, members, memberships, billing, payments, products, schedule, bookings, attendance, check_ins, coaches, staff, programming, class_programming, personal_programming, whiteboard, challenges, competitions, member_app, website, integrations, ai, reports, settings. Pass one of these IDs directly — no need to call support_list_modules first. Use this to diagnose why a specific module is not working or to check if it is ready to use. Call support_get_module_health for runtime health (vs. configuration completeness). Requires support:read scope and an active gym context.
support_get_setup_guidance
ChatGPTReturn prioritised setup guidance for a gym — either overall or for a specific area (billing, programming, classes, member_app). Use when the user asks 'what should I set up next', 'help me get started', or 'how do I finish setting up [area]'. Requires support:read scope and an active gym context.
support_get_support_context
ChatGPTRetrieve the current user's role, gym membership status, last booking date, and active plan name. Use this first to understand who the authenticated user is and what they have access to at this gym. Returns status, role, membershipStatus, lastBookingDate, and activePlanName. Requires support:read scope and an active gym context.
support_list_modules
ChatGPTList all support modules available for this gym, each with its setup status and health summary. Modules represent major Forj capabilities such as Billing, Scheduling, Programming, Members, and CRM. Setup status indicates whether the module is fully configured (ok), partially configured (warning), not yet configured (missing), or status could not be determined (unknown). Use this for a high-level overview of which modules are active and which need attention. Call support_get_module_setup or support_get_module_health for detailed status on a single module. Requires support:read scope and an active gym context.
support_resolve_feature
ChatGPTLook up where a specific feature, page, or action lives in Forj using the feature registry. Returns the route, step-by-step instructions, and breadcrumb path from Forj's own registry. Use this FIRST for any 'where do I...', 'how do I...', or 'how to...' questions about navigation or setup steps. Never guess routes — only use what this tool returns. Results include featureId, route, steps, breadcrumbs, and unavailableMatches for blocked or disabled features. The optional currentRoute parameter can be supplied for 'already here' detection (when the caller knows the user's current page). Requires support:read scope and an active gym context.
support_resolve_member
ChatGPTResolve a member name or email to a verified member entity within the caller's gym. On a confident single match returns
memberResolved: true plus memberId (the stable internal member ID), name, email, and status. On an ambiguous match returns choices[] where each entry contains both token (choiceToken for opaque resolution) and memberId (direct usable ID for write actions). Pass the returned memberId directly to downstream write tools such as support_action_preview with actionId book-member-into-class, assign-membership, send-member-message, etc. Always call this before any member-specific write action. Requires support:read scope and an active gym context.support_resolve_session
ChatGPTResolve a natural-language session time description to a verified class session entity. Returns a single confident match, disambiguation choices, or no-match. Required before booking a class for a member. Requires support:read scope and an active gym context.
support_search_capabilities
ChatGPTSearch Forj capability providers and modules using a natural-language query, focused on what the platform can do. Complements support_search_features: while search_features returns step-by-step how-to guides, this tool returns capability-level results — which modules handle a topic and how well they match. Use this when the user asks 'does Forj support X', 'can I do X in Forj', or 'what modules cover X'. Results include module names, matched topics, and relevance scores. Call support_diagnose for a deeper cross-provider diagnosis of a query. Requires support:read scope and an active gym context.
support_search_features
ChatGPTSearch across Forj features, navigation items, and capability modules using a natural-language keyword query. Returns a ranked list of matching features, routes, and modules relevant to the query. Use this when the user asks 'how do I do X', 'where is X', or 'what does X do'. Results include step-by-step instructions when the query is instructional (e.g. 'how do I add a member'). Call support_get_feature with the returned featureId for full step-by-step detail on a specific feature. Call support_diagnose instead when you need to understand the health or configuration status of a module. Requires support:read scope and an active gym context.
suspend_automation_policy
ChatGPTSuspend an active automation policy to prevent it from being executed. A suspended policy can be reactivated by the owner. Use this when a policy is causing unexpected results or needs to be reviewed. Policies are also automatically suspended when any constituent tool fails. Strong confirmation required: shows the policy name and reason. Requires OWNER role (setup:write + admin:write scopes).
switch_active_gym
ChatGPTSwitch the active gym context for this ChatGPT connection. Subsequent gym-scoped tool calls will use the selected gym. Provide either gymSlug (preferred) or gymName (partial match). Use get_my_gyms to see available options. Requires explicit confirmation before switching. Requires gyms:read scope.
unpublish_programming
ChatGPTRevert one or more published programming assignments from MEMBER_VISIBLE back to STAFF_ONLY. Does NOT modify workout content — only reverts the lifecycle visibility. Use this to withdraw programming that was published in error or needs rework before members see it. Requires explicit confirmation before any change is written. Target assignments by assignmentIds array OR by weekStartDate + optional scope filter. Requires programming:write scope. gymId is never accepted from input — always resolved from the authenticated session.
update_challenge
ChatGPTUpdate challenge configuration. Requires challenges:write and confirmation.
update_competition
ChatGPTUpdate a competition. Published schedule or registration changes may affect athletes; confirm before continuing. Requires competitions:write.
update_competition_event
ChatGPTUpdate a competition event. Requires competitions:write and explicit confirmation.
update_internal_heat
ChatGPTUpdate a heat time or capacity; published schedule changes require confirmation. Requires heats:write.
update_internal_heat_event
ChatGPTUpdate an internal heat event; confirm if changing a published schedule. Requires heats:write.
update_member_plan
ChatGPTUpdate a member's active membership plan at the authenticated admin's active gym. Can change the plan status (e.g. ACTIVE → PAUSED), adjust billing dates, or add a billing note. Requires billing:write scope and OWNER role or higher. Requires explicit confirmation before executing. Use get_member_plans (when available) or the admin members screen to find memberId and memberPlanId. Only the fields included in the patch will be changed — omitted fields are left unchanged.
update_programming_assignment
ChatGPTUpdate an existing programming assignment after explicit confirmation. Uses the existing Forj assignment update route and validation.
update_programming_template
ChatGPTUpdate a canonical Forj programming template using the existing programming validation and tenant boundary.
use_gym
ChatGPTAlias for switch_active_gym. Activates the gym context for this ChatGPT connection.
validate_automation_domain
ChatGPTValidate a structured domain condition tree against a target model's field/operator allowlist WITHOUT querying data. Returns validation errors if any field, operator, or value shape is invalid.
validate_programming_week
ChatGPTValidate the programming assignments for a given week at the active gym against: movement variety, block count balance, scoring rule completeness, and missing scaling notes. Read-only — no changes are made. No confirmation required. Returns a list of validation conflicts and recommendations. Use this after create_programming_week to catch issues before publishing. Requires OWNER or COACH role (admin:read scope).
void_invoice
ChatGPTVoid an invoice at the authenticated admin's active gym. Voiding an invoice marks it as cancelled — the invoice can no longer be collected or reissued. Requires billing:write scope and OWNER role or higher. Requires explicit confirmation before executing. Use get_invoices or the admin billing screen to find the invoiceId. An optional reason/notes string may be provided and will be recorded on the invoice.
Capabilities
Writes
Example Prompts
Click any prompt to copy it.
Links
App Stats
166
Tools
3
Prompts
ChatGPT
Platforms
Category
Company OperationsWorks with
ChatGPT
Data refreshed daily