Kinevo

Set up a RECURRING form/check-in for one or more students: the form is sent automatically on each due date (the student is notified every time). Use for ongoing weekly check-ins, monthly or QUARTERLY reassessments, etc. For a ONE-OFF send, use kinevo_send_form instead. Pick template_id via kinevo_list_form_templates and student ids via kinevo_list_students. Confirm the cadence with the trainer before scheduling. Cadence: use `frequency` for the four common ones, or `interval_unit` + `interval_count` for anything else — bimestral = month/2, trimestral = month/3, semestral = month/6, anual = month/12.

kinevo_schedule_form

Schedule a training session for a student. Set frequency='once' for a single session, or 'weekly'/'biweekly'/'monthly' for a recurring routine that repeats on the weekday of starts_on. The student gets a reminder push and an inbox notification automatically. Overlapping sessions at the same time are allowed (group/duo classes).

kinevo_create_appointment

Apply a stage's template to the group's students — each student gets their OWN COPY of the program, which they can then diverge from. This CREATES PROGRAMS FOR REAL STUDENTS and notifies them. ALWAYS call it first WITHOUT confirm to get the preview (which classifies every member: who would be replaced, who is blocked, who is already queued), show that to the trainer, and only call again with confirm=true after explicit approval.

kinevo_apply_group_stage

AUTOMATIC WEEKLY PROGRESSION for strength exercises: from one rule ('+1 rep por semana', '+2,5 kg por semana', '+1 série', '−10s de descanso', 'deload na semana 4') it generates weeks 2..duration_weeks for every exercise in scope, written as the same weekly overrides the trainer would set by hand. USE THIS instead of writing progression week by week with kinevo_update_workout_item when the trainer asks for a linear/automatic progression. Rules: week 1 is the exercise as prescribed; per-set loads, RIR and tempo are kept in every week; sets never change in named methods (5x5, pyramid, top+backoff, drop-set, cluster) and only change in a superset when the whole block is included; timed sets (plank) are skipped; warmups, cardio and notes never enter. In a deload week the progression pauses and resumes from where it stopped. Requires the program's duration_weeks — if it is missing the tool refuses: ask the trainer, do not pick a duration. Returns, per exercise, applied / kept (hand-made progression, conflict='keep') / skipped (reason) and the generated weeks.

kinevo_apply_auto_progression

Archive (offboard) a student who stopped training: cancels their active contracts/subscriptions (including Stripe), optionally ends their recurring appointment routines, ends the trainer-student link and notifies the student. In a STUDIO any active member (trainer or manager) can archive any student of the organization, not only the one responsible for them. The workout HISTORY is preserved and the student moves to the archived list — they can be brought back later with kinevo_reactivate_student (canceled contracts/routines do NOT come back automatically). This is NOT the same as kinevo_update_student status='inactive' (which just marks the student inactive, keeping contracts and the link). Without confirm=true it only returns a PREVIEW (contracts/routines that would be affected). If the student has active appointment routines and appointment_decision was not given, it returns needs_appointment_decision — ask the trainer whether to cancel or keep them, then call again.

kinevo_archive_student

Archive a class (turma): it stops being offered and no one new can join. It does NOT cancel the students already enrolled — their sessions keep happening. To take a student out, end that student's routine with kinevo_cancel_appointment_series. Tell the trainer this before archiving.

kinevo_archive_class_slot

Assign an existing program template to a student, creating a copy. Or activate a draft assigned program by setting its start date. Before scheduling a FUTURE start, confirm the date WITH ITS WEEKDAY with the trainer ("terça-feira, 06/10"). To start right after the current program, use `next_program_starts_on` from kinevo_get_student / kinevo_get_program — never compute it from started_at + weeks yourself. A program's last day depends on the weekday it started: a 4-week block started on a Tuesday ends on a MONDAY, so 'when the current one ends' may not be the Monday the trainer has in mind. Relay the `schedule.message` of the result to the trainer as-is. When it activates now, the last day of the program is `program_window.last_day_label`; `expires_at` is an exclusive limit, never present it as the end date.

kinevo_assign_program

Update an existing student's profile data such as name, phone, objective, modality, notes, or training level. To change the student's STATUS use status_name (the trainer's own statuses such as 'Férias' or 'Lesionado', or 'Ativo' / 'Inativo') and, for a return date, status_until — e.g. 'coloca a Ana de férias até dia 20' = status_name 'Férias' + status_until.

kinevo_update_student

Edit an item inside a workout session in-place: change sets, reps, rest, notes, function, training method, position, or swap the exercise itself. Also supports advanced per-set prescription via set_scheme (replaces the whole per-set scheme). For cardio blocks, pass cardio_config to replace the block's aerobic prescription (mode/equipment/duration/intervals/intensity); for WARMUP blocks, pass warmup_config to rewrite the block (drills, bands, targets, title) — ADJUSTING a warmup is an edit, never a delete followed by a new block. Only the fields you pass are changed. WEEKLY PERIODIZATION: pass `progression` on a root exercise to make its prescription change across the program's weeks (each entry applies FROM its week on; the item's own sets/reps ARE week 1). Requires duration_weeks covering the highest week. Pass `progression: []` to remove the weekly periodization of the exercise entirely.

kinevo_update_workout_item

Update an existing plan. Only the fields you pass are changed (the rest keep their current values). Changing price/interval on a plan with online payment archives the old Stripe price and creates a new one — existing subscriptions keep the old price. Does NOT charge anyone.

kinevo_update_plan

Update a program's metadata in-place: name, description, duration_weeks or week_labels (names of the program weeks / periodization phases). Works for assigned programs (any status) and library templates — use it instead of recreating the program. Typical use: extending duration_weeks so a cardio block's weekly progression fits (the progression's highest week must be ≤ duration_weeks).

kinevo_update_program

Rename, reorder, or reschedule an existing workout session in a program. Use this to edit a session in-place without recreating the program — including setting which weekdays the session falls on (scheduled_days) and converting its type (session_type 'strength' ↔ 'cardio'; converting to 'cardio' requires the session to have no strength exercises).

kinevo_update_workout_session

Update a lead's status in the CRM pipeline (new → read → contacted → converted/archived). Use to mark a lead as contacted or archive it. To actually turn a lead into a student account, that is done in the app (not via this tool).

kinevo_update_lead_status

Search scientific evidence (PubMed/Europe PMC) for training-related questions: training volume, frequency, load, periodization, aerobic prescription, special populations, pain/injury, recovery, supplements, adherence. Answers from a curated corpus of 49 topics; for anything outside it, falls back to a live PubMed search when you provide search_terms_en. Returns papers with a PT-BR summary (finding, population, dose, practical takeaway, strength of evidence) and a ready-to-paste markdown `citation` field. ONLY cite studies returned by this tool. Use it when the trainer asks what the science says, asks you to justify a prescription choice, or questions a recommendation — not for operational tasks.

kinevo_search_evidence

Find substitute candidates for an exercise (injury/pain, missing equipment, or preference). Returns the reference exercise plus catalog alternatives that share its movement pattern and/or muscle groups, and — when student_id is given — the student's medical restrictions. THE TOOL DOES NOT DO CLINICAL REASONING: from the candidates, YOU pick 2-3 options that avoid the limitation the trainer described (e.g. shoulder pain → prefer neutral-grip/machine variants, avoid overhead), explain why, and let the trainer choose. Then apply the swap with kinevo_update_workout_item if a program item was given.

kinevo_find_exercise_substitutes

Cancel a student's contract. For online (Stripe/Asaas) contracts this also cancels the subscription at the provider. cancel_at_period_end=true schedules the cancellation for the end of the paid period (student keeps access until then); false cancels IMMEDIATELY (access is revoked now). HIGH IMPACT and hard to undo. Call WITHOUT confirm first to preview; call again with confirm=true only after the trainer approved.

kinevo_cancel_contract

Cancel a single scheduled session occurrence (not the whole routine). The student is notified. To end an entire recurring routine, use kinevo_cancel_appointment_series.

kinevo_cancel_appointment_occurrence

IMPORTING a program the trainer already has (attached file, image or pasted text): match ALL exercise names of the source in ONE call, written exactly as in the source. Each name comes back as 'matched' (use its exercise_id), 'review' (no clear match: use the best candidate's exercise_id — the trainer confirms it on the preview card) or 'new' (nothing in the catalog: send the item with new_exercise: { name } instead of exercise_id; it is created only when the program is saved). Use this INSTEAD of kinevo_list_exercises when importing. Not for designing new programs.

kinevo_match_exercises

Put an existing workout session on a specific day of the student's calendar. THE MODE IS THE WHOLE POINT: mode='date' places it ONLY on that date (a one-off — the weekly recurrence is untouched), while mode='weekly' writes that weekday into the session's recurrence, exactly like the scheduled_days chip in the builder, so it repeats every week from then on. Use 'date' for a one-off (a race, a test, a session pulled forward because of a trip) and 'weekly' when the trainer is changing the routine itself. Placing a date OUTSIDE the program's window is allowed — the occurrence still counts; the trainer can extend the program afterwards with kinevo_update_program.

kinevo_place_workout_on_date

Convert a lead into a real student account (courtesy / no contract — billing can be set up later with kinevo_create_contract). This CREATES a login account and returns a ONE-TIME, short-lived activation link the trainer sends to the student so they set their OWN password. No password is ever returned. Idempotent: a lead already converted (or whose e-mail already exists under this trainer) just links to the existing student, with no new link. Call WITHOUT confirm first to preview; call again with confirm=true only after the trainer approved.

kinevo_convert_lead

Copy one or more SESSIONS (workouts) from any of the trainer's programs — any status, including COMPLETED ('previous program') — into another program (draft, scheduled or active), of the same or another student. Copies everything in one transaction: exercises, per-set schemes, supersets/circuits, aerobic blocks, warmups, notes, progression and the session type. The copies go to the END of the target program. Use kinevo_get_program to read the source sessions' ids and the target program id. On an ACTIVE target this becomes an edit card the trainer approves. To copy a WHOLE program use kinevo_duplicate_program instead.

kinevo_copy_workout_sessions

Register a new student for this trainer. Creates the student profile with Supabase Auth account and optionally sets clinical/training preferences.

kinevo_create_student

Set up a MANUAL billing contract linking a student to a plan (or courtesy/free access). This CANCELS the student's current active contract and creates the new one. It does NOT charge the student — it just records the billing arrangement. Call WITHOUT confirm first to get a preview of exactly what will happen, then call again with confirm=true only after the trainer approved.

kinevo_create_contract

Add a stage to the group's track. A stage is one leg of the journey (e.g. 'Base', 'Específico', 'Polimento'), optionally dated and pointing at a program template. Creating the stage does NOT write anything to the students — that is kinevo_apply_group_stage.

kinevo_create_group_stage

Create a custom STRENGTH exercise in THIS trainer's own library (owner = the trainer), e.g. when you want to prescribe a movement that isn't in the catalog yet. Link it to muscle groups by name — existing groups (the trainer's own + Kinevo's) are matched case-insensitively; names that don't match are reported back (not created). After creating, the exercise is available to kinevo_list_exercises and the program builder. IMPORTANT: aerobic ACTIVITIES (running, walking, bike, swimming, treadmill, rowing…) are NOT library exercises — prescribe them as cardio blocks via kinevo_add_cardio_to_session (standalone cardio sessions via session_type='cardio'), which gives the student a guided timer, structured intensity (zones/RPE/pace) and weekly progression. Names that look aerobic are rejected unless confirm_strength=true.

kinevo_create_exercise

Create a student group — a cohort that trains the same plan (e.g. 'Maratona de São Paulo', 'Turma da manhã'). In a studio the group belongs to the ORGANIZATION and colleagues can see it. Adding students is a separate step (kinevo_add_group_members).

kinevo_create_group

Create a billing plan (a product students can subscribe to). With the Kinevo Wallet (Asaas) approved, the plan can already generate online payment links — no Stripe involved. with_online_payment=true additionally creates a legacy Stripe Product/Price when the trainer still has Stripe Connect active. Does NOT charge anyone.

kinevo_create_plan

Create an EMPTY program shell, to be populated afterwards with kinevo_add_workout_session + kinevo_add_exercise_to_session. Omit student_id to create a REUSABLE TEMPLATE that appears in the trainer's Program Library (Biblioteca de Programas); pass student_id to create it already assigned to that student as a draft. TIP: to build a full library template (sessions + exercises) in a single call, prefer kinevo_create_program_template.

kinevo_create_program

Create a named PRESCRIPTION PROTOCOL (Skill) for this trainer — his method for ONE specific case (e.g. 'Retorno pós-parto', 'Off-season de corredor'). A protocol does NOT replace his prescription style: it OVERRIDES it field by field, and every field left out is inherited from the style. Every number the trainer STATES for this protocol (reps, rest, exercises per session, weekly sets) goes into its structured field too, even when it is also written in the playbook — an unfilled field is inherited from his style and the two would contradict each other at build time. Fields he did not talk about stay out (they keep following his style). `playbook` is the heart of it: the method in his own words (phases, progression criteria, what to do when the student stalls) — things that never fit in numeric fields. Use this when the trainer asks to create/save a protocol, method or 'jeito de prescrever' for a case, INCLUDING when he attaches a document (PDF/spreadsheet) and asks for a protocol based on it. Volume ceilings of the build playbook always win over the protocol.

kinevo_create_prescription_skill

Create a COMPLETE workout program as a DRAFT assigned directly to a SPECIFIC student, in ONE transactional call: the program plus all its workout sessions, exercises, supersets and per-set schemes. The draft is INVISIBLE to the student and lands on the student's profile ("Rascunho criado pelo assistente") for the trainer to review and then ACTIVATE — or discard. Prefer this over kinevo_create_program_template (which creates a REUSABLE library template, not tied to a student) and over kinevo_create_program + N add_session (incremental, NOT transactional) whenever you've designed a program FOR THIS STUDENT. It does NOT activate the program — the trainer activates from the profile (or via kinevo_assign_program action 'activate_draft'). All exercise_id values must exist in the catalog (kinevo_list_exercises). WEEKLY PERIODIZATION: pass `progression` on a root exercise to make its prescription change across the program's weeks (each entry applies FROM its week on; the item's own sets/reps ARE week 1). Requires duration_weeks covering the highest week.

kinevo_create_student_draft_program

Create a NEW, EMPTY session that happens on ONE date only — the 5 km race on Saturday, the 1RM test, a session that does not repeat. It is born with NO weekday, so it never enters the weekly recurrence; it counts once, on that day. Fill it afterwards with kinevo_add_exercise_to_session (strength) or kinevo_add_cardio_to_session (aerobic), exactly like any other session. Do NOT use this to change what an EXISTING session does on one day — that is a different thing (the trainer does it in the calendar, which copies the session for that day). Do NOT use it for an EXTRA workout available any day ("treino avulso", "em casa para quando não puder ir", "reserva") — that is kinevo_add_workout_session with NO scheduled_days in a program whose other sessions have days: the app shows it as "Extra", outside the weekly goal.

kinevo_create_dated_workout

Create a superset (or bi-set/tri-set) inside a workout session: a group of exercises performed back-to-back with rest taken only after the group. Creates the superset container plus its child exercises in one call. Works for templates and assigned programs.

kinevo_create_superset

Create a NEW form template (anamnese / check-in / survey / feedback) in the trainer's library from a list of structured questions. The app shows a card with the questions for the trainer to APPROVE before anything is created. Use it whenever the trainer asks for a form, questionnaire, anamnese, check-in or evaluation form — NEVER paste a form as chat text as if it were the product (chat text never reaches a student). After creation, send it with kinevo_send_form.

kinevo_create_form_template

Create a COMPLETE reusable program template in the trainer's Program Library (Biblioteca de Programas) in ONE transactional call: the program plus all its workout sessions, exercises, supersets and per-set schemes. Use this — instead of orchestrating create_program + N add_session + M add_exercise — whenever you have the whole template designed up front. The template can later be assigned to any student with kinevo_assign_program (action 'assign_template'), which copies it and materializes the schedule. All exercise_id values must exist in the catalog (kinevo_list_exercises). WEEKLY PERIODIZATION: pass `progression` on a root exercise to make its prescription change across the program's weeks (each entry applies FROM its week on; the item's own sets/reps ARE week 1). Requires duration_weeks covering the highest week.

kinevo_create_program_template

Dismiss an alert/insight the trainer says is wrong or already handled. It is the TRAINER'S call: when they ask to dismiss, dismiss — do not demand evidence or re-check the data first (you may mention what you saw). reason 'not_true' = the alert does not make sense; 'resolved' = already handled outside. Use the insight id from kinevo_list_insights. It disappears from the attention panel and the same alert stays quiet for a while.

kinevo_dismiss_insight

Duplicate an existing program in one call: copy an ASSIGNED program (any status — great for "same program for another student" or "next cycle") or a library TEMPLATE into a new STUDENT DRAFT (target='student_draft', requires student_id) or a new library TEMPLATE (target='template'). Copies sessions, schedules, exercises, supersets, per-set schemes, pre-configured substitutes and notes. The copy is created INERT (draft/template) — nothing changes for any student until the trainer activates it. Use kinevo_list_programs / kinevo_get_program to pick the source.

kinevo_duplicate_program

Edit a stage of the track in place: rename it, point it at another template, or move its window. Only the fields you pass change. Editing a stage does NOT rewrite programs already applied to students — those are their own copies.

kinevo_update_group_stage

Edit an EXISTING prescription protocol of this trainer — rename it, change when to use it, rewrite or extend its playbook, or change its structured fields. Use this (never kinevo_create_prescription_skill again) whenever the trainer adds details to, corrects or renames a protocol that already exists, INCLUDING one created earlier in this same conversation. Identify it by `skill_name` (its current name). Only the fields you send change: `playbook` REPLACES the whole method text, so send it complete (start from the current text in <<METODO_DA_SKILL>> or from the card you proposed earlier); if you do not have the current text, use `playbook_append` to add a paragraph instead. Structured fields you send replace those fields; `clear_fields` makes a field go back to following his style.

kinevo_update_prescription_skill

Edit a form template that belongs to THIS trainer: title, description, category, or the questions. The app shows the same approval card as creation, with the resulting question list. Pass `questions` only when changing them — it REPLACES the whole set, so send the full list including the ones you are keeping. Answers already submitted are NOT affected (each submission keeps a snapshot of the form the student saw). Pick template_id via kinevo_list_form_templates; system templates (not owned by the trainer) cannot be edited.

kinevo_update_form_template

Change a class (turma): name, number of spots or note. Weekday, time and duration can only change while the class has NO student enrolled (to move a class with students, open a new one and move each student). Spots can't go below the number already enrolled. Only the fields you pass change.

kinevo_update_class_slot