@trainheroic-unofficial/athlete-mcp 1.6.1 → 1.7.1

package/dist/server.mjs

@@ -195,7 +195,14 @@ z.object({
 		sets: z.array(loggedSetSchema).min(1)
 	})).min(1)
 });
-z.object({
+/**
+* Args for the coach per-athlete exercise swap: replace the exercise prescribed in one of a
+* roster athlete's saved-workout slots with a different exercise, the API equivalent of the
+* app's per-athlete "swap exercise". `savedWorkoutSetExerciseId` is that athlete's own slot id
+* (the same id `coachLogSetArgsSchema` uses, read off athlete_saved_workouts raw);
+* `exerciseId` is the replacement exercise. The team/program prescription is left untouched.
+*/
+const swapAthleteExerciseArgsSchema = z.object({
 	savedWorkoutSetExerciseId: idArgSchema,
 	exerciseId: idArgSchema
 });
@@ -331,6 +338,23 @@ const DEFAULT_RESULT_BUDGET = 6e4;
 const MARKER_RESERVE = 300;
 const DEFAULT_ARRAY_HINT = "Result was truncated to fit the size budget. Narrow it with a filter/search argument or paginate to see the rest.";
 const DEFAULT_OBJECT_HINT = "Result was truncated to fit the size budget. Request a more specific id or sub-resource.";
+/**
+* Clip an array to its first `keep` items and attach the `__truncated` marker describing what was
+* dropped. The marker is model-facing (tools instruct the model to key off `__truncated`), so its
+* shape has exactly one definition here: the size-budget path (`boundedSerialize`) and any tool
+* that deliberately caps a list (e.g. `athlete_exercises`) emit the same thing.
+*/
+function clipArray(items, keep, hint) {
+	return {
+		items: items.slice(0, keep),
+		__truncated: {
+			returned: keep,
+			total: items.length,
+			omitted: items.length - keep,
+			hint: hint ?? DEFAULT_ARRAY_HINT
+		}
+	};
+}
 /** Active budget. Overridable via TH_MCP_RESULT_BUDGET on Node; the default on workerd. */
 function resultBudget() {
 	const raw = (globalThis.process?.env)?.TH_MCP_RESULT_BUDGET;
@@ -387,16 +411,7 @@ function boundedSerialize(data, budget, hint) {
 	}
 	if (Array.isArray(data)) {
 		const k = largestPrefixCount(data.map((el) => JSON.stringify(el) ?? "null"), budget - MARKER_RESERVE);
-		const wrapped = {
-			items: data.slice(0, k),
-			__truncated: {
-				returned: k,
-				total: data.length,
-				omitted: data.length - k,
-				hint: hint ?? DEFAULT_ARRAY_HINT
-			}
-		};
-		const out = JSON.stringify(wrapped);
+		const out = JSON.stringify(clipArray(data, k, hint));
 		if (out.length <= budget) return out;
 	} else if (isPlainObject(data)) {
 		const key = largestArrayValuedKey(data);
@@ -775,66 +790,40 @@ function nonEmpty(value) {
 	return value !== void 0 && value !== null && String(value).trim() !== "";
 }
 /**
-* Per-set prescriptions from the param_N_data slots, e.g. ["5 @ 225", "3 @ 245"] or ["AMRAP"].
-* Values are kept raw (a non-numeric prescription like "AMRAP" or "8-12" must survive); the
-* positional units come from the exercise's param types, mirroring the coach presenter.
+* Slot-indexed values for one exercise. With `requireMade`, only slots the athlete logged
+* (`param_i_made === 1`) — the performed reader; otherwise every slot carrying data — the
+* prescription reader. Values stay raw; the projectors format or parse them.
 */
-function prescribedSets(ex) {
-	const out = [];
+function slotValues(ex, requireMade) {
+	const map = /* @__PURE__ */ new Map();
 	for (let i = 1; i <= 10; i += 1) {
+		if (requireMade && coerceInt(ex[`param_${i}_made`]) !== 1) continue;
 		const p1 = ex[`param_1_data_${i}`];
 		const p2 = ex[`param_2_data_${i}`];
-		const has1 = nonEmpty(p1);
-		const has2 = nonEmpty(p2);
-		if (!has1 && !has2) continue;
-		if (has1 && has2) out.push(`${p1} @ ${p2}`);
-		else if (has1) out.push(String(p1));
-		else out.push(`@ ${p2}`);
+		if (!nonEmpty(p1) && !nonEmpty(p2)) continue;
+		map.set(i, {
+			p1: nonEmpty(p1) ? p1 : null,
+			p2: nonEmpty(p2) ? p2 : null
+		});
 	}
-	return out;
+	return map;
 }
-/**
-* The per-set values the athlete actually logged, read from a saved-copy exercise. A set
-* counts as performed only when its `param_{i}_made` flag is 1: the saved copy pre-fills the
-* `param_N_data` slots with the prescription, so the presence of data alone does not mean a
-* set was done. `param_{i}_made` is the same per-set flag the logging write sets, and is the
-* only reliable signal (the `completed` flags are often left at 0 on a logged session).
-*/
-function performedSets(ex) {
-	const out = [];
-	for (let i = 1; i <= 10; i += 1) {
-		if (coerceInt(ex[`param_${i}_made`]) !== 1) continue;
-		const p1 = ex[`param_1_data_${i}`];
-		const p2 = ex[`param_2_data_${i}`];
-		const has1 = nonEmpty(p1);
-		const has2 = nonEmpty(p2);
-		if (has1 && has2) out.push(`${p1} @ ${p2}`);
-		else if (has1) out.push(String(p1));
-		else if (has2) out.push(`@ ${p2}`);
-	}
-	return out;
+/** The joined display for a slot, kept verbatim (`"5 @ 225"`, `"AMRAP"`, `"@ 225"`). */
+function fmtSlot(slot) {
+	const has1 = slot.p1 !== null;
+	const has2 = slot.p2 !== null;
+	if (has1 && has2) return `${slot.p1} @ ${slot.p2}`;
+	if (has1) return String(slot.p1);
+	if (has2) return `@ ${slot.p2}`;
+	return "";
 }
-function presentExercise(ex, performedById) {
-	const instruction = typeof ex.instruction === "string" && ex.instruction !== "" ? ex.instruction : null;
-	const id = coerceInt(ex.id);
-	return {
-		exerciseId: coerceInt(ex.exercise_id),
-		title: typeof ex.title === "string" ? ex.title : "",
-		instruction,
-		units: exerciseUnits(ex.param_1_type, ex.param_2_type),
-		prescribed: prescribedSets(ex),
-		performed: (id !== null ? performedById.get(id) : void 0) ?? []
-	};
+/** Every slot carrying data, joined for display (the prescription reader): `["5 @ 225", "AMRAP"]`. */
+function prescribedStrings(ex) {
+	return [...slotValues(ex, false).values()].map(fmtSlot);
 }
-function presentBlock(set, performedById) {
-	const exercises = Array.isArray(set.workoutSetExercises) ? set.workoutSetExercises : [];
-	return {
-		order: coerceInt(set.order) ?? 0,
-		title: typeof set.title === "string" && set.title !== "" ? set.title : null,
-		instruction: typeof set.instruction === "string" && set.instruction !== "" ? set.instruction : null,
-		isTest: coerceInt(set.is_test) === 1,
-		exercises: exercises.filter(isRecord).map((ex) => presentExercise(ex, performedById))
-	};
+/** The slots the athlete logged (`param_i_made === 1`), joined for display (the performed reader). */
+function performedStrings(ex) {
+	return [...slotValues(ex, true).values()].map(fmtSlot);
 }
 /** Every logged set (programmed + athlete-added) in the saved copy, paired with its exercises. */
 function savedSets(saved) {
@@ -853,54 +842,82 @@ function savedSets(saved) {
 	return out;
 }
 /**
-* Map each prescription exercise id to the per-set values the athlete logged. In the saved
-* copy, `workout_set_exercise_id` points back at the prescription exercise's `id`, and the
-* entered values live in the same `param_N_data` slots as a prescription — so the
-* prescription reader works on them unchanged.
+* Map each prescription exercise id to the slot-indexed values the athlete logged against it. In
+* the saved copy `workout_set_exercise_id` points back at the prescription exercise's `id`, and the
+* entered values live in the same `param_N_data` slots as a prescription.
 */
-function performedByExerciseId(sets) {
+function performedSlotsByExerciseId(sets) {
 	const map = /* @__PURE__ */ new Map();
 	for (const { exercises } of sets) for (const ex of exercises) {
 		const id = coerceInt(ex.workout_set_exercise_id);
 		if (id === null) continue;
-		const values = performedSets(ex);
-		if (values.length > 0) map.set(id, values);
+		const slots = slotValues(ex, true);
+		if (slots.size > 0) map.set(id, slots);
 	}
 	return map;
 }
-/** Present a logged set straight from the saved copy (athlete-added or personal work). */
-function presentSavedBlock(set, exercises) {
+/** Align an exercise's prescribed slots with the slots the athlete logged, per set index. */
+function mergeExercise(prescribed, performed, meta) {
+	const indices = [.../* @__PURE__ */ new Set([...prescribed.keys(), ...performed.keys()])].sort((a, b) => a - b);
+	return {
+		...meta,
+		sets: indices.map((i) => ({
+			set: i,
+			prescribed: prescribed.get(i) ?? null,
+			performed: performed.get(i) ?? null
+		}))
+	};
+}
+/** A prescription block, each exercise aligned with the slots the athlete logged against it. */
+function mergePrescriptionBlock(set, performedById) {
+	const exercises = Array.isArray(set.workoutSetExercises) ? set.workoutSetExercises : [];
+	return {
+		order: coerceInt(set.order) ?? 0,
+		title: str(set.title),
+		instruction: str(set.instruction),
+		isTest: coerceInt(set.is_test) === 1,
+		exercises: exercises.filter(isRecord).map((ex) => {
+			const id = coerceInt(ex.id);
+			const performed = (id !== null ? performedById.get(id) : void 0) ?? /* @__PURE__ */ new Map();
+			return mergeExercise(slotValues(ex, false), performed, {
+				exerciseId: coerceInt(ex.exercise_id),
+				title: typeof ex.title === "string" ? ex.title : "",
+				instruction: str(ex.instruction),
+				units: exerciseUnits(ex.param_1_type, ex.param_2_type)
+			});
+		})
+	};
+}
+/** A logged block straight from the saved copy (athlete-added or personal work; no prescription). */
+function mergeSavedBlock(set, exercises) {
 	return {
 		order: coerceInt(set.order) ?? 0,
-		title: typeof set.title === "string" && set.title !== "" ? set.title : null,
-		instruction: typeof set.instruction === "string" && set.instruction !== "" ? set.instruction : null,
+		title: str(set.title),
+		instruction: str(set.instruction),
 		isTest: coerceInt(set.is_test) === 1,
-		exercises: exercises.map((ex) => ({
+		exercises: exercises.map((ex) => mergeExercise(/* @__PURE__ */ new Map(), slotValues(ex, true), {
 			exerciseId: coerceInt(ex.exercise_id),
 			title: typeof ex.exercise_title === "string" ? ex.exercise_title : "",
-			instruction: typeof ex.instruction === "string" && ex.instruction !== "" ? ex.instruction : null,
-			units: exerciseUnits(ex.param_1_type, ex.param_2_type),
-			prescribed: [],
-			performed: performedSets(ex)
+			instruction: str(ex.instruction),
+			units: exerciseUnits(ex.param_1_type, ex.param_2_type)
 		}))
 	};
 }
 /**
-* Flatten one `/3.0/athlete/programworkout/range` item into a readable workout, merging the
+* Flatten one `/3.0/athlete/programworkout/range` item into the canonical merged form, joining the
 * prescription (`summarizedSavedWorkout.workout`) with what the athlete logged
-* (`summarizedSavedWorkout.saved_workout`). Each exercise carries both its `prescribed` and
-* `performed` sets; athlete-added/personal work that has no prescription is appended as its
-* own blocks. No `raw` is needed to see logged results.
+* (`summarizedSavedWorkout.saved_workout`). Prescription blocks are enriched with logged slots;
+* athlete-added / personal work with no prescription is appended as its own block.
 */
-function presentAthleteWorkout(raw) {
+function mergeAthleteWorkout(raw) {
 	const rec = raw;
 	const ssw = isRecord(rec.summarizedSavedWorkout) ? rec.summarizedSavedWorkout : {};
 	const workout = isRecord(ssw.workout) ? ssw.workout : {};
 	const saved = isRecord(ssw.saved_workout) ? ssw.saved_workout : {};
 	const prescriptionSets = (Array.isArray(workout.workoutSets) ? workout.workoutSets : []).filter(isRecord);
 	const logged = savedSets(saved);
-	const performedById = performedByExerciseId(logged);
-	const blocks = prescriptionSets.map((s) => presentBlock(s, performedById)).sort((a, b) => a.order - b.order);
+	const performedById = performedSlotsByExerciseId(logged);
+	const blocks = prescriptionSets.map((s) => mergePrescriptionBlock(s, performedById)).sort((a, b) => a.order - b.order);
 	const prescribedIds = /* @__PURE__ */ new Set();
 	for (const s of prescriptionSets) {
 		const exs = Array.isArray(s.workoutSetExercises) ? s.workoutSetExercises : [];
@@ -912,11 +929,11 @@ function presentAthleteWorkout(raw) {
 	}
 	for (const { set, exercises } of logged) {
 		const extra = exercises.filter((ex) => {
-			if (performedSets(ex).length === 0) return false;
+			if (slotValues(ex, true).size === 0) return false;
 			const id = coerceInt(ex.workout_set_exercise_id);
 			return id === null || !prescribedIds.has(id);
 		});
-		if (extra.length > 0) blocks.push(presentSavedBlock(set, extra));
+		if (extra.length > 0) blocks.push(mergeSavedBlock(set, extra));
 	}
 	return {
 		id: coerceInt(rec.id),
@@ -925,11 +942,58 @@ function presentAthleteWorkout(raw) {
 		program: str(rec.program_title),
 		team: str(rec.team_title),
 		instruction: str(workout.instruction),
-		logged: blocks.some((b) => b.exercises.some((e) => e.performed.length > 0)),
+		logged: blocks.some((b) => b.exercises.some((e) => e.sets.some((s) => s.performed !== null))),
 		personal: isPersonalSession(rec),
 		blocks
 	};
 }
+/** The per-set displays for one side (prescribed or performed), in slot order. */
+function sideStrings(sets, pick) {
+	const out = [];
+	for (const s of sets) {
+		const slot = pick(s);
+		if (slot) out.push(fmtSlot(slot));
+	}
+	return out;
+}
+function toStringExercise(ex) {
+	return {
+		exerciseId: ex.exerciseId,
+		title: ex.title,
+		instruction: ex.instruction,
+		units: ex.units,
+		prescribed: sideStrings(ex.sets, (s) => s.prescribed),
+		performed: sideStrings(ex.sets, (s) => s.performed)
+	};
+}
+function toStringBlock(b) {
+	return {
+		order: b.order,
+		title: b.title,
+		instruction: b.instruction,
+		isTest: b.isTest,
+		exercises: b.exercises.map(toStringExercise)
+	};
+}
+/**
+* Flatten one range item into a readable workout: each exercise carries its `prescribed` and
+* `performed` sets as joined `"5 @ 225"` strings; athlete-added/personal work that has no
+* prescription is appended as its own blocks. No `raw` is needed to see logged results.
+*/
+function presentAthleteWorkout(raw) {
+	const w = mergeAthleteWorkout(raw);
+	return {
+		id: w.id,
+		date: w.date,
+		title: w.title,
+		program: w.program,
+		team: w.team,
+		instruction: w.instruction,
+		logged: w.logged,
+		personal: w.personal,
+		blocks: w.blocks.map(toStringBlock)
+	};
+}
 function presentAthleteWorkouts(list) {
 	return list.map(presentAthleteWorkout);
 }
@@ -989,8 +1053,8 @@ function presentLogTargets(list) {
 					savedWorkoutSetExerciseId: id,
 					title: exerciseTitle(ex),
 					units: exerciseUnits(ex.param_1_type, ex.param_2_type),
-					prescribed: prescribedSets(ex),
-					performed: performedSets(ex)
+					prescribed: prescribedStrings(ex),
+					performed: performedStrings(ex)
 				};
 			}).filter((e) => e !== null);
 			targets.push({
@@ -1009,10 +1073,11 @@ function presentLogTargets(list) {
 	return targets;
 }
 /**
-* Narrow a presented workout list for the common "what did I actually do" reads. `loggedOnly`
-* keeps only workouts the athlete logged a set on (the reliable signal, not the API's
-* completion flag). `limit` keeps the most recent N by date (newest first). Both are pure
-* post-filters over the presented view; the raw API path is left untouched.
+* Narrow a workout list for the common "what did I actually do" reads. `loggedOnly` keeps only
+* workouts the athlete logged a set on (the reliable signal, not the API's completion flag).
+* `limit` keeps the most recent N by date (newest first). Both are pure post-filters; the raw API
+* path is left untouched. Generic over the presented (`AthleteWorkoutView`) and exported
+* (`WorkoutHistoryExport`) shapes, which both carry `date` and `logged`, so one rule serves both.
 */
 function selectWorkouts(list, opts = {}) {
 	let out = opts.loggedOnly === true ? list.filter((w) => w.logged) : [...list];
@@ -1309,6 +1374,41 @@ async function logForAthlete(client, args) {
 	};
 }
 /**
+* Swap the exercise prescribed in one of an athlete's saved-workout slots for a different
+* exercise — the API equivalent of the app's per-athlete "swap exercise":
+* `PUT /v5/savedWorkoutSetExercises/{savedWorkoutSetExerciseId}?exerciseId={exerciseId}` with an
+* empty body. The new exercise rides in the query string, not the body.
+*
+* This overrides only this athlete's copy of the slot; the underlying team/program prescription
+* (`workout_set_exercise.exercise_id`) is untouched, so other athletes on the same program keep
+* the original exercise. A coach's session token may write another user's row because the row
+* already carries its owner's `user_id`.
+*
+* `savedWorkoutSetExerciseId` is the same id {@link logForAthlete}/{@link logAthleteSet} use,
+* read off the athlete's saved workouts (the raw view). `exerciseId` is any exercise id the org
+* can use (resolve one via the exercise index).
+*
+* NOTE: as with logging, TrainHeroic's seeded *demo* athletes are read-only and return 401/403;
+* real (invited) athletes accept the swap.
+*/
+async function swapAthleteExercise(client, args) {
+	const res = await client.request("PUT", `/v5/savedWorkoutSetExercises/${args.savedWorkoutSetExerciseId}?exerciseId=${args.exerciseId}`);
+	if (!res.ok) {
+		const readOnly = res.status === 401 || res.status === 403 ? ` Athlete may be read-only for changes — TrainHeroic's seeded demo/sample athletes return ${res.status} here; swaps only persist for real (invited) athletes.` : "";
+		throw new Error(`Swap failed (HTTP ${res.status}) for savedWorkoutSetExercise ${args.savedWorkoutSetExerciseId}.${readOnly}`);
+	}
+	const row = isRecord(res.data) ? res.data : {};
+	const template = isRecord(row.workout_set_exercise) ? row.workout_set_exercise : {};
+	const exercise = isRecord(row.exercise) ? row.exercise : {};
+	return {
+		savedWorkoutSetExerciseId: args.savedWorkoutSetExerciseId,
+		athleteId: coerceInt(row.user_id),
+		newExerciseId: coerceInt(row.exercise_id) ?? args.exerciseId,
+		newExerciseTitle: str(exercise.title),
+		originalTeamExerciseId: coerceInt(template.exercise_id)
+	};
+}
+/**
 * Shared set-write behind {@link logAthleteSet}, {@link logForAthlete}, and
 * {@link prescribeForAthlete}. `target` selects the surface: `athlete` writes `/1.0/athlete/...`;
 * `coach` writes `/1.0/coach/...{athleteId}` and stamps `athleteId` into each body.
@@ -1679,7 +1779,7 @@ function registerProfileTools(server, ctx, whoami, userId) {
 const ATHLETE_WORKOUTS_DESC = "Workouts in an inclusive YYYY-MM-DD window, flattened to blocks/exercises. Each exercise carries both its `prescribed` sets (what the program called for) and `performed` sets (what the athlete actually logged); each workout has a top-level `logged` flag. Use `performed`/`logged` to tell what was recorded or done. That is the reliable signal: a session can hold logged sets while the API's own completion flags stay 0, and an empty `performed` means nothing was logged for that exercise. For 'did I record anything / what did I do', set loggedOnly:true to return only sessions with logged sets (it keeps whole sessions that have any logged set, so individual exercises inside can still show empty `performed`; it also shrinks a large result); limit returns the most recent N workouts (newest first). For a high-level overview ('what's on my schedule this week', 'what have I been training lately') set summary:true to get one compact row per session (date, program, title, logged flag, and exerciseCount/performedCount — read performedCount against exerciseCount, e.g. 1 of 12 logged) instead of every set — a multi-program week of full detail is large, so prefer summary first, then re-query a single day without it to drill into that day's sets. For 'what's my next workout', query a forward window from today; if it comes back empty, the most recent session is likely yesterday's still-unlogged one, so widen the window backward a day or two. Both filters apply to the presented view, not raw. raw:true returns the untouched API objects. This is a date-windowed fetch, NOT an aggregate: for lifetime totals (all-time session count, total volume, first/last logged date) call athlete_profile instead of summing windows — a multi-year range here can time out. Narrow the window if the result is truncated.";
 const ATHLETE_LOG_TARGETS_DESC = "The savedWorkoutSetId + savedWorkoutSetExerciseId that athlete_log_set needs, read straight off your scheduled/logged workouts in an inclusive YYYY-MM-DD window — no raw needed. This is the self-service path for logging into a COACH-SCHEDULED workout: read the ids here, then pass them to athlete_log_set. The default view is COMPACT: one row per saved set, each carrying its program/programId, the savedWorkoutSetId, and every exercise's savedWorkoutSetExerciseId with prescribed/performed values. When several workouts fall on the same day (you're on more than one program), narrow to one with program (a case-insensitive title substring, e.g. 'bodybuilding' — no id lookup needed), or programId/teamId if you have the id. raw:true returns the untouched API objects, but that blob is large and can be truncated when several workouts share a date — prefer the program filter + the default view. For reading what you actually did (not the log ids), use athlete_workouts.";
 const ATHLETE_EXERCISE_HISTORY_DESC = "Per-exercise PRs and the dated session time-series (sets performed, estimated 1RM). The returned `sessions` run all-time, newest first; pass since/until (YYYY-MM-DD, inclusive) to keep only sessions in that window — use it for 'last 3 months' / 'this year' questions so the result stays small. estimated1RM is a formula off the session's best set and reads high when a session mixes a heavy single with high-rep backdown work, so treat it as approximate, not a logged single. `liftPRs` are always all-time and ignore since/until, but each carries the date it was set, so filter those dates yourself to answer 'PRs set this year'. Set raw:true for the untouched API object. Get the exercise id from athlete_exercises.";
-const ATHLETE_EXERCISES_DESC = "The exercises the athlete has logged (id + title + positional units). Pass q to free-text search by name; use the returned id with athlete_exercise_history, athlete_personal_records, or athlete_exercise_stats (all of which require an exercise id). A common name returns several variants (e.g. plain 'Bench Press' id 1162 vs 'BARBELL BENCH PRESS'); each variant keeps its own separate history and PR board, so prefer the plain canonical entry, and if a PR or trend looks incomplete, the work may be split across variants — check the others.";
+const ATHLETE_EXERCISES_DESC = "The exercises the athlete has logged (id + title + positional units). Call with no arguments to get the athlete's complete catalog, which often runs to several hundred entries; leave limit off when you want the whole list, since a no-q call returns everything by default. Pass q to free-text search by name (returns the top ranked matches, capped by limit, default 20). Use a returned id with athlete_exercise_history, athlete_personal_records, or athlete_exercise_stats (all of which require an exercise id). If a no-q result comes back wrapped with a __truncated marker, you passed a limit smaller than the catalog and are seeing a partial list; re-call without limit for all of it. A common name returns several variants (e.g. plain 'Bench Press' id 1162 vs 'BARBELL BENCH PRESS'); each variant keeps its own separate history and PR board, so prefer the plain canonical entry, and if a PR or trend looks incomplete, the work may be split across variants, so check the others.";
 function runAthleteWorkouts(ctx, args) {
 	return attempt(async () => {
 		const workouts = await fetchAthleteWorkouts(ctx.client, args.startDate, args.endDate);
@@ -1692,6 +1792,24 @@ function runAthleteWorkouts(ctx, args) {
 		return jsonResult(selected, { hint: "Large? Set summary:true for one row per session, loggedOnly:true, pass limit, or narrow the dates." });
 	});
 }
+/**
+* Body of the athlete_exercises handler, hoisted to module scope so registerExerciseTools stays
+* under the oxlint max-lines-per-function cap (mirrors runAthleteWorkouts above).
+*/
+function runAthleteExercises(ctx, args) {
+	const { q, limit } = args;
+	return attempt(async () => {
+		const searching = q !== void 0 && q.trim() !== "";
+		const items = (searching ? await searchExerciseHistory(ctx.client, q, limit ?? 20) : await fetchExerciseHistoryList(ctx.client)).map((r) => ({
+			id: r.id,
+			title: r.title,
+			isCircuit: r.isCircuit ?? false,
+			units: exerciseUnits(r.param1Type, r.param2Type)
+		}));
+		if (!searching && limit !== void 0 && items.length > limit) return jsonResult(clipArray(items, limit, "Partial catalog: re-call athlete_exercises without limit to get all of them."));
+		return jsonResult(items, { hint: searching ? "Ranked matches for q. Omit q for the full catalog." : "The athlete's full exercise catalog. Pass q to search by name." });
+	});
+}
 /** Workouts, exercise catalog, per-exercise history/PRs/stats. */
 function registerExerciseTools(server, ctx, userId) {
 	server.registerTool("athlete_workouts", {
@@ -1712,18 +1830,10 @@ function registerExerciseTools(server, ctx, userId) {
 		description: ATHLETE_EXERCISES_DESC,
 		inputSchema: {
 			q: z.string().optional(),
-			limit: z.number().int().positive().max(200).optional()
+			limit: z.number().int().positive().optional()
 		},
 		annotations: READ
-	}, ({ q, limit }) => attempt(async () => {
-		const items = (q !== void 0 && q.trim() !== "" ? await searchExerciseHistory(ctx.client, q, limit ?? 20) : await fetchExerciseHistoryList(ctx.client)).map((r) => ({
-			id: r.id,
-			title: r.title,
-			isCircuit: r.isCircuit ?? false,
-			units: exerciseUnits(r.param1Type, r.param2Type)
-		}));
-		return jsonResult(limit !== void 0 ? items.slice(0, limit) : items, { hint: "Pass q to search by name, or limit to cap the list." });
-	}));
+	}, (args) => runAthleteExercises(ctx, args));
 	server.registerTool("athlete_exercise_history", {
 		title: "Exercise history + PRs",
 		description: ATHLETE_EXERCISE_HISTORY_DESC,
@@ -1889,6 +1999,31 @@ function registerLogTool(server, ctx) {
 	}));
 }
 /**
+* The athlete's own per-exercise swap, in its own function so registerLogTool/registerSessionTools
+* stay under the oxlint max-lines-per-function cap. Lets an athlete substitute a prescribed
+* exercise in a coach-scheduled workout for a different one — the self-service equivalent of the
+* app's "swap exercise", overriding only the athlete's own copy of that slot.
+*/
+function registerSwapTool(server, ctx) {
+	server.registerTool("athlete_swap_exercise", {
+		title: "Swap one exercise in your scheduled workout",
+		description: "Athlete-facing write: substitute one prescribed exercise in your scheduled workout for a different one — the API equivalent of the app's \"swap exercise\". This is the way to change which movement a slot is BEFORE logging: session_add/remove only touch personal sessions, and athlete_log_set records results into a slot without changing its exercise, so use this when a COACH-SCHEDULED slot should be a different lift. It overrides only your copy of the slot; the team/program prescription is untouched. Give savedWorkoutSetExerciseId (the slot to change, from athlete_log_targets — each row lists it per exercise) and exerciseId (the replacement, from athlete_exercises). After swapping, log against the slot as usual with athlete_log_set. Requires confirmation (elicitation or confirm:true).",
+		inputSchema: {
+			...swapAthleteExerciseArgsSchema.shape,
+			confirm: z.boolean().optional()
+		},
+		annotations: DESTRUCTIVE
+	}, ({ savedWorkoutSetExerciseId, exerciseId, confirm }, extra) => attempt(async () => {
+		const sweId = toId(savedWorkoutSetExerciseId);
+		const exId = toId(exerciseId);
+		if (!await confirmGate(server, extra.requestId, `Swap the exercise in your saved workout slot ${sweId} to exercise ${exId}? This changes what that slot is prescribed (your copy only).`, confirm)) return errorResult(NOT_CONFIRMED);
+		return jsonResult(await swapAthleteExercise(ctx.client, {
+			savedWorkoutSetExerciseId: sweId,
+			exerciseId: exId
+		}));
+	}));
+}
+/**
 * Live tools over the logged-in user's own training (history, scheduled/completed workouts,
 * PRs, working maxes), plus a gated set-logging write. The athlete user id is
 * resolved once from /user/simple and reused across tools.
@@ -1913,10 +2048,11 @@ function registerAthleteTrainingTools(server, ctx) {
 	registerLogTargetsTool(server, ctx);
 	registerSessionTools(server, ctx);
 	registerLogTool(server, ctx);
+	registerSwapTool(server, ctx);
 }
 //#endregion
 //#region package.json
-var version = "1.6.1";
+var version = "1.7.1";
 //#endregion
 //#region src/server.ts
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trainheroic-unofficial/athlete-mcp",
-  "version": "1.6.1",
+  "version": "1.7.1",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -21,8 +21,8 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "^4.4.3",
-    "@trainheroic-unofficial/core": "1.6.1",
-    "@trainheroic-unofficial/js": "1.6.1"
+    "@trainheroic-unofficial/core": "1.7.1",
+    "@trainheroic-unofficial/js": "1.7.1"
   },
   "devDependencies": {
     "@types/node": "^26.0.1",