@trainheroic-unofficial/athlete-mcp 1.4.0 → 1.6.0

package/dist/server.mjs

@@ -160,20 +160,41 @@ const loggedSetSchema = z.object({
 	param2: z.union([z.number(), z.string()]).optional()
 });
 /**
+* A logged set that can name the prescribed position it fills. `slot` is the 1-based set
+* index in the prescription (10 max) the result should land in; omit it to fill the next
+* sequential position (the first entry is set 1, the second set 2, and so on). Targeting a
+* slot lets a partial log land in the right positions of a multi-set prescription — e.g.
+* three top singles into the 4th/5th/6th positions of an `8,5,3,1,1,1` ramp. Used by the
+* by-set logging write (not the by-exercise session log, where each exercise's sets are
+* always sequential).
+*/
+const loggedSetWithSlotSchema = loggedSetSchema.extend({ slot: z.number().int().min(1).max(10).optional() });
+/**
 * Args for the set-logging write. `date` (the workout's day) locates the saved
 * workout via the range endpoint; `savedWorkoutSetId` picks the set to complete; `results`
-* gives, per exercise in it, the entered value of each set (param 1 / param 2 by entry slot).
+* gives, per exercise in it, the entered value of each set. Each set fills the next position by
+* default, or names its `slot` (1-based) to place a partial log at specific positions. A partial
+* log keeps positions already logged in an earlier call and leaves the positions it does not
+* write empty.
 */
 const logSetArgsSchema = z.object({
 	date: dateString,
 	savedWorkoutSetId: idArgSchema,
 	results: z.array(z.object({
 		savedWorkoutSetExerciseId: idArgSchema,
-		sets: z.array(loggedSetSchema).min(1)
+		sets: z.array(loggedSetWithSlotSchema).min(1)
 	})).min(1)
 });
 logSetArgsSchema.extend({ athleteId: idArgSchema });
-logSetArgsSchema.extend({ athleteId: idArgSchema });
+z.object({
+	date: dateString,
+	savedWorkoutSetId: idArgSchema,
+	athleteId: idArgSchema,
+	results: z.array(z.object({
+		savedWorkoutSetExerciseId: idArgSchema,
+		sets: z.array(loggedSetSchema).min(1)
+	})).min(1)
+});
 z.object({
 	savedWorkoutSetExerciseId: idArgSchema,
 	exerciseId: idArgSchema
@@ -193,6 +214,16 @@ const logSessionArgsSchema = z.object({
 	})).min(1)
 });
 logSessionArgsSchema.extend({ athleteId: idArgSchema });
+/**
+* Args for removing a personal (athlete-created) workout session. `programWorkoutId` is the
+* range item's top-level `id`; `date` is that session's day, used to look the item back up so the
+* write can confirm it is a personal session (`personal_cal === true`) before deleting. A
+* coach-scheduled workout is never removed this way.
+*/
+const athleteSessionRemoveArgsSchema = z.object({
+	programWorkoutId: idArgSchema,
+	date: dateString
+});
 z.looseObject({
 	title: z.string().min(1),
 	param_1_type: z.number().optional(),
@@ -635,6 +666,26 @@ function exerciseUnits(param1, param2) {
 function isRecord(x) {
 	return typeof x === "object" && x !== null && !Array.isArray(x);
 }
+/** A non-empty string, or null. Narrows a loosely-typed API field to a usable string. */
+function str(v) {
+	return typeof v === "string" && v !== "" ? v : null;
+}
+/**
+* The display title of a saved-copy exercise row, preferring `exercise_title`, then `title`, then
+* the given fallback. The saved-workout shape carries the title under either key depending on the
+* endpoint, so this is the one place that reconciles them.
+*/
+function exerciseTitle(ex, fallback = "") {
+	return typeof ex.exercise_title === "string" && ex.exercise_title || typeof ex.title === "string" && ex.title || fallback;
+}
+/**
+* True when a program-workout range item is a personal (athlete-created) session rather than a
+* coach-scheduled one. The API marks these with `personal_cal === true`; this is the single
+* definition every consumer (presenter, find-or-create, the remove guard) reads through.
+*/
+function isPersonalSession(pw) {
+	return isRecord(pw) && pw.personal_cal === true;
+}
 /**
 * Rank candidate rows for a free-text query (FTS5 replacement). Higher is better:
 * exact title, then prefix, then count of matched tokens, with shorter titles and
@@ -720,7 +771,6 @@ function fetchLeaderboard(client, workoutId, opts = {}) {
 	const query = qs.toString();
 	return getJson(client, `/3.0/athlete/leaderboard/${workoutId}${query ? `?${query}` : ""}`, "athlete leaderboard");
 }
-const SLOTS = 10;
 function nonEmpty(value) {
 	return value !== void 0 && value !== null && String(value).trim() !== "";
 }
@@ -731,7 +781,7 @@ function nonEmpty(value) {
 */
 function prescribedSets(ex) {
 	const out = [];
-	for (let i = 1; i <= SLOTS; i += 1) {
+	for (let i = 1; i <= 10; i += 1) {
 		const p1 = ex[`param_1_data_${i}`];
 		const p2 = ex[`param_2_data_${i}`];
 		const has1 = nonEmpty(p1);
@@ -752,7 +802,7 @@ function prescribedSets(ex) {
 */
 function performedSets(ex) {
 	const out = [];
-	for (let i = 1; i <= SLOTS; i += 1) {
+	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}`];
@@ -786,9 +836,6 @@ function presentBlock(set, performedById) {
 		exercises: exercises.filter(isRecord).map((ex) => presentExercise(ex, performedById))
 	};
 }
-function str(v) {
-	return typeof v === "string" && v !== "" ? v : null;
-}
 /** Every logged set (programmed + athlete-added) in the saved copy, paired with its exercises. */
 function savedSets(saved) {
 	const out = [];
@@ -879,6 +926,7 @@ function presentAthleteWorkout(raw) {
 		team: str(rec.team_title),
 		instruction: str(workout.instruction),
 		logged: blocks.some((b) => b.exercises.some((e) => e.performed.length > 0)),
+		personal: isPersonalSession(rec),
 		blocks
 	};
 }
@@ -886,6 +934,81 @@ function presentAthleteWorkouts(list) {
 	return list.map(presentAthleteWorkout);
 }
 /**
+* Narrow a coach-athlete workout range to a single program or team. The range endpoint returns
+* every program the athlete is enrolled in on a date; for a high-enrollment athlete that is many
+* workouts, so a caller wanting one program's session narrows it here. Match by `programId`/`teamId`
+* (exact, on the raw `program_id`/`team_id`) or by `programTitle` (case-insensitive substring on the
+* `program_title`/`team_title`) — the title match lets a caller target a program by name without
+* first resolving its id. Any one match keeps the workout; with no filter the list is unchanged.
+*/
+function selectWorkoutsByProgram(list, filter) {
+	const { programId, teamId, programTitle } = filter;
+	const needle = programTitle?.trim().toLowerCase();
+	if (programId === void 0 && teamId === void 0 && !needle) return [...list];
+	return list.filter((pw) => {
+		const rec = pw;
+		if (programId !== void 0 && coerceInt(rec.program_id) === programId) return true;
+		if (teamId !== void 0 && coerceInt(rec.team_id) === teamId) return true;
+		if (needle) {
+			if (`${str(rec.program_title) ?? ""} ${str(rec.team_title) ?? ""}`.toLowerCase().includes(needle)) return true;
+		}
+		return false;
+	});
+}
+/**
+* Project a workout range to just the ids a set-log write needs, read from the SAME saved-copy
+* location {@link findSavedWorkoutSet} matches against (`summarizedSavedWorkout.saved_workout`).
+* This is the self-service path for logging: instead of grepping the multi-KB `--raw` blob for
+* which of several id fields maps to `--set`, callers read `savedWorkoutSetId` and each
+* `savedWorkoutSetExerciseId` straight off these rows. Each target also carries its program/team
+* so a caller can pick the right session when the athlete is on several. One row per saved set,
+* dropping any set with no resolvable id.
+*/
+function presentLogTargets(list) {
+	const targets = [];
+	for (const pw of list) {
+		const rec = pw;
+		const ssw = isRecord(rec.summarizedSavedWorkout) ? rec.summarizedSavedWorkout : {};
+		const saved = isRecord(ssw.saved_workout) ? ssw.saved_workout : null;
+		if (!saved) continue;
+		const date = str(rec.date) ?? "";
+		const workoutTitle = str(rec.workout_title) ?? "";
+		const program = str(rec.program_title);
+		const programId = coerceInt(rec.program_id);
+		const team = str(rec.team_title);
+		const teamId = coerceInt(rec.team_id);
+		const sets = Array.isArray(saved.workoutSets) ? saved.workoutSets : [];
+		for (const s of sets) {
+			if (!isRecord(s)) continue;
+			const savedWorkoutSetId = coerceInt(s.id);
+			if (savedWorkoutSetId === null) continue;
+			const exercises = (Array.isArray(s.workoutSetExercises) ? s.workoutSetExercises : []).filter(isRecord).map((ex) => {
+				const id = coerceInt(ex.id);
+				if (id === null) return null;
+				return {
+					savedWorkoutSetExerciseId: id,
+					title: exerciseTitle(ex),
+					units: exerciseUnits(ex.param_1_type, ex.param_2_type),
+					prescribed: prescribedSets(ex),
+					performed: performedSets(ex)
+				};
+			}).filter((e) => e !== null);
+			targets.push({
+				date,
+				workoutTitle,
+				program,
+				programId,
+				team,
+				teamId,
+				savedWorkoutSetId,
+				setTitle: str(s.title),
+				exercises
+			});
+		}
+	}
+	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
@@ -913,12 +1036,58 @@ function summarizeAthleteWorkouts(list) {
 			program: w.program,
 			team: w.team,
 			logged: w.logged,
+			personal: w.personal,
 			exerciseCount,
 			performedCount
 		};
 	});
 }
-const MAX_PARAM_SLOTS = 10;
+/** Flatten `/v5/exercises/{id}/history` into PRs + a session time-series. */
+function presentExerciseHistory(detail) {
+	return {
+		liftPRs: (detail.liftPRs ?? []).map((p) => ({
+			description: p.description ?? null,
+			reps: p.reps ?? null,
+			weight: p.weight ?? null,
+			units: p.units ?? null,
+			date: p.dateCompleted ?? null
+		})),
+		sessions: (detail.history ?? []).map((h) => ({
+			date: h.dateCompleted,
+			abr: h.abr ?? null,
+			estimated1RM: h.bestEstimated1RM ?? null,
+			sets: (h.sets ?? []).map((s) => ({
+				setNumber: s.setNumber,
+				value: s.formattedValue ?? null
+			}))
+		}))
+	};
+}
+//#endregion
+//#region ../js/src/athlete-set-write.ts
+/**
+* Coerce the loosely-typed `results` from a validated log/prescribe args object into the SDK's
+* {@link SetResult}[]. The dto schemas validate ids as a number or a numeric string and leave
+* empty param slots optional; this narrows the id to a number and copies only the present per-set
+* values (so the per-set type stays free of `undefined` under exactOptionalPropertyTypes). Shared
+* by the MCP tools and the CLI so the mapping lives in one place rather than once per surface.
+*/
+function toSetResults(results) {
+	return results.map((r) => {
+		const id = coerceInt(r.savedWorkoutSetExerciseId);
+		if (id === null) throw new Error(`Invalid savedWorkoutSetExerciseId: ${String(r.savedWorkoutSetExerciseId)}`);
+		return {
+			savedWorkoutSetExerciseId: id,
+			sets: r.sets.map((s) => {
+				const set = {};
+				if (s.param1 !== void 0) set.param1 = s.param1;
+				if (s.param2 !== void 0) set.param2 = s.param2;
+				if (s.slot !== void 0) set.slot = s.slot;
+				return set;
+			})
+		};
+	});
+}
 /**
 * Build the body for `PUT /1.0/{role}/savedworkoutsetexercise/{id}`. The body uses snake_case
 * keys matching the live API response shape. Each set slot (1-10) carries `param_1_data_N` /
@@ -926,36 +1095,96 @@ const MAX_PARAM_SLOTS = 10;
 *
 * `mode` selects which write this is — the same endpoint serves both:
 *   - `"log"`: the values ARE a performed result, so `param_N_made` is 1 where the slot has data
-*     and the exercise `completed` flag is 1 when any set has data.
+*     and the exercise `completed` flag is 1 when any set has logged data.
 *   - `"prescribe"`: the values are prescribed targets, written with every `param_N_made` and
 *     `completed` left at 0 so the set is not marked done. This matches what the app sends when a
 *     coach edits an athlete's prescribed reps/weight.
 *
+* Each set fills a 1-based slot: its explicit `slot`, or its sequential position in `results`
+* when `slot` is omitted. A `log` carrying the live exercise record in `existing` keeps the slots
+* it does not write that were ALREADY performed (`param_N_made === 1`), so logging a second part of
+* a set does not wipe the earlier-logged sets. A slot holding only un-logged prescription pre-fill
+* (`param_N_made === 0`) is left blank rather than carried over: marking the set completed makes
+* the server flag every data-bearing slot performed, so preserving that pre-fill would fabricate
+* sets the athlete never did. The prescription is unaffected (it lives in the separate `workout`
+* copy, not this saved copy). A `prescribe` ignores `existing` and replaces the whole prescription.
+*
 * Only `savedWorkoutSetExerciseId`, `savedWorkoutSetId`, and `workoutSetExerciseId` are
-* required from the live exercise record; everything else is derived from `results`.
+* required from the live exercise record; everything else is derived from `results` and the
+* preserved slots of `existing`.
 *
 * Exported for unit testing — callers should use `logAthleteSet` / `prescribeForAthlete` instead.
 */
-function buildExerciseSetPayload(savedWorkoutSetExerciseId, savedWorkoutSetId, workoutSetExerciseId, results, mode) {
-	if (results.length > MAX_PARAM_SLOTS) throw new Error(`At most ${MAX_PARAM_SLOTS} sets are supported per exercise; got ${results.length}.`);
+function buildExerciseSetPayload(savedWorkoutSetExerciseId, savedWorkoutSetId, workoutSetExerciseId, results, mode, existing) {
+	if (results.length > 10) throw new Error(`At most 10 sets are supported per exercise; got ${results.length}.`);
+	const bySlot = /* @__PURE__ */ new Map();
+	results.forEach((set, i) => {
+		const slot = set.slot ?? i + 1;
+		if (slot < 1 || slot > 10) throw new Error(`Set slot ${slot} is out of range; slots are 1–10.`);
+		if (bySlot.has(slot)) throw new Error(`Two sets target slot ${slot}; each slot can be written once.`);
+		bySlot.set(slot, set);
+	});
 	const performed = mode === "log";
-	const hasData = results.some((s) => s.param1 !== void 0 || s.param2 !== void 0);
+	const carryOver = performed && existing !== void 0;
 	const body = {
 		id: savedWorkoutSetExerciseId,
 		saved_workout_set_id: savedWorkoutSetId,
-		workout_set_exercise_id: workoutSetExerciseId,
-		completed: performed && hasData ? 1 : 0
+		workout_set_exercise_id: workoutSetExerciseId
 	};
-	for (let i = 1; i <= MAX_PARAM_SLOTS; i += 1) {
-		const slot = results[i - 1];
-		const p1 = slot?.param1 !== void 0 ? String(slot.param1) : "";
-		const p2 = slot?.param2 !== void 0 ? String(slot.param2) : "";
-		body[`param_${i}_made`] = performed && (p1 !== "" || p2 !== "") ? 1 : 0;
+	let anyMade = false;
+	for (let i = 1; i <= 10; i += 1) {
+		const target = bySlot.get(i);
+		let p1;
+		let p2;
+		let made;
+		if (target) {
+			p1 = target.param1 !== void 0 ? String(target.param1) : "";
+			p2 = target.param2 !== void 0 ? String(target.param2) : "";
+			made = performed && (p1 !== "" || p2 !== "") ? 1 : 0;
+		} else if (carryOver && coerceInt(existing?.[`param_${i}_made`]) === 1) {
+			p1 = existingSlotData(existing, `param_1_data_${i}`);
+			p2 = existingSlotData(existing, `param_2_data_${i}`);
+			made = 1;
+		} else {
+			p1 = "";
+			p2 = "";
+			made = 0;
+		}
+		if (made === 1) anyMade = true;
+		body[`param_${i}_made`] = made;
 		body[`param_1_data_${i}`] = p1;
 		body[`param_2_data_${i}`] = p2;
 	}
+	body.completed = performed && anyMade ? 1 : 0;
 	return body;
 }
+/** Read a saved-copy slot value (`param_1_data_N` / `param_2_data_N`) as the string the body uses. */
+function existingSlotData(existing, key) {
+	const v = existing?.[key];
+	return v === void 0 || v === null ? "" : String(v);
+}
+/** True when a saved-copy exercise already carries a performed slot (any `param_N_made` === 1). */
+function exerciseHasLoggedData(ex) {
+	for (let i = 1; i <= 10; i += 1) if (coerceInt(ex[`param_${i}_made`]) === 1) return true;
+	return false;
+}
+/** True when a result carries at least one non-empty param value (so it produces a performed slot). */
+function resultHasData(result) {
+	return result.sets.some((s) => s.param1 !== void 0 && String(s.param1) !== "" || s.param2 !== void 0 && String(s.param2) !== "");
+}
+/**
+* Whether every exercise in a saved workout set now has logged data — either written with data in
+* this call (`loggedIds`) or already carrying a performed slot. Gates the set-completion PUT: a
+* superset/circuit stays open until the last exercise is logged, so completing it on a partial log
+* does not flip its still-empty siblings to "done". An exercise written with only empty values does
+* not count (it would not be marked performed), so an all-empty log never completes the set.
+*/
+function isSetFullyLogged(exercises, loggedIds) {
+	return exercises.every((ex) => {
+		const id = coerceInt(ex.id);
+		return id !== null && loggedIds.has(id) || exerciseHasLoggedData(ex);
+	});
+}
 /**
 * Locate the target saved workout set across all program workouts on the given day.
 * Returns the `savedWorkoutId`, the matching set's `workoutSetExercises` array so callers
@@ -986,8 +1215,7 @@ function findSavedWorkoutSet(workouts, savedWorkoutSetId) {
 			if (setId !== null) {
 				const exLabels = exercises.map((ex) => {
 					const exId = coerceInt(ex.id);
-					const title = typeof ex.exercise_title === "string" && ex.exercise_title || typeof ex.title === "string" && ex.title || "exercise";
-					return exId === null ? null : `${exId} (${title})`;
+					return exId === null ? null : `${exId} (${exerciseTitle(ex, "exercise")})`;
 				}).filter((x) => x !== null);
 				available.push(`set ${setId} → exercise ids: ${exLabels.join(", ") || "none"}`);
 			}
@@ -1054,7 +1282,8 @@ async function logAthleteSet(client, args) {
 	const r = await writeSetResults(client, { role: "athlete" }, await fetchAthleteWorkouts(client, args.date, args.date), args.savedWorkoutSetId, args.results, "log");
 	return {
 		savedWorkoutSetId: r.savedWorkoutSetId,
-		exercisesLogged: r.exercisesWritten
+		exercisesLogged: r.exercisesWritten,
+		setCompleted: r.setCompleted
 	};
 }
 /**
@@ -1075,7 +1304,8 @@ async function logForAthlete(client, args) {
 	}, workouts, args.savedWorkoutSetId, args.results, "log");
 	return {
 		savedWorkoutSetId: r.savedWorkoutSetId,
-		exercisesLogged: r.exercisesWritten
+		exercisesLogged: r.exercisesWritten,
+		setCompleted: r.setCompleted
 	};
 }
 /**
@@ -1100,15 +1330,14 @@ async function writeSetResults(client, target, workouts, savedWorkoutSetId, resu
 		if (!ex) {
 			const valid = exercises.map((e) => {
 				const id = coerceInt(e.id);
-				const title = typeof e.exercise_title === "string" && e.exercise_title || typeof e.title === "string" && e.title || "exercise";
-				return id === null ? null : `${id} (${title})`;
+				return id === null ? null : `${id} (${exerciseTitle(e, "exercise")})`;
 			}).filter((x) => x !== null);
 			throw new Error(`savedWorkoutSetExerciseId ${result.savedWorkoutSetExerciseId} not found in saved workout set ${savedWorkoutSetId}. Exercises in this set: ${valid.join(", ") || "none"}.`);
 		}
 		const workoutSetExerciseId = coerceInt(ex.workout_set_exercise_id);
 		if (!workoutSetExerciseId) throw new Error(`savedWorkoutSetExercise ${result.savedWorkoutSetExerciseId} is missing its workout_set_exercise_id (the prescription-template pointer the write needs). This is the savedWorkoutSetExerciseId, not an exercise_id — re-read the ids from athlete_saved_workouts.`);
 		const body = {
-			...buildExerciseSetPayload(result.savedWorkoutSetExerciseId, savedWorkoutSetId, workoutSetExerciseId, result.sets, mode),
+			...buildExerciseSetPayload(result.savedWorkoutSetExerciseId, savedWorkoutSetId, workoutSetExerciseId, result.sets, mode, ex),
 			...extra
 		};
 		const res = await client.request("PUT", `/1.0/${target.role}/savedworkoutsetexercise/${result.savedWorkoutSetExerciseId}${suffix}`, { body });
@@ -1118,17 +1347,22 @@ async function writeSetResults(client, target, workouts, savedWorkoutSetId, resu
 		}
 		exercisesWritten += 1;
 	}
+	let setCompleted = false;
 	if (mode === "log") {
-		const setBody = {
-			...buildSetCompletePayload(rawSet, exercises.map((e) => coerceInt(e.id)).filter((n) => n !== null), true),
-			...extra
-		};
-		const setRes = await client.request("PUT", `/1.0/${target.role}/savedworkoutset/${savedWorkoutSetId}${suffix}`, { body: setBody });
-		if (!setRes.ok) throw new Error(`Failed to mark workout set ${savedWorkoutSetId} completed (HTTP ${setRes.status}).`);
+		if (isSetFullyLogged(exercises, new Set(results.filter(resultHasData).map((r) => r.savedWorkoutSetExerciseId)))) {
+			const setBody = {
+				...buildSetCompletePayload(rawSet, exercises.map((e) => coerceInt(e.id)).filter((n) => n !== null), true),
+				...extra
+			};
+			const setRes = await client.request("PUT", `/1.0/${target.role}/savedworkoutset/${savedWorkoutSetId}${suffix}`, { body: setBody });
+			if (!setRes.ok) throw new Error(`Failed to mark workout set ${savedWorkoutSetId} completed (HTTP ${setRes.status}).`);
+			setCompleted = true;
+		}
 	}
 	return {
 		savedWorkoutSetId,
-		exercisesWritten
+		exercisesWritten,
+		setCompleted
 	};
 }
 /**
@@ -1171,17 +1405,30 @@ async function addExercisesToWorkout(client, workoutId, exercises) {
 	return res.data;
 }
 /**
+* DELETE /v5/programWorkouts/{programWorkoutId} — remove a personal (athlete-created) workout
+* session from the athlete's own calendar. Re-reads the day and removes ONLY a personal session
+* (`personal_cal`): it throws if no workout with that id is on the date, or if the target is a
+* coach-scheduled workout (which is not the athlete's to delete). This guard lives here, at the
+* delete itself, so no caller can issue the DELETE against a coach workout by skipping a check.
+* Throws on a non-ok response.
+*/
+async function removePersonalWorkout(client, args) {
+	const target = (await fetchAthleteWorkouts(client, args.date, args.date)).find((pw) => coerceInt(pw.id) === args.programWorkoutId);
+	if (target === void 0) throw new Error(`No workout with id ${args.programWorkoutId} on ${args.date}. Get the id and date from athlete_workouts.`);
+	if (!isPersonalSession(target)) throw new Error(`Workout ${args.programWorkoutId} on ${args.date} is a coach-scheduled workout, not a personal session, so it can't be removed. To change logged results on a scheduled workout, use athlete_log_set.`);
+	const res = await client.request("DELETE", `/v5/programWorkouts/${args.programWorkoutId}`);
+	if (!res.ok) throw new Error(`Remove personal workout failed (HTTP ${res.status}).`);
+}
+/**
 * Find a personal-calendar session already on the given day. The range marks these with
 * `personal_cal === true`; the addable id is the program workout's `workout_id`. Returns the
 * first one's workoutId, or null when the day has no personal session.
 */
 function findPersonalSessionWorkoutId(workouts) {
 	for (const pw of workouts) {
-		const rec = pw;
-		if (rec.personal_cal === true) {
-			const workoutId = coerceInt(rec.workout_id);
-			if (workoutId !== null) return workoutId;
-		}
+		if (!isPersonalSession(pw)) continue;
+		const workoutId = coerceInt(pw.workout_id);
+		if (workoutId !== null) return workoutId;
 	}
 	return null;
 }
@@ -1212,6 +1459,59 @@ function indexAddedExercises(added) {
 	}
 	return out;
 }
+/**
+* Flatten a day's saved sets into `{ pw, savedWorkoutSetId, ex }` rows (both saved-set keys),
+* carrying the parent program-workout so a caller can read its identity (`personal_cal`, program
+* title) without re-walking. The one saved-copy traversal the by-exercise paths share.
+*/
+function eachPrescribedExercise(workouts) {
+	const rows = [];
+	for (const pw of workouts) {
+		const rec = pw;
+		const ssw = isRecord(rec.summarizedSavedWorkout) ? rec.summarizedSavedWorkout : {};
+		const sw = isRecord(ssw.saved_workout) ? ssw.saved_workout : null;
+		if (!sw) continue;
+		const sets = [...Array.isArray(sw.workoutSets) ? sw.workoutSets : [], ...Array.isArray(sw.addedWorkoutSets) ? sw.addedWorkoutSets : []];
+		for (const s of sets) {
+			if (!isRecord(s)) continue;
+			const savedWorkoutSetId = coerceInt(s.id);
+			if (savedWorkoutSetId === null) continue;
+			const exercises = Array.isArray(s.workoutSetExercises) ? s.workoutSetExercises : [];
+			for (const ex of exercises) if (isRecord(ex)) rows.push({
+				pw: rec,
+				savedWorkoutSetId,
+				ex
+			});
+		}
+	}
+	return rows;
+}
+/**
+* Find prescribed exercises on coach-scheduled (non-personal) workouts that day matching any of the
+* given exercise ids. Used to warn after an ad-hoc log that the same lift was already on the
+* athlete's scheduled workout — a caller can then point at {@link logAthleteSet}. Personal sessions
+* (`personal_cal === true`) are skipped: the ad-hoc log itself lands there, so they are not an
+* alternative. One row per matching saved-set exercise, dropping any with an unresolvable id.
+*/
+function findScheduledMatches(workouts, exerciseIds) {
+	const out = [];
+	for (const { pw, savedWorkoutSetId, ex } of eachPrescribedExercise(workouts)) {
+		if (isPersonalSession(pw)) continue;
+		const exerciseId = coerceInt(ex.exercise_id);
+		const savedWorkoutSetExerciseId = coerceInt(ex.id);
+		if (exerciseId === null || savedWorkoutSetExerciseId === null) continue;
+		if (!exerciseIds.has(exerciseId)) continue;
+		out.push({
+			exerciseId,
+			title: exerciseTitle(ex),
+			program: str(pw.program_title),
+			workoutTitle: str(pw.workout_title) ?? "",
+			savedWorkoutSetId,
+			savedWorkoutSetExerciseId
+		});
+	}
+	return out;
+}
 /** Group resolved exercises by saved set and write each set via the given log target. */
 async function logResolvedExercises(client, target, date, resolved) {
 	const bySet = /* @__PURE__ */ new Map();
@@ -1235,7 +1535,10 @@ async function logResolvedExercises(client, target, date, resolved) {
 			savedWorkoutSetId,
 			results
 		});
-		out.push(written);
+		out.push({
+			savedWorkoutSetId: written.savedWorkoutSetId,
+			exercisesLogged: written.exercisesLogged
+		});
 	}
 	return out;
 }
@@ -1248,7 +1551,8 @@ async function logResolvedExercises(client, target, date, resolved) {
 */
 async function logAdHocSession(client, args) {
 	if (args.exercises.length === 0) throw new Error("Provide at least one exercise to log.");
-	const existing = findPersonalSessionWorkoutId(await fetchAthleteWorkouts(client, args.date, args.date));
+	const day = await fetchAthleteWorkouts(client, args.date, args.date);
+	const existing = findPersonalSessionWorkoutId(day);
 	const created = existing === null;
 	const workoutId = existing ?? (await createPersonalWorkout(client, args.date)).workoutId;
 	const withOrder = args.exercises.map((e, i) => ({
@@ -1272,32 +1576,30 @@ async function logAdHocSession(client, args) {
 		};
 	});
 	const sets = await logResolvedExercises(client, { role: "athlete" }, args.date, resolved);
-	return {
+	const result = {
 		date: args.date,
 		created,
 		sets
 	};
+	const scheduledAlternatives = findScheduledMatches(day, new Set(args.exercises.map((e) => e.exerciseId)));
+	if (scheduledAlternatives.length > 0) result.scheduledAlternatives = scheduledAlternatives;
+	return result;
 }
-/** Flatten `/v5/exercises/{id}/history` into PRs + a session time-series. */
-function presentExerciseHistory(detail) {
-	return {
-		liftPRs: (detail.liftPRs ?? []).map((p) => ({
-			description: p.description ?? null,
-			reps: p.reps ?? null,
-			weight: p.weight ?? null,
-			units: p.units ?? null,
-			date: p.dateCompleted ?? null
-		})),
-		sessions: (detail.history ?? []).map((h) => ({
-			date: h.dateCompleted,
-			abr: h.abr ?? null,
-			estimated1RM: h.bestEstimated1RM ?? null,
-			sets: (h.sets ?? []).map((s) => ({
-				setNumber: s.setNumber,
-				value: s.formattedValue ?? null
-			}))
-		}))
-	};
+//#endregion
+//#region ../js/src/util.ts
+/**
+* Drop the keys whose value is `undefined`, so the result can be passed to a function or
+* spread into an object under `exactOptionalPropertyTypes` without the per-key
+* `...(x !== undefined ? { x } : {})` dance. Required keys stay required in the result type;
+* optional ones lose `undefined` from their value type.
+*
+* Example:
+*   definedProps({ metric, teamId: maybeId, date })  // omits teamId/date if they're undefined
+*/
+function definedProps(obj) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) if (value !== void 0) result[key] = value;
+	return result;
 }
 //#endregion
 //#region ../core/src/history.ts
@@ -1375,6 +1677,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.";
 function runAthleteWorkouts(ctx, args) {
@@ -1452,7 +1755,31 @@ function registerExerciseTools(server, ctx, userId) {
 		annotations: READ
 	}, ({ exerciseId, date }) => attempt(async () => jsonResult(await fetchExerciseStats(ctx.client, toId(exerciseId), await userId(), date))));
 }
-/** Create a personal workout session and add exercises to it. */
+/** The compact log-id read: savedWorkoutSetId + savedWorkoutSetExerciseId for athlete_log_set. */
+function registerLogTargetsTool(server, ctx) {
+	server.registerTool("athlete_log_targets", {
+		title: "Saved-workout log ids (for athlete_log_set)",
+		description: ATHLETE_LOG_TARGETS_DESC,
+		inputSchema: {
+			startDate: dateString,
+			endDate: dateString,
+			program: z.string().optional(),
+			programId: idParam.optional(),
+			teamId: idParam.optional(),
+			raw: z.boolean().optional()
+		},
+		annotations: READ
+	}, ({ startDate, endDate, program, programId, teamId, raw }) => attempt(async () => {
+		const workouts = selectWorkoutsByProgram(await fetchAthleteWorkouts(ctx.client, startDate, endDate), definedProps({
+			programTitle: program,
+			programId: programId === void 0 ? void 0 : toId(programId),
+			teamId: teamId === void 0 ? void 0 : toId(teamId)
+		}));
+		if (raw === true) return jsonResult(workouts, { hint: "Each set's id is the savedWorkoutSetId; each savedWorkoutSetExercises[].id is the savedWorkoutSetExerciseId. Large — if truncated, pass program (a title substring) or use the default compact view." });
+		return jsonResult(presentLogTargets(workouts), { hint: "One row per saved set: savedWorkoutSetId plus each savedWorkoutSetExerciseId, with the program it belongs to. Pass both to athlete_log_set. Filter with program (title substring), programId, or teamId if you're on several programs." });
+	}));
+}
+/** Create a personal workout session, add exercises, and remove a stray personal session. */
 function registerSessionTools(server, ctx) {
 	server.registerTool("athlete_session_create", {
 		title: "Create personal workout session",
@@ -1486,6 +1813,27 @@ function registerSessionTools(server, ctx) {
 		}));
 		return jsonResult(await addExercisesToWorkout(ctx.client, toId(workoutId), mapped), { hint: "Each top-level id is a savedWorkoutSetId; savedWorkoutSetExercises[].id is the savedWorkoutSetExerciseId for athlete_log_set." });
 	}));
+	server.registerTool("athlete_session_remove", {
+		title: "Remove a personal workout session",
+		description: "Delete a personal (self-created) workout session from your calendar — use it to clean up a stray ad-hoc session, e.g. one athlete_log_session created when you meant to log into a coach-scheduled workout. Give the programWorkoutId (the `id` of the session in athlete_workouts, where personal:true marks a personal session) and its date. ONLY personal sessions can be removed: the tool re-reads that day and refuses a coach-scheduled workout. Requires confirmation (elicitation or confirm:true).",
+		inputSchema: {
+			...athleteSessionRemoveArgsSchema.shape,
+			confirm: z.boolean().optional()
+		},
+		annotations: DESTRUCTIVE
+	}, ({ programWorkoutId, date, confirm }, extra) => attempt(async () => {
+		const id = toId(programWorkoutId);
+		if (!await confirmGate(server, extra.requestId, `Permanently remove personal session ${id} on ${date}? This deletes the session and anything logged in it.`, confirm)) return errorResult(NOT_CONFIRMED);
+		await removePersonalWorkout(ctx.client, {
+			programWorkoutId: id,
+			date
+		});
+		return jsonResult({
+			removed: true,
+			programWorkoutId: id,
+			date
+		});
+	}));
 }
 /** Map validated logSession exercises to the SDK's SessionExercise[] (ids coerced, slots trimmed). */
 function mapSessionExercises(exercises) {
@@ -1516,14 +1864,16 @@ function registerLogTool(server, ctx) {
 		annotations: DESTRUCTIVE
 	}, ({ date, exercises, confirm }, extra) => attempt(async () => {
 		if (!await confirmGate(server, extra.requestId, `Log a session of ${exercises.length} exercise(s) on ${date}? This writes to your coach-visible training log.`, confirm)) return errorResult(NOT_CONFIRMED);
-		return jsonResult(await logAdHocSession(ctx.client, {
+		const res = await logAdHocSession(ctx.client, {
 			date,
 			exercises: mapSessionExercises(exercises)
-		}));
+		});
+		if (res.scheduledAlternatives !== void 0 && res.scheduledAlternatives.length > 0) return jsonResult(res, { hint: "Heads up: one or more of these lifts were already on a coach-scheduled workout today (see scheduledAlternatives). This logged a SEPARATE personal session. To log into the scheduled workout instead, use athlete_log_set with the savedWorkoutSetId / savedWorkoutSetExerciseId shown there — and athlete_session_remove to delete this personal session if it was a mistake." });
+		return jsonResult(res);
 	}));
 	server.registerTool("athlete_log_set", {
 		title: "Log completed set results",
-		description: "Athlete-facing write: record entered results (reps/weight per set) for a saved workout set on a given day, marking the set completed. Writes to the athlete's (coach-visible) training log and shows in exercise history. Get savedWorkoutSetId + savedWorkoutSetExerciseId from athlete_workouts (raw:true). Requires confirmation (elicitation or confirm:true).",
+		description: "Athlete-facing write: record entered results (reps/weight per set) for a saved workout set on a given day. Writes to the athlete's (coach-visible) training log and shows in exercise history. Each set fills the next position in order; give a set a 1-based `slot` to place it at a specific position — e.g. log three top singles into positions 4-6 of an 8,5,3,1,1,1 ramp. A partial log records only the positions you send (plus any logged in an earlier call) and leaves the rest unlogged, so it does not mark untouched sets as performed. In a superset/circuit the block is marked done only once every exercise in it has logged results, so logging one exercise leaves its siblings untouched (the response's `setCompleted` reports whether the block was completed). Get savedWorkoutSetId + savedWorkoutSetExerciseId from athlete_log_targets (filter by program when several workouts share a date). Requires confirmation (elicitation or confirm:true).",
 		inputSchema: {
 			...logSetArgsSchema.shape,
 			confirm: z.boolean().optional()
@@ -1531,19 +1881,10 @@ function registerLogTool(server, ctx) {
 		annotations: DESTRUCTIVE
 	}, ({ date, savedWorkoutSetId, results, confirm }, extra) => attempt(async () => {
 		if (!await confirmGate(server, extra.requestId, `Log results to saved workout set ${toId(savedWorkoutSetId)} on ${date}? This writes to your coach-visible training log.`, confirm)) return errorResult(NOT_CONFIRMED);
-		const mapped = results.map((r) => ({
-			savedWorkoutSetExerciseId: toId(r.savedWorkoutSetExerciseId),
-			sets: r.sets.map((s) => {
-				const slot = {};
-				if (s.param1 !== void 0) slot.param1 = s.param1;
-				if (s.param2 !== void 0) slot.param2 = s.param2;
-				return slot;
-			})
-		}));
 		return jsonResult(await logAthleteSet(ctx.client, {
 			date,
 			savedWorkoutSetId: toId(savedWorkoutSetId),
-			results: mapped
+			results: toSetResults(results)
 		}));
 	}));
 }
@@ -1569,12 +1910,13 @@ function registerAthleteTrainingTools(server, ctx) {
 	};
 	registerProfileTools(server, ctx, whoami, userId);
 	registerExerciseTools(server, ctx, userId);
+	registerLogTargetsTool(server, ctx);
 	registerSessionTools(server, ctx);
 	registerLogTool(server, ctx);
 }
 //#endregion
 //#region package.json
-var version = "1.4.0";
+var version = "1.6.0";
 //#endregion
 //#region src/server.ts
 async function main() {

package/package.json

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