@trainheroic-unofficial/athlete-mcp 3.5.1 → 3.6.0

package/dist/server.mjs

@@ -830,12 +830,16 @@ function resultBudget() {
 function isPlainObject(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-/** Largest count k such that the JSON of the first k pre-serialized pieces fits. O(n). */
-function largestPrefixCount(pieces, charBudget) {
+/**
+* Largest count k such that the JSON of the first k elements fits. Elements are serialized one
+* at a time and the walk stops at the first overflow, so an oversized 10k-row result costs the
+* serialization of the rows that fit, not of every row.
+*/
+function largestPrefixCount(elements, charBudget) {
 	let used = 2;
 	let k = 0;
-	for (const piece of pieces) {
-		const add = piece.length + (k > 0 ? 1 : 0);
+	for (const element of elements) {
+		const add = (JSON.stringify(element) ?? "null").length + (k > 0 ? 1 : 0);
 		if (used + add > charBudget) break;
 		used += add;
 		k += 1;
@@ -843,11 +847,12 @@ function largestPrefixCount(pieces, charBudget) {
 	return k;
 }
 function largestArrayValuedKey(obj) {
+	const arrayKeys = Object.keys(obj).filter((key) => Array.isArray(obj[key]));
+	if (arrayKeys.length <= 1) return arrayKeys[0] ?? null;
 	let best = null;
 	let bestLen = -1;
-	for (const [key, value] of Object.entries(obj)) {
-		if (!Array.isArray(value)) continue;
-		const len = (JSON.stringify(value) ?? "[]").length;
+	for (const key of arrayKeys) {
+		const len = (JSON.stringify(obj[key]) ?? "[]").length;
 		if (len > bestLen) {
 			best = key;
 			bestLen = len;
@@ -855,9 +860,6 @@ function largestArrayValuedKey(obj) {
 	}
 	return best;
 }
-function jsonValue(data) {
-	return JSON.parse(JSON.stringify(data) ?? "null");
-}
 function previewEnvelope(source, budget, hint) {
 	const total = source.length;
 	const makeValue = (preview, markerHint) => ({
@@ -884,8 +886,8 @@ function boundedResult(data, budget, hint) {
 		text: data,
 		value: data
 	};
-	const value = jsonValue(data);
-	const compact = JSON.stringify(value);
+	const compact = JSON.stringify(data) ?? "null";
+	const value = JSON.parse(compact);
 	if (compact.length <= budget) {
 		const pretty = JSON.stringify(value, null, 2);
 		return {
@@ -894,7 +896,7 @@ function boundedResult(data, budget, hint) {
 		};
 	}
 	if (Array.isArray(value)) {
-		const truncated = clipArray(value, largestPrefixCount(value.map((element) => JSON.stringify(element)), budget - MARKER_RESERVE), hint);
+		const truncated = clipArray(value, largestPrefixCount(value, budget - MARKER_RESERVE), hint);
 		const text = JSON.stringify(truncated);
 		if (text.length <= budget) return {
 			text,
@@ -904,7 +906,7 @@ function boundedResult(data, budget, hint) {
 		const key = largestArrayValuedKey(value);
 		if (key !== null) {
 			const array = value[key];
-			const truncated = clipArray(array, largestPrefixCount(array.map((element) => JSON.stringify(element)), budget - MARKER_RESERVE), hint ?? DEFAULT_OBJECT_HINT, key);
+			const truncated = clipArray(array, largestPrefixCount(array, budget - MARKER_RESERVE), hint ?? DEFAULT_OBJECT_HINT, key);
 			const text = JSON.stringify(truncated);
 			if (text.length <= budget) return {
 				text,
@@ -999,30 +1001,200 @@ function confirmGate(ctx, message, confirmArg) {
 const SERVER_INSTRUCTIONS = "Speak to the user in plain, everyday language about their training. Describe what you are doing in the TrainHeroic app's own terms (for example, say you are creating a workout rather than naming a tool). Do not surface internal tool names (the snake_case identifiers such as athlete_session_create), raw parameter names, or numeric ids in your replies unless the user explicitly asks for them; they are implementation details. The tool descriptions cross-reference each other by name only so you can chain them correctly. Keep that wiring to yourself.";
 //#endregion
 //#region ../js/src/http-error.ts
-/**
-* A final non-2xx response from TrainHeroic. The error deliberately carries only request
-* metadata that is safe to send to telemetry: never the path, query string, request body,
-* response body, credentials, or session token.
-*/
+const MAX_REQUEST_KEYS = 50;
+const MAX_RESPONSE_DEPTH = 4;
+const MAX_RESPONSE_KEYS = 20;
+const MAX_RESPONSE_ITEMS = 10;
+const MAX_RESPONSE_NODES = 50;
+const RESPONSE_DIAGNOSTIC_KEYS = /* @__PURE__ */ new Set([
+	"code",
+	"detail",
+	"details",
+	"error",
+	"error_code",
+	"errors",
+	"message",
+	"reason",
+	"status",
+	"status_code",
+	"success"
+]);
+const RESPONSE_CONTAINER_KEYS = /* @__PURE__ */ new Set([
+	"data",
+	"received",
+	"response",
+	"result"
+]);
+const RESPONSE_STATUS_KEYS = /* @__PURE__ */ new Set(["status", "status_code"]);
+const RESPONSE_BOOLEAN_KEYS = /* @__PURE__ */ new Set(["success"]);
+const PARAMETER_TYPES = /* @__PURE__ */ new Set([
+	0,
+	1,
+	2,
+	3,
+	4,
+	5,
+	6,
+	7,
+	10,
+	11,
+	12,
+	13,
+	14,
+	18
+]);
+function safeFieldName(key) {
+	if (key === "__proto__" || key === "constructor" || key === "prototype") return "[Redacted key]";
+	if (!/^[A-Za-z_][A-Za-z0-9_.-]{0,79}$/.test(key)) return "[Redacted key]";
+	return key;
+}
+function boundedEntries(object, limit) {
+	const entries = [];
+	for (const key of Object.keys(object)) {
+		const descriptor = Object.getOwnPropertyDescriptor(object, key);
+		entries.push([key, descriptor && "value" in descriptor ? descriptor.value : void 0]);
+		if (entries.length >= limit) break;
+	}
+	return entries;
+}
+function safeRequestValue(key, value) {
+	if (key === "is_circuit" && typeof value === "boolean") return value;
+	if (["param_1_type", "param_2_type"].includes(key) && typeof value === "number" && PARAMETER_TYPES.has(value)) return value;
+}
+function requestBodySummary(body) {
+	if (Array.isArray(body)) return {
+		type: "array",
+		length: body.length
+	};
+	if (body && typeof body === "object") {
+		const entries = boundedEntries(body, MAX_REQUEST_KEYS).sort(([left], [right]) => left.localeCompare(right));
+		const keys = entries.map(([key]) => safeFieldName(key));
+		const values = {};
+		for (const [key, value] of entries) {
+			const safeValue = safeRequestValue(key, value);
+			if (safeValue !== void 0) values[safeFieldName(key)] = safeValue;
+		}
+		return Object.keys(values).length > 0 ? {
+			type: "object",
+			keys,
+			values
+		} : {
+			type: "object",
+			keys
+		};
+	}
+	const primitive = typeof body;
+	return primitive === "boolean" || primitive === "number" || primitive === "string" ? { type: primitive } : { type: "other" };
+}
+function sanitizedDiagnosticValue(value, depth, budget, field) {
+	if (budget.nodes <= 0) return "[Truncated]";
+	budget.nodes -= 1;
+	if (value === null) return null;
+	if (typeof value === "boolean") return field && RESPONSE_BOOLEAN_KEYS.has(field) ? value : "[Redacted]";
+	if (typeof value === "number") return field && RESPONSE_STATUS_KEYS.has(field) && Number.isInteger(value) && value >= 100 && value <= 599 ? value : "[Redacted]";
+	if (typeof value === "string") return "[Redacted]";
+	if (depth >= MAX_RESPONSE_DEPTH) return "[Truncated]";
+	if (Array.isArray(value)) {
+		const result = [];
+		for (const item of value.slice(0, MAX_RESPONSE_ITEMS)) {
+			if (budget.nodes <= 0) {
+				result.push("[Truncated]");
+				break;
+			}
+			result.push(sanitizedDiagnosticValue(item, depth + 1, budget));
+		}
+		return result;
+	}
+	if (value && typeof value === "object") {
+		const result = {};
+		for (const [key, item] of boundedEntries(value, MAX_RESPONSE_KEYS)) {
+			if (budget.nodes <= 0) {
+				result.truncated = "[Truncated]";
+				break;
+			}
+			const safeKey = safeFieldName(key);
+			const safeValue = safeRequestValue(key, item);
+			if (RESPONSE_DIAGNOSTIC_KEYS.has(key)) result[safeKey] = sanitizedDiagnosticValue(item, depth + 1, budget, key);
+			else if (RESPONSE_CONTAINER_KEYS.has(key) && item && typeof item === "object") result[safeKey] = sanitizedDiagnosticValue(item, depth + 1, budget);
+			else if (safeValue !== void 0) {
+				budget.nodes -= 1;
+				result[safeKey] = safeValue;
+			}
+		}
+		return result;
+	}
+	return `[${typeof value}]`;
+}
+function responseBodyDiagnostics(body, budget, depth = 0) {
+	const activeBudget = budget ?? { nodes: MAX_RESPONSE_NODES };
+	if (activeBudget.nodes <= 0 || depth >= MAX_RESPONSE_DEPTH) return "[Truncated]";
+	if (!body || typeof body !== "object" || Array.isArray(body)) return sanitizedDiagnosticValue(body, depth, activeBudget);
+	const object = body;
+	const result = {};
+	for (const [key, value] of boundedEntries(object, MAX_RESPONSE_KEYS)) {
+		if (activeBudget.nodes <= 0) {
+			result.truncated = "[Truncated]";
+			break;
+		}
+		if (RESPONSE_DIAGNOSTIC_KEYS.has(key)) {
+			result[safeFieldName(key)] = sanitizedDiagnosticValue(value, depth + 1, activeBudget, key);
+			continue;
+		}
+		if (RESPONSE_CONTAINER_KEYS.has(key) && value && typeof value === "object") {
+			activeBudget.nodes -= 1;
+			const nested = responseBodyDiagnostics(value, activeBudget, depth + 1);
+			if (nested === "[Truncated]" || nested && typeof nested === "object" && Object.keys(nested).length > 0) result[safeFieldName(key)] = nested;
+		}
+	}
+	if (Object.keys(result).length > 0) return result;
+	return { type: "object" };
+}
+function parseResponseText(text) {
+	if (text.length === 0) return text;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+function safeRequestBodySummary(body) {
+	try {
+		return requestBodySummary(body);
+	} catch {
+		return { type: "other" };
+	}
+}
+function safeResponseBodyDiagnostics(body) {
+	try {
+		return responseBodyDiagnostics(body);
+	} catch {
+		return "[Unavailable]";
+	}
+}
+/** A final non-2xx response plus bounded, telemetry-safe request and response diagnostics. */
 var TrainHeroicHttpError = class extends Error {
 	name = "TrainHeroicHttpError";
 	method;
 	status;
 	host;
-	constructor(method, url, status) {
+	requestBody;
+	responseBody;
+	constructor(method, url, status, diagnostics = {}) {
 		const parsed = new URL(url);
 		const normalizedMethod = method.toUpperCase();
 		super(`TrainHeroic ${normalizedMethod} request failed with HTTP ${status}`);
 		this.method = normalizedMethod;
 		this.status = status;
 		this.host = parsed.host;
+		this.requestBody = diagnostics.requestBody === void 0 ? void 0 : safeRequestBodySummary(diagnostics.requestBody);
+		this.responseBody = diagnostics.responseBody === void 0 ? void 0 : safeResponseBodyDiagnostics(diagnostics.responseBody);
 	}
 };
 /** Call observability hooks without allowing them to change SDK behavior. */
-function notifyHttpError(handler, method, url, status) {
+function notifyHttpError(handler, method, url, status, diagnostics = {}) {
 	if (!handler) return;
 	try {
-		Promise.resolve(handler(new TrainHeroicHttpError(method, url, status))).catch(() => {});
+		Promise.resolve(handler(new TrainHeroicHttpError(method, url, status, diagnostics))).catch(() => {});
 	} catch {}
 }
 //#endregion
@@ -1146,14 +1318,19 @@ var TrainHeroicClient = class {
 			session = await this.#ensureSession();
 			res = await this.#send(method, url, session, options.body);
 		}
-		if (!res.ok && !options.expectedStatuses?.includes(res.status)) notifyHttpError(this.#onHttpError, method, url, res.status);
-		const text = await res.text();
-		let data = text;
-		if (text.length > 0) try {
-			data = JSON.parse(text);
-		} catch {
-			data = text;
+		const shouldReport = !res.ok && !options.expectedStatuses?.includes(res.status);
+		let text;
+		try {
+			text = await res.text();
+		} catch (error) {
+			if (shouldReport) notifyHttpError(this.#onHttpError, method, url, res.status, { requestBody: options.body });
+			throw error;
 		}
+		const data = parseResponseText(text);
+		if (shouldReport) notifyHttpError(this.#onHttpError, method, url, res.status, {
+			requestBody: options.body,
+			responseBody: data
+		});
 		return {
 			status: res.status,
 			ok: res.ok,
@@ -1223,6 +1400,9 @@ function unitLabel(paramType) {
 function exerciseUnits(param1, param2) {
 	return [unitLabel(param1), unitLabel(param2)];
 }
+function buildSearchText(title) {
+	return title.trim().toLowerCase();
+}
 function isRecord(x) {
 	return typeof x === "object" && x !== null && !Array.isArray(x);
 }
@@ -1277,6 +1457,82 @@ function rankSearch(rows, query, limit) {
 		};
 	}).sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.row);
 }
+/**
+* Map over items with a bounded number of concurrent workers. Used to fan out upstream
+* fetches (per-exercise history, the CLI export) without bursting the host all at once or,
+* on workerd, blowing the subrequest budget.
+*/
+async function mapPool(items, limit, fn) {
+	assertPositiveInteger(limit, "Concurrency limit");
+	const out = Array.from({ length: items.length });
+	let next = 0;
+	const state = { failure: null };
+	const worker = async () => {
+		while (next < items.length && state.failure === null) {
+			const i = next;
+			next += 1;
+			try {
+				out[i] = await fn(items[i], i);
+			} catch (error) {
+				state.failure ??= { error };
+			}
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
+	if (state.failure !== null) throw state.failure.error;
+	return out;
+}
+function createLimiter(max) {
+	assertPositiveInteger(max, "Maximum concurrency");
+	let active = 0;
+	let cancelled = null;
+	const waiting = [];
+	const acquire = (finalizer) => new Promise((resolve, reject) => {
+		if (cancelled !== null && !finalizer) reject(cancelled.error);
+		else if (active < max) {
+			active += 1;
+			resolve();
+		} else waiting.push({
+			start: () => {
+				active += 1;
+				resolve();
+			},
+			abort: reject,
+			finalizer
+		});
+	});
+	const release = () => {
+		active -= 1;
+		waiting.shift()?.start();
+	};
+	return {
+		async run(task) {
+			await acquire(false);
+			try {
+				return await task();
+			} finally {
+				release();
+			}
+		},
+		async runFinalizer(task) {
+			await acquire(true);
+			try {
+				return await task();
+			} finally {
+				release();
+			}
+		},
+		cancel(error) {
+			cancelled ??= { error };
+			const queued = waiting.splice(0);
+			for (const entry of queued) if (entry.finalizer) waiting.push(entry);
+			else entry.abort(error);
+		}
+	};
+}
+function assertPositiveInteger(value, label) {
+	if (!Number.isInteger(value) || value < 1) throw new RangeError(`${label} must be a positive integer; received ${value}.`);
+}
 //#endregion
 //#region ../js/src/athlete.ts
 async function getJson(client, path, label) {
@@ -1314,9 +1570,19 @@ function fetchAthleteCircuits(client, kind = "recent") {
 function fetchAthleteProgrammingPrograms(client) {
 	return getArray(client, "/1.0/athlete/programming/programs", "athlete programming programs");
 }
-/** Free-text search over the athlete's logged exercises (FTS replacement via rankSearch). */
+/**
+* Free-text search over the athlete's logged exercises (FTS replacement via rankSearch). Only
+* rows whose title carries every query token are candidates; rankSearch scores but never drops a
+* row, so ranking the whole catalog would pad a no-match query with the shortest titles up to
+* `limit`. Mirrors the coach `ExerciseLibrary.search` filter, and a blank query returns nothing.
+*/
 async function searchExerciseHistory(client, query, limit = 20) {
-	return rankSearch(await fetchExerciseHistoryList(client), query, limit);
+	const tokens = buildSearchText(query).split(/\s+/u).filter((t) => t.length > 0);
+	if (tokens.length === 0) return [];
+	return rankSearch((await fetchExerciseHistoryList(client)).filter((row) => {
+		const text = buildSearchText(row.title);
+		return tokens.every((t) => text.includes(t));
+	}), query, limit);
 }
 function fetchExerciseHistoryDetail(client, exerciseId, userId) {
 	return getJson(client, `/v5/exercises/${exerciseId}/history?userId=${userId}`, "athlete exercise history");
@@ -1371,6 +1637,28 @@ function slotValues(ex, requireMade) {
 	}
 	return map;
 }
+/**
+* The slots carrying data that the athlete has NOT marked performed (`param_i_made !== 1`). On a
+* saved-copy row these are the row's own targets: the pre-filled prescription, an athlete- or
+* coach-level override written with `made = 0` (`prescribeAthleteSet`), or a personal session's
+* only prescription, since personal work has no template tree at all.
+*/
+function unmadeSlotValues(ex) {
+	const map = slotValues(ex, false);
+	for (const i of map.keys()) if (coerceInt(ex[`param_${i}_made`]) === 1) map.delete(i);
+	return map;
+}
+/**
+* The prescription for one exercise: the template row's slots, with any target the saved copy
+* still holds unperformed taking precedence per set index (that is what the athlete's app shows,
+* and where a per-athlete override lives). Without a template row the saved copy's unperformed
+* slots are the whole prescription.
+*/
+function prescriptionSlots(template, saved) {
+	const map = template ? slotValues(template, false) : /* @__PURE__ */ new Map();
+	if (saved) for (const [i, v] of unmadeSlotValues(saved)) map.set(i, v);
+	return map;
+}
 /** The joined display for a slot, kept verbatim (`"5 @ 225"`, `"AMRAP"`, `"@ 225"`). */
 function fmtSlot(slot) {
 	const has1 = slot.p1 !== null;
@@ -1380,10 +1668,6 @@ function fmtSlot(slot) {
 	if (has2) return `@ ${slot.p2}`;
 	return "";
 }
-/** Every slot carrying data, joined for display (the prescription reader): `["5 @ 225", "AMRAP"]`. */
-function prescribedStrings(ex) {
-	return [...slotValues(ex, false).values()].map(fmtSlot);
-}
 /** 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);
@@ -1419,6 +1703,15 @@ function performedSlotsByExerciseId(sets) {
 	}
 	return map;
 }
+/** Each saved-copy row keyed by the prescription exercise id it was copied from. */
+function savedRowsByTemplateId(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 && !map.has(id)) map.set(id, ex);
+	}
+	return map;
+}
 /** Per-exercise athlete notes keyed by the prescription template id (`workout_set_exercise_id`). */
 function notesByTemplateId(sets) {
 	const map = /* @__PURE__ */ new Map();
@@ -1442,7 +1735,7 @@ function mergeExercise(prescribed, performed, meta) {
 	};
 }
 /** A prescription block, each exercise aligned with the slots the athlete logged against it. */
-function mergePrescriptionBlock(set, performedById, notesById) {
+function mergePrescriptionBlock(set, performedById, savedById, notesById) {
 	const exercises = Array.isArray(set.workoutSetExercises) ? set.workoutSetExercises : [];
 	return {
 		order: coerceInt(set.order) ?? 0,
@@ -1452,7 +1745,7 @@ function mergePrescriptionBlock(set, performedById, notesById) {
 		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, {
+			return mergeExercise(prescriptionSlots(ex, id !== null ? savedById.get(id) : void 0), performed, {
 				exerciseId: coerceInt(ex.exercise_id),
 				title: typeof ex.title === "string" ? ex.title : "",
 				instruction: str(ex.instruction),
@@ -1462,14 +1755,18 @@ function mergePrescriptionBlock(set, performedById, notesById) {
 		})
 	};
 }
-/** A logged block straight from the saved copy (athlete-added or personal work; no prescription). */
+/**
+* A block straight from the saved copy (athlete-added or personal work; no template row). Its
+* unperformed slots are the prescription — a personal session's targets live only here — and its
+* performed slots are what was logged.
+*/
 function mergeSavedBlock(set, exercises) {
 	return {
 		order: coerceInt(set.order) ?? 0,
 		title: str(set.title),
 		instruction: str(set.instruction),
 		isTest: coerceInt(set.is_test) === 1,
-		exercises: exercises.map((ex) => mergeExercise(/* @__PURE__ */ new Map(), slotValues(ex, true), {
+		exercises: exercises.map((ex) => mergeExercise(prescriptionSlots(void 0, ex), slotValues(ex, true), {
 			exerciseId: coerceInt(ex.exercise_id),
 			title: typeof ex.exercise_title === "string" ? ex.exercise_title : "",
 			instruction: str(ex.instruction),
@@ -1492,8 +1789,9 @@ function mergeAthleteWorkout(raw) {
 	const prescriptionSets = (Array.isArray(workout.workoutSets) ? workout.workoutSets : []).filter(isRecord);
 	const logged = savedSets(saved);
 	const performedById = performedSlotsByExerciseId(logged);
+	const savedById = savedRowsByTemplateId(logged);
 	const notesById = notesByTemplateId(logged);
-	const blocks = prescriptionSets.map((s) => mergePrescriptionBlock(s, performedById, notesById)).sort((a, b) => a.order - b.order);
+	const blocks = prescriptionSets.map((s) => mergePrescriptionBlock(s, performedById, savedById, notesById)).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 : [];
@@ -1505,7 +1803,7 @@ function mergeAthleteWorkout(raw) {
 	}
 	for (const { set, exercises } of logged) {
 		const extra = exercises.filter((ex) => {
-			if (slotValues(ex, true).size === 0) return false;
+			if (slotValues(ex, false).size === 0) return false;
 			const id = coerceInt(ex.workout_set_exercise_id);
 			return id === null || !prescribedIds.has(id);
 		});
@@ -1616,6 +1914,16 @@ function presentLogTargets(list) {
 		const ssw = isRecord(rec.summarizedSavedWorkout) ? rec.summarizedSavedWorkout : {};
 		const saved = isRecord(ssw.saved_workout) ? ssw.saved_workout : null;
 		if (!saved) continue;
+		const workout = isRecord(ssw.workout) ? ssw.workout : {};
+		const templatesById = /* @__PURE__ */ new Map();
+		for (const tSet of Array.isArray(workout.workoutSets) ? workout.workoutSets : []) {
+			if (!isRecord(tSet)) continue;
+			const tExs = Array.isArray(tSet.workoutSetExercises) ? tSet.workoutSetExercises : [];
+			for (const tEx of tExs) {
+				const tId = isRecord(tEx) ? coerceInt(tEx.id) : null;
+				if (tId !== null && isRecord(tEx)) templatesById.set(tId, tEx);
+			}
+		}
 		const date = str(rec.date) ?? "";
 		const workoutTitle = str(rec.workout_title) ?? "";
 		const program = str(rec.program_title);
@@ -1630,12 +1938,14 @@ function presentLogTargets(list) {
 			const exercises = (Array.isArray(s.workoutSetExercises) ? s.workoutSetExercises : []).filter(isRecord).map((ex) => {
 				const id = coerceInt(ex.id);
 				if (id === null) return null;
+				const templateId = coerceInt(ex.workout_set_exercise_id);
+				const template = templateId === null ? void 0 : templatesById.get(templateId);
 				return {
 					savedWorkoutSetExerciseId: id,
 					title: exerciseTitle(ex),
 					units: exerciseUnits(ex.param_1_type, ex.param_2_type),
 					notes: str(ex.notes),
-					prescribed: prescribedStrings(ex),
+					prescribed: [...prescriptionSlots(template, ex).values()].map(fmtSlot),
 					performed: performedStrings(ex)
 				};
 			}).filter((e) => e !== null);
@@ -1712,6 +2022,28 @@ function presentExerciseHistory(detail) {
 	};
 }
 //#endregion
+//#region ../js/src/exercise-history.ts
+/**
+* Trim a presented exercise history's session time-series to an inclusive YYYY-MM-DD window.
+* The `liftPRs` board stays all-time (PRs are not a windowed concept). Dates compare as their
+* first 10 chars so both "YYYY-MM-DD" and "YYYY-MM-DDThh:mm" values filter correctly. The one
+* window rule shared by the athlete's own history tool, the coach's per-roster-athlete history
+* tool, and the CLI, so a timestamped session cannot fall out of an inclusive upper bound.
+*/
+function historyInRange(presented, since, until) {
+	if (since === void 0 && until === void 0) return presented;
+	const sessions = presented.sessions.filter((s) => {
+		const d = (s.date ?? "").slice(0, 10);
+		if (since !== void 0 && d < since) return false;
+		if (until !== void 0 && d > until) return false;
+		return true;
+	});
+	return {
+		...presented,
+		sessions
+	};
+}
+//#endregion
 //#region ../js/src/exercise-set-payload.ts
 function slotData(exercise, key) {
 	const value = exercise?.[key];
@@ -1782,6 +2114,7 @@ function buildExerciseSetPayload(savedWorkoutSetExerciseId, savedWorkoutSetId, w
 }
 //#endregion
 //#region ../js/src/athlete-set-write.ts
+const WRITE_CONCURRENCY = 4;
 /**
 * 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
@@ -1974,6 +2307,41 @@ async function swapAthleteExercise(client, args) {
 		originalTeamExerciseId: coerceInt(template.exercise_id)
 	};
 }
+function prepareSetWrite(target, workouts, savedWorkoutSetId, results, mode) {
+	const { exercises, rawSet } = findSavedWorkoutSet(workouts, savedWorkoutSetId);
+	assertUniqueExerciseResults(results);
+	const suffix = target.role === "coach" ? `/${target.athleteId}` : "";
+	const extra = target.role === "coach" ? { athleteId: target.athleteId } : {};
+	return {
+		savedWorkoutSetId,
+		exercises,
+		rawSet,
+		suffix,
+		extra,
+		writes: results.map((result) => {
+			const ex = exercises.find((candidate) => coerceInt(candidate.id) === result.savedWorkoutSetExerciseId);
+			if (!ex) {
+				const valid = exercises.map((candidate) => {
+					const id = coerceInt(candidate.id);
+					return id === null ? null : `${id} (${exerciseTitle(candidate, "exercise")})`;
+				}).filter((label) => label !== 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.`);
+			return {
+				id: result.savedWorkoutSetExerciseId,
+				body: {
+					...buildExerciseSetPayload(result.savedWorkoutSetExerciseId, savedWorkoutSetId, workoutSetExerciseId, result.sets, mode, ex),
+					...extra
+				}
+			};
+		})
+	};
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
 /**
 * Shared set-write behind {@link logAthleteSet}, {@link prescribeAthleteSet},
 * {@link logForAthlete}, and {@link prescribeForAthlete}. `target` selects the surface: `athlete`
@@ -1987,36 +2355,40 @@ async function swapAthleteExercise(client, args) {
 * the written ones); `"prescribe"` writes them as a prescription and skips Step 2, leaving the set
 * open.
 */
-async function writeSetResults(client, target, workouts, savedWorkoutSetId, results, mode) {
-	const { exercises, rawSet } = findSavedWorkoutSet(workouts, savedWorkoutSetId);
-	assertUniqueExerciseResults(results);
-	const suffix = target.role === "coach" ? `/${target.athleteId}` : "";
-	const extra = target.role === "coach" ? { athleteId: target.athleteId } : {};
-	let exercisesWritten = 0;
-	const projectedCompletion = /* @__PURE__ */ new Map();
-	for (const result of results) {
-		const ex = exercises.find((e) => coerceInt(e.id) === result.savedWorkoutSetExerciseId);
-		if (!ex) {
-			const valid = exercises.map((e) => {
-				const id = coerceInt(e.id);
-				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, ex),
-			...extra
+async function executeSetWrite(client, target, prepared, mode, limit, sessionProgress) {
+	const { savedWorkoutSetId, exercises, rawSet, suffix, extra, writes } = prepared;
+	const put = (path, body, failureMessage, finalizer = false) => {
+		const request = async () => {
+			try {
+				const res = await client.request("PUT", path, { body });
+				if (!res.ok) throw new Error(failureMessage(res.status));
+			} catch (error) {
+				limit.cancel(error);
+				throw error;
+			}
 		};
-		const res = await client.request("PUT", `/1.0/${target.role}/savedworkoutsetexercise/${result.savedWorkoutSetExerciseId}${suffix}`, { body });
-		if (!res.ok) {
-			const readOnly = target.role === "coach" && (res.status === 401 || res.status === 403) ? ` Athlete ${target.athleteId} appears to be read-only for changes — TrainHeroic's seeded demo/sample athletes return ${res.status} here; writes only persist for real (invited) athletes.` : "";
-			throw new Error(`Failed to write exercise ${result.savedWorkoutSetExerciseId} (HTTP ${res.status}).${readOnly}`);
-		}
-		projectedCompletion.set(result.savedWorkoutSetExerciseId, body.completed === 1);
-		exercisesWritten += 1;
+		return finalizer ? limit.runFinalizer(request) : limit.run(request);
+	};
+	const confirmed = [];
+	try {
+		await mapPool(writes, WRITE_CONCURRENCY, async ({ id, body }) => {
+			await put(`/1.0/${target.role}/savedworkoutsetexercise/${id}${suffix}`, body, (status) => {
+				return `Failed to write exercise ${id} (HTTP ${status}).${target.role === "coach" && (status === 401 || status === 403) ? ` Athlete ${target.athleteId} appears to be read-only for changes — TrainHeroic's seeded demo/sample athletes return ${status} here; writes only persist for real (invited) athletes.` : ""}`;
+			});
+			confirmed.push(id);
+			if (sessionProgress) {
+				const sessionConfirmed = sessionProgress.get(savedWorkoutSetId) ?? [];
+				sessionConfirmed.push(id);
+				sessionProgress.set(savedWorkoutSetId, sessionConfirmed);
+			}
+		});
+	} catch (error) {
+		if (sessionProgress || confirmed.length === 0) throw error;
+		confirmed.sort((a, b) => a - b);
+		throw new Error(`${errorMessage(error)} Confirmed exercise writes before the failure: ${confirmed.join(", ")}. The set was not marked complete; retry the same request to reconcile it.`, { cause: error });
 	}
+	const exercisesWritten = writes.length;
+	const projectedCompletion = new Map(writes.map((w) => [w.id, w.body.completed === 1]));
 	let setCompleted = false;
 	if (mode === "log") {
 		if (isSetFullyLogged(exercises, projectedCompletion)) {
@@ -2024,8 +2396,11 @@ async function writeSetResults(client, target, workouts, savedWorkoutSetId, resu
 				...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}).`);
+			try {
+				await put(`/1.0/${target.role}/savedworkoutset/${savedWorkoutSetId}${suffix}`, setBody, (status) => `Failed to mark workout set ${savedWorkoutSetId} completed (HTTP ${status}).`, true);
+			} catch (error) {
+				throw new Error(`${errorMessage(error)} Exercise values were written successfully; retry the same request to complete the set.`, { cause: error });
+			}
 			setCompleted = true;
 		}
 	}
@@ -2035,6 +2410,9 @@ async function writeSetResults(client, target, workouts, savedWorkoutSetId, resu
 		setCompleted
 	};
 }
+async function writeSetResults(client, target, workouts, savedWorkoutSetId, results, mode, limit = createLimiter(WRITE_CONCURRENCY)) {
+	return executeSetWrite(client, target, prepareSetWrite(target, workouts, savedWorkoutSetId, results, mode), mode, limit);
+}
 /**
 * POST /v5/programWorkouts/personal — create a personal workout session for a given date.
 * Returns the key ids: workoutId (needed for addExercisesToWorkout), programWorkoutId,
@@ -2180,7 +2558,7 @@ function findScheduledMatches(workouts, exerciseIds) {
 	return out;
 }
 /** Group resolved exercises by saved set and write each set via the given log target. */
-async function logResolvedExercises(client, target, workouts, resolved) {
+async function logResolvedExercises(client, target, workouts, resolved, retryGuidance) {
 	const bySet = /* @__PURE__ */ new Map();
 	for (const r of resolved) {
 		const list = bySet.get(r.savedWorkoutSetId) ?? [];
@@ -2190,15 +2568,28 @@ async function logResolvedExercises(client, target, workouts, resolved) {
 		});
 		bySet.set(r.savedWorkoutSetId, list);
 	}
-	const out = [];
-	for (const [savedWorkoutSetId, results] of bySet) {
-		const written = await writeSetResults(client, target, workouts, savedWorkoutSetId, results, "log");
-		out.push({
-			savedWorkoutSetId: written.savedWorkoutSetId,
-			exercisesLogged: written.exercisesWritten
+	const prepared = [...bySet].map(([savedWorkoutSetId, results]) => prepareSetWrite(target, workouts, savedWorkoutSetId, results, "log"));
+	const limit = createLimiter(WRITE_CONCURRENCY);
+	const confirmedBySet = /* @__PURE__ */ new Map();
+	const succeeded = [];
+	try {
+		return await mapPool(prepared, WRITE_CONCURRENCY, async (set) => {
+			const written = await executeSetWrite(client, target, set, "log", limit, confirmedBySet);
+			succeeded.push(written.savedWorkoutSetId);
+			return {
+				savedWorkoutSetId: written.savedWorkoutSetId,
+				exercisesLogged: written.exercisesWritten
+			};
 		});
+	} catch (error) {
+		const completed = new Set(succeeded);
+		const incomplete = [...confirmedBySet].filter(([savedWorkoutSetId]) => !completed.has(savedWorkoutSetId)).sort(([a], [b]) => a - b).map(([savedWorkoutSetId, ids]) => `set ${savedWorkoutSetId}: ${ids.toSorted((a, b) => a - b).join(", ")}`);
+		if (incomplete.length === 0 && succeeded.length === 0) throw error;
+		succeeded.sort((a, b) => a - b);
+		const partial = incomplete.length === 0 ? "" : ` Confirmed exercise writes in incomplete sets before the failure: ${incomplete.join("; ")}.${retryGuidance ? ` ${retryGuidance}` : ""}`;
+		const complete = succeeded.length === 0 ? "" : ` Set writes confirmed before the failure: ${succeeded.join(", ")}.`;
+		throw new Error(`${errorMessage(error)}${partial}${complete}`, { cause: error });
 	}
-	return out;
 }
 /**
 * Log a whole session for the logged-in athlete by exercise, with no pre-existing prescription
@@ -2312,27 +2703,6 @@ async function setAthleteExerciseNote(client, args) {
 		notes: typeof data.notes === "string" ? data.notes : args.notes
 	};
 }
-//#endregion
-//#region ../core/src/history.ts
-/**
-* Trim a presented exercise history's session time-series to an inclusive YYYY-MM-DD window.
-* The `liftPRs` board stays all-time (PRs are not a windowed concept). Dates compare as their
-* first 10 chars so both "YYYY-MM-DD" and "YYYY-MM-DDThh:mm" values filter correctly. Shared by
-* the athlete's own history tool and the coach's per-roster-athlete history tool.
-*/
-function historyInRange(presented, since, until) {
-	if (since === void 0 && until === void 0) return presented;
-	const sessions = presented.sessions.filter((s) => {
-		const d = (s.date ?? "").slice(0, 10);
-		if (since !== void 0 && d < since) return false;
-		if (until !== void 0 && d > until) return false;
-		return true;
-	});
-	return {
-		...presented,
-		sessions
-	};
-}
 z.number().int().positive().max(36).optional();
 //#endregion
 //#region ../core/src/tools/athlete-training.ts
@@ -2765,7 +3135,7 @@ function registerAthleteTrainingTools(server, ctx) {
 }
 //#endregion
 //#region package.json
-var version = "3.5.1";
+var version = "3.6.0";
 //#endregion
 //#region src/server.ts
 function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trainheroic-unofficial/athlete-mcp",
-  "version": "3.5.1",
+  "version": "3.6.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -21,8 +21,8 @@
   "dependencies": {
     "@modelcontextprotocol/server": "2.0.0",
     "zod": "^4.4.3",
-    "@trainheroic-unofficial/core": "3.5.1",
-    "@trainheroic-unofficial/js": "3.5.1"
+    "@trainheroic-unofficial/core": "3.6.0",
+    "@trainheroic-unofficial/js": "3.6.0"
   },
   "devDependencies": {
     "@types/node": "^26.3.0",