@trainheroic-unofficial/coach-mcp 0.1.0

package/dist/server.mjs

@@ -0,0 +1,1554 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import process from "node:process";
+import { z } from "zod";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+//#region ../dto/src/common.ts
+/** An entity id as it arrives over the wire — a number or a numeric string. */
+const idSchema = z.union([z.string(), z.number()]);
+/**
+* An id as a tool argument: a number, or a string of digits. Unlike idSchema (which
+* tolerates whatever the API sends back), this rejects non-numeric strings up front so
+* a bad argument fails validation instead of becoming NaN in a URL or a query.
+*/
+const idArgSchema = z.union([z.number().int(), z.string().regex(/^\d+$/u)]);
+//#endregion
+//#region ../dto/src/exercise.ts
+/** Body for creating a custom exercise; extra fields the API accepts are preserved. */
+const exerciseCreateSchema = z.looseObject({
+	title: z.string().min(1),
+	param_1_type: z.number().optional(),
+	param_2_type: z.number().optional()
+});
+//#endregion
+//#region ../dto/src/messaging.ts
+/** A chat comment to draft or send: target stream, body text, optional threaded reply. */
+const commentDraftSchema = z.object({
+	streamId: idSchema,
+	text: z.string().min(1),
+	replyTo: idSchema.optional()
+});
+//#endregion
+//#region ../dto/src/responses.ts
+const intLike = z.union([z.number(), z.string()]);
+const intLikeOrNull = z.union([
+	z.number(),
+	z.string(),
+	z.null()
+]);
+/** An exercise as the library + create endpoints return it (only the fields we read). */
+const exerciseResponseSchema = z.looseObject({
+	id: intLike,
+	title: z.string(),
+	param_1_type: intLikeOrNull.optional(),
+	param_2_type: intLikeOrNull.optional()
+});
+/** The exercise library list (envelope already unwrapped). */
+const exerciseLibraryResponseSchema = z.array(exerciseResponseSchema);
+/** The create-session response (a programWorkout): we read workout_id + id. */
+const sessionCreateResponseSchema = z.looseObject({
+	workout_id: intLike,
+	id: intLike
+});
+/** A programWorkout from the calendar edit view (we match by id and walk sets). */
+const programWorkoutResponseSchema = z.looseObject({
+	id: intLike,
+	sets: z.record(z.string(), z.unknown()).optional()
+});
+/** The calendar edit-view response we read sessions back from. */
+const programsEditResponseSchema = z.looseObject({ programWorkouts: z.array(programWorkoutResponseSchema).optional() });
+//#endregion
+//#region ../dto/src/workout.ts
+/** A single exercise prescription inside a block. */
+const exerciseSpecSchema = z.object({
+	id: z.union([z.number(), z.string()]),
+	title: z.string().optional(),
+	reps: z.union([
+		z.number(),
+		z.string(),
+		z.array(z.union([z.number(), z.string()]))
+	]).optional(),
+	sets: z.number().optional(),
+	weight: z.union([z.number(), z.array(z.number())]).optional(),
+	rpe: z.union([z.number(), z.string()]).optional(),
+	instr: z.string().optional(),
+	param_1_type: z.number().optional(),
+	param_2_type: z.number().optional()
+});
+/** A block's Red-Zone leaderboard: a unit string/number, or an object with options. */
+const leaderboardSpecSchema = z.union([
+	z.string(),
+	z.number(),
+	z.object({
+		unit: z.union([z.string(), z.number()]).optional(),
+		type: z.union([z.string(), z.number()]).optional(),
+		lowest_wins: z.boolean().optional(),
+		instruction: z.string().optional()
+	})
+]);
+/** A block (group of exercises); two exercises render as a superset. */
+const blockSpecSchema = z.object({
+	title: z.string(),
+	type: z.number().optional(),
+	instruction: z.string().optional(),
+	leaderboard: leaderboardSpecSchema.optional(),
+	exercises: z.array(exerciseSpecSchema)
+});
+z.object({
+	blocks: z.array(blockSpecSchema),
+	instruction: z.string().optional()
+});
+/**
+* Parse a `YYYY-M-D` string into the `WorkoutDate` tuple. The single home for this
+* conversion, shared by the MCP tools and the CLI so they cannot drift on what counts
+* as a valid date. Each part must be an integer.
+*/
+function parseWorkoutDate(s) {
+	const parts = s.split("-").map((p) => Number(p));
+	if (parts.length !== 3 || parts.some((n) => !Number.isInteger(n))) throw new Error(`date must be YYYY-M-D, got "${s}".`);
+	return [
+		parts[0],
+		parts[1],
+		parts[2]
+	];
+}
+//#endregion
+//#region ../core/src/context.ts
+/** A tool argument that accepts a numeric id as a number or a string of digits. */
+const idParam = idArgSchema;
+function toId(value) {
+	return typeof value === "number" ? value : Number(value);
+}
+const READ = {
+	readOnlyHint: true,
+	openWorldHint: true
+};
+const SYNC = {
+	readOnlyHint: false,
+	idempotentHint: true,
+	destructiveHint: false,
+	openWorldHint: true
+};
+const DESTRUCTIVE = {
+	readOnlyHint: false,
+	destructiveHint: true,
+	openWorldHint: true
+};
+/** Run a tool body, converting thrown errors into an in-band tool error. */
+async function attempt(fn) {
+	try {
+		return await fn();
+	} catch (err) {
+		return errorResult(err instanceof Error ? err.message : String(err));
+	}
+}
+/** Conservative per-result character cap, below the smallest host cap. */
+const DEFAULT_RESULT_BUDGET = 6e4;
+/** Reserve for the `__truncated` marker so wrapping cannot push back over budget. */
+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.";
+/** 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;
+	const n = raw ? Number(raw) : NaN;
+	return Number.isFinite(n) && n > 0 ? n : DEFAULT_RESULT_BUDGET;
+}
+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) {
+	let used = 2;
+	let k = 0;
+	for (const piece of pieces) {
+		const add = piece.length + (k > 0 ? 1 : 0);
+		if (used + add > charBudget) break;
+		used += add;
+		k += 1;
+	}
+	return k;
+}
+/** Last resort: cap a string at the budget and label it as truncated, non-JSON output. */
+function hardCap(text, budget, hint) {
+	if (text.length <= budget) return text;
+	const note = `\n\n[TRUNCATED: output exceeded ${budget} chars and is NOT valid JSON. ${hint ?? "Narrow the query (filter, paginate, or fetch a specific id)."}]`;
+	const keep = Math.max(0, budget - note.length);
+	return text.slice(0, keep) + note;
+}
+function largestArrayValuedKey(obj) {
+	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;
+		if (len > bestLen) {
+			best = key;
+			bestLen = len;
+		}
+	}
+	return best;
+}
+/**
+* Serialize `data` as JSON within `budget` characters. Small results are pretty-printed.
+* Oversized results degrade in order: trim a top-level array (wrapping it as
+* `{ items, __truncated }`), then a top-level object's largest array property (annotated
+* with `__truncated`), then a last-resort hard character cap. Pure and side-effect free.
+*/
+function boundedSerialize(data, budget, hint) {
+	if (typeof data === "string") return hardCap(data, budget, hint);
+	const compact = JSON.stringify(data) ?? "null";
+	if (compact.length <= budget) {
+		const pretty = JSON.stringify(data, null, 2) ?? "null";
+		return pretty.length <= budget ? pretty : compact;
+	}
+	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);
+		if (out.length <= budget) return out;
+	} else if (isPlainObject(data)) {
+		const key = largestArrayValuedKey(data);
+		if (key !== null) {
+			const arr = data[key];
+			const pieces = arr.map((el) => JSON.stringify(el) ?? "null");
+			const restLen = (JSON.stringify({
+				...data,
+				[key]: []
+			}) ?? "{}").length;
+			const k = largestPrefixCount(pieces, Math.max(0, budget - MARKER_RESERVE - restLen));
+			const clone = {
+				...data,
+				[key]: arr.slice(0, k),
+				__truncated: {
+					field: key,
+					returned: k,
+					total: arr.length,
+					omitted: arr.length - k,
+					hint: hint ?? DEFAULT_OBJECT_HINT
+				}
+			};
+			const out = JSON.stringify(clone);
+			if (out.length <= budget) return out;
+		}
+	}
+	return hardCap(compact, budget, hint);
+}
+/** A successful tool result carrying JSON (or text) for the model, size-bounded. */
+function jsonResult(data, opts) {
+	return { content: [{
+		type: "text",
+		text: boundedSerialize(data, resultBudget(), opts?.hint)
+	}] };
+}
+/** A tool-level error: returned in-band (isError) so the model can self-correct. */
+function errorResult(message) {
+	return {
+		isError: true,
+		content: [{
+			type: "text",
+			text: message
+		}]
+	};
+}
+/** Issue a TrainHeroic request and format the outcome as a tool result. */
+async function apiCall(ctx, method, path, options, hint) {
+	return attempt(async () => {
+		const res = await ctx.client.request(method, path, options);
+		if (!res.ok) {
+			const detail = hardCap(typeof res.data === "string" ? res.data : JSON.stringify(res.data) ?? "", resultBudget());
+			return errorResult(`TrainHeroic API error (HTTP ${res.status}): ${detail}`);
+		}
+		return jsonResult(res.data, { hint });
+	});
+}
+//#endregion
+//#region ../core/src/confirm.ts
+const NOT_CONFIRMED = "Not confirmed. Re-run with confirm:true, or connect a client that supports MCP elicitation.";
+/**
+* Confirm a destructive/athlete-facing action. Prefers MCP elicitation (an
+* in-the-moment user prompt); falls back to an explicit confirm:true argument when
+* the client does not support elicitation. Never proceeds without one of the two.
+*/
+async function confirmGate(server, requestId, message, confirmArg) {
+	if (confirmArg === true) return true;
+	try {
+		const result = await server.server.elicitInput({
+			message,
+			requestedSchema: {
+				type: "object",
+				properties: { confirm: {
+					type: "boolean",
+					title: "Confirm",
+					description: message
+				} },
+				required: ["confirm"]
+			}
+		}, requestId === void 0 ? void 0 : { relatedRequestId: requestId });
+		return result.action === "accept" && result.content?.confirm === true;
+	} catch (err) {
+		console.warn("MCP elicitation unavailable; treating as not confirmed", err);
+		return false;
+	}
+}
+//#endregion
+//#region ../core/src/tools/reads.ts
+function enc(value) {
+	return encodeURIComponent(String(value));
+}
+/** No-argument GET endpoints, registered from a table to keep the wiring compact. */
+const SIMPLE_GETS = [
+	{
+		name: "whoami",
+		title: "Who am I",
+		description: "The authenticated TrainHeroic coach profile (id, org_id, name, roles, trial days).",
+		path: "/user/simple"
+	},
+	{
+		name: "head_coach",
+		title: "Head coach / org",
+		description: "Org, license, and trial status for the head coach account.",
+		path: "/v5/headCoach"
+	},
+	{
+		name: "list_programs",
+		title: "List programs",
+		description: "Coach programs (standalone). Team group-programs come from list_teams.",
+		path: "/1.0/coach/programs"
+	},
+	{
+		name: "notifications",
+		title: "Notification counts",
+		description: "Unread counts including countMessagingNotViewed (cheap 'anything new?' poll).",
+		path: "/v5/notifications/counts"
+	},
+	{
+		name: "analytics_categories",
+		title: "Analytics categories",
+		description: "Lists available analytics types. Pull the data via th_request POST /v5/analytics/*.",
+		path: "/v5/analytics"
+	}
+];
+/** Read-only coach/athlete queries. Exercise lookups live in the exercise store tools. */
+function registerReadTools(server, ctx) {
+	for (const t of SIMPLE_GETS) server.registerTool(t.name, {
+		title: t.title,
+		description: t.description,
+		inputSchema: {},
+		annotations: READ
+	}, () => apiCall(ctx, "GET", t.path));
+	server.registerTool("list_athletes", {
+		title: "List athletes",
+		description: "Athletes visible to this coach. Optional q (case-insensitive substring filter over each athlete record) and limit, applied client-side, to keep large rosters small.",
+		inputSchema: {
+			q: z.string().optional(),
+			limit: z.number().int().positive().max(500).optional()
+		},
+		annotations: READ
+	}, ({ q, limit }) => attempt(async () => {
+		const res = await ctx.client.request("GET", "/v5/athletes");
+		if (!res.ok) {
+			const detail = typeof res.data === "string" ? res.data : JSON.stringify(res.data);
+			throw new Error(`TrainHeroic API error (HTTP ${res.status}): ${detail}`);
+		}
+		if (!Array.isArray(res.data)) return jsonResult(res.data);
+		let rows = res.data;
+		if (q !== void 0) {
+			const needle = q.toLowerCase();
+			rows = rows.filter((row) => JSON.stringify(row).toLowerCase().includes(needle));
+		}
+		const total = rows.length;
+		if (limit !== void 0 && rows.length > limit) return jsonResult({
+			items: rows.slice(0, limit),
+			returned: limit,
+			total,
+			note: "Limited client-side. Raise limit or narrow with q for the rest."
+		});
+		return jsonResult(rows, { hint: "Filter with q (name/email substring) or cap with limit to shrink this list." });
+	}));
+	server.registerTool("list_teams", {
+		title: "List teams",
+		description: "Coach teams. Optional pagination and search.",
+		inputSchema: {
+			page: z.number().int().positive().optional(),
+			pageSize: z.number().int().positive().optional(),
+			q: z.string().optional()
+		},
+		annotations: READ
+	}, ({ page, pageSize, q }) => {
+		const qs = new URLSearchParams();
+		if (page !== void 0) qs.set("page", String(page));
+		if (pageSize !== void 0) qs.set("pageSize", String(pageSize));
+		if (q !== void 0) qs.set("q", q);
+		const query = qs.toString();
+		return apiCall(ctx, "GET", `/1.0/coach/teams${query ? `?${query}` : ""}`);
+	});
+	server.registerTool("get_team", {
+		title: "Get team",
+		description: "Full team object by team id.",
+		inputSchema: { teamId: idParam },
+		annotations: READ
+	}, ({ teamId }) => apiCall(ctx, "GET", `/v5/teams/${enc(teamId)}`));
+	server.registerTool("list_team_codes", {
+		title: "List team access codes",
+		description: "Join/access codes for a team.",
+		inputSchema: { teamId: idParam },
+		annotations: READ
+	}, ({ teamId }) => apiCall(ctx, "GET", `/v5/teams/${enc(teamId)}/teamCodes`));
+	server.registerTool("get_program", {
+		title: "Get program detail",
+		description: "Full nested program structure (blocks + sessions) live from the API, by program id.",
+		inputSchema: { programId: idParam },
+		annotations: READ
+	}, ({ programId }) => apiCall(ctx, "GET", `/3.0/coach/program/${enc(programId)}`, void 0, "This is a large, deep object. If it is truncated, fetch a narrower view (a specific session) instead."));
+}
+//#endregion
+//#region ../core/src/tools/raw.ts
+/**
+* Escape hatch covering every endpoint without a dedicated tool (e.g. the analytics
+* POSTs). GET is ungated; mutating methods go through the same confirmation gate as
+* the dedicated destructive tools so this cannot be used to bypass it.
+*/
+function registerRawTools(server, ctx) {
+	server.registerTool("th_request", {
+		title: "Raw TrainHeroic request",
+		description: "Call any TrainHeroic endpoint directly. `path` is everything after the host. `base` selects the host: 'coach' = api.trainheroic.com (default), 'apis' = apis.trainheroic.com. Prefer dedicated tools where they exist. POST/PUT/DELETE act on the live account and require confirmation.",
+		inputSchema: {
+			method: z.enum([
+				"GET",
+				"POST",
+				"PUT",
+				"DELETE"
+			]),
+			path: z.string().min(1),
+			body: z.unknown().optional(),
+			base: z.enum(["coach", "apis"]).optional(),
+			confirm: z.boolean().optional()
+		},
+		annotations: DESTRUCTIVE
+	}, async ({ method, path, body, base, confirm }, extra) => {
+		if (method !== "GET") {
+			if (!await confirmGate(server, extra.requestId, `Run ${method} ${path} against the live TrainHeroic account?`, confirm)) return errorResult(NOT_CONFIRMED);
+		}
+		const options = {};
+		if (body !== void 0) options.body = body;
+		if (base !== void 0) options.base = base;
+		return apiCall(ctx, method, path, options, "Large or unfiltered response. Add query params to narrow it, or use a dedicated tool for this endpoint if one exists.");
+	});
+}
+//#endregion
+//#region ../core/src/tools/exercises.ts
+/**
+* Exercise library tools over the ExerciseIndex — a D1 mirror on the hosted server, an
+* on-disk/in-memory cache locally. The descriptions stay at the interface level so they
+* read correctly on both backends.
+*/
+function registerExerciseTools(server, ctx) {
+	const index = ctx.index;
+	server.registerTool("exercise_resolve", {
+		title: "Resolve exercise name",
+		description: "Map a name to an exercise id via the local mirror. Returns the match plus ranked candidates; when ambiguous, match is null and you should pick from candidates. Units (param_1_unit/param_2_unit) are fixed per exercise — check them before prescribing.",
+		inputSchema: { name: z.string().min(1) },
+		annotations: READ
+	}, ({ name }) => attempt(async () => jsonResult(await index.resolve(name))));
+	server.registerTool("exercise_search", {
+		title: "Search exercises",
+		description: "Ranked fuzzy search over exercise titles. Returns candidates with units.",
+		inputSchema: {
+			query: z.string().min(1),
+			limit: z.number().int().positive().max(100).optional()
+		},
+		annotations: READ
+	}, ({ query, limit }) => attempt(async () => jsonResult(await index.search(query, limit ?? 20))));
+	server.registerTool("exercise_get", {
+		title: "Get exercise",
+		description: "Full exercise object (with units) by id.",
+		inputSchema: { id: idParam },
+		annotations: READ
+	}, ({ id }) => attempt(async () => {
+		const ex = await index.get(toId(id));
+		return ex ? jsonResult(ex) : errorResult(`No exercise with id ${toId(id)}.`);
+	}));
+	server.registerTool("exercise_sync", {
+		title: "Sync exercise library",
+		description: "Refresh the cached exercise index from TrainHeroic.",
+		inputSchema: { force: z.boolean().optional() },
+		annotations: SYNC
+	}, ({ force }) => attempt(async () => {
+		if (force ?? false) return jsonResult(await index.refresh());
+		await index.ensureFresh();
+		return jsonResult(await index.stats());
+	}));
+	server.registerTool("exercise_create", {
+		title: "Create custom exercise",
+		description: "Create a custom exercise (POST /2.0/coach/exercise/create) and write it through to the mirror. Body example: {\"title\":\"Sandbag Clean\",\"param_1_type\":3,\"param_2_type\":1}.",
+		inputSchema: { exercise: exerciseCreateSchema },
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			openWorldHint: true
+		}
+	}, ({ exercise }) => attempt(async () => jsonResult(await index.create(exercise))));
+	server.registerTool("exercise_forget", {
+		title: "Forget exercise (cache only)",
+		description: "Remove an exercise from the local mirror only. Run after deleting it via the API.",
+		inputSchema: { id: idParam },
+		annotations: {
+			readOnlyHint: false,
+			idempotentHint: true,
+			openWorldHint: false
+		}
+	}, ({ id }) => attempt(async () => {
+		await index.recordDelete(toId(id));
+		return jsonResult({ forgotten: toId(id) });
+	}));
+	server.registerTool("store_stats", {
+		title: "Exercise index stats",
+		description: "Row counts and sync state for the cached exercise index.",
+		inputSchema: {},
+		annotations: READ
+	}, () => attempt(async () => jsonResult(await index.stats())));
+}
+//#endregion
+//#region ../js/src/auth.ts
+const AUTH_URL = "https://apis.trainheroic.com/auth";
+/**
+* Authenticate against TrainHeroic. Returns the session bundle, or null on bad
+* credentials. TrainHeroic returns only { id, scope, role, session_id } (verified in
+* the Phase 0 spike: no refresh_token, no api_token, no TTL). The 48-char session_id
+* is sent as the `session-token` header and works against both API hosts.
+*/
+async function loginTrainHeroic(email, password) {
+	const res = await fetch(AUTH_URL, {
+		method: "POST",
+		headers: {
+			"content-type": "application/x-www-form-urlencoded",
+			accept: "application/json"
+		},
+		body: new URLSearchParams({
+			email,
+			password
+		}).toString()
+	});
+	if (!res.ok) return null;
+	const data = await res.json().catch(() => null);
+	if (!data || typeof data.id !== "number" || !data.session_id) return null;
+	return {
+		thUserId: data.id,
+		sessionId: data.session_id,
+		scope: data.scope ?? "",
+		role: data.role ?? ""
+	};
+}
+//#endregion
+//#region ../js/src/client.ts
+const COACH_BASE = "https://api.trainheroic.com";
+const APIS_BASE = "https://apis.trainheroic.com";
+var TrainHeroicAuthError = class extends Error {
+	name = "TrainHeroicAuthError";
+};
+/**
+* Authenticated TrainHeroic API client. Holds the coach credentials (from the grant's
+* encrypted props) and a lazily-acquired session token cached in memory for the life
+* of the Durable Object instance. On a 401/403 it re-logs in once and retries, since
+* TrainHeroic has no refresh token and sessions expire after ~1-2h.
+*/
+var TrainHeroicClient = class {
+	#email;
+	#password;
+	#sessionId;
+	#loginInFlight = null;
+	constructor(email, password, sessionId = null) {
+		this.#email = email;
+		this.#password = password;
+		this.#sessionId = sessionId;
+	}
+	get sessionId() {
+		return this.#sessionId;
+	}
+	async #ensureSession() {
+		if (this.#sessionId) return this.#sessionId;
+		this.#loginInFlight ??= this.#login();
+		try {
+			return await this.#loginInFlight;
+		} finally {
+			this.#loginInFlight = null;
+		}
+	}
+	async #login() {
+		const session = await loginTrainHeroic(this.#email, this.#password);
+		if (!session) throw new TrainHeroicAuthError("TrainHeroic login failed");
+		this.#sessionId = session.sessionId;
+		return this.#sessionId;
+	}
+	async request(method, path, options = {}) {
+		const url = `${options.base === "apis" ? APIS_BASE : COACH_BASE}/${path.replace(/^\//, "")}`;
+		let session = await this.#ensureSession();
+		let res = await this.#send(method, url, session, options.body);
+		if (res.status === 401 || res.status === 403) {
+			if (this.#sessionId === session) this.#sessionId = null;
+			session = await this.#ensureSession();
+			res = await this.#send(method, url, session, options.body);
+		}
+		const text = await res.text();
+		let data = text;
+		if (text.length > 0) try {
+			data = JSON.parse(text);
+		} catch {
+			data = text;
+		}
+		return {
+			status: res.status,
+			ok: res.ok,
+			data
+		};
+	}
+	#send(method, url, session, body) {
+		const upper = method.toUpperCase();
+		const headers = {
+			accept: "application/json",
+			"session-token": session
+		};
+		const init = {
+			method: upper,
+			headers
+		};
+		if (body !== void 0 && upper !== "GET" && upper !== "DELETE") {
+			headers["content-type"] = "application/json";
+			init.body = JSON.stringify(body);
+		}
+		return fetch(url, init);
+	}
+};
+//#endregion
+//#region ../js/src/response-check.ts
+/**
+* Validate an API response against its (loose) expected shape and warn once on drift.
+* Never throws: callers keep working via defensive coercion. This only surfaces a signal
+* when TrainHeroic renames or drops a field we read.
+*/
+function checkResponse(schema, data, label) {
+	const result = schema.safeParse(data);
+	if (result.success) return;
+	const issue = result.error.issues[0];
+	const where = issue && issue.path.length > 0 ? issue.path.join(".") : "(root)";
+	console.warn(`[trainheroic] response drift in ${label} at ${where}: ${issue?.message ?? "shape mismatch"}`);
+}
+//#endregion
+//#region ../js/src/exercise-util.ts
+/**
+* Display labels for TrainHeroic parameter types. The unit is FIXED PER EXERCISE
+* (the API forces param_1_type/param_2_type back to the library default on save), so
+* resolve/search surface it to stop callers picking, say, the miles "Run" for a
+* metric workout. Keep in sync with the workout builder's unit table.
+*/
+const PARAM_UNIT = {
+	0: null,
+	1: "lb",
+	2: "%max",
+	3: "reps",
+	4: "sec",
+	5: "yd",
+	6: "m",
+	7: "in",
+	10: "mi",
+	11: "ft",
+	12: "in",
+	13: "bpm",
+	14: "RPE",
+	18: "sec"
+};
+function coerceInt(value) {
+	if (typeof value === "boolean") return value ? 1 : 0;
+	if (typeof value === "number") return Number.isFinite(value) ? Math.trunc(value) : null;
+	if (typeof value === "string" && value.trim() !== "") {
+		const n = Number(value);
+		return Number.isFinite(n) ? Math.trunc(n) : null;
+	}
+	return null;
+}
+function unitLabel(paramType) {
+	const t = coerceInt(paramType);
+	if (t === null) return null;
+	return PARAM_UNIT[t] ?? null;
+}
+/** Annotate a row with human-readable units for display. */
+function withUnits(row) {
+	return {
+		...row,
+		param_1_unit: unitLabel(row.param_1_type),
+		param_2_unit: unitLabel(row.param_2_type)
+	};
+}
+function buildSearchText(title) {
+	return title.trim().toLowerCase();
+}
+/** Strip the {"success":1,"data":X} envelope some 2.0/coach endpoints use. */
+function unwrapEnvelope(body) {
+	if (body && typeof body === "object" && !Array.isArray(body)) {
+		const obj = body;
+		const keys = new Set(Object.keys(obj));
+		const envelope = /* @__PURE__ */ new Set([
+			"success",
+			"data",
+			"message",
+			"error"
+		]);
+		if ("data" in obj && [...keys].every((k) => envelope.has(k))) return obj.data;
+	}
+	return body;
+}
+/** Pull the exercise array out of whatever shape the bulk endpoint returns. */
+function asExerciseList(body) {
+	const unwrapped = unwrapEnvelope(body);
+	if (Array.isArray(unwrapped)) return unwrapped.filter((x) => isRecord(x));
+	if (isRecord(unwrapped)) {
+		const items = [];
+		for (const key of [
+			"exercises",
+			"circuits",
+			"workoutCircuits",
+			"library",
+			"items",
+			"results"
+		]) {
+			const value = unwrapped[key];
+			if (Array.isArray(value)) items.push(...value.filter((x) => isRecord(x)));
+		}
+		if (items.length > 0) return items;
+		const values = Object.values(unwrapped);
+		if (values.length > 0 && values.every(isRecord)) return values;
+	}
+	return [];
+}
+function isRecord(x) {
+	return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+/**
+* 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
+* standard (non-custom) exercises preferred on ties.
+*/
+function rankSearch(rows, query, limit) {
+	const q = query.trim().toLowerCase();
+	const tokens = q.split(/\s+/u).filter((t) => t.length > 0);
+	return rows.map((row) => {
+		const title = row.title.toLowerCase();
+		let score = 0;
+		if (title === q) score += 1e3;
+		if (title.startsWith(q)) score += 100;
+		for (const tok of tokens) if (title.includes(tok)) score += 10;
+		score -= title.length * .05;
+		if (row.can_edit === 0) score += 1;
+		return {
+			row,
+			score
+		};
+	}).sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.row);
+}
+//#endregion
+//#region ../js/src/workout-encode.ts
+const LEADERBOARD_TYPE = {
+	completion: 0,
+	"for completion": 0,
+	weight: 1,
+	lb: 1,
+	load: 1,
+	reps: 2,
+	rep: 2,
+	rounds: 3,
+	round: 3,
+	time: 4,
+	yards: 5,
+	yd: 5,
+	meters: 6,
+	m: 6,
+	feet: 7,
+	ft: 7,
+	calories: 8,
+	cal: 8,
+	cals: 8,
+	miles: 10,
+	mi: 10,
+	inches: 12,
+	in: 12,
+	watts: 15,
+	w: 15,
+	velocity: 17,
+	"m/s": 17,
+	seconds: 18,
+	sec: 18,
+	s: 18
+};
+const LEADERBOARD_LABEL = {
+	0: "For Completion",
+	1: "Weight",
+	2: "Reps",
+	3: "Rounds",
+	4: "Time",
+	5: "Yards",
+	6: "Meters",
+	7: "Feet",
+	8: "Calories",
+	10: "Miles",
+	12: "Inches",
+	13: "Other",
+	15: "Watts",
+	16: "Percent",
+	17: "Velocity",
+	18: "Seconds"
+};
+function resolveLeaderboard(block) {
+	const lb = block.leaderboard;
+	if (lb === void 0 || lb === null) return {
+		isRedzone: null,
+		redzoneType: 0,
+		smallerIsBetter: null,
+		redzoneInstruction: ""
+	};
+	let unit;
+	let instruction = "";
+	let lowest;
+	if (typeof lb === "object") {
+		unit = lb.unit ?? lb.type;
+		instruction = lb.instruction ?? "";
+		lowest = lb.lowest_wins;
+	} else unit = lb;
+	let rz;
+	if (typeof unit === "string") {
+		const found = LEADERBOARD_TYPE[unit.trim().toLowerCase()];
+		if (found === void 0) throw new Error(`Unknown leaderboard unit '${unit}'. Use one of: ${Object.keys(LEADERBOARD_TYPE).join(", ")}.`);
+		rz = found;
+	} else if (typeof unit === "number") rz = Math.trunc(unit);
+	else throw new Error("Leaderboard requires a unit.");
+	if (lowest === void 0) lowest = rz === 4 || rz === 18;
+	return {
+		isRedzone: 1,
+		redzoneType: rz,
+		smallerIsBetter: lowest ? 1 : 0,
+		redzoneInstruction: instruction
+	};
+}
+function slots(values, n = 10) {
+	const out = [];
+	for (let i = 0; i < n; i += 1) out.push(values && i < values.length ? values[i] ?? "" : "");
+	return out;
+}
+function repsList(ex) {
+	const reps = ex.reps;
+	if (Array.isArray(reps)) return reps.map((r) => String(r));
+	if (reps === void 0 || reps === null) return [];
+	const sets = Math.max(1, Math.trunc(Number(ex.sets ?? 1)) || 1);
+	return Array.from({ length: sets }, () => String(reps));
+}
+/** Build one saveWorkoutSetExercises payload entry with all ten param slots filled. */
+function makeExercise(ex, workoutSetId, order, key) {
+	const reps = repsList(ex);
+	let instruction = ex.instr ?? "";
+	if (instruction === "" && ex.rpe !== void 0 && ex.rpe !== null) instruction = `RPE ${ex.rpe}`;
+	const hasWeight = ex.weight !== void 0 && ex.weight !== null;
+	const weightArr = Array.isArray(ex.weight) ? ex.weight : null;
+	let count = reps.length;
+	if (count === 0 && hasWeight) count = weightArr ? weightArr.length : Math.max(1, Math.trunc(Number(ex.sets ?? 1)) || 1);
+	let param2Type;
+	let param2Values;
+	if (hasWeight) {
+		param2Type = ex.param_2_type ?? 1;
+		param2Values = (weightArr ?? Array.from({ length: count }, () => ex.weight)).map((v) => String(v));
+	} else {
+		param2Type = 0;
+		param2Values = null;
+	}
+	const entry = {
+		exercise_id: ex.id,
+		workout_set_id: workoutSetId,
+		set_id: workoutSetId,
+		setKey: workoutSetId,
+		title: ex.title ?? "",
+		instruction,
+		order,
+		param_1_type: ex.param_1_type ?? 3,
+		param_2_type: param2Type,
+		workout_set_exercise_template_id: null,
+		no_sets: 0,
+		param_count: count,
+		set_num: count,
+		key,
+		video_url: "",
+		thumbnail_url: "",
+		tags: [],
+		eType: "e",
+		use_count: 0
+	};
+	const p1 = slots(reps);
+	const p2 = slots(param2Values);
+	for (let i = 0; i < 10; i += 1) {
+		entry[`param_1_data_${i + 1}`] = p1[i] ?? "";
+		entry[`param_2_data_${i + 1}`] = p2[i] ?? "";
+	}
+	return entry;
+}
+function buildBlockPayload(blocks, workoutId) {
+	return blocks.map((b, i) => {
+		const lb = resolveLeaderboard(b);
+		return {
+			workout_id: workoutId,
+			order: i + 1,
+			type: b.type ?? 2,
+			instruction: b.instruction ?? "",
+			is_redzone: lb.isRedzone,
+			redzone_type: lb.redzoneType,
+			smaller_is_better: lb.smallerIsBetter,
+			redzone_instruction: lb.redzoneInstruction,
+			exercises: [],
+			exerciseKeys: [],
+			key: `k::${workoutId}${i + 1}`,
+			title: b.title
+		};
+	});
+}
+function unitOr(t) {
+	return unitLabel(t) ?? "?";
+}
+/** Flag spec params the API will silently override to the exercise's fixed units. */
+function unitAdvisory(blockTitle, ex, defaults) {
+	const notes = [];
+	const warnings = [];
+	const u = unitOr;
+	const label = `${blockTitle} / ${ex.title ?? ex.id}`;
+	if (Array.isArray(ex.reps) && ex.sets !== void 0 && ex.reps.length !== ex.sets) warnings.push(`${label}: reps array has ${ex.reps.length} entr${ex.reps.length === 1 ? "y" : "ies"}; sets:${ex.sets} is ignored — building ${ex.reps.length} set(s).`);
+	const sentP1 = ex.param_1_type;
+	if (sentP1 !== void 0 && sentP1 !== null && Math.trunc(Number(sentP1)) !== defaults.param1) {
+		const sp1 = Math.trunc(Number(sentP1));
+		warnings.push(`${label}: param_1_type ${sentP1} (${u(sp1)}) is ignored — this exercise is fixed to ${u(defaults.param1)}; values render as ${u(defaults.param1)}.`);
+	} else if (defaults.param1 !== 3 && defaults.param1 !== null) notes.push(`${label}: values are in ${u(defaults.param1)} (the exercise's fixed primary unit).`);
+	if (ex.weight !== void 0 && ex.weight !== null) {
+		const sentP2 = Math.trunc(Number(ex.param_2_type ?? 1));
+		const effP2 = defaults.param2 === 0 || defaults.param2 === null ? 1 : defaults.param2;
+		if (sentP2 !== effP2) if (sentP2 === 2 || sentP2 === 14) warnings.push(`${label}: ${u(sentP2)} does not stick on this exercise — it renders as ${u(effP2)}. Put it in the exercise 'instr' text and leave load blank.`);
+		else warnings.push(`${label}: load renders as ${u(effP2)}, not ${u(sentP2)} (this exercise's secondary unit is fixed).`);
+	}
+	return {
+		notes,
+		warnings
+	};
+}
+/**
+* Run unit advisories across a whole block list against an exercise index. Shared by the
+* MCP workout_build tool and the CLI so both surface the same notes/warnings. Ensures the
+* index is loaded first, otherwise `defaults` returns null on a cold index and every
+* advisory is silently dropped.
+*/
+async function collectAdvisories(blocks, index) {
+	await index.ensureFresh();
+	const pairs = blocks.flatMap((b) => b.exercises.map((ex) => ({
+		block: b,
+		ex
+	})));
+	const defaults = await Promise.all(pairs.map((p) => {
+		const id = Number(p.ex.id);
+		return Number.isFinite(id) ? index.defaults(id) : Promise.resolve(null);
+	}));
+	const notes = [];
+	const warnings = [];
+	pairs.forEach((p, i) => {
+		const def = defaults[i];
+		if (!def) return;
+		const advisory = unitAdvisory(p.block.title, p.ex, def);
+		notes.push(...advisory.notes);
+		warnings.push(...advisory.warnings);
+	});
+	return {
+		notes,
+		warnings
+	};
+}
+//#endregion
+//#region ../js/src/workout-session.ts
+async function req(client, method, path, body) {
+	const res = await client.request(method, path, body === void 0 ? void 0 : { body });
+	if (!res.ok) {
+		const detail = typeof res.data === "string" ? res.data : JSON.stringify(res.data);
+		throw new Error(`${method} ${path} failed (HTTP ${res.status}): ${detail}`);
+	}
+	return res.data;
+}
+function createPath(opts) {
+	if (opts.timelineDay !== void 0) return `/2.0/coach/calendar/workout/createWorkoutForTimelineDay/${opts.programId}/${opts.timelineDay}/null`;
+	if (!opts.date) throw new Error("workout build requires either date or timelineDay");
+	const [y, m, d] = opts.date;
+	return `/2.0/coach/calendar/workout/createWorkoutForDay/${opts.programId}/${y}/${m}/${d}/0`;
+}
+async function buildSession(client, opts) {
+	const sess = await req(client, "POST", createPath(opts), {});
+	checkResponse(sessionCreateResponseSchema, sess, "session create");
+	const workoutId = Number(sess.workout_id);
+	const pwId = Number(sess.id);
+	const created = await req(client, "POST", "/2.0/coach/calendar/saveProgramWorkoutSets", buildBlockPayload(opts.blocks, workoutId));
+	const byOrder = new Map(created.map((b) => [b.order, b.id]));
+	let counter = 0;
+	const payloads = opts.blocks.map((block, i) => {
+		const wsid = byOrder.get(i + 1);
+		if (wsid === void 0) throw new Error(`No saved block for order ${i + 1}.`);
+		return block.exercises.map((ex, j) => {
+			counter += 1;
+			return makeExercise(ex, wsid, j + 1, `k::${workoutId}${String(counter).padStart(3, "0")}`);
+		});
+	});
+	await Promise.all(payloads.map((p) => req(client, "POST", "/2.0/coach/calendar/saveWorkoutSetExercises", p)));
+	if (opts.instruction !== void 0 && opts.instruction !== "") {
+		const blockIds = [...byOrder.entries()].sort((a, b) => a[0] - b[0]).map(([, id]) => id);
+		await setSessionInstruction(client, workoutId, sess, opts.instruction, blockIds);
+	}
+	if (opts.publish ?? false) await req(client, "POST", "/2.0/coach/calendar/programWorkout/publish", [pwId]);
+	return {
+		pwId,
+		workoutId
+	};
+}
+/**
+* Set a session's Coach Instructions (the day-note at the top of a session). `pw` is the
+* programWorkout object (the create-time response or a day's edit-GET entry). The PUT wants
+* the whole object back with `instruction` set and `sets`/`setKeys` as a flat list of block
+* ids. This does NOT change publish state: `published` is sent exactly as it is on `pw`.
+*/
+async function setSessionInstruction(client, workoutId, pw, instruction, blockIds) {
+	const body = {
+		...pw,
+		instruction,
+		sets: blockIds,
+		setKeys: blockIds
+	};
+	await req(client, "PUT", `/3.0/coach/workout/${workoutId}`, body);
+}
+async function removeSession(client, programId, pwId) {
+	await req(client, "POST", "/2.0/coach/calendar/removeProgramWorkout", {
+		programId,
+		pwId
+	});
+}
+async function publishSession(client, pwId) {
+	await req(client, "POST", "/2.0/coach/calendar/programWorkout/publish", [pwId]);
+}
+function str(value) {
+	return value === void 0 || value === null ? "" : String(value);
+}
+async function readSession(client, programId, date, pwId) {
+	const [y, m, d] = date;
+	const data = await req(client, "GET", `/1.0/coach/programs/edit/${programId}/${y}/${m}/${d}`);
+	checkResponse(programsEditResponseSchema, data, "programs edit");
+	const pw = (data.programWorkouts ?? []).find((p) => coerceInt(p.id) === pwId);
+	if (!pw) throw new Error(`programWorkout ${pwId} not found on ${y}-${m}-${d}.`);
+	const setsObj = pw.sets ?? {};
+	const blocks = Object.values(setsObj).sort((a, b) => Number(a.order) - Number(b.order)).map((b) => readBlock(b));
+	return {
+		pwId,
+		date: `${str(pw.year)}-${str(pw.month)}-${str(pw.day)}`,
+		published: pw.published,
+		instruction: str(pw.instruction),
+		blocks
+	};
+}
+function readBlock(b) {
+	const rz = coerceInt(b.redzone_type);
+	let leaderboard = null;
+	if (rz && rz > 0) leaderboard = `FOR ${(LEADERBOARD_LABEL[rz] ?? `type ${rz}`).toUpperCase()}${b.smaller_is_better ? " (lowest wins)" : ""}`;
+	const exercises = (Array.isArray(b.exercises) ? b.exercises : []).sort((a, e) => Number(a.order) - Number(e.order)).map((ex) => readExercise(ex));
+	return {
+		order: Number(b.order),
+		title: str(b.title),
+		leaderboard,
+		exercises
+	};
+}
+function readExercise(ex) {
+	const reps = [];
+	const load = [];
+	for (let i = 1; i <= 10; i += 1) {
+		const r = str(ex[`param_1_data_${i}`]);
+		if (r !== "") reps.push(r);
+		const w = str(ex[`param_2_data_${i}`]);
+		if (w !== "") load.push(w);
+	}
+	return {
+		order: Number(ex.order),
+		title: str(ex.title),
+		reps,
+		primaryUnit: unitLabel(coerceInt(ex.param_1_type)),
+		load,
+		loadUnit: unitLabel(coerceInt(ex.param_2_type)),
+		instruction: str(ex.instruction)
+	};
+}
+//#endregion
+//#region ../js/src/messaging.ts
+const BUCKETS = [
+	["team", "teams"],
+	["athlete", "athletes"],
+	["program", "programs"],
+	["coach", "coaches"]
+];
+/** Live list of chat streams, flattened to (stream, kind) tuples. */
+async function fetchStreams(client) {
+	const res = await client.request("GET", "/v5/messaging/streams");
+	if (!res.ok || !isRecord(res.data)) throw new Error(`GET /v5/messaging/streams failed (HTTP ${res.status}).`);
+	const out = [];
+	for (const [kind, key] of BUCKETS) {
+		const bucket = res.data[key];
+		if (Array.isArray(bucket)) {
+			for (const s of bucket) if (isRecord(s) && coerceInt(s.id) !== null) out.push({
+				stream: s,
+				kind
+			});
+		}
+	}
+	return out;
+}
+/**
+* The exact chat comment body the web app sends. The non-obvious required field is
+* `feed_id` (the stream id repeated in the body); omitting it returns 400.
+*/
+function buildCommentPayload(streamId, text, replyTo = null) {
+	return {
+		type: 0,
+		content: text,
+		photo_url: "",
+		photoUrl: "",
+		access_level: 0,
+		parent_feed_item_id: replyTo,
+		feed_id: streamId
+	};
+}
+async function sendComment(client, streamId, text, replyTo = null) {
+	const res = await client.request("POST", `/v5/messaging/streams/${streamId}/comments`, { body: buildCommentPayload(streamId, text, replyTo) });
+	if (!res.ok || typeof res.data !== "object" || res.data === null || res.data.id === void 0) throw new Error(`Message send failed (HTTP ${res.status}).`);
+	return res.data;
+}
+async function deleteComment(client, streamId, commentId) {
+	const res = await client.request("DELETE", `/v5/messaging/streams/${streamId}/comments/${commentId}`);
+	if (!res.ok) throw new Error(`Message delete failed (HTTP ${res.status}).`);
+	return res.data;
+}
+async function readLive(client, streamId, limit) {
+	const res = await client.request("GET", `/v5/messaging/streams/${streamId}/comments?lastCommentId=`);
+	if (!res.ok || !Array.isArray(res.data)) throw new Error(`Message read failed (HTTP ${res.status}).`);
+	return limit !== void 0 && limit > 0 ? res.data.slice(-limit) : res.data;
+}
+//#endregion
+//#region ../js/src/library-cache.ts
+/** In-memory cache (no persistence). The default when none is supplied. */
+var MemoryLibraryCache = class {
+	#snapshot = null;
+	async load() {
+		return this.#snapshot;
+	}
+	async save(snapshot) {
+		this.#snapshot = snapshot;
+	}
+};
+//#endregion
+//#region ../js/src/exercise-index.ts
+const LIBRARY_PATH = "/v5/exerciseLibrary/all";
+const CREATE_PATH = "/2.0/coach/exercise/create";
+const TTL_MS = 168 * 3600 * 1e3;
+function toStored(ex) {
+	const id = coerceInt(ex.id);
+	if (id === null) return null;
+	const title = String(ex.title ?? "");
+	return {
+		id,
+		title,
+		search: buildSearchText(title),
+		param_1_type: coerceInt(ex.param_1_type),
+		param_2_type: coerceInt(ex.param_2_type),
+		can_edit: coerceInt(ex.can_edit) ?? 0,
+		user_id: coerceInt(ex.user_id),
+		use_count: coerceInt(ex.use_count) ?? 0,
+		raw: ex
+	};
+}
+function toRow(s) {
+	return {
+		id: s.id,
+		title: s.title,
+		param_1_type: s.param_1_type,
+		param_2_type: s.param_2_type,
+		can_edit: s.can_edit,
+		user_id: s.user_id,
+		use_count: s.use_count
+	};
+}
+/**
+* The exercise library held in memory for fast queries and persisted through a
+* LibraryCache (JSON file for a CLI/local server, in-memory by default). Same
+* resolve/search/unit behavior as the D1-backed store, with no database.
+*/
+var ExerciseLibrary = class {
+	#client;
+	#cache;
+	#byId = /* @__PURE__ */ new Map();
+	#loaded = false;
+	#fetchedAt = 0;
+	constructor(client, cache = new MemoryLibraryCache()) {
+		this.#client = client;
+		this.#cache = cache;
+	}
+	#hydrate(list, fetchedAt) {
+		const next = /* @__PURE__ */ new Map();
+		for (const ex of list) {
+			const s = toStored(ex);
+			if (s) next.set(s.id, s);
+		}
+		this.#byId = next;
+		this.#fetchedAt = fetchedAt;
+		this.#loaded = true;
+	}
+	async #ensureLoaded() {
+		if (this.#loaded) return;
+		const snap = await this.#cache.load();
+		if (snap && snap.exercises.length > 0 && Date.now() - snap.fetchedAt <= TTL_MS) this.#hydrate(snap.exercises, snap.fetchedAt);
+		else await this.refresh();
+	}
+	async #persist() {
+		await this.#cache.save({
+			fetchedAt: this.#fetchedAt,
+			exercises: [...this.#byId.values()].map((s) => s.raw)
+		});
+	}
+	async ensureFresh() {
+		if (!this.#loaded) await this.#ensureLoaded();
+		else if (Date.now() - this.#fetchedAt > TTL_MS) await this.refresh();
+	}
+	async refresh() {
+		const res = await this.#client.request("GET", LIBRARY_PATH);
+		if (!res.ok) throw new Error(`Exercise library fetch failed (HTTP ${res.status}).`);
+		const list = asExerciseList(res.data);
+		if (list.length === 0) throw new Error("Exercise library returned no rows; keeping the cache.");
+		checkResponse(exerciseLibraryResponseSchema, list, "exercise library");
+		this.#hydrate(list, Date.now());
+		await this.#persist();
+		return { synced: this.#byId.size };
+	}
+	async get(id) {
+		await this.ensureFresh();
+		const s = this.#byId.get(id);
+		if (!s) return null;
+		const full = { ...s.raw };
+		full.param_1_unit = unitLabel(full.param_1_type);
+		full.param_2_unit = unitLabel(full.param_2_type);
+		return full;
+	}
+	async defaults(id) {
+		const s = this.#byId.get(id);
+		return s ? {
+			param1: s.param_1_type,
+			param2: s.param_2_type
+		} : null;
+	}
+	async search(query, limit = 20) {
+		await this.ensureFresh();
+		return this.#searchOnly(query, limit);
+	}
+	#searchOnly(query, limit) {
+		const tokens = query.toLowerCase().split(/\s+/u).filter((t) => t.length > 0);
+		if (tokens.length === 0) return [];
+		return rankSearch([...this.#byId.values()].filter((s) => tokens.every((t) => s.search.includes(t))).map((s) => toRow(s)), query, limit).map(withUnits);
+	}
+	#exact(name) {
+		const q = name.trim().toLowerCase();
+		const first = [...this.#byId.values()].filter((s) => s.search === q).sort((a, b) => a.can_edit - b.can_edit)[0];
+		return first ? withUnits(toRow(first)) : null;
+	}
+	async resolve(name) {
+		await this.ensureFresh();
+		let hit = this.#exact(name);
+		if (hit) return {
+			match: hit,
+			candidates: [hit]
+		};
+		let candidates = this.#searchOnly(name, 20);
+		if (candidates.length === 0) {
+			await this.refresh();
+			hit = this.#exact(name);
+			if (hit) return {
+				match: hit,
+				candidates: [hit]
+			};
+			candidates = this.#searchOnly(name, 20);
+		}
+		if (candidates.length === 1) return {
+			match: candidates[0] ?? null,
+			candidates
+		};
+		return {
+			match: null,
+			candidates
+		};
+	}
+	async create(body) {
+		await this.ensureFresh();
+		const res = await this.#client.request("POST", CREATE_PATH, { body });
+		if (!res.ok) throw new Error(`Exercise create failed (HTTP ${res.status}).`);
+		const ex = unwrapEnvelope(res.data);
+		if (ex && typeof ex === "object") {
+			checkResponse(exerciseResponseSchema, ex, "exercise create");
+			const s = toStored(ex);
+			if (s) {
+				this.#byId.set(s.id, s);
+				await this.#persist();
+			}
+		}
+		return ex;
+	}
+	async recordDelete(id) {
+		await this.ensureFresh();
+		if (this.#byId.delete(id)) await this.#persist();
+	}
+	async stats() {
+		let custom = 0;
+		for (const s of this.#byId.values()) if (s.can_edit === 1) custom += 1;
+		return {
+			exercises: this.#byId.size,
+			custom,
+			loaded: this.#loaded,
+			fetchedAt: this.#fetchedAt
+		};
+	}
+};
+//#endregion
+//#region ../core/src/tools/workout.ts
+/** Workout building, read-back, publishing, and removal. */
+function registerWorkoutTools(server, ctx) {
+	server.registerTool("workout_build", {
+		title: "Build a workout session (draft)",
+		description: "Build an UNPUBLISHED session from a spec (program -> session -> blocks -> exercises). Two exercises in one block become a superset. Add a block 'leaderboard' for a Red-Zone score, or a top-level 'instruction' for the session note (Coach Instructions). Returns the draft ids, a read-back, and unit advisories. Review, then workout_publish.",
+		inputSchema: {
+			programId: z.number(),
+			date: z.string().optional(),
+			timelineDay: z.number().optional(),
+			blocks: z.array(blockSpecSchema),
+			instruction: z.string().optional()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: false,
+			openWorldHint: true
+		}
+	}, ({ programId, date, timelineDay, blocks, instruction }) => attempt(async () => {
+		if (date === void 0 && timelineDay === void 0) return errorResult("Provide either date (YYYY-M-D) or timelineDay.");
+		const typed = blocks;
+		const opts = {
+			programId,
+			blocks: typed,
+			publish: false
+		};
+		if (date !== void 0) opts.date = parseWorkoutDate(date);
+		if (timelineDay !== void 0) opts.timelineDay = timelineDay;
+		if (instruction !== void 0) opts.instruction = instruction;
+		const advisories = await collectAdvisories(typed, ctx.index);
+		const built = await buildSession(ctx.client, opts);
+		const readback = opts.date ? await readSession(ctx.client, programId, opts.date, built.pwId) : null;
+		return jsonResult({
+			...built,
+			published: false,
+			advisories,
+			readback,
+			note: "Draft created (unpublished). Review, then call workout_publish to make it athlete-facing."
+		});
+	}));
+	server.registerTool("workout_read", {
+		title: "Read a built session",
+		description: "Read-back a session by programId, date (YYYY-M-D), and programWorkout id.",
+		inputSchema: {
+			programId: z.number(),
+			date: z.string(),
+			pwId: z.number()
+		},
+		annotations: {
+			readOnlyHint: true,
+			openWorldHint: true
+		}
+	}, ({ programId, date, pwId }) => attempt(async () => jsonResult(await readSession(ctx.client, programId, parseWorkoutDate(date), pwId))));
+	server.registerTool("workout_publish", {
+		title: "Publish a session",
+		description: "Publish a built session — ATHLETE-FACING and immediate. Requires confirmation (elicitation, or confirm:true).",
+		inputSchema: {
+			programId: z.number(),
+			date: z.string(),
+			pwId: z.number(),
+			confirm: z.boolean().optional()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, ({ programId, date, pwId, confirm }, extra) => attempt(async () => {
+		if (!await confirmGate(server, extra.requestId, `Publish session ${pwId} on ${date}? This is athlete-facing and immediate.`, confirm)) return errorResult(NOT_CONFIRMED);
+		await publishSession(ctx.client, pwId);
+		return jsonResult({
+			published: pwId,
+			readback: await readSession(ctx.client, programId, parseWorkoutDate(date), pwId)
+		});
+	}));
+	server.registerTool("session_remove", {
+		title: "Remove a session",
+		description: "Delete a session from the live calendar (also the way to replace a date: remove then build). Hard to undo. Requires confirmation (elicitation, or confirm:true).",
+		inputSchema: {
+			programId: z.number(),
+			pwId: z.number(),
+			confirm: z.boolean().optional()
+		},
+		annotations: {
+			readOnlyHint: false,
+			destructiveHint: true,
+			openWorldHint: true
+		}
+	}, ({ programId, pwId, confirm }, extra) => attempt(async () => {
+		if (!await confirmGate(server, extra.requestId, `Delete session ${pwId}? This removes it from the live calendar and is hard to undo.`, confirm)) return errorResult(NOT_CONFIRMED);
+		await removeSession(ctx.client, programId, pwId);
+		return jsonResult({ removed: pwId });
+	}));
+}
+//#endregion
+//#region ../core/src/tools/messaging.ts
+function registerReads(server, ctx) {
+	server.registerTool("messaging_conversations", {
+		title: "List conversations (live)",
+		description: "List chat streams (id, kind, title) live from the API; no setup needed. Use the id to read/draft/send.",
+		inputSchema: {},
+		annotations: READ
+	}, () => attempt(async () => {
+		return jsonResult((await fetchStreams(ctx.client)).map(({ stream, kind }) => ({
+			id: stream.id,
+			kind,
+			title: stream.title ?? "",
+			teamId: stream.teamId,
+			userId: stream.userId
+		})));
+	}));
+	server.registerTool("messaging_read", {
+		title: "Read messages (live)",
+		description: "Recent comments in a stream, live from the API (the stream is fetched whole, then trimmed to `limit`).",
+		inputSchema: {
+			streamId: idParam,
+			limit: z.number().int().positive().max(200).optional()
+		},
+		annotations: READ
+	}, ({ streamId, limit }) => attempt(async () => jsonResult(await readLive(ctx.client, toId(streamId), limit ?? 20))));
+	server.registerTool("message_draft", {
+		title: "Draft a message (preview only)",
+		description: "Preview the exact payload and target WITHOUT sending. Always safe.",
+		inputSchema: commentDraftSchema.shape,
+		annotations: READ
+	}, ({ streamId, text, replyTo }) => attempt(async () => {
+		const id = toId(streamId);
+		return jsonResult({
+			draft: true,
+			note: "NOT sent. This is a preview. Run message_send to deliver it.",
+			would_POST: `/v5/messaging/streams/${id}/comments`,
+			payload: buildCommentPayload(id, text, replyTo === void 0 ? null : toId(replyTo))
+		});
+	}));
+}
+function registerWrites(server, ctx) {
+	server.registerTool("message_send", {
+		title: "Send a message",
+		description: "Send a chat message — ATHLETE-FACING and immediate (no draft state on the server). Requires confirmation (elicitation, or confirm:true). Prefer message_draft first.",
+		inputSchema: {
+			...commentDraftSchema.shape,
+			confirm: z.boolean().optional()
+		},
+		annotations: DESTRUCTIVE
+	}, ({ streamId, text, replyTo, confirm }, extra) => attempt(async () => {
+		const id = toId(streamId);
+		if (!await confirmGate(server, extra.requestId, `Send this message to stream ${id}? It is athlete-facing and immediate.`, confirm)) return errorResult(NOT_CONFIRMED);
+		return jsonResult({
+			sent: true,
+			comment: await sendComment(ctx.client, id, text, replyTo === void 0 ? null : toId(replyTo))
+		});
+	}));
+	server.registerTool("message_delete", {
+		title: "Delete a message",
+		description: "Soft-delete a chat message on the live account. Requires confirmation.",
+		inputSchema: {
+			streamId: idParam,
+			commentId: idParam,
+			confirm: z.boolean().optional()
+		},
+		annotations: DESTRUCTIVE
+	}, ({ streamId, commentId, confirm }, extra) => attempt(async () => {
+		if (!await confirmGate(server, extra.requestId, `Delete comment ${toId(commentId)} from stream ${toId(streamId)}? Acts on the live account.`, confirm)) return errorResult(NOT_CONFIRMED);
+		return jsonResult({
+			deleted: true,
+			response: await deleteComment(ctx.client, toId(streamId), toId(commentId))
+		});
+	}));
+}
+/** Live messaging: list/read conversations, draft a message, and the gated send/delete. */
+function registerMessagingTools(server, ctx) {
+	registerReads(server, ctx);
+	registerWrites(server, ctx);
+}
+//#endregion
+//#region ../js/src/node.ts
+/** Default exercise-cache path, overridable with TRAINHEROIC_CACHE_FILE. */
+function defaultCachePath() {
+	return process.env.TRAINHEROIC_CACHE_FILE ?? join(homedir(), ".trainheroic", "library.json");
+}
+/** Persists the exercise library to a JSON file. */
+var JsonFileLibraryCache = class {
+	#path;
+	constructor(path = defaultCachePath()) {
+		this.#path = path;
+	}
+	async load() {
+		try {
+			const parsed = JSON.parse(await readFile(this.#path, "utf8"));
+			if (typeof parsed.fetchedAt === "number" && Array.isArray(parsed.exercises)) return parsed;
+		} catch {}
+		return null;
+	}
+	async save(snapshot) {
+		await mkdir(dirname(this.#path), { recursive: true });
+		await writeFile(this.#path, JSON.stringify(snapshot), { mode: 384 });
+	}
+};
+//#endregion
+//#region src/server.ts
+async function main() {
+	const email = process.env.TRAINHEROIC_EMAIL;
+	const password = process.env.TRAINHEROIC_PASSWORD;
+	if (!email || !password) {
+		process.stderr.write("Set TRAINHEROIC_EMAIL and TRAINHEROIC_PASSWORD in the environment.\n");
+		process.exit(1);
+	}
+	const client = new TrainHeroicClient(email, password);
+	const ctx = {
+		client,
+		index: new ExerciseLibrary(client, new JsonFileLibraryCache())
+	};
+	const server = new McpServer({
+		name: "trainheroic-local",
+		version: "0.1.0"
+	});
+	registerReadTools(server, ctx);
+	registerRawTools(server, ctx);
+	registerExerciseTools(server, ctx);
+	registerWorkoutTools(server, ctx);
+	registerMessagingTools(server, ctx);
+	await server.connect(new StdioServerTransport());
+}
+await main();
+//#endregion
+export {};