@gehlich/calicomp-mcp 1.0.0

package/dist/index.js

@@ -0,0 +1,4040 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/schemas.ts
+import { z as z2 } from "zod";
+
+// src/coach-parameters.ts
+import { z } from "zod";
+
+// src/http.ts
+var HttpError = class extends Error {
+  constructor(status, path) {
+    super(`HTTP ${status} from ${path}`);
+    this.status = status;
+    this.name = "HttpError";
+  }
+  status;
+};
+async function assertOk(res, path) {
+  if (!res.ok) {
+    throw new HttpError(res.status, path);
+  }
+}
+var REQUEST_TIMEOUT_MS = 3e4;
+var DATA_PULL_PATH = "/api/mcp/data/pull";
+var PROFILE_PATH = "/api/mcp/profile";
+var CATALOG_PATH = "/api/exercises";
+var SUGGEST_PATH = "/api/mcp/suggest";
+var COACH_SUGGESTIONS_PATH = "/api/mcp/coach/suggestions";
+var COACH_PARAMETERS_PATH = "/api/mcp/coach/parameters";
+async function fetchSnapshot(pat2, serverUrl2) {
+  const path = DATA_PULL_PATH;
+  const res = await fetch(`${serverUrl2}${path}`, {
+    headers: { Authorization: `Bearer ${pat2}` },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  await assertOk(res, path);
+  return res.json();
+}
+async function fetchProfile(pat2, serverUrl2) {
+  const path = PROFILE_PATH;
+  const res = await fetch(`${serverUrl2}${path}`, {
+    headers: { Authorization: `Bearer ${pat2}` },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  await assertOk(res, path);
+  return res.json();
+}
+async function fetchCatalog(serverUrl2) {
+  const path = CATALOG_PATH;
+  const res = await fetch(`${serverUrl2}${path}`, {
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  await assertOk(res, path);
+  return res.json();
+}
+async function postSuggest(body, pat2, serverUrl2) {
+  const path = SUGGEST_PATH;
+  const res = await fetch(`${serverUrl2}${path}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${pat2}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  await assertOk(res, path);
+  return res.json();
+}
+async function fetchSuggestions(cfg, status, limit) {
+  const path = COACH_SUGGESTIONS_PATH;
+  const params = new URLSearchParams();
+  if (status !== void 0) params.set("status", status);
+  if (limit !== void 0) params.set("limit", String(limit));
+  const query = params.toString();
+  const res = await fetch(`${cfg.serverUrl}${path}${query ? `?${query}` : ""}`, {
+    headers: { Authorization: `Bearer ${cfg.pat}` },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  await assertOk(res, path);
+  return res.json();
+}
+async function fetchSuggestion(cfg, id) {
+  const path = `${COACH_SUGGESTIONS_PATH}/${encodeURIComponent(id)}`;
+  const res = await fetch(`${cfg.serverUrl}${path}`, {
+    headers: { Authorization: `Bearer ${cfg.pat}` },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (res.status === 404) return null;
+  await assertOk(res, path);
+  return res.json();
+}
+async function postWithdraw(cfg, id) {
+  const path = `${COACH_SUGGESTIONS_PATH}/${encodeURIComponent(id)}/withdraw`;
+  const res = await fetch(`${cfg.serverUrl}${path}`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${cfg.pat}` },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (res.status === 404) return "not-withdrawable";
+  await assertOk(res, path);
+  return "withdrawn";
+}
+async function fetchCoachParameters(cfg) {
+  const path = COACH_PARAMETERS_PATH;
+  const res = await fetch(`${cfg.serverUrl}${path}`, {
+    headers: { Authorization: `Bearer ${cfg.pat}` },
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (res.status === 404) return null;
+  await assertOk(res, path);
+  return res.json();
+}
+async function putCoachParameters(cfg, params) {
+  const path = COACH_PARAMETERS_PATH;
+  const res = await fetch(`${cfg.serverUrl}${path}`, {
+    method: "PUT",
+    headers: {
+      Authorization: `Bearer ${cfg.pat}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ params }),
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (res.status === 400) return "rejected";
+  await assertOk(res, path);
+  return res.json();
+}
+
+// src/coach-parameters.ts
+var COACH_PARAMETER_DEFAULTS = {
+  toleranceDays: 1,
+  adherenceWindowWeeks: 4,
+  consistencyWindowWeeks: 12,
+  exerciseTrendPoints: 10,
+  recentExerciseCount: 5,
+  matchThreshold: 0.542,
+  uncertainThreshold: 0.454
+};
+var COACH_PARAMETER_RANGES = {
+  toleranceDays: {
+    min: 0,
+    max: 7,
+    integer: true,
+    description: "Calendar-day slack for counting a session as matching its planned day."
+  },
+  adherenceWindowWeeks: {
+    min: 1,
+    max: 52,
+    integer: true,
+    description: "Rolling window, in weeks, the adherence calculator scores against."
+  },
+  consistencyWindowWeeks: {
+    min: 4,
+    max: 52,
+    integer: true,
+    description: "Rolling window, in weeks, the training-consistency calculator considers."
+  },
+  exerciseTrendPoints: {
+    min: 3,
+    max: 30,
+    integer: true,
+    description: "How many recent data points a per-exercise trend series returns."
+  },
+  recentExerciseCount: {
+    min: 1,
+    max: 20,
+    integer: true,
+    description: 'How many recent sessions the "recent exercises" overview lists.'
+  },
+  matchThreshold: {
+    min: 0,
+    max: 1,
+    integer: false,
+    description: "Ruzicka similarity at/above which an unplanned session counts as a matched candidate."
+  },
+  uncertainThreshold: {
+    min: 0,
+    max: 1,
+    integer: false,
+    description: "Ruzicka similarity at/above which an unplanned session counts as an uncertain candidate. Must stay strictly below matchThreshold."
+  }
+};
+function baseCoachParametersObject() {
+  const r = COACH_PARAMETER_RANGES;
+  return z.object({
+    toleranceDays: z.number().int().min(r.toleranceDays.min).max(r.toleranceDays.max).optional(),
+    adherenceWindowWeeks: z.number().int().min(r.adherenceWindowWeeks.min).max(r.adherenceWindowWeeks.max).optional(),
+    consistencyWindowWeeks: z.number().int().min(r.consistencyWindowWeeks.min).max(r.consistencyWindowWeeks.max).optional(),
+    exerciseTrendPoints: z.number().int().min(r.exerciseTrendPoints.min).max(r.exerciseTrendPoints.max).optional(),
+    recentExerciseCount: z.number().int().min(r.recentExerciseCount.min).max(r.recentExerciseCount.max).optional(),
+    matchThreshold: z.number().min(r.matchThreshold.min).max(r.matchThreshold.max).optional(),
+    uncertainThreshold: z.number().min(r.uncertainThreshold.min).max(r.uncertainThreshold.max).optional()
+  }).strict();
+}
+function coachParametersSchemaFor(current) {
+  return baseCoachParametersObject().refine(
+    (data) => {
+      const effectiveMatch = data.matchThreshold ?? current.matchThreshold;
+      const effectiveUncertain = data.uncertainThreshold ?? current.uncertainThreshold;
+      return effectiveUncertain < effectiveMatch;
+    },
+    { message: "uncertainThreshold must be strictly less than matchThreshold" }
+  );
+}
+var CoachParametersSchema = coachParametersSchemaFor(COACH_PARAMETER_DEFAULTS);
+function mergeCoachParameters(partial) {
+  if (partial === null) return { ...COACH_PARAMETER_DEFAULTS };
+  return { ...COACH_PARAMETER_DEFAULTS, ...partial };
+}
+var UNCALIBRATED_NOTE = "These seven starting values are uncalibrated defaults, not measured quantities. Consider setting them deliberately after an initial conversation with the athlete about their training rhythm and how strict a session-to-plan match should be.";
+function describeCoachParameters(current, source) {
+  const params = {};
+  for (const key of Object.keys(COACH_PARAMETER_DEFAULTS)) {
+    const range = COACH_PARAMETER_RANGES[key];
+    params[key] = {
+      value: current[key],
+      default: COACH_PARAMETER_DEFAULTS[key],
+      min: range.min,
+      max: range.max,
+      integer: range.integer,
+      description: range.description
+    };
+  }
+  return { params, source, note: UNCALIBRATED_NOTE };
+}
+async function loadCoachParameters(cfg) {
+  try {
+    const fetched = await fetchCoachParameters(cfg);
+    if (fetched === null) {
+      return { params: { ...COACH_PARAMETER_DEFAULTS }, source: "defaults" };
+    }
+    return { params: mergeCoachParameters(fetched.params), source: "server" };
+  } catch {
+    return { params: { ...COACH_PARAMETER_DEFAULTS }, source: "defaults" };
+  }
+}
+
+// src/schemas.ts
+var ISO_DATE = z2.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Must be YYYY-MM-DD");
+var UUID_STRING = z2.string().uuid();
+var MUSCLE_KEY = z2.enum([
+  "chest",
+  "back",
+  "lats",
+  "shoulders",
+  "traps",
+  "biceps",
+  "triceps",
+  "forearms",
+  "abs",
+  "obliques",
+  "lower_back",
+  "quads",
+  "hamstrings",
+  "glutes",
+  "calves",
+  "hip_flexors",
+  "adductors",
+  "neck"
+]);
+var GetProfileSchema = z2.object({});
+var ListTemplatesSchema = z2.object({});
+var GetTemplateSchema = z2.object({
+  templateId: UUID_STRING
+});
+var OUTPUT_FILE_FLAG = z2.boolean().optional();
+var GetHistorySchema = z2.object({
+  from: ISO_DATE,
+  to: ISO_DATE,
+  exercise: UUID_STRING.optional(),
+  limit: z2.number().int().min(1).max(500).optional().default(200),
+  outputFile: OUTPUT_FILE_FLAG
+}).refine((d) => d.from <= d.to, { message: "`to` must be >= `from`" });
+var GetPlannedWorkoutsSchema = z2.object({
+  from: ISO_DATE,
+  to: ISO_DATE
+}).refine((d) => d.from <= d.to, { message: "`to` must be >= `from`" }).refine(
+  (d) => (new Date(d.to).getTime() - new Date(d.from).getTime()) / 864e5 <= 366,
+  { message: "`to` - `from` must be at most 366 days" }
+);
+var GetAdherenceSchema = z2.object({
+  from: ISO_DATE.optional(),
+  to: ISO_DATE.optional(),
+  toleranceDays: z2.number().int().min(0).max(7).optional(),
+  windowWeeks: z2.number().int().min(1).max(52).optional(),
+  outputFile: OUTPUT_FILE_FLAG
+}).refine((d) => d.from === void 0 || d.to === void 0 || d.from <= d.to, {
+  message: "`to` must be >= `from`"
+}).refine(
+  (d) => d.from === void 0 || d.to === void 0 || (new Date(d.to).getTime() - new Date(d.from).getTime()) / 864e5 <= 366,
+  { message: "`to` - `from` must be at most 366 days" }
+).refine((d) => !(d.windowWeeks !== void 0 && d.from !== void 0 && d.to !== void 0), {
+  message: "`windowWeeks` cannot be combined with a complete `from`/`to` pair"
+});
+var GetStatsSchema = z2.discriminatedUnion("by", [
+  z2.object({ by: z2.literal("exercise"), exerciseId: UUID_STRING }),
+  z2.object({ by: z2.literal("muscle"), muscle: MUSCLE_KEY }),
+  z2.object({ by: z2.literal("capabilities") }).strict()
+]);
+var GetProgressSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("exercise"),
+    exerciseId: UUID_STRING.optional(),
+    points: z2.number().int().min(3).max(30).optional(),
+    outputFile: OUTPUT_FILE_FLAG
+  }).strict(),
+  z2.object({
+    kind: z2.literal("format"),
+    templateId: UUID_STRING.optional(),
+    points: z2.number().int().min(3).max(30).optional(),
+    outputFile: OUTPUT_FILE_FLAG
+  }).strict()
+]);
+var GetExerciseCatalogSchema = z2.object({
+  lang: z2.string().min(2).max(5).optional()
+});
+var GetTrainingStateSchema = z2.object({});
+var ExerciseRefSchema = z2.discriminatedUnion("source", [
+  z2.object({ source: z2.literal("catalog"), exerciseId: UUID_STRING }),
+  z2.object({ source: z2.literal("new"), tempId: z2.string().min(1).max(64) })
+]);
+var RoundTargetInputSchema = z2.object({
+  round: z2.number().int().min(1).max(100),
+  targetReps: z2.number().int().min(0).optional(),
+  targetTimeSeconds: z2.number().int().min(0).optional(),
+  targetWeight: z2.number().min(0).optional()
+});
+var PlanOpSchema = z2.discriminatedUnion("op", [
+  z2.object({
+    op: z2.literal("addExercise"),
+    blockId: UUID_STRING.nullable(),
+    // null = standalone (top-level) exercise
+    exercise: ExerciseRefSchema,
+    mode: z2.enum(["REPS", "TIME", "MAX"]),
+    // Phase 134 (G-134-12): widened to accept an explicit JSON `null` (not just an
+    // omitted key) — the shared formatProposal corpus's `format-params-required-ops-
+    // against-circuit` vector encodes "not set" as literal `null` for these four
+    // fields, mirroring the Kotlin side's `Int?`/`Double?`/`List<...>? = null`
+    // nullable defaults (`PlanOp.AddExercise`, ProposalPayload.kt). `blockId` above
+    // already accepted `null`; these four did not until now.
+    targetReps: z2.number().int().min(0).nullable().optional(),
+    targetTimeSeconds: z2.number().int().min(0).nullable().optional(),
+    restTimeSeconds: z2.number().int().min(0),
+    sets: z2.number().int().min(1),
+    targetWeight: z2.number().min(0).nullable().optional(),
+    orderIndex: z2.number().int().min(0),
+    roundTargets: z2.array(RoundTargetInputSchema).max(50).nullable().optional()
+  }),
+  z2.object({ op: z2.literal("removeExercise"), workoutExerciseId: UUID_STRING }),
+  z2.object({
+    op: z2.literal("updateSetsReps"),
+    workoutExerciseId: UUID_STRING,
+    sets: z2.number().int().min(1).optional(),
+    targetReps: z2.number().int().min(0).optional(),
+    targetTimeSeconds: z2.number().int().min(0).optional(),
+    targetWeight: z2.number().min(0).optional(),
+    restTimeSeconds: z2.number().int().min(0).optional(),
+    roundTargets: z2.array(RoundTargetInputSchema).max(50).optional()
+  }),
+  z2.object({
+    op: z2.literal("reorder"),
+    blockId: UUID_STRING.nullable(),
+    order: z2.array(UUID_STRING).min(1).max(200)
+    // full ordered list of workoutExerciseIds in this block/standalone group
+  })
+]);
+var NewExerciseDefSchema = z2.object({
+  tempId: z2.string().min(1).max(64),
+  name: z2.string().min(1).max(200),
+  mode: z2.enum(["REPS", "TIME", "MAX"]),
+  usesWeight: z2.boolean(),
+  // Phase 134 (G-134-12): widened to accept an explicit JSON `null` — mirrors the
+  // Kotlin side's `description: String? = null` (NewExerciseDef, ProposalPayload.kt);
+  // the shared formatProposal corpus's tempId vector encodes an absent description
+  // as literal `null`, not an omitted key.
+  description: z2.string().max(2e3).nullable().optional()
+});
+var FormatExerciseEntrySchema = z2.object({
+  exercise: ExerciseRefSchema,
+  mode: z2.enum(["REPS", "TIME"]),
+  targetReps: z2.number().int().min(0).nullable().optional(),
+  targetTimeSeconds: z2.number().int().min(0).nullable().optional(),
+  orderIndex: z2.number().int().min(0),
+  targetWeight: z2.number().min(0).nullable().optional()
+}).strict();
+var FormatSlotEntrySchema = z2.object({
+  exercise: ExerciseRefSchema,
+  orderIndex: z2.number().int().min(0)
+}).strict();
+var FormatWeightEntrySchema = z2.object({
+  exercise: ExerciseRefSchema,
+  orderIndex: z2.number().int().min(0),
+  targetWeight: z2.number().min(0).nullable().optional()
+}).strict();
+function addTargetInvalidIssues(entries, ctx) {
+  for (const entry of entries) {
+    if (entry.mode === "REPS" && entry.targetReps == null) {
+      ctx.addIssue("FORMAT_PARAMS_INVALID: a REPS entry requires targetReps");
+    }
+    if (entry.mode === "TIME" && entry.targetTimeSeconds == null) {
+      ctx.addIssue("FORMAT_PARAMS_INVALID: a TIME entry requires targetTimeSeconds");
+    }
+  }
+}
+var EMOM_WINDOW_MIN_SECONDS = 30;
+var EMOM_WINDOW_MAX_SECONDS = 300;
+function clampEmomWindowSeconds(proposed) {
+  return Math.min(Math.max(proposed, EMOM_WINDOW_MIN_SECONDS), EMOM_WINDOW_MAX_SECONDS);
+}
+var FormatParamsSchema = z2.discriminatedUnion("workoutType", [
+  z2.object({
+    workoutType: z2.literal("CIRCUIT"),
+    rounds: z2.number().int().min(1).optional().default(3),
+    restSeconds: z2.number().int().min(0).optional().default(60),
+    exercises: z2.array(FormatExerciseEntrySchema).min(1).max(50)
+  }).strict().superRefine((val, ctx) => addTargetInvalidIssues(val.exercises, ctx)),
+  /**
+   * `rounds` is the TOTAL number of intervals across the whole workout, not
+   * per-station (Protocol §2.5, "Where the EMOM minute slot lives") — a station's
+   * minute slot is derived entirely from its `orderIndex` within `stations`.
+   *
+   * `windowSeconds` is passed through UNCHANGED — the MCP proposes what the coach
+   * means and does not alter the value (`134-21-PLAN.md:277`'s original mandate,
+   * restored by `T-134-21-01` after `134-21` clamped it here by mistake instead). The
+   * App normalizes it to the editor's stepper range at its own save boundary and
+   * REPORTS the normalization in `applied_payload` (`SaveNormalization`, Plan 134-45;
+   * Protocol v1.8 §2.5, `accepted_modified` per §5) — the window bends, visibly. A
+   * TIME station whose target is not strictly below the window still does NOT bend:
+   * it remains a `FORMAT_PARAMS_INVALID` refusal (D-03/T-123-03-01), exactly
+   * mirroring `FormatProposalApplier.validateParams`'s EMOM branch (Kotlin). That
+   * refusal rule compares against the NORMALIZED window (the helper declared above,
+   * not the raw field) — not an inconsistency, but the condition under which the MCP
+   * and the App's `SaveNormalization` decide every boundary case identically
+   * (T-134-21-03). Do not reintroduce a clamp on the field itself.
+   */
+  z2.object({
+    workoutType: z2.literal("EMOM"),
+    windowSeconds: z2.number().int().min(1).optional().default(60),
+    rounds: z2.number().int().min(1).optional().default(12),
+    stations: z2.array(FormatExerciseEntrySchema).min(1).max(50)
+  }).strict().superRefine((val, ctx) => {
+    addTargetInvalidIssues(val.stations, ctx);
+    const normalizedWindowSeconds = clampEmomWindowSeconds(val.windowSeconds);
+    for (const station of val.stations) {
+      if (station.mode === "TIME" && station.targetTimeSeconds != null && station.targetTimeSeconds >= normalizedWindowSeconds) {
+        ctx.addIssue("FORMAT_PARAMS_INVALID: a TIME station target must be strictly less than the (normalized) EMOM window");
+      }
+    }
+  }),
+  /** An AMRAP round is the `exercises` list itself, repeated until `timeCapMinutes` elapses. */
+  z2.object({
+    workoutType: z2.literal("AMRAP"),
+    timeCapMinutes: z2.number().int().min(1).optional().default(10),
+    exercises: z2.array(FormatExerciseEntrySchema).min(1).max(50)
+  }).strict().superRefine((val, ctx) => addTargetInvalidIssues(val.exercises, ctx)),
+  /** TABATA carries no per-entry mode or target — the work interval comes from
+   * `workSeconds` alone and the compiler sets `mode = TIME` on the authoring side.
+   * `exercises` therefore uses `formatSlotEntry`, which has no field for either —
+   * a payload entry carrying `mode` or `targetReps` is rejected by `.strict()`. */
+  z2.object({
+    workoutType: z2.literal("TABATA"),
+    workSeconds: z2.number().int().min(1).optional().default(20),
+    restSeconds: z2.number().int().min(0).optional().default(10),
+    rounds: z2.number().int().min(1).optional().default(8),
+    exercises: z2.array(FormatSlotEntrySchema).min(1).max(50)
+  }).strict(),
+  /**
+   * `repsPerRound` is AUTHORITATIVE — its length is the round count. `pattern`/
+   * `startReps`/`step` are generator inputs kept only so the wrapper's re-display
+   * can offer a starting point for further editing; they never regenerate the ramp
+   * (Protocol §2.5, "Where the ladder ramp lives") — a proposal that changes the
+   * progression changes `repsPerRound` directly.
+   */
+  z2.object({
+    workoutType: z2.literal("LADDER"),
+    pattern: z2.enum(["ASCENDING", "DESCENDING", "PYRAMID", "PYRAMID_REVERSE"]).optional().default("ASCENDING"),
+    startReps: z2.number().int().min(1).optional().default(1),
+    step: z2.number().int().min(1).optional().default(1),
+    restSeconds: z2.number().int().min(0).optional().default(60),
+    repsPerRound: z2.array(z2.number().int().min(1)).min(1).max(100),
+    exercises: z2.array(FormatWeightEntrySchema).min(1).max(50)
+  }).strict(),
+  z2.object({
+    workoutType: z2.literal("FOR_TIME"),
+    rounds: z2.number().int().min(1).optional().default(1),
+    raceTimer: z2.boolean().optional().default(true),
+    exercises: z2.array(FormatExerciseEntrySchema).min(1).max(50)
+  }).strict().superRefine((val, ctx) => addTargetInvalidIssues(val.exercises, ctx)),
+  /**
+   * Shares FOR_TIME's schema exactly (Protocol §2.5) — INCLUDING `rounds`, even
+   * though the app always overwrites it to `1` at apply time
+   * (`FormatProposalApplier.toChipperParams`, Kotlin). `rounds` stays on the wire
+   * deliberately: the frozen shared corpus's `chipper-rounds-normalized-not-rejected`
+   * vector carries `rounds: 3`, and `ProposalPayloadParser`'s `ignoreUnknownKeys =
+   * false` means omitting the field here would make that ACCEPTED corpus vector
+   * fail to parse on the Kotlin side's decoder — the two enforcement points must
+   * decode the identical wire shape. `rounds` is deliberately NOT validated as a
+   * `FORMAT_PARAMS_INVALID` condition (Protocol §2.5, "Normalizing rather than
+   * rejecting CHIPPER's rounds") — any value is accepted; the app normalizes it.
+   *
+   * WR-03 (134-REVIEW.md): unlike every sibling member's `rounds` field, this one
+   * deliberately has NO `.min(1)` — `FormatProposalApplier.validateParams`'s CHIPPER
+   * branch (Kotlin) never checks `rounds` at all, so `rounds: 0` or a negative value
+   * must reach the app to be normalized to `1`, not be refused here before the coach
+   * can even propose it. A `.min(1)` here would make the MCP strictly MORE restrictive
+   * than the documented, Kotlin-enforced contract this schema is supposed to mirror.
+   */
+  z2.object({
+    workoutType: z2.literal("CHIPPER"),
+    rounds: z2.number().int().optional().default(1),
+    raceTimer: z2.boolean().optional().default(true),
+    exercises: z2.array(FormatExerciseEntrySchema).min(1).max(50)
+  }).strict().superRefine((val, ctx) => addTargetInvalidIssues(val.exercises, ctx)),
+  /** Same shape as LADDER minus `pattern`: an ascending ladder run per-minute until
+   * failure. `roundCap` is a forward-compatibility bound with no wrapper UI element. */
+  z2.object({
+    workoutType: z2.literal("DEATH_BY"),
+    startReps: z2.number().int().min(1).optional().default(1),
+    step: z2.number().int().min(1).optional().default(1),
+    roundCap: z2.number().int().min(1).optional().default(30),
+    exercises: z2.array(FormatWeightEntrySchema).min(1).max(50)
+  }).strict()
+]);
+function formatParamsEntries(formatParams) {
+  switch (formatParams.workoutType) {
+    case "CIRCUIT":
+      return formatParams.exercises;
+    case "EMOM":
+      return formatParams.stations;
+    case "AMRAP":
+      return formatParams.exercises;
+    case "TABATA":
+      return formatParams.exercises;
+    case "LADDER":
+      return formatParams.exercises;
+    case "FOR_TIME":
+      return formatParams.exercises;
+    case "CHIPPER":
+      return formatParams.exercises;
+    case "DEATH_BY":
+      return formatParams.exercises;
+  }
+}
+var ProposePlanUpdateSchema = z2.object({
+  templateId: UUID_STRING,
+  rationale: z2.string().min(1).max(2e3),
+  newExercises: z2.array(NewExerciseDefSchema).max(20).optional(),
+  ops: z2.array(PlanOpSchema).max(50).optional(),
+  formatParams: FormatParamsSchema.optional()
+}).refine(
+  (d) => {
+    const definedTempIds = new Set((d.newExercises ?? []).map((e) => e.tempId));
+    const referencedTempIds = (d.ops ?? []).filter((op) => op.op === "addExercise" && op.exercise.source === "new").map((op) => op.exercise.tempId);
+    return referencedTempIds.every((id) => definedTempIds.has(id));
+  },
+  { message: 'Every addExercise op with source:"new" must reference a tempId defined in newExercises[]' }
+).refine(
+  (d) => {
+    const ids = (d.newExercises ?? []).map((e) => e.tempId);
+    return new Set(ids).size === ids.length;
+  },
+  { message: "newExercises[].tempId values must be unique" }
+).superRefine((d, ctx) => {
+  const hasOps = (d.ops ?? []).length > 0;
+  const hasFormatParams = d.formatParams !== void 0;
+  if (hasOps && hasFormatParams) {
+    ctx.addIssue("OPS_AND_FORMAT_PARAMS_EXCLUSIVE: a proposal may carry ops[] or formatParams, never both");
+  } else if (!hasOps && !hasFormatParams) {
+    ctx.addIssue("FORMAT_PARAMS_REQUIRED: a proposal must carry a non-empty ops[] or formatParams");
+  }
+}).superRefine((d, ctx) => {
+  if (d.formatParams === void 0) {
+    return;
+  }
+  const definedTempIds = new Set((d.newExercises ?? []).map((e) => e.tempId));
+  for (const entry of formatParamsEntries(d.formatParams)) {
+    if (entry.exercise.source === "new" && !definedTempIds.has(entry.exercise.tempId)) {
+      ctx.addIssue(
+        `FORMAT_PARAMS_INVALID: a formatParams entry references a tempId not declared in newExercises[] (${entry.exercise.tempId})`
+      );
+    }
+  }
+});
+var ProposeNewPlanSchema = z2.object({
+  name: z2.string().min(1).max(200),
+  rationale: z2.string().min(1).max(2e3),
+  newExercises: z2.array(NewExerciseDefSchema).max(20).optional(),
+  blocks: z2.array(
+    z2.object({
+      tempBlockId: z2.string().min(1).max(64),
+      // LLM-facing placeholder, mirrors tempId pattern
+      rounds: z2.number().int().min(1),
+      orderIndex: z2.number().int().min(0),
+      exercises: z2.array(
+        z2.object({
+          exercise: ExerciseRefSchema,
+          mode: z2.enum(["REPS", "TIME", "MAX"]),
+          targetReps: z2.number().int().min(0).optional(),
+          targetTimeSeconds: z2.number().int().min(0).optional(),
+          restTimeSeconds: z2.number().int().min(0),
+          sets: z2.number().int().min(1),
+          targetWeight: z2.number().min(0).optional(),
+          orderIndex: z2.number().int().min(0),
+          roundTargets: z2.array(RoundTargetInputSchema).max(50).optional()
+        })
+      ).min(1).max(50)
+    })
+  ).min(1).max(20)
+}).refine(
+  (d) => {
+    const definedTempIds = new Set((d.newExercises ?? []).map((e) => e.tempId));
+    return d.blocks.every(
+      (b) => b.exercises.every(
+        (ex) => ex.exercise.source !== "new" || definedTempIds.has(ex.exercise.tempId)
+      )
+    );
+  },
+  { message: 'Every exercise ref with source:"new" must reference a tempId defined in newExercises[]' }
+).refine(
+  (d) => {
+    const ids = (d.newExercises ?? []).map((e) => e.tempId);
+    return new Set(ids).size === ids.length;
+  },
+  { message: "newExercises[].tempId values must be unique" }
+).refine(
+  (d) => {
+    const ids = d.blocks.map((b) => b.tempBlockId);
+    return new Set(ids).size === ids.length;
+  },
+  { message: "blocks[].tempBlockId values must be unique" }
+);
+var ProposeNewExerciseSchema = z2.object({
+  name: z2.string().min(1).max(200),
+  mode: z2.enum(["REPS", "TIME", "MAX"]),
+  usesWeight: z2.boolean(),
+  rationale: z2.string().min(1).max(2e3),
+  description: z2.string().max(2e3).optional()
+});
+var ProposePlannedUpdateSchema = z2.discriminatedUnion("intent", [
+  z2.object({
+    intent: z2.literal("move_occurrence"),
+    rootId: UUID_STRING,
+    occurrenceDate: ISO_DATE,
+    newDate: ISO_DATE,
+    newTime: z2.string().optional(),
+    rationale: z2.string().min(1).max(2e3)
+  }),
+  z2.object({
+    intent: z2.literal("cancel_occurrence"),
+    rootId: UUID_STRING,
+    occurrenceDate: ISO_DATE,
+    rationale: z2.string().min(1).max(2e3)
+  }),
+  z2.object({
+    intent: z2.literal("schedule_workout"),
+    templateId: UUID_STRING.optional(),
+    chainSuggestionId: UUID_STRING.optional(),
+    date: ISO_DATE,
+    time: z2.string().optional(),
+    recurrenceRule: z2.string().optional(),
+    rationale: z2.string().min(1).max(2e3)
+  }).superRefine((d, ctx) => {
+    const hasTemplateId = d.templateId !== void 0;
+    const hasChain = d.chainSuggestionId !== void 0;
+    if (hasTemplateId === hasChain) {
+      ctx.addIssue(
+        "CHAIN_EXCLUSIVITY: schedule_workout requires exactly one of templateId or chainSuggestionId, never both, never neither"
+      );
+    }
+  }),
+  z2.object({
+    intent: z2.literal("change_series_rule"),
+    rootId: UUID_STRING,
+    scope: z2.enum(["this_and_following", "whole_series"]),
+    newRecurrenceRule: z2.string().min(1),
+    cutoffDate: ISO_DATE.optional(),
+    rationale: z2.string().min(1).max(2e3)
+  }).superRefine((val, ctx) => {
+    if (val.scope === "this_and_following" && val.cutoffDate === void 0) {
+      ctx.addIssue("cutoffDate is required when scope is this_and_following");
+    }
+  })
+]);
+var SUGGESTION_STATUS = z2.enum([
+  "pending",
+  "accepted",
+  "accepted_modified",
+  "rejected",
+  "expired",
+  "withdrawn",
+  "obsolete"
+]);
+var GetSuggestionsSchema = z2.object({
+  status: SUGGESTION_STATUS.optional(),
+  limit: z2.number().int().optional()
+});
+var GetSuggestionSchema = z2.object({
+  id: UUID_STRING
+});
+var WithdrawSuggestionSchema = z2.object({
+  id: UUID_STRING
+});
+var GetCoachParametersSchema = z2.object({});
+var SetCoachParametersSchema = CoachParametersSchema;
+
+// src/crypto.ts
+import { createDecipheriv } from "crypto";
+function decrypt(encryptedJson, keyBase64) {
+  const { iv: ivB64, ct: ctB64 } = JSON.parse(encryptedJson);
+  const key = Buffer.from(keyBase64, "base64");
+  const iv = Buffer.from(ivB64, "base64");
+  const ctBuf = Buffer.from(ctB64, "base64");
+  const decipher = createDecipheriv("aes-256-gcm", key, iv);
+  decipher.setAuthTag(ctBuf.subarray(-16));
+  const plaintext = Buffer.concat([
+    decipher.update(ctBuf.subarray(0, -16)),
+    // actual ciphertext (without tag)
+    decipher.final()
+    // throws on GCM auth failure
+  ]);
+  return plaintext.toString("utf8");
+}
+
+// src/cache.ts
+var TTL_MS = 6e4;
+var cached = null;
+var inflightPromise = null;
+function decryptSession(s, keyB642) {
+  const { encryptedPayload, startTime, endTime, ...rest } = s;
+  if (encryptedPayload) {
+    const d = JSON.parse(decrypt(encryptedPayload, keyB642));
+    return {
+      ...rest,
+      startTime: d.st,
+      endTime: d.et > 0 ? d.et : void 0
+    };
+  }
+  return { ...rest, startTime, endTime };
+}
+function decryptSetLog(sl, keyB642) {
+  const {
+    encryptedPayload,
+    completedReps,
+    completedTimeSeconds,
+    weightUsed,
+    startedAt,
+    measuredTimeSeconds,
+    ...rest
+  } = sl;
+  if (encryptedPayload) {
+    const d = JSON.parse(decrypt(encryptedPayload, keyB642));
+    return {
+      ...rest,
+      completedReps: d.r ?? null,
+      completedTimeSeconds: d.t ?? null,
+      weightUsed: d.w ?? null,
+      startedAt: d.sa ?? null,
+      measuredTimeSeconds: d.mt ?? null
+    };
+  }
+  return {
+    ...rest,
+    completedReps: completedReps ?? null,
+    completedTimeSeconds: completedTimeSeconds ?? null,
+    weightUsed: weightUsed ?? null,
+    startedAt: startedAt ?? null,
+    measuredTimeSeconds: measuredTimeSeconds ?? null
+  };
+}
+function decryptHrSample(hr, keyB642) {
+  const { encryptedPayload, timestampMs, bpm, ...rest } = hr;
+  if (encryptedPayload) {
+    const d = JSON.parse(decrypt(encryptedPayload, keyB642));
+    return { ...rest, timestampMs: d.ts, bpm: d.bpm };
+  }
+  return { ...rest, timestampMs, bpm };
+}
+function decryptPlannedWorkout(row, keyB642) {
+  if (!row.encryptedPayload) {
+    throw new Error(
+      `planned_workout row ${row.id} arrived with an empty encryptedPayload \u2014 this is the tombstone shape the server should already filter out of plannedWorkouts (133 D-03); the pull contract may have changed`
+    );
+  }
+  const plaintext = JSON.parse(decrypt(row.encryptedPayload, keyB642));
+  if (plaintext.v !== 1) {
+    throw new Error(`planned_workout row ${row.id} has unknown schema version v=${plaintext.v}`);
+  }
+  return {
+    id: plaintext.id,
+    templateId: plaintext.templateId,
+    scheduledDate: plaintext.scheduledDate,
+    scheduledTime: plaintext.scheduledTime ?? null,
+    note: plaintext.note ?? null,
+    recurrenceRule: plaintext.recurrenceRule ?? null,
+    recurrenceGroupId: plaintext.recurrenceGroupId ?? null,
+    deletedOccurrencesRaw: plaintext.deletedOccurrences ?? null,
+    completedSessionId: plaintext.completedSessionId ?? null
+    // calendarEventId, createdAt: D-06 — deliberately not copied; the type has no
+    // field to carry them.
+  };
+}
+function decryptSetting(row, keyB642) {
+  if (!row.encryptedPayload) {
+    throw new Error(
+      `settings row ${row.id} (key "${row.clientLocalId}") arrived with an empty encryptedPayload \u2014 this is the tombstone shape the server should already filter out of settings; the pull contract may have changed`
+    );
+  }
+  const plaintext = JSON.parse(decrypt(row.encryptedPayload, keyB642));
+  if (plaintext.v !== 1) {
+    throw new Error(`settings row ${row.id} (key "${row.clientLocalId}") has unknown schema version v=${plaintext.v}`);
+  }
+  if (!plaintext.t) {
+    throw new Error(`settings row ${row.id} (key "${row.clientLocalId}") is missing its type tag`);
+  }
+  return { key: row.clientLocalId, type: plaintext.t, value: plaintext.value };
+}
+function normalizeWireBlock(b) {
+  return { ...b, rounds: b.rounds ?? 1 };
+}
+function normalizeWireTemplateExercise(te) {
+  return { ...te, sets: te.sets ?? 1, exerciseSource: te.exerciseSource ?? "CATALOG" };
+}
+function decryptMerge(raw, keyB642) {
+  return {
+    syncedAt: raw.syncedAt,
+    exercises: raw.exercises,
+    exerciseTranslations: raw.exerciseTranslations,
+    templates: raw.templates,
+    blocks: raw.blocks.map(normalizeWireBlock),
+    templateExercises: raw.templateExercises.map(normalizeWireTemplateExercise),
+    sessions: raw.sessions.map((s) => decryptSession(s, keyB642)),
+    setLogs: raw.setLogs.map((sl) => decryptSetLog(sl, keyB642)),
+    hrSamples: raw.hrSamples.map((hr) => decryptHrSample(hr, keyB642)),
+    // `?? []` is what makes the optional wire key (SyncPullResponse.plannedWorkouts)
+    // safe for a user with no planned workouts — see that field's own doc in types.ts.
+    plannedWorkouts: (raw.plannedWorkouts ?? []).map((pw) => decryptPlannedWorkout(pw, keyB642)),
+    // `?? []` — same reasoning as plannedWorkouts above, for a user with no synced settings.
+    settings: (raw.settings ?? []).map((s) => decryptSetting(s, keyB642))
+  };
+}
+function normalizeCatalog(wireCatalog) {
+  return wireCatalog.map((ex) => ({
+    ...ex,
+    capabilities: ex.capabilities ?? [],
+    equipment: ex.equipment ?? [],
+    isSkill: ex.isSkill ?? false
+  }));
+}
+async function doFetch(pat2, keyB642, serverUrl2) {
+  const [rawSnapshot, profile, rawCatalog] = await Promise.all([
+    fetchSnapshot(pat2, serverUrl2),
+    fetchProfile(pat2, serverUrl2),
+    fetchCatalog(serverUrl2)
+  ]);
+  const snapshot = decryptMerge(rawSnapshot, keyB642);
+  const catalog = normalizeCatalog(rawCatalog);
+  return { snapshot, catalog, profile, fetchedAt: Date.now() };
+}
+async function getSnapshot(pat2, keyB642, serverUrl2) {
+  const now = Date.now();
+  if (cached && now - cached.fetchedAt < TTL_MS) return cached;
+  if (inflightPromise) return inflightPromise;
+  inflightPromise = doFetch(pat2, keyB642, serverUrl2).finally(() => {
+    inflightPromise = null;
+  });
+  cached = await inflightPromise;
+  return cached;
+}
+
+// src/file-channel.ts
+import { mkdir, readdir, stat, unlink, writeFile } from "fs/promises";
+import { randomUUID } from "crypto";
+import { tmpdir } from "os";
+import { join } from "path";
+var EXPORT_DIR = join(tmpdir(), "calicomp-mcp-exports");
+var EXPORT_TTL_MS = 24 * 60 * 60 * 1e3;
+async function writeExportFile(payload, itemCount, dir = EXPORT_DIR) {
+  await mkdir(dir, { recursive: true });
+  const json = JSON.stringify(payload);
+  const path = join(dir, `${randomUUID()}.json`);
+  await writeFile(path, json, { mode: 384 });
+  return { path, bytes: Buffer.byteLength(json), itemCount };
+}
+async function pruneExports(now = Date.now(), dir = EXPORT_DIR) {
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return 0;
+  }
+  let deleted = 0;
+  for (const entry of entries) {
+    const entryPath = join(dir, entry);
+    try {
+      const info = await stat(entryPath);
+      if (now - info.mtimeMs > EXPORT_TTL_MS) {
+        await unlink(entryPath);
+        deleted++;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return deleted;
+}
+
+// src/tools/get_history.ts
+function getHistory(args, snapshot) {
+  const { from, to, exercise, limit } = args;
+  const fromEpoch = new Date(from).getTime();
+  const toEpoch = (/* @__PURE__ */ new Date(to + "T23:59:59.999Z")).getTime();
+  let sessions = snapshot.sessions.filter(
+    (s) => s.startTime >= fromEpoch && s.startTime <= toEpoch
+  );
+  if (exercise !== void 0) {
+    const sessionIdsWithExercise = new Set(
+      snapshot.setLogs.filter((sl) => sl.exerciseId === exercise).map((sl) => sl.sessionId)
+    );
+    sessions = sessions.filter((s) => sessionIdsWithExercise.has(s.id));
+  }
+  sessions = [...sessions].sort((a, b) => b.startTime - a.startTime);
+  sessions = sessions.slice(0, limit);
+  const retainedSessionIds = new Set(sessions.map((s) => s.id));
+  const setLogs = snapshot.setLogs.filter(
+    (sl) => retainedSessionIds.has(sl.sessionId)
+  );
+  return { sessions, setLogs };
+}
+function registerToolGetHistory(server2, cfg) {
+  const { pat: pat2, keyB64: keyB642, serverUrl: serverUrl2 } = cfg;
+  server2.registerTool(
+    "get_history",
+    {
+      title: "Get Workout History",
+      description: "Return sessions and set-logs within a date range (YYYY-MM-DD), newest-first, for a TARGETED detail lookup \u2014 a specific window, a specific exercise. For the athlete's overall standing, call `get_training_state` first; use this tool once you need the underlying raw sessions and set-logs. Optionally filter by exercise UUID. Results are capped by `limit` (default 200, max 500). Set `outputFile: true` to write the full result to a local file instead of returning it inline \u2014 the tool result then reports only the file path, byte size and item count.",
+      inputSchema: GetHistorySchema,
+      annotations: { readOnlyHint: true }
+    },
+    async (args) => {
+      try {
+        const data = await getSnapshot(pat2, keyB642, serverUrl2);
+        const result = getHistory(args, data.snapshot);
+        if (args.outputFile) {
+          const itemCount = result.sessions.length + result.setLogs.length;
+          const handle = await writeExportFile(result, itemCount);
+          const summary = {
+            outputFile: { path: handle.path, bytes: handle.bytes, itemCount: handle.itemCount },
+            from: args.from,
+            to: args.to,
+            exercise: args.exercise,
+            limit: args.limit
+          };
+          return { content: [{ type: "text", text: JSON.stringify(summary) }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `History error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/e1rm.ts
+var REP_CAP = 12;
+function setE1rm(weightKg, reps) {
+  const w = weightKg ?? 0;
+  const r = reps ?? 0;
+  if (w <= 0 || r < 1) return null;
+  return w * (1 + Math.min(r, REP_CAP) / 30);
+}
+function bestE1rm(sets) {
+  let best = null;
+  for (const s of sets) {
+    const e = setE1rm(s.weightUsed, s.completedReps);
+    if (e !== null && (best === null || e > best)) best = e;
+  }
+  return best;
+}
+
+// src/training-state/muscle-balance.ts
+var MUSCLE_TO_RADAR_CATEGORY = {
+  chest: "chest",
+  back: "back",
+  lats: "back",
+  traps: "back",
+  lower_back: "back",
+  neck: "back",
+  quads: "legs",
+  hamstrings: "legs",
+  glutes: "legs",
+  calves: "legs",
+  adductors: "legs",
+  hip_flexors: "legs",
+  shoulders: "shoulders",
+  biceps: "arms",
+  triceps: "arms",
+  forearms: "arms",
+  abs: "core",
+  obliques: "core"
+};
+var RADAR_CATEGORIES = ["chest", "shoulders", "back", "legs", "core", "arms"];
+function toRadarValues(muscleSetCounts) {
+  const categorySums = {};
+  for (const category of RADAR_CATEGORIES) categorySums[category] = 0;
+  for (const [muscleKey, sets] of Object.entries(muscleSetCounts)) {
+    const category = MUSCLE_TO_RADAR_CATEGORY[muscleKey];
+    if (category === void 0) continue;
+    categorySums[category] = (categorySums[category] ?? 0) + sets;
+  }
+  const maxVal = Math.max(...RADAR_CATEGORIES.map((category) => categorySums[category]));
+  if (maxVal === 0) {
+    const zeroed = {};
+    for (const category of RADAR_CATEGORIES) zeroed[category] = 0;
+    return zeroed;
+  }
+  const result = {};
+  for (const category of RADAR_CATEGORIES) result[category] = categorySums[category] / maxVal;
+  return result;
+}
+var WEIGHT_PRIMARY = 1;
+var WEIGHT_SECONDARY = 0.5;
+var WEIGHT_STABILIZER = 0.25;
+function weightFor(level) {
+  switch (level) {
+    case "SECONDARY":
+      return WEIGHT_SECONDARY;
+    case "STABILIZER":
+      return WEIGHT_STABILIZER;
+    case "PRIMARY":
+    case null:
+    case void 0:
+      return WEIGHT_PRIMARY;
+  }
+}
+function muscleSetCountsInPeriod(snapshot, catalog, sinceMs) {
+  const catalogById = new Map(catalog.map((ex) => [ex.id, ex]));
+  const templateExerciseById = new Map(snapshot.templateExercises.map((te) => [te.id, te]));
+  const sessionById = new Map(snapshot.sessions.map((s) => [s.id, s]));
+  const counts = {};
+  for (const setLog of snapshot.setLogs) {
+    if (setLog.deletedAt !== void 0) continue;
+    const session = sessionById.get(setLog.sessionId);
+    if (session === void 0) continue;
+    if (session.deletedAt !== void 0) continue;
+    if (session.endTime === void 0) continue;
+    if (setLog.createdAt < sinceMs) continue;
+    const exerciseId = setLog.exerciseId ?? (setLog.workoutExerciseId !== void 0 ? templateExerciseById.get(setLog.workoutExerciseId)?.exerciseId : void 0);
+    if (exerciseId === void 0) continue;
+    const exercise = catalogById.get(exerciseId);
+    if (exercise === void 0) continue;
+    for (const muscleGroup of exercise.muscleGroups) {
+      counts[muscleGroup.key] = (counts[muscleGroup.key] ?? 0) + weightFor(muscleGroup.involvementLevel);
+    }
+  }
+  return counts;
+}
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+function computeMuscleBalance(snapshot, catalog, nowMs) {
+  const windowFor = (sinceMs) => {
+    const setCounts = muscleSetCountsInPeriod(snapshot, catalog, sinceMs);
+    return { setCounts, radar: toRadarValues(setCounts) };
+  };
+  return {
+    last7Days: windowFor(nowMs - 7 * MS_PER_DAY),
+    last30Days: windowFor(nowMs - 30 * MS_PER_DAY),
+    allTime: windowFor(0)
+  };
+}
+
+// src/training-state/capability-balance.ts
+var WEIGHT_HAUPTREIZ = 1;
+var WEIGHT_MITTRAINIERT = 0.5;
+var WEIGHT_GERING = 0.25;
+function weightFor2(level) {
+  switch (level) {
+    case "HAUPTREIZ":
+      return WEIGHT_HAUPTREIZ;
+    case "MITTRAINIERT":
+      return WEIGHT_MITTRAINIERT;
+    case "GERING":
+      return WEIGHT_GERING;
+    case null:
+    case void 0:
+      throw new Error(
+        "capability-balance.weightFor: level must not be null/undefined \u2014 a present exercise_capabilities row always carries an explicit level (D-04 of Phase 138.1). A missing level here is a bug, not a valid default."
+      );
+  }
+}
+function weightedCounts(rows) {
+  const sums = {};
+  for (const row of rows) {
+    const contribution = row.setCount * weightFor2(row.capabilityLevel);
+    sums[row.capabilityAxisKey] = (sums[row.capabilityAxisKey] ?? 0) + contribution;
+  }
+  return sums;
+}
+
+// src/tools/get_stats.ts
+function computeAggregates(matchingSetLogs, snapshot) {
+  if (matchingSetLogs.length === 0) {
+    return {
+      bestE1rm: null,
+      totalVolume: 0,
+      avgVolumePerSession: 0,
+      setCount: 0,
+      sessionCount: 0,
+      firstSessionDate: null,
+      lastSessionDate: null,
+      trend: null
+    };
+  }
+  const touchedSessionIds = new Set(matchingSetLogs.map((sl) => sl.sessionId));
+  const touchedSessions = snapshot.sessions.filter((s) => touchedSessionIds.has(s.id)).sort((a, b) => a.startTime - b.startTime);
+  const sessionCount = touchedSessions.length;
+  const overallBestE1rm = bestE1rm(matchingSetLogs);
+  let totalVolume = 0;
+  for (const sl of matchingSetLogs) {
+    const w = sl.weightUsed;
+    const r = sl.completedReps;
+    if (w !== null && w > 0 && r !== null && r > 0) {
+      totalVolume += r * w;
+    }
+  }
+  const avgVolumePerSession = sessionCount > 0 ? totalVolume / sessionCount : 0;
+  const firstSession = touchedSessions[0];
+  const lastSession = touchedSessions[touchedSessions.length - 1];
+  const firstSessionDate = firstSession ? new Date(firstSession.startTime).toISOString().slice(0, 10) : null;
+  const lastSessionDate = lastSession ? new Date(lastSession.startTime).toISOString().slice(0, 10) : null;
+  let trend = null;
+  if (touchedSessions.length > 0) {
+    const points = touchedSessions.map((session) => {
+      const sessionLogs = matchingSetLogs.filter((sl) => sl.sessionId === session.id);
+      return {
+        date: new Date(session.startTime).toISOString().slice(0, 10),
+        sessionId: session.id,
+        e1rm: bestE1rm(sessionLogs)
+      };
+    });
+    const firstE1rm = points[0].e1rm;
+    const lastE1rm = points[points.length - 1].e1rm;
+    const delta = firstE1rm !== null && lastE1rm !== null ? lastE1rm - firstE1rm : null;
+    trend = { firstE1rm, lastE1rm, delta, points };
+  }
+  return {
+    bestE1rm: overallBestE1rm,
+    totalVolume,
+    avgVolumePerSession,
+    setCount: matchingSetLogs.length,
+    sessionCount,
+    firstSessionDate,
+    lastSessionDate,
+    trend
+  };
+}
+function getStatsByExercise(args, data) {
+  const matchingSetLogs = data.snapshot.setLogs.filter(
+    (sl) => sl.exerciseId === args.exerciseId
+  );
+  return {
+    by: "exercise",
+    exerciseId: args.exerciseId,
+    ...computeAggregates(matchingSetLogs, data.snapshot)
+  };
+}
+function getStatsByMuscle(args, data) {
+  const matchingExerciseIds = [];
+  const weightByExerciseId = /* @__PURE__ */ new Map();
+  for (const ex of data.catalog) {
+    const muscleGroup = ex.muscleGroups.find((mg) => mg.key === args.muscle);
+    if (muscleGroup === void 0) continue;
+    matchingExerciseIds.push(ex.id);
+    weightByExerciseId.set(ex.id, weightFor(muscleGroup.involvementLevel));
+  }
+  const matchingExerciseIdSet = new Set(matchingExerciseIds);
+  const matchingSetLogs = data.snapshot.setLogs.filter(
+    (sl) => sl.exerciseId !== void 0 && matchingExerciseIdSet.has(sl.exerciseId)
+  );
+  let weightedSetCount = 0;
+  for (const sl of matchingSetLogs) {
+    weightedSetCount += weightByExerciseId.get(sl.exerciseId) ?? 0;
+  }
+  return {
+    by: "muscle",
+    muscle: args.muscle,
+    matchingExerciseIds,
+    weightedSetCount,
+    ...computeAggregates(matchingSetLogs, data.snapshot)
+  };
+}
+function getStatsByCapabilities(data) {
+  const axisNames = /* @__PURE__ */ new Map();
+  const capabilitiesByExerciseId = /* @__PURE__ */ new Map();
+  for (const ex of data.catalog) {
+    if (ex.capabilities.length === 0) continue;
+    capabilitiesByExerciseId.set(ex.id, ex.capabilities);
+    for (const axis of ex.capabilities) {
+      if (axisNames.has(axis.key)) continue;
+      const nameEn = axis.translations.find((t) => t.languageCode === "en")?.name ?? axis.key;
+      const nameDe = axis.translations.find((t) => t.languageCode === "de")?.name ?? axis.key;
+      axisNames.set(axis.key, { nameEn, nameDe });
+    }
+  }
+  const accByAxis = /* @__PURE__ */ new Map();
+  const accumulatorFor = (key) => {
+    let acc = accByAxis.get(key);
+    if (acc === void 0) {
+      acc = { setCount: 0, sessionIds: /* @__PURE__ */ new Set(), exerciseIds: /* @__PURE__ */ new Set(), lastSessionStart: null };
+      accByAxis.set(key, acc);
+    }
+    return acc;
+  };
+  const allRows = [];
+  const sessionById = new Map(data.snapshot.sessions.map((s) => [s.id, s]));
+  for (const setLog of data.snapshot.setLogs) {
+    if (setLog.exerciseId === void 0) continue;
+    const axes2 = capabilitiesByExerciseId.get(setLog.exerciseId);
+    if (axes2 === void 0) continue;
+    const session = sessionById.get(setLog.sessionId);
+    for (const axis of axes2) {
+      allRows.push({ capabilityAxisKey: axis.key, capabilityLevel: axis.capabilityLevel, setCount: 1 });
+      const acc = accumulatorFor(axis.key);
+      acc.setCount += 1;
+      acc.exerciseIds.add(setLog.exerciseId);
+      if (session !== void 0) {
+        acc.sessionIds.add(session.id);
+        if (acc.lastSessionStart === null || session.startTime > acc.lastSessionStart) {
+          acc.lastSessionStart = session.startTime;
+        }
+      }
+    }
+  }
+  const weightedByAxis = weightedCounts(allRows);
+  const axes = [];
+  for (const [key, names] of axisNames) {
+    const acc = accByAxis.get(key);
+    axes.push({
+      key,
+      nameEn: names.nameEn,
+      nameDe: names.nameDe,
+      setCount: acc?.setCount ?? 0,
+      weightedSetCount: weightedByAxis[key] ?? 0,
+      sessionCount: acc?.sessionIds.size ?? 0,
+      contributingExerciseIds: acc !== void 0 ? [...acc.exerciseIds] : [],
+      lastSessionDate: acc?.lastSessionStart !== null && acc?.lastSessionStart !== void 0 ? new Date(acc.lastSessionStart).toISOString().slice(0, 10) : null
+    });
+  }
+  return { by: "capabilities", axes };
+}
+function getStats(args, data) {
+  if (args.by === "exercise") {
+    return getStatsByExercise(args, data);
+  }
+  if (args.by === "muscle") {
+    return getStatsByMuscle(args, data);
+  }
+  return getStatsByCapabilities(data);
+}
+function registerToolGetStats(server2, cfg) {
+  const { pat: pat2, keyB64: keyB642, serverUrl: serverUrl2 } = cfg;
+  server2.registerTool(
+    "get_stats",
+    {
+      title: "Get Training Stats",
+      description: 'Compute app-consistent training statistics (e1RM, volume, set/session counts, trend) for a specific exercise (`by: "exercise"`) or all exercises targeting a muscle group (`by: "muscle"`), or break down over every capability axis at once with no further argument (`by: "capabilities"` \u2014 balance, mobility, breath, etc.). e1RM uses the same Epley formula as the app. `trend.points` carries the full per-session e1RM series alongside the existing first-vs-last delta.',
+      inputSchema: GetStatsSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async (args) => {
+      try {
+        const data = await getSnapshot(pat2, keyB642, serverUrl2);
+        const result = getStats(args, {
+          snapshot: data.snapshot,
+          catalog: data.catalog
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Stats error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/get_profile.ts
+function getProfile(profile) {
+  return profile;
+}
+function registerToolGetProfile(server2, cfg) {
+  const { pat: pat2, keyB64: keyB642, serverUrl: serverUrl2 } = cfg;
+  server2.registerTool(
+    "get_profile",
+    {
+      title: "Get User Profile",
+      description: "Return the authenticated user's profile: email, displayName, avatarUrl, isPremium, and account createdAt epoch.",
+      inputSchema: GetProfileSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      try {
+        const data = await getSnapshot(pat2, keyB642, serverUrl2);
+        const result = getProfile(data.profile);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Profile error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/list_templates.ts
+function listTemplates(snapshot) {
+  return snapshot.templates.filter((t) => t.deletedAt == null).map((t) => ({
+    id: t.id,
+    name: t.name,
+    isFavoriteForWatch: t.isFavoriteForWatch,
+    blockCount: snapshot.blocks.filter((b) => b.templateId === t.id).length,
+    exerciseCount: snapshot.templateExercises.filter((te) => te.templateId === t.id).length,
+    // CR-01 (134-REVIEW.md): `!= null` catches both `undefined` (CLASSIC/pre-Phase-134 row)
+    // and `null` (a post-migration row not yet re-synced — the server emits an explicit wire
+    // `null`, see SyncTemplateDto's KDoc) — a strict `!== undefined` let `null` through verbatim.
+    ...t.workoutType != null ? { workoutType: t.workoutType } : {}
+  }));
+}
+function registerToolListTemplates(server2, cfg) {
+  const { pat: pat2, keyB64: keyB642, serverUrl: serverUrl2 } = cfg;
+  server2.registerTool(
+    "list_templates",
+    {
+      title: "List Workout Templates",
+      description: "Return all non-deleted workout templates with their block and exercise counts. Use `get_template` to fetch a specific template's full detail (blocks + exercises).",
+      inputSchema: ListTemplatesSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      try {
+        const data = await getSnapshot(pat2, keyB642, serverUrl2);
+        const result = listTemplates(data.snapshot);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `List templates error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/get_template.ts
+function getTemplate(args, snapshot) {
+  const template = snapshot.templates.find((t) => t.id === args.templateId);
+  if (!template) return null;
+  const blocks = snapshot.blocks.filter(
+    (b) => b.templateId === args.templateId
+  );
+  const templateExercises = snapshot.templateExercises.filter(
+    (te) => te.templateId === args.templateId
+  );
+  return {
+    id: template.id,
+    name: template.name,
+    isFavoriteForWatch: template.isFavoriteForWatch,
+    createdAt: template.createdAt,
+    updatedAt: template.updatedAt,
+    ...template.deletedAt !== void 0 ? { deletedAt: template.deletedAt } : {},
+    // CR-01 (134-REVIEW.md): `!= null` catches BOTH `undefined` (a pre-Phase-134/CLASSIC row,
+    // the key never existed) AND `null` (a post-migration row whose column has not been
+    // (re-)written since deploy, the server emits an explicit JSON `null` — see
+    // SyncTemplateDto's KDoc). A strict `!== undefined` check let a `null` through verbatim,
+    // violating this projection's declared `string`-only optional type.
+    ...template.workoutType != null ? { workoutType: template.workoutType } : {},
+    ...template.formatParams != null ? { formatParams: template.formatParams } : {},
+    blocks,
+    templateExercises
+  };
+}
+function registerToolGetTemplate(server2, cfg) {
+  const { pat: pat2, keyB64: keyB642, serverUrl: serverUrl2 } = cfg;
+  server2.registerTool(
+    "get_template",
+    {
+      title: "Get Workout Template",
+      description: "Return one workout template with its blocks and template-exercises joined. Pass the UUID from `list_templates`. Returns an error if the template is not found.",
+      inputSchema: GetTemplateSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async (args) => {
+      try {
+        const data = await getSnapshot(pat2, keyB642, serverUrl2);
+        const result = getTemplate(args, data.snapshot);
+        if (!result) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Template not found: ${args.templateId}` }]
+          };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Get template error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/get_exercise_catalog.ts
+function getExerciseCatalog(args, catalog) {
+  if (!args.lang) {
+    return catalog;
+  }
+  return catalog.map((ex) => {
+    const translation = ex.translations.find((t) => t.languageCode === args.lang);
+    return {
+      ...ex,
+      localizedName: translation ? translation.name : ex.nameEn
+    };
+  });
+}
+function registerToolGetExerciseCatalog(server2, cfg) {
+  const { pat: pat2, keyB64: keyB642, serverUrl: serverUrl2 } = cfg;
+  server2.registerTool(
+    "get_exercise_catalog",
+    {
+      title: "Get Exercise Catalog",
+      description: 'Return the full exercise catalog with muscle groups, equipment, and optional localized names. Provide `lang` (e.g. "de", "fr") to add a `localizedName` field (falls back to `nameEn` when no translation exists). Use `muscleGroups[].key` with `get_stats { by: "muscle" }` to query aggregates by muscle group.',
+      inputSchema: GetExerciseCatalogSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async (args) => {
+      try {
+        const data = await getSnapshot(pat2, keyB642, serverUrl2);
+        const result = getExerciseCatalog(args, data.catalog);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Exercise catalog error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/recurrence.ts
+var RRULE_DAY_ORDER = ["MO", "TU", "WE", "TH", "FR", "SA", "SU"];
+function epochDay(date) {
+  const yy = date.y - (date.m <= 2 ? 1 : 0);
+  const era = Math.floor((yy >= 0 ? yy : yy - 399) / 400);
+  const yoe = yy - era * 400;
+  const doy = Math.floor((153 * (date.m + (date.m > 2 ? -3 : 9)) + 2) / 5) + date.d - 1;
+  const doe = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + doy;
+  return era * 146097 + doe - 719468;
+}
+function fromEpochDay(epoch) {
+  const z3 = epoch + 719468;
+  const era = Math.floor((z3 >= 0 ? z3 : z3 - 146096) / 146097);
+  const doe = z3 - era * 146097;
+  const yoe = Math.floor(
+    (doe - Math.floor(doe / 1460) + Math.floor(doe / 36524) - Math.floor(doe / 146096)) / 365
+  );
+  const y = yoe + era * 400;
+  const doy = doe - (365 * yoe + Math.floor(yoe / 4) - Math.floor(yoe / 100));
+  const mp = Math.floor((5 * doy + 2) / 153);
+  const d = doy - Math.floor((153 * mp + 2) / 5) + 1;
+  const m = mp + (mp < 10 ? 3 : -9);
+  return { y: y + (m <= 2 ? 1 : 0), m, d };
+}
+function parseIsoDate(s) {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(s);
+  if (!match) throw new Error(`Invalid ISO date: "${s}"`);
+  const y = Number(match[1]);
+  const m = Number(match[2]);
+  const d = Number(match[3]);
+  if (m < 1 || m > 12) throw new Error(`Invalid ISO date: "${s}"`);
+  if (d < 1 || d > lengthOfMonth(y, m)) throw new Error(`Invalid ISO date: "${s}"`);
+  return { y, m, d };
+}
+function formatIsoDate(date) {
+  const y = String(date.y).padStart(4, "0");
+  const m = String(date.m).padStart(2, "0");
+  const d = String(date.d).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function plusDays(date, n) {
+  return fromEpochDay(epochDay(date) + n);
+}
+function plusWeeks(date, n) {
+  return plusDays(date, n * 7);
+}
+function lengthOfMonth(y, m) {
+  return new Date(Date.UTC(y, m, 0)).getUTCDate();
+}
+function plusMonths(date, n) {
+  const totalMonths = date.y * 12 + (date.m - 1) + n;
+  const y = Math.floor(totalMonths / 12);
+  const m = (totalMonths % 12 + 12) % 12 + 1;
+  const d = Math.min(date.d, lengthOfMonth(y, m));
+  return { y, m, d };
+}
+function withDayOfMonth(date, day) {
+  return { y: date.y, m: date.m, d: day };
+}
+function dayOfWeekIso(date) {
+  const ed = epochDay(date);
+  return ((ed + 3) % 7 + 7) % 7 + 1;
+}
+function mondayOf(date) {
+  return plusDays(date, -(dayOfWeekIso(date) - 1));
+}
+function compareCalDate(a, b) {
+  return epochDay(a) - epochDay(b);
+}
+function isWithinRange(date, start, end) {
+  return compareCalDate(date, start) >= 0 && compareCalDate(date, end) <= 0;
+}
+function parseRRule(rrule) {
+  const result = {};
+  for (const part of rrule.split(";")) {
+    const eqIdx = part.indexOf("=");
+    if (eqIdx === -1) {
+      result[part] = "";
+    } else {
+      result[part.slice(0, eqIdx)] = part.slice(eqIdx + 1);
+    }
+  }
+  return result;
+}
+function parseIntOrNull(s) {
+  if (s === void 0) return null;
+  if (!/^[+-]?\d+$/.test(s)) return null;
+  const n = Number(s);
+  if (!Number.isSafeInteger(n)) return null;
+  return n >= -2147483648 && n <= 2147483647 ? n : null;
+}
+function parseUntilDate(s) {
+  const digits = s.slice(0, 8);
+  if (!/^\d{8}$/.test(digits)) return null;
+  const y = Number(digits.slice(0, 4));
+  const m = Number(digits.slice(4, 6));
+  const d = Number(digits.slice(6, 8));
+  if (m < 1 || m > 12) return null;
+  if (d < 1 || d > lengthOfMonth(y, m)) return null;
+  return { y, m, d };
+}
+function withRootSuffix(message, rootId) {
+  return rootId !== void 0 ? `${message} (root ${rootId})` : message;
+}
+var RecurrenceRuleError = class extends Error {
+  code;
+  rootId;
+  constructor(message, code, rootId) {
+    super(message);
+    this.name = "RecurrenceRuleError";
+    this.code = code;
+    this.rootId = rootId;
+  }
+};
+function parseRRuleConfig(rrule) {
+  if (rrule === null || rrule.trim() === "") {
+    return { freq: "WEEKLY", interval: 1, byDay: [], until: null };
+  }
+  const params = parseRRule(rrule);
+  const freq = params["FREQ"] ?? "WEEKLY";
+  const interval = parseIntOrNull(params["INTERVAL"]) ?? 1;
+  const byDayTokens = new Set(
+    (params["BYDAY"] ?? "").split(",").map((t) => t.trim()).filter((t) => RRULE_DAY_ORDER.includes(t))
+  );
+  const byDay = RRULE_DAY_ORDER.filter((d) => byDayTokens.has(d));
+  const untilDate = params["UNTIL"] !== void 0 ? parseUntilDate(params["UNTIL"]) : null;
+  const until = untilDate !== null ? formatIsoDate(untilDate) : null;
+  return { freq, interval, byDay, until };
+}
+function parseDeletedOccurrences(raw) {
+  if (raw === null || raw.trim() === "") return [];
+  try {
+    let body = raw.trim();
+    if (body.length >= 2 && body.startsWith("[") && body.endsWith("]")) {
+      body = body.slice(1, -1);
+    }
+    const dates = [];
+    for (const rawToken of body.split(",")) {
+      let token = rawToken.trim();
+      if (token.length >= 2 && token.startsWith('"') && token.endsWith('"')) {
+        token = token.slice(1, -1);
+      }
+      if (token === "") continue;
+      dates.push(formatIsoDate(parseIsoDate(token)));
+    }
+    return Array.from(new Set(dates)).sort();
+  } catch {
+    return [];
+  }
+}
+function expandDates(startDate, rrule, rangeStart, rangeEnd, deletedDates, rootId) {
+  if (rrule === null || rrule.trim() === "") {
+    if (isWithinRange(startDate, rangeStart, rangeEnd) && !deletedDates.has(formatIsoDate(startDate))) {
+      return [startDate];
+    }
+    return [];
+  }
+  const params = parseRRule(rrule);
+  const freq = params["FREQ"];
+  if (freq === void 0) {
+    return isWithinRange(startDate, rangeStart, rangeEnd) ? [startDate] : [];
+  }
+  const interval = parseIntOrNull(params["INTERVAL"]) ?? 1;
+  if (interval < 1) {
+    throw new RecurrenceRuleError(
+      withRootSuffix(`Recurrence rule "${rrule}" has INTERVAL below 1 \u2014 refusing to expand (would loop forever)`, rootId),
+      "INTERVAL_MUST_BE_POSITIVE",
+      rootId
+    );
+  }
+  const byDay = new Set(
+    (params["BYDAY"] ?? "").split(",").map((t) => t.trim()).filter((t) => RRULE_DAY_ORDER.includes(t))
+  );
+  const byMonthDay = parseIntOrNull(params["BYMONTHDAY"]) ?? void 0;
+  const ruleUntil = params["UNTIL"] !== void 0 ? parseUntilDate(params["UNTIL"]) : null;
+  const effectiveEnd = ruleUntil !== null && compareCalDate(ruleUntil, rangeEnd) < 0 ? ruleUntil : rangeEnd;
+  const results = [];
+  if (freq === "DAILY") {
+    let current = startDate;
+    while (compareCalDate(current, effectiveEnd) <= 0) {
+      if (compareCalDate(current, rangeStart) >= 0 && !deletedDates.has(formatIsoDate(current))) {
+        results.push(current);
+      }
+      current = plusDays(current, interval);
+    }
+  } else if (freq === "WEEKLY") {
+    if (byDay.size === 0) {
+      let current = startDate;
+      while (compareCalDate(current, effectiveEnd) <= 0) {
+        if (compareCalDate(current, rangeStart) >= 0 && !deletedDates.has(formatIsoDate(current))) {
+          results.push(current);
+        }
+        current = plusWeeks(current, interval);
+      }
+    } else {
+      let weekStart = mondayOf(startDate);
+      while (compareCalDate(weekStart, effectiveEnd) <= 0) {
+        for (let offset = 0; offset < RRULE_DAY_ORDER.length; offset++) {
+          const token = RRULE_DAY_ORDER[offset];
+          if (!byDay.has(token)) continue;
+          const date = plusDays(weekStart, offset);
+          if (compareCalDate(date, startDate) >= 0 && compareCalDate(date, effectiveEnd) <= 0 && compareCalDate(date, rangeStart) >= 0 && !deletedDates.has(formatIsoDate(date))) {
+            results.push(date);
+          }
+        }
+        weekStart = plusWeeks(weekStart, interval);
+      }
+    }
+  } else if (freq === "MONTHLY") {
+    if (byMonthDay !== void 0 && byMonthDay < 1) {
+      throw new RecurrenceRuleError(
+        withRootSuffix(`Recurrence rule "${rrule}" has BYMONTHDAY=${byMonthDay} below 1`, rootId),
+        "BYMONTHDAY_OUT_OF_RANGE",
+        rootId
+      );
+    }
+    const dayOfMonth = byMonthDay ?? startDate.d;
+    let current = startDate;
+    while (compareCalDate(current, effectiveEnd) <= 0) {
+      const day = Math.min(dayOfMonth, lengthOfMonth(current.y, current.m));
+      const date = withDayOfMonth(current, day);
+      if (compareCalDate(date, startDate) >= 0 && compareCalDate(date, effectiveEnd) <= 0 && compareCalDate(date, rangeStart) >= 0 && !deletedDates.has(formatIsoDate(date))) {
+        results.push(date);
+      }
+      current = plusMonths(current, interval);
+    }
+  }
+  return results;
+}
+function epochMsToUtcCalDate(ms) {
+  return fromEpochDay(Math.floor(ms / 864e5));
+}
+function renderSeriesFields(recurrenceRule) {
+  return parseRRuleConfig(recurrenceRule);
+}
+function weekOffsetsForGroups(roots) {
+  const offsets = /* @__PURE__ */ new Map();
+  const groups = /* @__PURE__ */ new Map();
+  for (const root of roots) {
+    if (root.recurrenceGroupId === null) {
+      offsets.set(root.id, 0);
+      continue;
+    }
+    const existing = groups.get(root.recurrenceGroupId);
+    if (existing) {
+      existing.push(root);
+    } else {
+      groups.set(root.recurrenceGroupId, [root]);
+    }
+  }
+  for (const group of groups.values()) {
+    const filtered = group.filter((r) => r.recurrenceRule !== null || group.length === 1);
+    const sorted = (filtered.length > 0 ? filtered : group).slice().sort((a, b) => a.scheduledDate - b.scheduledDate);
+    const refMonday = mondayOf(epochMsToUtcCalDate(sorted[0].scheduledDate));
+    const refMondayEpoch = epochDay(refMonday);
+    for (const root of group) {
+      const rootMonday = mondayOf(epochMsToUtcCalDate(root.scheduledDate));
+      offsets.set(root.id, (epochDay(rootMonday) - refMondayEpoch) / 7);
+    }
+  }
+  return offsets;
+}
+
+// src/tools/get_planned_workouts.ts
+function getPlannedWorkouts(args, snapshot) {
+  const rangeStart = parseIsoDate(args.from);
+  const rangeEnd = parseIsoDate(args.to);
+  const templateNameById = /* @__PURE__ */ new Map();
+  for (const t of snapshot.templates) {
+    templateNameById.set(t.id, t.deletedAt == null ? t.name : null);
+  }
+  const weekOffsets = weekOffsetsForGroups(snapshot.plannedWorkouts);
+  const occurrences = [];
+  const rootIdsWithOccurrence = /* @__PURE__ */ new Set();
+  for (const root of snapshot.plannedWorkouts) {
+    const dtstart = epochMsToUtcCalDate(root.scheduledDate);
+    const deletedOccurrences = parseDeletedOccurrences(root.deletedOccurrencesRaw);
+    const dates = expandDates(
+      dtstart,
+      root.recurrenceRule,
+      rangeStart,
+      rangeEnd,
+      new Set(deletedOccurrences),
+      root.id
+    );
+    if (dates.length === 0) continue;
+    rootIdsWithOccurrence.add(root.id);
+    const isRecurring = root.recurrenceRule !== null && root.recurrenceRule.trim() !== "";
+    const templateName = templateNameById.get(root.templateId) ?? null;
+    for (const date of dates) {
+      occurrences.push({
+        date: formatIsoDate(date),
+        rootId: root.id,
+        templateId: root.templateId,
+        templateName,
+        scheduledTime: root.scheduledTime,
+        note: root.note,
+        recurrenceGroupId: root.recurrenceGroupId,
+        isRecurring
+      });
+    }
+  }
+  occurrences.sort((a, b) => {
+    if (a.date !== b.date) return a.date < b.date ? -1 : 1;
+    if (a.scheduledTime !== b.scheduledTime) {
+      if (a.scheduledTime === null) return 1;
+      if (b.scheduledTime === null) return -1;
+      return a.scheduledTime < b.scheduledTime ? -1 : 1;
+    }
+    if (a.rootId !== b.rootId) return a.rootId < b.rootId ? -1 : 1;
+    return 0;
+  });
+  const roots = snapshot.plannedWorkouts.filter((root) => rootIdsWithOccurrence.has(root.id)).map((root) => {
+    const seriesFields = renderSeriesFields(root.recurrenceRule);
+    return {
+      id: root.id,
+      templateId: root.templateId,
+      scheduledDate: formatIsoDate(epochMsToUtcCalDate(root.scheduledDate)),
+      scheduledTime: root.scheduledTime,
+      note: root.note,
+      recurrenceRule: root.recurrenceRule,
+      recurrenceGroupId: root.recurrenceGroupId,
+      freq: seriesFields.freq,
+      interval: seriesFields.interval,
+      byDay: seriesFields.byDay,
+      until: seriesFields.until,
+      // Every root in `snapshot.plannedWorkouts` was fed into `weekOffsets` above
+      // (step 7), so this lookup is always defined — `?? 0` is a defensive fallback,
+      // never an expected path.
+      weekOffset: weekOffsets.get(root.id) ?? 0,
+      deletedOccurrences: parseDeletedOccurrences(root.deletedOccurrencesRaw),
+      completedSessionId: root.completedSessionId
+    };
+  });
+  return { occurrences, roots };
+}
+function registerToolGetPlannedWorkouts(server2, cfg) {
+  const { pat: pat2, keyB64: keyB642, serverUrl: serverUrl2 } = cfg;
+  server2.registerTool(
+    "get_planned_workouts",
+    {
+      title: "Get Planned Workouts",
+      description: 'Return concrete calendar occurrences and their planned-workout roots for a required date window (`from`/`to`, YYYY-MM-DD, both mandatory, span at most 366 days). Cancelled occurrences (deletedOccurrences) are already excluded. Completed occurrences are NOT excluded \u2014 a past date alone is not evidence of a missed workout. Each root also carries structured series fields (freq, interval, byDay, until, weekOffset) alongside the raw recurrenceRule, so a series can be described ("every 2 days", "every other week on Monday and Friday") without parsing the RRULE string.',
+      inputSchema: GetPlannedWorkoutsSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async (args) => {
+      try {
+        const data = await getSnapshot(pat2, keyB642, serverUrl2);
+        const result = getPlannedWorkouts(args, data.snapshot);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Planned workouts error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/training-state/time-zone.ts
+var TRAINING_TIMEZONE_SETTING_KEY = "training_timezone_id";
+var TimeZoneUnavailableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeZoneUnavailableError";
+  }
+};
+function resolveTimeZoneId(snapshot) {
+  const row = snapshot.settings.find((s) => s.key === TRAINING_TIMEZONE_SETTING_KEY);
+  if (!row) {
+    throw new TimeZoneUnavailableError(
+      `Missing synchronized settings key "${TRAINING_TIMEZONE_SETTING_KEY}" \u2014 the app has not synced its time zone yet (Protocol \xA71.4 Rule 3). This tool cannot fall back to a host zone; the athlete must open the app once so it can sync.`
+    );
+  }
+  const knownZones = Intl.supportedValuesOf("timeZone");
+  if (!knownZones.includes(row.value)) {
+    throw new TimeZoneUnavailableError(
+      `Synchronized settings key "${TRAINING_TIMEZONE_SETTING_KEY}" carries an unrecognized time-zone value \u2014 this is not a valid IANA zone identifier (Protocol \xA71.4 Rule 3).`
+    );
+  }
+  return row.value;
+}
+function toCalendarDay(epochMs, timeZoneId) {
+  const formatter = new Intl.DateTimeFormat("en-CA", {
+    timeZone: timeZoneId,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+  return formatter.format(new Date(epochMs));
+}
+function isoWeekKey(isoDate) {
+  const [year, month, day] = isoDate.split("-").map(Number);
+  const date = new Date(Date.UTC(year, month - 1, day));
+  const isoDayIndex = (date.getUTCDay() + 6) % 7;
+  date.setUTCDate(date.getUTCDate() - isoDayIndex + 3);
+  const weekBasedYear = date.getUTCFullYear();
+  const firstThursday = new Date(Date.UTC(weekBasedYear, 0, 4));
+  const firstThursdayIsoDayIndex = (firstThursday.getUTCDay() + 6) % 7;
+  firstThursday.setUTCDate(firstThursday.getUTCDate() - firstThursdayIsoDayIndex + 3);
+  const week = 1 + Math.round((date.getTime() - firstThursday.getTime()) / (7 * 864e5));
+  return weekBasedYear * 100 + week;
+}
+
+// src/training-state/consistency.ts
+function areConsecutiveWeeks(week1, week2) {
+  const year1 = Math.floor(week1 / 100);
+  const w1 = week1 % 100;
+  const year2 = Math.floor(week2 / 100);
+  const w2 = week2 % 100;
+  return year1 === year2 && w2 === w1 + 1 || year2 === year1 + 1 && w1 >= 52 && w2 === 1;
+}
+function calculateLongestStreak(sortedWeeks) {
+  if (sortedWeeks.length === 0) return 0;
+  let longest = 1;
+  let current = 1;
+  for (let i = 1; i < sortedWeeks.length; i++) {
+    if (areConsecutiveWeeks(sortedWeeks[i - 1], sortedWeeks[i])) {
+      current++;
+      if (current > longest) longest = current;
+    } else {
+      current = 1;
+    }
+  }
+  return longest;
+}
+function calculateCurrentStreak(sortedWeeks, currentWeekKey) {
+  if (sortedWeeks.length === 0) return 0;
+  const lastWeek = sortedWeeks[sortedWeeks.length - 1];
+  if (lastWeek !== currentWeekKey && !areConsecutiveWeeks(lastWeek, currentWeekKey)) return 0;
+  let streak = 1;
+  for (let i = sortedWeeks.length - 2; i >= 0; i--) {
+    if (areConsecutiveWeeks(sortedWeeks[i], sortedWeeks[i + 1])) {
+      streak++;
+    } else {
+      break;
+    }
+  }
+  return streak;
+}
+function trainingWeekKeys(sessions, timeZoneId) {
+  const weeks = /* @__PURE__ */ new Set();
+  for (const session of sessions) {
+    if (session.deletedAt != null) continue;
+    const calendarDay = toCalendarDay(session.startTime, timeZoneId);
+    weeks.add(isoWeekKey(calendarDay));
+  }
+  return [...weeks].sort((a, b) => a - b);
+}
+function computeStreaks(sessions, timeZoneId, nowMs) {
+  const sortedWeeks = trainingWeekKeys(sessions, timeZoneId);
+  const currentWeekKey = isoWeekKey(toCalendarDay(nowMs, timeZoneId));
+  return {
+    currentStreakWeeks: calculateCurrentStreak(sortedWeeks, currentWeekKey),
+    longestStreakWeeks: calculateLongestStreak(sortedWeeks),
+    trainingWeekCount: sortedWeeks.length
+  };
+}
+function shiftCalendarDay(isoDate, days) {
+  const [y, mm, d] = isoDate.split("-").map(Number);
+  const date = new Date(Date.UTC(y, mm - 1, d));
+  date.setUTCDate(date.getUTCDate() + days);
+  return date.toISOString().slice(0, 10);
+}
+function computeFrequency(sessions, timeZoneId, nowMs) {
+  const completedSessions = sessions.filter((s) => s.deletedAt == null && s.endTime !== void 0);
+  const todayIso = toCalendarDay(nowMs, timeZoneId);
+  const todayWeekKey = isoWeekKey(todayIso);
+  const fourWeeksAgoIso = shiftCalendarDay(todayIso, -28);
+  const eightWeeksAgoIso = shiftCalendarDay(todayIso, -56);
+  let sessionsThisIsoWeek = 0;
+  let sessionsLast4Weeks = 0;
+  let sessionsPrior4Weeks = 0;
+  for (const session of completedSessions) {
+    const dayIso = toCalendarDay(session.startTime, timeZoneId);
+    if (isoWeekKey(dayIso) === todayWeekKey) sessionsThisIsoWeek++;
+    if (dayIso >= fourWeeksAgoIso && dayIso <= todayIso) sessionsLast4Weeks++;
+    if (dayIso >= eightWeeksAgoIso && dayIso < fourWeeksAgoIso) sessionsPrior4Weeks++;
+  }
+  return {
+    sessionsThisIsoWeek,
+    sessionsLast4Weeks,
+    sessionsPrior4Weeks,
+    totalCompletedSessions: completedSessions.length
+  };
+}
+function trackBest(map, exerciseId, value, achievedAtMs) {
+  const existing = map.get(exerciseId);
+  if (existing === void 0 || value > existing.value || value === existing.value && achievedAtMs < existing.achievedAtMs) {
+    map.set(exerciseId, { value, achievedAtMs });
+  }
+}
+function toSortedRecords(candidates, catalogById, timeZoneId) {
+  return [...candidates.entries()].map(([exerciseId, candidate]) => ({
+    exerciseId,
+    exerciseName: catalogById.get(exerciseId)?.nameEn ?? null,
+    value: candidate.value,
+    achievedOn: toCalendarDay(candidate.achievedAtMs, timeZoneId)
+  })).sort((a, b) => b.value - a.value || a.exerciseId.localeCompare(b.exerciseId));
+}
+function computePersonalRecords(snapshot, catalog, timeZoneId) {
+  const catalogById = new Map(catalog.map((ex) => [ex.id, ex]));
+  const templateExerciseById = new Map(snapshot.templateExercises.map((te) => [te.id, te]));
+  const sessionById = new Map(snapshot.sessions.map((s) => [s.id, s]));
+  const maxRepsByExercise = /* @__PURE__ */ new Map();
+  const maxHoldByExercise = /* @__PURE__ */ new Map();
+  for (const setLog of snapshot.setLogs) {
+    if (setLog.deletedAt != null) continue;
+    const session = sessionById.get(setLog.sessionId);
+    if (session === void 0) continue;
+    if (session.deletedAt != null) continue;
+    const exerciseId = setLog.exerciseId ?? (setLog.workoutExerciseId !== void 0 ? templateExerciseById.get(setLog.workoutExerciseId)?.exerciseId : void 0);
+    if (exerciseId === void 0) continue;
+    if (setLog.completedReps !== null) {
+      trackBest(maxRepsByExercise, exerciseId, setLog.completedReps, setLog.createdAt);
+    }
+    const exercise = catalogById.get(exerciseId);
+    if (exercise?.mode === "TIME" && setLog.completedTimeSeconds !== null) {
+      trackBest(maxHoldByExercise, exerciseId, setLog.completedTimeSeconds, setLog.createdAt);
+    }
+  }
+  return {
+    maxReps: toSortedRecords(maxRepsByExercise, catalogById, timeZoneId),
+    maxHoldSeconds: toSortedRecords(maxHoldByExercise, catalogById, timeZoneId)
+  };
+}
+function computeConsistency(snapshot, catalog, timeZoneId, nowMs) {
+  const streaks = computeStreaks(snapshot.sessions, timeZoneId, nowMs);
+  const frequency = computeFrequency(snapshot.sessions, timeZoneId, nowMs);
+  return { ...streaks, ...frequency };
+}
+
+// src/training-state/muscle-similarity.ts
+function buildMuscleVector(hits, catalogById) {
+  const vector = /* @__PURE__ */ new Map();
+  for (const hit of hits) {
+    const exercise = catalogById.get(hit.exerciseId);
+    if (exercise === void 0) continue;
+    for (const muscleGroup of exercise.muscleGroups) {
+      vector.set(
+        muscleGroup.key,
+        (vector.get(muscleGroup.key) ?? 0) + hit.setCount * weightFor(muscleGroup.involvementLevel)
+      );
+    }
+  }
+  return vector;
+}
+var CAPABILITY_VECTOR_KEY_PREFIX = "capability:";
+function buildCombinedVector(hits, catalogById) {
+  const vector = buildMuscleVector(hits, catalogById);
+  for (const hit of hits) {
+    const exercise = catalogById.get(hit.exerciseId);
+    if (exercise === void 0) continue;
+    for (const axis of exercise.capabilities) {
+      const key = `${CAPABILITY_VECTOR_KEY_PREFIX}${axis.key}`;
+      vector.set(key, (vector.get(key) ?? 0) + hit.setCount * weightFor2(axis.capabilityLevel));
+    }
+  }
+  return vector;
+}
+function ruzickaSimilarity(a, b) {
+  const keys = /* @__PURE__ */ new Set([...a.keys(), ...b.keys()]);
+  let sumMin = 0;
+  let sumMax = 0;
+  for (const key of keys) {
+    const av = a.get(key) ?? 0;
+    const bv = b.get(key) ?? 0;
+    sumMin += Math.min(av, bv);
+    sumMax += Math.max(av, bv);
+  }
+  if (sumMax === 0) return 0;
+  return sumMin / sumMax;
+}
+function classifySimilarity(similarity, matchThreshold, uncertainThreshold) {
+  if (similarity >= matchThreshold) return "matched";
+  if (similarity >= uncertainThreshold) return "uncertain";
+  return "none";
+}
+
+// src/training-state/adherence.ts
+var ADHERENCE_EXPLANATION = "removedOccurrenceCount counts how many planned occurrences the athlete removed from the calendar inside this window. The stored data carries no timestamp for a removal, so it cannot say whether a given occurrence was cancelled ahead of its date on purpose or cleaned up afterward because it was missed \u2014 ask the athlete rather than assuming either reading. A planned occurrence that was removed entirely (its whole recurring series, or its only single date) leaves no trace inside this window at all, and this calculation treats it exactly as if nothing had ever been planned on that day.";
+function occKeyOf(occ) {
+  return `${occ.date}::${occ.rootId}`;
+}
+function daysBetween(a, b) {
+  return Math.abs(epochDay(parseIsoDate(a)) - epochDay(parseIsoDate(b)));
+}
+function compareTieBreak(aDate, aRootId, aSessionId, bDate, bRootId, bSessionId) {
+  if (aDate !== bDate) return aDate < bDate ? -1 : 1;
+  if (aRootId !== bRootId) return aRootId < bRootId ? -1 : 1;
+  if (aSessionId !== bSessionId) return aSessionId < bSessionId ? -1 : 1;
+  return 0;
+}
+function computeAdherence(args, data) {
+  const { snapshot, catalog, timeZoneId } = data;
+  const { from, to, toleranceDays, matchThreshold, uncertainThreshold } = args;
+  const denom = getPlannedWorkouts({ from, to }, snapshot);
+  const plannedCount = denom.occurrences.length;
+  let removedOccurrenceCount = 0;
+  for (const root of denom.roots) {
+    for (const deletedDate of root.deletedOccurrences) {
+      if (deletedDate >= from && deletedDate <= to) removedOccurrenceCount++;
+    }
+  }
+  const searchStart = formatIsoDate(plusDays(parseIsoDate(from), -toleranceDays));
+  const searchEnd = formatIsoDate(plusDays(parseIsoDate(to), toleranceDays));
+  const candidateSessions = [];
+  for (const session of snapshot.sessions) {
+    if (session.deletedAt !== void 0) continue;
+    if (session.endTime === void 0) continue;
+    const calDay = toCalendarDay(session.startTime, timeZoneId);
+    if (calDay < searchStart || calDay > searchEnd) continue;
+    candidateSessions.push({ session, calDay });
+  }
+  const usedOccKeys = /* @__PURE__ */ new Set();
+  const usedSessionIds = /* @__PURE__ */ new Set();
+  const matches = [];
+  const exactCandidates = [];
+  for (const occ of denom.occurrences) {
+    for (const cs of candidateSessions) {
+      if (cs.session.templateId !== occ.templateId) continue;
+      const dateDistanceDays = daysBetween(occ.date, cs.calDay);
+      if (dateDistanceDays > toleranceDays) continue;
+      exactCandidates.push({ occKey: occKeyOf(occ), occ, session: cs.session, calDay: cs.calDay, dateDistanceDays });
+    }
+  }
+  exactCandidates.sort((a, b) => {
+    if (a.dateDistanceDays !== b.dateDistanceDays) return a.dateDistanceDays - b.dateDistanceDays;
+    return compareTieBreak(
+      a.occ.date,
+      a.occ.rootId,
+      a.session.id,
+      b.occ.date,
+      b.occ.rootId,
+      b.session.id
+    );
+  });
+  for (const c of exactCandidates) {
+    if (usedOccKeys.has(c.occKey) || usedSessionIds.has(c.session.id)) continue;
+    usedOccKeys.add(c.occKey);
+    usedSessionIds.add(c.session.id);
+    matches.push({
+      date: c.occ.date,
+      rootId: c.occ.rootId,
+      templateId: c.occ.templateId,
+      sessionId: c.session.id,
+      sessionDate: c.calDay,
+      dateDistanceDays: c.dateDistanceDays,
+      via: "templateId",
+      similarity: null,
+      confidence: "matched"
+    });
+  }
+  const catalogById = new Map(catalog.map((ex) => [ex.id, ex]));
+  const templateExerciseById = new Map(snapshot.templateExercises.map((te) => [te.id, te]));
+  const blockById = new Map(snapshot.blocks.map((b) => [b.id, b]));
+  function roundsFor(te) {
+    if (te.blockId === void 0) return 1;
+    return blockById.get(te.blockId)?.rounds ?? 1;
+  }
+  const templateExercisesByTemplateId = /* @__PURE__ */ new Map();
+  for (const te of snapshot.templateExercises) {
+    const list = templateExercisesByTemplateId.get(te.templateId) ?? [];
+    list.push({ exerciseId: te.exerciseId, sets: te.sets * roundsFor(te) });
+    templateExercisesByTemplateId.set(te.templateId, list);
+  }
+  const setLogsBySessionId = /* @__PURE__ */ new Map();
+  for (const setLog of snapshot.setLogs) {
+    if (setLog.deletedAt !== void 0) continue;
+    const list = setLogsBySessionId.get(setLog.sessionId) ?? [];
+    list.push(setLog);
+    setLogsBySessionId.set(setLog.sessionId, list);
+  }
+  const planVectorCache = /* @__PURE__ */ new Map();
+  function planVectorFor(templateId) {
+    const cached2 = planVectorCache.get(templateId);
+    if (cached2) return cached2;
+    const hits = (templateExercisesByTemplateId.get(templateId) ?? []).map((te) => ({
+      exerciseId: te.exerciseId,
+      // WR-01/MUSC-07 (138-15): te.sets is already pre-multiplied by the containing
+      // block's rounds — see the blockById-based construction of
+      // templateExercisesByTemplateId above (a rounds:3 block's sets:1 row means the
+      // exercise is actually performed 3 times per template, not once).
+      setCount: te.sets
+    }));
+    const vector = buildCombinedVector(hits, catalogById);
+    planVectorCache.set(templateId, vector);
+    return vector;
+  }
+  const sessionVectorCache = /* @__PURE__ */ new Map();
+  function sessionVectorFor(session) {
+    const cached2 = sessionVectorCache.get(session.id);
+    if (cached2) return cached2;
+    const hits = [];
+    for (const setLog of setLogsBySessionId.get(session.id) ?? []) {
+      const exerciseId = setLog.exerciseId ?? (setLog.workoutExerciseId !== void 0 ? templateExerciseById.get(setLog.workoutExerciseId)?.exerciseId : void 0);
+      if (exerciseId === void 0) continue;
+      hits.push({ exerciseId, setCount: 1 });
+    }
+    const vector = buildCombinedVector(hits, catalogById);
+    sessionVectorCache.set(session.id, vector);
+    return vector;
+  }
+  const remainingOccs = denom.occurrences.filter((occ) => !usedOccKeys.has(occKeyOf(occ)));
+  const remainingSessions = candidateSessions.filter((cs) => !usedSessionIds.has(cs.session.id));
+  const similarityCandidates = [];
+  for (const occ of remainingOccs) {
+    const planVector = planVectorFor(occ.templateId);
+    for (const cs of remainingSessions) {
+      const dateDistanceDays = daysBetween(occ.date, cs.calDay);
+      if (dateDistanceDays > toleranceDays) continue;
+      const sessionVector = sessionVectorFor(cs.session);
+      const similarity = ruzickaSimilarity(sessionVector, planVector);
+      const verdict = classifySimilarity(similarity, matchThreshold, uncertainThreshold);
+      if (verdict === "none") continue;
+      similarityCandidates.push({
+        occKey: occKeyOf(occ),
+        occ,
+        session: cs.session,
+        calDay: cs.calDay,
+        dateDistanceDays,
+        similarity,
+        verdict
+      });
+    }
+  }
+  similarityCandidates.sort((a, b) => {
+    if (a.dateDistanceDays !== b.dateDistanceDays) return a.dateDistanceDays - b.dateDistanceDays;
+    if (a.similarity !== b.similarity) return b.similarity - a.similarity;
+    return compareTieBreak(
+      a.occ.date,
+      a.occ.rootId,
+      a.session.id,
+      b.occ.date,
+      b.occ.rootId,
+      b.session.id
+    );
+  });
+  for (const c of similarityCandidates) {
+    if (usedOccKeys.has(c.occKey) || usedSessionIds.has(c.session.id)) continue;
+    usedOccKeys.add(c.occKey);
+    usedSessionIds.add(c.session.id);
+    matches.push({
+      date: c.occ.date,
+      rootId: c.occ.rootId,
+      templateId: c.occ.templateId,
+      sessionId: c.session.id,
+      sessionDate: c.calDay,
+      dateDistanceDays: c.dateDistanceDays,
+      via: "muscleSimilarity",
+      similarity: c.similarity,
+      confidence: c.verdict
+    });
+  }
+  matches.sort((a, b) => compareTieBreak(a.date, a.rootId, a.sessionId, b.date, b.rootId, b.sessionId));
+  const missed = denom.occurrences.filter((occ) => !usedOccKeys.has(occKeyOf(occ)));
+  const unplannedSessionIds = candidateSessions.filter((cs) => cs.calDay >= from && cs.calDay <= to && !usedSessionIds.has(cs.session.id)).map((cs) => cs.session.id);
+  const matchedCount = matches.filter((m) => m.confidence === "matched").length;
+  const uncertainCount = matches.filter((m) => m.confidence === "uncertain").length;
+  const missedCount = missed.length;
+  const adherenceRatio = plannedCount === 0 ? null : matchedCount / plannedCount;
+  return {
+    window: { from, to },
+    toleranceDays,
+    plannedCount,
+    matchedCount,
+    missedCount,
+    uncertainCount,
+    removedOccurrenceCount,
+    adherenceRatio,
+    matches,
+    missed,
+    unplannedSessionIds,
+    explanation: ADHERENCE_EXPLANATION
+  };
+}
+
+// src/training-state/exercise-progress.ts
+var DEAD_BAND = 0.03;
+var MIN_USABLE_VALUES = 4;
+var DIRECTION_RULE = "The series is split into a first half and a second half by position (for an odd number of points, the middle point falls into neither half). Null values are excluded when averaging each half. The relative change of the second half's mean versus the first half's mean is computed; a change within a 3% dead band counts as flat, below -3% as down, and above +3% as up. At least four usable (non-null) values are required overall \u2014 fewer, or a half with no usable values, yields insufficient-data.";
+function mean(values) {
+  if (values.length === 0) return null;
+  return values.reduce((sum, v) => sum + v, 0) / values.length;
+}
+function directionOf(values) {
+  const usableCount = values.filter((v) => v !== null).length;
+  if (usableCount < MIN_USABLE_VALUES) {
+    return { label: "insufficient-data", firstHalfMean: null, secondHalfMean: null, relativeChange: null };
+  }
+  const mid = Math.floor(values.length / 2);
+  const isOdd = values.length % 2 === 1;
+  const firstHalf = values.slice(0, mid);
+  const secondHalf = isOdd ? values.slice(mid + 1) : values.slice(mid);
+  const firstHalfMean = mean(firstHalf.filter((v) => v !== null));
+  const secondHalfMean = mean(secondHalf.filter((v) => v !== null));
+  if (firstHalfMean === null || secondHalfMean === null) {
+    return { label: "insufficient-data", firstHalfMean, secondHalfMean, relativeChange: null };
+  }
+  const relativeChange = firstHalfMean === 0 ? secondHalfMean === 0 ? 0 : secondHalfMean > 0 ? 1 : -1 : (secondHalfMean - firstHalfMean) / Math.abs(firstHalfMean);
+  const label = relativeChange > DEAD_BAND ? "up" : relativeChange < -DEAD_BAND ? "down" : "flat";
+  return { label, firstHalfMean, secondHalfMean, relativeChange };
+}
+function summarizeSession(logs, metric) {
+  if (metric === "e1rm") {
+    const bestSet2 = bestE1rm(logs);
+    let sessionTotal2 = null;
+    for (const log of logs) {
+      const w = log.weightUsed;
+      const r = log.completedReps;
+      if (w !== null && w > 0 && r !== null && r > 0) {
+        sessionTotal2 = (sessionTotal2 ?? 0) + r * w;
+      }
+    }
+    return { bestSet: bestSet2, sessionTotal: sessionTotal2 };
+  }
+  let bestSet = null;
+  let sessionTotal = null;
+  for (const log of logs) {
+    const value = metric === "reps" ? log.completedReps : log.completedTimeSeconds;
+    if (value === null) continue;
+    if (bestSet === null || value > bestSet) bestSet = value;
+    sessionTotal = (sessionTotal ?? 0) + value;
+  }
+  return { bestSet, sessionTotal };
+}
+function buildSeriesForExercise(exerciseId, logs, ctx) {
+  const exercise = ctx.catalogById.get(exerciseId);
+  const usesWeight = exercise?.usesWeight ?? false;
+  const mode = exercise?.mode ?? "REPS";
+  const metric = usesWeight ? "e1rm" : mode === "TIME" ? "timeSeconds" : "reps";
+  const logsBySessionId = /* @__PURE__ */ new Map();
+  for (const log of logs) {
+    const bucket = logsBySessionId.get(log.sessionId);
+    if (bucket) bucket.push(log);
+    else logsBySessionId.set(log.sessionId, [log]);
+  }
+  const sessionsTouched = [...logsBySessionId.keys()].map((sessionId) => ctx.sessionById.get(sessionId)).filter((s) => s !== void 0).sort((a, b) => a.startTime - b.startTime);
+  const points = sessionsTouched.map((session) => {
+    const sessionLogs = logsBySessionId.get(session.id) ?? [];
+    const { bestSet, sessionTotal } = summarizeSession(sessionLogs, metric);
+    return {
+      sessionId: session.id,
+      date: toCalendarDay(session.startTime, ctx.timeZoneId),
+      setCount: sessionLogs.length,
+      bestSet,
+      sessionTotal
+    };
+  });
+  const trimmedPoints = points.length > ctx.maxPoints ? points.slice(points.length - ctx.maxPoints) : points;
+  return {
+    exerciseId,
+    exerciseName: exercise?.nameEn ?? null,
+    mode,
+    usesWeight,
+    metric,
+    points: trimmedPoints,
+    bestSetDirection: directionOf(trimmedPoints.map((p) => p.bestSet)),
+    sessionTotalDirection: directionOf(trimmedPoints.map((p) => p.sessionTotal)),
+    rule: DIRECTION_RULE
+  };
+}
+function computeExerciseProgress(args, data) {
+  const { snapshot, catalog, timeZoneId } = data;
+  const catalogById = new Map(catalog.map((ex) => [ex.id, ex]));
+  const templateExerciseById = new Map(snapshot.templateExercises.map((te) => [te.id, te]));
+  const sessionById = new Map(snapshot.sessions.map((s) => [s.id, s]));
+  const setLogsByExerciseId = /* @__PURE__ */ new Map();
+  for (const setLog of snapshot.setLogs) {
+    if (setLog.deletedAt !== void 0) continue;
+    const session = sessionById.get(setLog.sessionId);
+    if (session === void 0) continue;
+    if (session.deletedAt !== void 0) continue;
+    if (session.endTime === void 0) continue;
+    const exerciseId = setLog.exerciseId ?? (setLog.workoutExerciseId !== void 0 ? templateExerciseById.get(setLog.workoutExerciseId)?.exerciseId : void 0);
+    if (exerciseId === void 0) continue;
+    const bucket = setLogsByExerciseId.get(exerciseId);
+    if (bucket) bucket.push(setLog);
+    else setLogsByExerciseId.set(exerciseId, [setLog]);
+  }
+  let exerciseIds;
+  if (args.exerciseId !== void 0) {
+    exerciseIds = [args.exerciseId];
+  } else {
+    const lastOccurrenceMs = /* @__PURE__ */ new Map();
+    for (const [exerciseId, logs] of setLogsByExerciseId) {
+      let latest = -Infinity;
+      for (const log of logs) {
+        const session = sessionById.get(log.sessionId);
+        if (session !== void 0 && session.startTime > latest) latest = session.startTime;
+      }
+      lastOccurrenceMs.set(exerciseId, latest);
+    }
+    exerciseIds = [...lastOccurrenceMs.entries()].sort((a, b) => b[1] - a[1]).slice(0, args.recentExerciseCount).map(([exerciseId]) => exerciseId);
+  }
+  return exerciseIds.map(
+    (exerciseId) => buildSeriesForExercise(exerciseId, setLogsByExerciseId.get(exerciseId) ?? [], {
+      sessionById,
+      catalogById,
+      timeZoneId,
+      maxPoints: args.maxPoints
+    })
+  );
+}
+
+// src/training-state/narrative.ts
+function streakClause(currentStreakWeeks) {
+  if (currentStreakWeeks === 0) {
+    return "The current training streak is 0 weeks.";
+  }
+  const weekWord = currentStreakWeeks === 1 ? "week" : "weeks";
+  return `The current training streak is ${currentStreakWeeks} ${weekWord}.`;
+}
+function frequencyClause(sessionsLast4Weeks, sessionsPrior4Weeks) {
+  if (sessionsLast4Weeks === sessionsPrior4Weeks) {
+    return `Training frequency is unchanged: ${sessionsLast4Weeks} sessions in each of the last two 4-week windows.`;
+  }
+  if (sessionsPrior4Weeks === 0) {
+    return `${sessionsLast4Weeks} session(s) were logged in the last 4 weeks, versus none in the previous 4-week window.`;
+  }
+  if (sessionsLast4Weeks === 0) {
+    return `No sessions were logged in the last 4 weeks, versus ${sessionsPrior4Weeks} in the previous 4-week window.`;
+  }
+  const relativePercent = Math.round((sessionsLast4Weeks - sessionsPrior4Weeks) / sessionsPrior4Weeks * 100);
+  const signedPercent = relativePercent >= 0 ? `+${relativePercent}` : `${relativePercent}`;
+  return `${sessionsLast4Weeks} sessions were logged in the last 4 weeks versus ${sessionsPrior4Weeks} in the previous 4-week window (${signedPercent}%).`;
+}
+function adherenceClause(adherence) {
+  if (adherence.adherenceRatio === null) {
+    return "Nothing was scheduled in the adherence window, so no adherence percentage applies.";
+  }
+  const percent = Math.round(adherence.adherenceRatio * 100);
+  return `Adherence over the window is ${percent}% (${adherence.matchedCount} of ${adherence.plannedCount} planned sessions matched).`;
+}
+function progressClause(recentExercises) {
+  const trendingUp = recentExercises.filter((e) => e.direction === "up");
+  if (trendingUp.length === 0) return null;
+  trendingUp.sort((a, b) => {
+    if (a.lastTrainedOn !== b.lastTrainedOn) return a.lastTrainedOn < b.lastTrainedOn ? 1 : -1;
+    return a.exerciseId.localeCompare(b.exerciseId);
+  });
+  const chosen = trendingUp[0];
+  const name = chosen.exerciseName ?? chosen.exerciseId;
+  return `${name} is trending upward across recent sessions.`;
+}
+function buildNarrative(input) {
+  const clauses = [
+    streakClause(input.currentStreakWeeks),
+    frequencyClause(input.sessionsLast4Weeks, input.sessionsPrior4Weeks),
+    adherenceClause(input.adherence)
+  ];
+  const progress = progressClause(input.recentExercises);
+  if (progress !== null) clauses.push(progress);
+  return clauses.join(" ");
+}
+
+// src/tools/get_training_state.ts
+function getTrainingState(args, data, nowMs) {
+  const { snapshot, catalog, coachParameters, parametersSource } = data;
+  const timeZoneId = resolveTimeZoneId(snapshot);
+  const asOfDate = toCalendarDay(nowMs, timeZoneId);
+  const consistency = computeConsistency(snapshot, catalog, timeZoneId, nowMs);
+  const muscleBalance = computeMuscleBalance(snapshot, catalog, nowMs);
+  const adherenceTo = asOfDate;
+  const adherenceFrom = formatIsoDate(
+    plusDays(parseIsoDate(asOfDate), -coachParameters.adherenceWindowWeeks * 7)
+  );
+  const fullAdherence = computeAdherence(
+    {
+      from: adherenceFrom,
+      to: adherenceTo,
+      toleranceDays: coachParameters.toleranceDays,
+      matchThreshold: coachParameters.matchThreshold,
+      uncertainThreshold: coachParameters.uncertainThreshold
+    },
+    { snapshot, catalog, timeZoneId }
+  );
+  const adherence = {
+    window: fullAdherence.window,
+    toleranceDays: fullAdherence.toleranceDays,
+    plannedCount: fullAdherence.plannedCount,
+    matchedCount: fullAdherence.matchedCount,
+    uncertainCount: fullAdherence.uncertainCount,
+    missedCount: fullAdherence.missedCount,
+    removedOccurrenceCount: fullAdherence.removedOccurrenceCount,
+    adherenceRatio: fullAdherence.adherenceRatio,
+    explanation: fullAdherence.explanation
+  };
+  const progressSeries = computeExerciseProgress(
+    { maxPoints: coachParameters.exerciseTrendPoints, recentExerciseCount: coachParameters.recentExerciseCount },
+    { snapshot, catalog, timeZoneId }
+  );
+  const recentExercises = progressSeries.map((series) => {
+    const lastPoint = series.points[series.points.length - 1];
+    return {
+      exerciseId: series.exerciseId,
+      exerciseName: series.exerciseName,
+      metric: series.metric,
+      lastTrainedOn: lastPoint?.date ?? asOfDate,
+      bestSetDirection: series.bestSetDirection,
+      sessionTotalDirection: series.sessionTotalDirection,
+      rule: series.rule
+    };
+  });
+  const personalRecords = computePersonalRecords(snapshot, catalog, timeZoneId);
+  const narrative = buildNarrative({
+    currentStreakWeeks: consistency.currentStreakWeeks,
+    sessionsLast4Weeks: consistency.sessionsLast4Weeks,
+    sessionsPrior4Weeks: consistency.sessionsPrior4Weeks,
+    adherence: {
+      plannedCount: adherence.plannedCount,
+      matchedCount: adherence.matchedCount,
+      adherenceRatio: adherence.adherenceRatio
+    },
+    recentExercises: recentExercises.map((e) => ({
+      exerciseId: e.exerciseId,
+      exerciseName: e.exerciseName,
+      lastTrainedOn: e.lastTrainedOn,
+      direction: e.bestSetDirection.label
+    }))
+  });
+  return {
+    timeZoneId,
+    asOfDate,
+    parametersSource,
+    parameters: coachParameters,
+    consistency,
+    muscleBalance,
+    adherence,
+    recentExercises,
+    personalRecords,
+    narrative
+  };
+}
+function registerToolGetTrainingState(server2, cfg) {
+  const { pat: pat2, keyB64: keyB642, serverUrl: serverUrl2 } = cfg;
+  server2.registerTool(
+    "get_training_state",
+    {
+      title: "Get Training State",
+      description: `The standard entry point for "how is the athlete doing" \u2014 a query-time-computed overview, rather than raw session-by-session history. In one call: the current and longest training streak in weeks plus session-frequency counts (consistency); the same radar-chart muscle balance data as the app's Analytics dashboard in all three app windows (muscleBalance); a plan-adherence short form \u2014 counts, ratio, and an honesty explanation about what removedOccurrenceCount does and does not mean (adherence); the most recently trained exercises with their direction labels (recentExercises); all-time personal records (personalRecords); and a short, deterministic narrative sentence built from these already-computed numbers, never a second model call. This tool stays narrow on purpose: it carries no point series and no pair lists. For per-exercise or per-format progress series, call get_progress. For the full adherence pair/missed lists, call get_adherence. For raw session history, call get_history. All calendar-day mapping binds to the athlete's own synchronized time zone, never the coach's own clock.`,
+      inputSchema: GetTrainingStateSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async (args) => {
+      try {
+        const data = await getSnapshot(pat2, keyB642, serverUrl2);
+        const { params, source } = await loadCoachParameters({ pat: pat2, serverUrl: serverUrl2 });
+        const result = getTrainingState(
+          args,
+          { snapshot: data.snapshot, catalog: data.catalog, coachParameters: params, parametersSource: source },
+          Date.now()
+        );
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Training state error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/dedupe.ts
+function normalizeExerciseName(name) {
+  const trimmed = name.trim();
+  const lowered = trimmed.toLocaleLowerCase("en-US");
+  const collapsed = lowered.replace(/\s+/g, " ");
+  const nfd = collapsed.normalize("NFD");
+  return nfd.replace(new RegExp("\\p{Mn}", "gu"), "");
+}
+function findCatalogMatch(proposedName, catalog) {
+  const key = normalizeExerciseName(proposedName);
+  if (!key) return void 0;
+  return catalog.find(
+    (ex) => normalizeExerciseName(ex.nameEn) === key || ex.translations.some((t) => normalizeExerciseName(t.name) === key)
+  );
+}
+
+// src/hash.ts
+import { createHash } from "crypto";
+function canonicalStringify(value, path = "<root>") {
+  if (value === void 0) {
+    throw new Error(
+      `canonicalStringify: refusing to serialize undefined at "${path}". A field this hash depends on is missing. JSON.stringify(undefined) produces no string at all, so a prior version of this function silently wrote the bare word \`undefined\` into the hash input here \u2014 invalid JSON, and a hash that could never match the Kotlin side (G-134-37: exactly this bug on rounds/sets/exerciseSource, planhash-wire-defaults-parity.md). Fix the caller to supply a real value or an explicit null, not this function.`
+    );
+  }
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((v, i) => canonicalStringify(v, `${path}[${i}]`)).join(",")}]`;
+  }
+  const record = value;
+  const keys = Object.keys(record).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalStringify(record[k], path === "<root>" ? k : `${path}.${k}`)}`).join(",")}}`;
+}
+function canonWeight(w) {
+  return w == null ? null : decimalHalfUpScale2(String(w));
+}
+function decimalHalfUpScale2(repr) {
+  let s = repr;
+  let sign = "";
+  if (s.startsWith("-")) {
+    sign = "-";
+    s = s.slice(1);
+  }
+  let mantissa = s;
+  let exp = 0;
+  const eIdx = s.search(/[eE]/);
+  if (eIdx !== -1) {
+    mantissa = s.slice(0, eIdx);
+    exp = Number.parseInt(s.slice(eIdx + 1), 10);
+  }
+  const dot = mantissa.indexOf(".");
+  const digits = dot === -1 ? mantissa : mantissa.slice(0, dot) + mantissa.slice(dot + 1);
+  let pointPos = (dot === -1 ? mantissa.length : dot) + exp;
+  let padded = digits;
+  if (pointPos < 0) {
+    padded = "0".repeat(-pointPos) + padded;
+    pointPos = 0;
+  }
+  if (pointPos + 2 > padded.length) {
+    padded = padded + "0".repeat(pointPos + 2 - padded.length);
+  }
+  let scaled = BigInt(padded.slice(0, pointPos + 2));
+  const rest = padded.slice(pointPos + 2);
+  if (rest !== "" && rest.charCodeAt(0) >= 53) {
+    scaled += 1n;
+  }
+  const abs = scaled.toString().padStart(3, "0");
+  const out = `${abs.slice(0, -2)}.${abs.slice(-2)}`;
+  return sign !== "" && out !== "0.00" ? `${sign}${out}` : out;
+}
+function canonicalizeRoundTarget(rt) {
+  return {
+    round: rt.round,
+    targetReps: rt.targetReps ?? null,
+    targetTimeSeconds: rt.targetTimeSeconds ?? null,
+    targetWeight: canonWeight(rt.targetWeight)
+  };
+}
+function compareByOrderIndexThenId(a, b) {
+  if (a.orderIndex !== b.orderIndex) return a.orderIndex - b.orderIndex;
+  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+function computePlanHash(templateId, snapshot) {
+  const blocks = snapshot.blocks.filter((b) => b.templateId === templateId && b.deletedAt == null).sort(compareByOrderIndexThenId);
+  const templateExercises = snapshot.templateExercises.filter(
+    (te) => te.templateId === templateId && te.deletedAt == null
+  );
+  const canonical = {
+    templateId,
+    blocks: blocks.map((block) => {
+      const exercisesForBlock = templateExercises.filter((te) => te.blockId === block.id).sort(compareByOrderIndexThenId).map((te) => canonicalizeTemplateExercise(te));
+      return {
+        id: block.id,
+        rounds: block.rounds,
+        orderIndex: block.orderIndex,
+        templateExercises: exercisesForBlock
+      };
+    }),
+    standalone: templateExercises.filter((te) => te.blockId == null).sort(compareByOrderIndexThenId).map((te) => canonicalizeTemplateExercise(te))
+  };
+  return createHash("sha256").update(canonicalStringify(canonical), "utf8").digest("hex");
+}
+function canonicalizeTemplateExercise(te) {
+  const roundTargets = (te.roundTargets ?? []).slice().sort((a, b) => a.round - b.round).map(canonicalizeRoundTarget);
+  return {
+    id: te.id,
+    blockId: te.blockId ?? null,
+    exerciseId: te.exerciseId,
+    exerciseSource: te.exerciseSource,
+    mode: te.mode,
+    targetReps: te.targetReps ?? null,
+    targetTimeSeconds: te.targetTimeSeconds ?? null,
+    restTimeSeconds: te.restTimeSeconds,
+    sets: te.sets,
+    targetWeight: canonWeight(te.targetWeight),
+    orderIndex: te.orderIndex,
+    roundTargets
+  };
+}
+function computeChangeHash(type, payload) {
+  return createHash("sha256").update(`${type}:${canonicalStringify(payload)}`, "utf8").digest("hex");
+}
+
+// src/source_llm.ts
+var SOURCE_LLM_MAX_LEN = 64;
+function getSourceLlm(server2) {
+  const info = server2.server.getClientVersion();
+  if (!info || !info.name) return "unknown";
+  return `${info.name}/${info.version ?? "0"}`.slice(0, SOURCE_LLM_MAX_LEN);
+}
+
+// src/format_proposal.ts
+function validateFormatProposal(templateWorkoutType, payload) {
+  if (templateWorkoutType == null) {
+    return { kind: "classicOps" };
+  }
+  const hasOps = (payload.ops ?? []).length > 0;
+  const hasFormatParams = payload.formatParams !== void 0;
+  if (hasOps && hasFormatParams) {
+    return { kind: "refused", reason: "OPS_AND_FORMAT_PARAMS_EXCLUSIVE" };
+  }
+  if (templateWorkoutType === "CLASSIC") {
+    if (hasFormatParams) {
+      return { kind: "refused", reason: "FORMAT_PARAMS_NOT_ALLOWED" };
+    }
+    return { kind: "classicOps" };
+  }
+  if (!hasFormatParams) {
+    return { kind: "refused", reason: "FORMAT_PARAMS_REQUIRED" };
+  }
+  if (payload.formatParams.workoutType !== templateWorkoutType) {
+    return { kind: "refused", reason: "FORMAT_TYPE_MISMATCH" };
+  }
+  return { kind: "format" };
+}
+var FORMAT_REFUSAL_MESSAGES = {
+  FORMAT_PARAMS_REQUIRED: "This template is a format template \u2014 propose formatParams, not an ops[] diff.",
+  FORMAT_PARAMS_NOT_ALLOWED: "This template is CLASSIC \u2014 propose ops[], not formatParams.",
+  FORMAT_TYPE_MISMATCH: "formatParams.workoutType does not match the target template's own workoutType.",
+  OPS_AND_FORMAT_PARAMS_EXCLUSIVE: "A proposal may carry ops[] or formatParams, never both.",
+  UNKNOWN_FORMAT_TYPE: "formatParams.workoutType is not one of the eight recognized formats.",
+  FORMAT_PARAMS_INVALID: "formatParams violates a constraint the format editor itself enforces."
+};
+
+// src/tools/propose_plan_update.ts
+function rewriteFormatParamsRefs(formatParams, rewriteRef) {
+  const rewriteEntry = (entry) => ({
+    ...entry,
+    exercise: rewriteRef(entry.exercise)
+  });
+  switch (formatParams.workoutType) {
+    case "CIRCUIT":
+      return { ...formatParams, exercises: formatParams.exercises.map(rewriteEntry) };
+    case "EMOM":
+      return { ...formatParams, stations: formatParams.stations.map(rewriteEntry) };
+    case "AMRAP":
+      return { ...formatParams, exercises: formatParams.exercises.map(rewriteEntry) };
+    case "TABATA":
+      return { ...formatParams, exercises: formatParams.exercises.map(rewriteEntry) };
+    case "LADDER":
+      return { ...formatParams, exercises: formatParams.exercises.map(rewriteEntry) };
+    case "FOR_TIME":
+      return { ...formatParams, exercises: formatParams.exercises.map(rewriteEntry) };
+    case "CHIPPER":
+      return { ...formatParams, exercises: formatParams.exercises.map(rewriteEntry) };
+    case "DEATH_BY":
+      return { ...formatParams, exercises: formatParams.exercises.map(rewriteEntry) };
+  }
+}
+function buildPlanUpdatePayload(args, catalog) {
+  const tempIdToUuid = /* @__PURE__ */ new Map();
+  const remainingNewExercises = [];
+  for (const entry of args.newExercises ?? []) {
+    const match = findCatalogMatch(entry.name, catalog);
+    if (match) {
+      tempIdToUuid.set(entry.tempId, match.id);
+    } else {
+      remainingNewExercises.push(entry);
+    }
+  }
+  const rewriteRef = (ref) => {
+    if (ref.source === "new" && tempIdToUuid.has(ref.tempId)) {
+      return { source: "catalog", exerciseId: tempIdToUuid.get(ref.tempId) };
+    }
+    return ref;
+  };
+  const ops = (args.ops ?? []).map((op) => {
+    if (op.op === "addExercise") {
+      return { ...op, exercise: rewriteRef(op.exercise) };
+    }
+    return op;
+  });
+  return {
+    templateId: args.templateId,
+    ops,
+    newExercises: remainingNewExercises,
+    ...args.formatParams !== void 0 ? { formatParams: rewriteFormatParamsRefs(args.formatParams, rewriteRef) } : {}
+  };
+}
+var FORMAT_PARAMS_ON_UNTYPED_TEMPLATE_REASON = "FORMAT_PARAMS_ON_UNTYPED_TEMPLATE";
+var FORMAT_PARAMS_ON_UNTYPED_TEMPLATE_MESSAGE = "This template's own format type is not known to the coach yet (its workoutType is absent or has not been re-synced) \u2014 a whole-parameter formatParams proposal cannot be applied to it. Propose an ops[] diff instead.";
+var EMPTY_PLAN_UPDATE_REASON = "EMPTY_PLAN_UPDATE";
+var EMPTY_PLAN_UPDATE_MESSAGE = "This proposal carries no ops[] and no formatParams \u2014 nothing to propose.";
+function registerToolProposePlanUpdate(server2, cfg) {
+  const { pat: pat2, keyB64: keyB642, serverUrl: serverUrl2 } = cfg;
+  server2.registerTool(
+    "propose_plan_update",
+    {
+      title: "Propose Plan Update",
+      description: "Propose a structural change to an existing workout template for human review. Against a CLASSIC template, pass an `ops[]` diff (add/remove/update-sets-reps/reorder). Against a format template (CIRCUIT/EMOM/AMRAP/TABATA/LADDER/FOR_TIME/CHIPPER/DEATH_BY \u2014 check `get_template`'s `workoutType`), pass `formatParams` instead: the complete new authoring parameters for that format, never an ops[] diff \u2014 the compiled rows are recomputed from formatParams on every save and an ops[] diff against them would be silently discarded. Exactly one of `ops`/`formatParams` may be set. Never mutates directly \u2014 the proposal is transported to the coach inbox for accept/reject. Fast-fails with an error (no network call) if the templateId is not found in the local snapshot, or if the proposal shape does not match the target template's own format. Inline `newExercises[]` entries that match an existing catalog exercise are automatically resolved to that catalog UUID instead of being proposed as duplicates.",
+      inputSchema: ProposePlanUpdateSchema,
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
+    },
+    async (args) => {
+      try {
+        const typedArgs = args;
+        const data = await getSnapshot(pat2, keyB642, serverUrl2);
+        const tpl = getTemplate({ templateId: typedArgs.templateId }, data.snapshot);
+        if (!tpl || tpl.deletedAt != null) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Template not found: ${typedArgs.templateId}` }]
+          };
+        }
+        const verdict = validateFormatProposal(tpl.workoutType, typedArgs);
+        if (verdict.kind === "refused") {
+          return {
+            isError: true,
+            content: [
+              { type: "text", text: `${verdict.reason}: ${FORMAT_REFUSAL_MESSAGES[verdict.reason]}` }
+            ]
+          };
+        }
+        if (verdict.kind === "classicOps" && typedArgs.formatParams !== void 0) {
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: `${FORMAT_PARAMS_ON_UNTYPED_TEMPLATE_REASON}: ${FORMAT_PARAMS_ON_UNTYPED_TEMPLATE_MESSAGE}`
+              }
+            ]
+          };
+        }
+        const argsForPayload = verdict.kind === "format" ? typedArgs : { ...typedArgs, formatParams: void 0 };
+        const payload = buildPlanUpdatePayload(argsForPayload, data.catalog);
+        if (payload.formatParams === void 0 && payload.ops.length === 0) {
+          return {
+            isError: true,
+            content: [
+              { type: "text", text: `${EMPTY_PLAN_UPDATE_REASON}: ${EMPTY_PLAN_UPDATE_MESSAGE}` }
+            ]
+          };
+        }
+        const planHash = computePlanHash(typedArgs.templateId, data.snapshot);
+        const changeHash = computeChangeHash("plan_update", payload);
+        const sourceLlm = getSourceLlm(server2);
+        const result = await postSuggest(
+          {
+            type: "plan_update",
+            payload: JSON.stringify(payload),
+            rationale: typedArgs.rationale,
+            sourceLlm,
+            changeHash,
+            planHash
+          },
+          pat2,
+          serverUrl2
+        );
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        if (err instanceof HttpError) {
+          console.error(`propose_plan_update: server ${err.status}`);
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Server rejected proposal: HTTP ${err.status}` }]
+          };
+        }
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Propose plan update error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/propose_new_plan.ts
+function buildNewPlanPayload(args, catalog) {
+  const tempIdToUuid = /* @__PURE__ */ new Map();
+  const remainingNewExercises = [];
+  for (const entry of args.newExercises ?? []) {
+    const match = findCatalogMatch(entry.name, catalog);
+    if (match) {
+      tempIdToUuid.set(entry.tempId, match.id);
+    } else {
+      remainingNewExercises.push(entry);
+    }
+  }
+  const rewriteRef = (ref) => {
+    if (ref.source === "new" && tempIdToUuid.has(ref.tempId)) {
+      return { source: "catalog", exerciseId: tempIdToUuid.get(ref.tempId) };
+    }
+    return ref;
+  };
+  const blocks = args.blocks.map((block) => ({
+    tempBlockId: block.tempBlockId,
+    rounds: block.rounds,
+    orderIndex: block.orderIndex,
+    exercises: block.exercises.map((ex) => ({
+      exercise: rewriteRef(ex.exercise),
+      mode: ex.mode,
+      ...ex.targetReps !== void 0 ? { targetReps: ex.targetReps } : {},
+      ...ex.targetTimeSeconds !== void 0 ? { targetTimeSeconds: ex.targetTimeSeconds } : {},
+      restTimeSeconds: ex.restTimeSeconds,
+      sets: ex.sets,
+      ...ex.targetWeight !== void 0 ? { targetWeight: ex.targetWeight } : {},
+      orderIndex: ex.orderIndex,
+      ...ex.roundTargets !== void 0 ? { roundTargets: ex.roundTargets } : {}
+    }))
+  }));
+  return { name: args.name, blocks, newExercises: remainingNewExercises };
+}
+function registerToolProposeNewPlan(server2, cfg) {
+  const { pat: pat2, keyB64: keyB642, serverUrl: serverUrl2 } = cfg;
+  server2.registerTool(
+    "propose_new_plan",
+    {
+      title: "Propose New Plan",
+      description: "Propose a brand-new workout plan (blocks + exercises) for human review. Never creates it directly \u2014 the proposal is transported to the coach inbox for accept/reject. Inline `newExercises[]` entries that match an existing catalog exercise are automatically resolved to that catalog UUID instead of being proposed as duplicates.",
+      inputSchema: ProposeNewPlanSchema,
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
+    },
+    async (args) => {
+      try {
+        const typedArgs = args;
+        const data = await getSnapshot(pat2, keyB642, serverUrl2);
+        const payload = buildNewPlanPayload(typedArgs, data.catalog);
+        const changeHash = computeChangeHash("new_plan", payload);
+        const sourceLlm = getSourceLlm(server2);
+        const result = await postSuggest(
+          {
+            type: "new_plan",
+            payload: JSON.stringify(payload),
+            rationale: typedArgs.rationale,
+            sourceLlm,
+            changeHash
+          },
+          pat2,
+          serverUrl2
+        );
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        if (err instanceof HttpError) {
+          console.error(`propose_new_plan: server ${err.status}`);
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Server rejected proposal: HTTP ${err.status}` }]
+          };
+        }
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Propose new plan error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/propose_new_exercise.ts
+function registerToolProposeNewExercise(server2, cfg) {
+  const { pat: pat2, keyB64: keyB642, serverUrl: serverUrl2 } = cfg;
+  server2.registerTool(
+    "propose_new_exercise",
+    {
+      title: "Propose New Exercise",
+      description: "Propose a brand-new custom exercise for human review. Never creates it directly \u2014 the proposal is transported to the coach inbox for accept/reject. If the name matches an existing catalog exercise, returns the existing UUID instead of proposing a duplicate.",
+      inputSchema: ProposeNewExerciseSchema,
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
+    },
+    async (args) => {
+      try {
+        const typedArgs = args;
+        const data = await getSnapshot(pat2, keyB642, serverUrl2);
+        const match = findCatalogMatch(typedArgs.name, data.catalog);
+        if (match) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ dedupedTo: match.id }) }]
+          };
+        }
+        const payload = {
+          name: typedArgs.name,
+          mode: typedArgs.mode,
+          usesWeight: typedArgs.usesWeight,
+          ...typedArgs.description ? { description: typedArgs.description } : {}
+        };
+        const changeHash = computeChangeHash("new_exercise", payload);
+        const sourceLlm = getSourceLlm(server2);
+        const result = await postSuggest(
+          {
+            type: "new_exercise",
+            payload: JSON.stringify(payload),
+            rationale: typedArgs.rationale,
+            sourceLlm,
+            changeHash
+          },
+          pat2,
+          serverUrl2
+        );
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        if (err instanceof HttpError) {
+          console.error(`propose_new_exercise: server ${err.status}`);
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Server rejected proposal: HTTP ${err.status}` }]
+          };
+        }
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Propose new exercise error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/propose_planned_update.ts
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/rrule-allowlist.ts
+var ALLOWED_PARAMS = /* @__PURE__ */ new Set(["FREQ", "INTERVAL", "BYDAY", "BYMONTHDAY", "UNTIL"]);
+var ALLOWED_FREQ = /* @__PURE__ */ new Set(["DAILY", "WEEKLY", "MONTHLY"]);
+var ALLOWED_BYDAY = /* @__PURE__ */ new Set(["MO", "TU", "WE", "TH", "FR", "SA", "SU"]);
+var REPLACEMENTS = {
+  COUNT_NOT_SUPPORTED: "UNTIL=YYYYMMDD",
+  YEARLY_NOT_SUPPORTED: "FREQ=MONTHLY;INTERVAL=12",
+  BYSETPOS_NOT_SUPPORTED: null,
+  ORDINAL_BYDAY_NOT_SUPPORTED: "BYDAY=MO combined with INTERVAL",
+  MULTI_VALUE_BYMONTHDAY_NOT_SUPPORTED: "a single BYMONTHDAY value, or two roots sharing one recurrenceGroupId",
+  INTERVAL_MUST_BE_POSITIVE: "INTERVAL must be 1 or greater",
+  BYMONTHDAY_OUT_OF_RANGE: "BYMONTHDAY must be between 1 and 31",
+  UNKNOWN_TOKEN: "Omit the token \u2014 the grammar above is the full closed allowlist"
+};
+function reject(code) {
+  return { valid: false, reasonCode: code, replacement: REPLACEMENTS[code] };
+}
+function parseRRuleParams(rrule) {
+  const params = {};
+  for (const part of rrule.split(";")) {
+    const idx = part.indexOf("=");
+    if (idx < 0) {
+      params[part] = "";
+    } else {
+      params[part.slice(0, idx)] = part.slice(idx + 1);
+    }
+  }
+  return params;
+}
+function parseIntOrNull2(s) {
+  if (!/^[+-]?\d+$/.test(s)) return null;
+  const n = Number(s);
+  if (!Number.isSafeInteger(n)) return null;
+  return n >= -2147483648 && n <= 2147483647 ? n : null;
+}
+function isValidUntilDate(value) {
+  if (!/^\d{8}$/.test(value)) return false;
+  const y = value.slice(0, 4);
+  const m = value.slice(4, 6);
+  const d = value.slice(6, 8);
+  try {
+    parseIsoDate(`${y}-${m}-${d}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateRRule(rrule) {
+  if (rrule == null || rrule.trim() === "") return { valid: true };
+  const params = parseRRuleParams(rrule);
+  if ("COUNT" in params) return reject("COUNT_NOT_SUPPORTED");
+  if ("BYSETPOS" in params) return reject("BYSETPOS_NOT_SUPPORTED");
+  for (const key of Object.keys(params)) {
+    if (!ALLOWED_PARAMS.has(key)) return reject("UNKNOWN_TOKEN");
+  }
+  const freq = params.FREQ;
+  if (freq === "YEARLY") return reject("YEARLY_NOT_SUPPORTED");
+  if (freq !== void 0 && !ALLOWED_FREQ.has(freq)) return reject("UNKNOWN_TOKEN");
+  if (params.BYDAY !== void 0) {
+    const codes = params.BYDAY.split(",").map((c) => c.trim());
+    if (codes.some((c) => !ALLOWED_BYDAY.has(c))) return reject("ORDINAL_BYDAY_NOT_SUPPORTED");
+  }
+  if (params.BYMONTHDAY !== void 0) {
+    if (params.BYMONTHDAY.includes(",")) return reject("MULTI_VALUE_BYMONTHDAY_NOT_SUPPORTED");
+    const value = parseIntOrNull2(params.BYMONTHDAY);
+    if (value === null || value < 1 || value > 31) return reject("BYMONTHDAY_OUT_OF_RANGE");
+  }
+  if (params.INTERVAL !== void 0) {
+    const value = parseIntOrNull2(params.INTERVAL);
+    if (value === null || value < 1) return reject("INTERVAL_MUST_BE_POSITIVE");
+  }
+  if (params.UNTIL !== void 0) {
+    if (!isValidUntilDate(params.UNTIL)) return reject("UNKNOWN_TOKEN");
+  }
+  return { valid: true };
+}
+
+// src/series-hash.ts
+import { createHash as createHash2 } from "crypto";
+function parseDeduplicatedSorted(raw) {
+  if (raw === null || raw.trim() === "") return [];
+  let body = raw.trim();
+  if (body.length >= 2 && body.startsWith("[") && body.endsWith("]")) {
+    body = body.slice(1, -1);
+  }
+  const dates = [];
+  for (const rawToken of body.split(",")) {
+    let token = rawToken.trim();
+    if (token.length >= 2 && token.startsWith('"') && token.endsWith('"')) {
+      token = token.slice(1, -1);
+    }
+    if (token === "") continue;
+    dates.push(token);
+  }
+  return Array.from(new Set(dates)).sort();
+}
+function canonicalSeriesString(roots) {
+  const sorted = [...roots].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  const objects = sorted.map((r) => ({
+    id: r.id,
+    templateId: r.templateId,
+    scheduledDate: r.scheduledDate,
+    scheduledTime: r.scheduledTime ?? null,
+    recurrenceRule: r.recurrenceRule ?? null,
+    recurrenceGroupId: r.recurrenceGroupId ?? null,
+    deletedOccurrences: parseDeduplicatedSorted(r.deletedOccurrencesRaw)
+  }));
+  return canonicalStringify(objects);
+}
+function computeSeriesHash(roots) {
+  return createHash2("sha256").update(canonicalSeriesString(roots), "utf8").digest("hex");
+}
+
+// src/tools/propose_planned_update.ts
+var PlannedUpdateRejection = class extends Error {
+  constructor(cause, message) {
+    super(message);
+    this.cause = cause;
+    this.name = "PlannedUpdateRejection";
+  }
+  cause;
+};
+function buildMoveOccurrenceEnvelope(args, root) {
+  const isRecurring = root.recurrenceRule !== null && root.recurrenceRule.trim() !== "";
+  const existingDeleted = parseDeletedOccurrences(root.deletedOccurrencesRaw);
+  const newScheduledTime = args.newTime ?? root.scheduledTime;
+  if (!isRecurring) {
+    const replaced = {
+      id: root.id,
+      templateId: root.templateId,
+      scheduledDate: args.newDate,
+      scheduledTime: newScheduledTime,
+      note: root.note,
+      recurrenceRule: null,
+      recurrenceGroupId: null,
+      deletedOccurrences: existingDeleted
+    };
+    return {
+      kind: "occurrence",
+      scope: "this_occurrence",
+      roots: [{ operation: "replace", root: replaced }]
+    };
+  }
+  const newDeleted = Array.from(/* @__PURE__ */ new Set([...existingDeleted, args.occurrenceDate])).sort();
+  const originalScheduledDate = formatIsoDate(epochMsToUtcCalDate(root.scheduledDate));
+  const originalRoot = {
+    id: root.id,
+    templateId: root.templateId,
+    scheduledDate: originalScheduledDate,
+    scheduledTime: root.scheduledTime,
+    note: root.note,
+    recurrenceRule: root.recurrenceRule,
+    recurrenceGroupId: root.recurrenceGroupId,
+    deletedOccurrences: newDeleted
+  };
+  const newRoot = {
+    id: randomUUID2(),
+    templateId: root.templateId,
+    scheduledDate: args.newDate,
+    scheduledTime: newScheduledTime,
+    note: null,
+    recurrenceRule: null,
+    recurrenceGroupId: null,
+    deletedOccurrences: []
+  };
+  return {
+    kind: "occurrence",
+    scope: "this_occurrence",
+    roots: [
+      { operation: "replace", root: originalRoot },
+      { operation: "create", root: newRoot }
+    ]
+  };
+}
+function buildCancelOccurrenceEnvelope(args, root) {
+  const isRecurring = root.recurrenceRule !== null && root.recurrenceRule.trim() !== "";
+  const scheduledDate = formatIsoDate(epochMsToUtcCalDate(root.scheduledDate));
+  if (!isRecurring) {
+    const deleted = {
+      id: root.id,
+      templateId: root.templateId,
+      scheduledDate,
+      scheduledTime: root.scheduledTime,
+      note: root.note,
+      recurrenceRule: null,
+      recurrenceGroupId: null,
+      deletedOccurrences: []
+    };
+    return {
+      kind: "occurrence",
+      scope: "this_occurrence",
+      roots: [{ operation: "delete", root: deleted }]
+    };
+  }
+  const existingDeleted = parseDeletedOccurrences(root.deletedOccurrencesRaw);
+  const newDeleted = Array.from(/* @__PURE__ */ new Set([...existingDeleted, args.occurrenceDate])).sort();
+  const replaced = {
+    id: root.id,
+    templateId: root.templateId,
+    scheduledDate,
+    scheduledTime: root.scheduledTime,
+    note: root.note,
+    recurrenceRule: root.recurrenceRule,
+    recurrenceGroupId: root.recurrenceGroupId,
+    deletedOccurrences: newDeleted
+  };
+  return {
+    kind: "occurrence",
+    scope: "this_occurrence",
+    roots: [{ operation: "replace", root: replaced }]
+  };
+}
+function buildScheduleWorkoutEnvelope(args) {
+  const created = {
+    id: randomUUID2(),
+    ...args.templateId !== void 0 ? { templateId: args.templateId } : {},
+    ...args.chainSuggestionId !== void 0 ? { chainSuggestionId: args.chainSuggestionId } : {},
+    scheduledDate: args.date,
+    scheduledTime: args.time ?? null,
+    note: null,
+    recurrenceRule: args.recurrenceRule ?? null,
+    recurrenceGroupId: null,
+    deletedOccurrences: []
+  };
+  return {
+    kind: "occurrence",
+    scope: "this_occurrence",
+    roots: [{ operation: "create", root: created }]
+  };
+}
+function replaceOrAppendUntil(rrule, untilWire) {
+  const parts = rrule.split(";");
+  let found = false;
+  const updated = parts.map((part) => {
+    const eqIdx = part.indexOf("=");
+    const key = eqIdx === -1 ? part : part.slice(0, eqIdx);
+    if (key === "UNTIL") {
+      found = true;
+      return `UNTIL=${untilWire}`;
+    }
+    return part;
+  });
+  if (!found) updated.push(`UNTIL=${untilWire}`);
+  return updated.join(";");
+}
+function splitMemberAtCutoff(member, cutoffDate, newRecurrenceRule) {
+  const cutoffCal = parseIsoDate(cutoffDate);
+  const memberScheduledCal = epochMsToUtcCalDate(member.scheduledDate);
+  const memberScheduledIso = formatIsoDate(memberScheduledCal);
+  const existingDeleted = parseDeletedOccurrences(member.deletedOccurrencesRaw);
+  const before = existingDeleted.filter((d) => compareCalDate(parseIsoDate(d), cutoffCal) < 0);
+  const onOrAfter = existingDeleted.filter((d) => compareCalDate(parseIsoDate(d), cutoffCal) >= 0);
+  if (compareCalDate(cutoffCal, memberScheduledCal) <= 0) {
+    assertRuleEmittableOnRoot(newRecurrenceRule, memberScheduledIso, member.id);
+    const replaced = {
+      id: member.id,
+      templateId: member.templateId,
+      scheduledDate: memberScheduledIso,
+      scheduledTime: member.scheduledTime,
+      note: member.note,
+      recurrenceRule: newRecurrenceRule,
+      recurrenceGroupId: member.recurrenceGroupId,
+      deletedOccurrences: onOrAfter
+    };
+    return [{ operation: "replace", root: replaced }];
+  }
+  const untilCal = plusDays(cutoffCal, -1);
+  const untilWire = formatIsoDate(untilCal).replace(/-/g, "");
+  const clampedRule = replaceOrAppendUntil(member.recurrenceRule, untilWire);
+  assertRuleEmittableOnRoot(clampedRule, memberScheduledIso, member.id);
+  const oldRoot = {
+    id: member.id,
+    templateId: member.templateId,
+    scheduledDate: memberScheduledIso,
+    scheduledTime: member.scheduledTime,
+    note: member.note,
+    recurrenceRule: clampedRule,
+    recurrenceGroupId: member.recurrenceGroupId,
+    deletedOccurrences: before
+  };
+  const newRootId = randomUUID2();
+  assertRuleEmittableOnRoot(newRecurrenceRule, cutoffDate, newRootId);
+  const newRoot = {
+    id: newRootId,
+    templateId: member.templateId,
+    scheduledDate: cutoffDate,
+    scheduledTime: member.scheduledTime,
+    note: null,
+    recurrenceRule: newRecurrenceRule,
+    recurrenceGroupId: member.recurrenceGroupId,
+    deletedOccurrences: onOrAfter
+  };
+  return [
+    { operation: "replace", root: oldRoot },
+    { operation: "create", root: newRoot }
+  ];
+}
+function buildChangeSeriesRuleEnvelope(args, members) {
+  if (args.scope === "whole_series") {
+    const roots2 = members.map((member) => {
+      const memberScheduledIso = formatIsoDate(epochMsToUtcCalDate(member.scheduledDate));
+      assertRuleEmittableOnRoot(args.newRecurrenceRule, memberScheduledIso, member.id);
+      return {
+        operation: "replace",
+        root: {
+          id: member.id,
+          templateId: member.templateId,
+          scheduledDate: memberScheduledIso,
+          scheduledTime: member.scheduledTime,
+          note: member.note,
+          recurrenceRule: args.newRecurrenceRule,
+          recurrenceGroupId: member.recurrenceGroupId,
+          deletedOccurrences: parseDeletedOccurrences(member.deletedOccurrencesRaw)
+        }
+      };
+    });
+    return { kind: "rule", scope: "whole_series", roots: roots2 };
+  }
+  const cutoffDate = args.cutoffDate;
+  const roots = [];
+  for (const member of members) {
+    roots.push(...splitMemberAtCutoff(member, cutoffDate, args.newRecurrenceRule));
+  }
+  return { kind: "rule", scope: "this_and_following", roots };
+}
+function findRoot(data, rootId) {
+  const root = data.snapshot.plannedWorkouts.find((r) => r.id === rootId);
+  if (!root) {
+    throw new PlannedUpdateRejection("ROOT_NOT_FOUND", `Unknown rootId: ${rootId}`);
+  }
+  return root;
+}
+function validateStoredRule(root) {
+  const rruleCheck = validateRRule(root.recurrenceRule);
+  if (!rruleCheck.valid) {
+    throw new PlannedUpdateRejection(
+      rruleCheck.reasonCode,
+      `Stored recurrenceRule for root ${root.id} is rejected by the allowlist: ${rruleCheck.reasonCode}`
+    );
+  }
+}
+function assertRuleEmittableOnRoot(rule, dtstartIso, rootId) {
+  const rruleCheck = validateRRule(rule);
+  if (!rruleCheck.valid) {
+    throw new PlannedUpdateRejection(
+      rruleCheck.reasonCode,
+      `recurrenceRule "${rule}" for root ${rootId} is rejected by the allowlist: ${rruleCheck.reasonCode}`
+    );
+  }
+  const until = parseRRuleConfig(rule).until;
+  if (until !== null && compareCalDate(parseIsoDate(until), parseIsoDate(dtstartIso)) < 0) {
+    throw new PlannedUpdateRejection(
+      "RULE_NOT_EMITTABLE",
+      `recurrenceRule "${rule}" for root ${rootId} has UNTIL=${until}, which precedes its own scheduledDate ${dtstartIso} \u2014 this rule can never emit an occurrence on this root`
+    );
+  }
+}
+function confirmOccurrence(root, occurrenceDate, options) {
+  const dtstart = epochMsToUtcCalDate(root.scheduledDate);
+  const deletedSet = options?.ignoreDeleted ? /* @__PURE__ */ new Set() : new Set(parseDeletedOccurrences(root.deletedOccurrencesRaw));
+  const occurrenceDateCal = parseIsoDate(occurrenceDate);
+  const expansion = expandDates(dtstart, root.recurrenceRule, occurrenceDateCal, occurrenceDateCal, deletedSet, root.id);
+  if (expansion.length === 0) {
+    throw new PlannedUpdateRejection(
+      "OCCURRENCE_NOT_IN_EXPANSION",
+      `occurrenceDate ${occurrenceDate} is not an occurrence of root ${root.id}`
+    );
+  }
+}
+function resolveGroupMembers(data, root) {
+  if (root.recurrenceGroupId === null) return [root];
+  const members = data.snapshot.plannedWorkouts.filter((r) => r.recurrenceGroupId === root.recurrenceGroupId).slice().sort((a, b) => a.scheduledDate - b.scheduledDate);
+  const incomplete = members.find((m) => m.recurrenceRule === null || m.recurrenceRule.trim() === "");
+  if (incomplete) {
+    throw new PlannedUpdateRejection(
+      "PARTIAL_GROUP_REJECTED",
+      `recurrenceGroupId ${root.recurrenceGroupId} has member ${incomplete.id} with no recurrenceRule \u2014 multi-root groups are indivisible (protocol \xA72), refusing to split a partial group`
+    );
+  }
+  return members;
+}
+function resolveBeforeStateRoots(data, envelope) {
+  const ids = /* @__PURE__ */ new Set();
+  const groupIds = /* @__PURE__ */ new Set();
+  for (const op of envelope.roots) {
+    ids.add(op.root.id);
+    if (op.root.recurrenceGroupId !== null) {
+      groupIds.add(op.root.recurrenceGroupId);
+    }
+  }
+  for (const row of data.snapshot.plannedWorkouts) {
+    if (row.recurrenceGroupId !== null && groupIds.has(row.recurrenceGroupId)) {
+      ids.add(row.id);
+    }
+  }
+  const rows = [];
+  for (const id of ids) {
+    const row = data.snapshot.plannedWorkouts.find((r) => r.id === id);
+    if (row !== void 0) {
+      rows.push(row);
+    }
+  }
+  return rows;
+}
+function storedRootToSeriesHashRoot(row) {
+  return {
+    id: row.id,
+    templateId: row.templateId,
+    scheduledDate: row.scheduledDate,
+    scheduledTime: row.scheduledTime,
+    recurrenceRule: row.recurrenceRule,
+    recurrenceGroupId: row.recurrenceGroupId,
+    deletedOccurrencesRaw: row.deletedOccurrencesRaw
+  };
+}
+async function proposePlannedUpdate(args, cfg) {
+  const data = await getSnapshot(cfg.pat, cfg.keyB64, cfg.serverUrl);
+  let envelope;
+  switch (args.intent) {
+    case "move_occurrence": {
+      const root = findRoot(data, args.rootId);
+      validateStoredRule(root);
+      confirmOccurrence(root, args.occurrenceDate);
+      envelope = buildMoveOccurrenceEnvelope(args, root);
+      break;
+    }
+    case "cancel_occurrence": {
+      const root = findRoot(data, args.rootId);
+      validateStoredRule(root);
+      confirmOccurrence(root, args.occurrenceDate, { ignoreDeleted: true });
+      envelope = buildCancelOccurrenceEnvelope(args, root);
+      break;
+    }
+    case "schedule_workout": {
+      if (args.templateId === void 0 === (args.chainSuggestionId === void 0)) {
+        throw new PlannedUpdateRejection(
+          "CHAIN_EXCLUSIVITY",
+          "schedule_workout requires exactly one of templateId or chainSuggestionId, never both, never neither"
+        );
+      }
+      if (args.chainSuggestionId !== void 0) {
+        const referenced = await fetchSuggestion(cfg, args.chainSuggestionId);
+        if (!referenced) {
+          throw new PlannedUpdateRejection(
+            "CHAIN_SUGGESTION_NOT_FOUND",
+            `Unknown or foreign chainSuggestionId: ${args.chainSuggestionId}`
+          );
+        }
+        if (referenced.type !== "new_plan") {
+          throw new PlannedUpdateRejection(
+            "CHAIN_SUGGESTION_WRONG_TYPE",
+            `chainSuggestionId ${args.chainSuggestionId} does not reference a new_plan proposal (type: ${referenced.type})`
+          );
+        }
+        if (referenced.status !== "pending") {
+          throw new PlannedUpdateRejection(
+            "CHAIN_SUGGESTION_NOT_PENDING",
+            `chainSuggestionId ${args.chainSuggestionId} is no longer pending (status: ${referenced.status})`
+          );
+        }
+      } else {
+        const template = data.snapshot.templates.find((t) => t.id === args.templateId);
+        if (!template) {
+          throw new PlannedUpdateRejection("TEMPLATE_NOT_FOUND", `Unknown templateId: ${args.templateId}`);
+        }
+      }
+      const rruleCheck = validateRRule(args.recurrenceRule);
+      if (!rruleCheck.valid) {
+        throw new PlannedUpdateRejection(
+          rruleCheck.reasonCode,
+          `recurrenceRule is rejected by the allowlist: ${rruleCheck.reasonCode}` + (rruleCheck.replacement !== null ? ` (permitted substitute: ${rruleCheck.replacement})` : "")
+        );
+      }
+      envelope = buildScheduleWorkoutEnvelope(args);
+      break;
+    }
+    case "change_series_rule": {
+      const root = findRoot(data, args.rootId);
+      if (root.recurrenceRule === null || root.recurrenceRule.trim() === "") {
+        throw new PlannedUpdateRejection(
+          "NO_RECURRENCE_RULE",
+          `root ${args.rootId} has no recurrenceRule \u2014 there is no series to change`
+        );
+      }
+      const members = resolveGroupMembers(data, root);
+      const rruleCheck = validateRRule(args.newRecurrenceRule);
+      if (!rruleCheck.valid) {
+        throw new PlannedUpdateRejection(
+          rruleCheck.reasonCode,
+          `newRecurrenceRule is rejected by the allowlist: ${rruleCheck.reasonCode}` + (rruleCheck.replacement !== null ? ` (permitted substitute: ${rruleCheck.replacement})` : "")
+        );
+      }
+      if (args.scope === "this_and_following" && args.cutoffDate === void 0) {
+        throw new PlannedUpdateRejection(
+          "MISSING_CUTOFF_DATE",
+          "cutoffDate is required when scope is this_and_following"
+        );
+      }
+      envelope = buildChangeSeriesRuleEnvelope(args, members);
+      break;
+    }
+  }
+  const seriesHash = computeSeriesHash(resolveBeforeStateRoots(data, envelope).map(storedRootToSeriesHashRoot));
+  const changeHash = computeChangeHash("planned_update", envelope);
+  const result = await postSuggest(
+    {
+      type: "planned_update",
+      payload: JSON.stringify(envelope),
+      rationale: args.rationale,
+      sourceLlm: cfg.sourceLlm,
+      changeHash,
+      seriesHash
+    },
+    cfg.pat,
+    cfg.serverUrl
+  );
+  return { suggestionId: result.id, status: result.status };
+}
+function registerToolProposePlannedUpdate(server2, cfg) {
+  const { pat: pat2, keyB64: keyB642, serverUrl: serverUrl2 } = cfg;
+  server2.registerTool(
+    "propose_planned_update",
+    {
+      title: "Propose Planned Update",
+      description: "Propose a change to the calendar for human review \u2014 name an intent, never a raw envelope. Four intents: move_occurrence (reschedule one occurrence, identified by rootId + occurrenceDate, to newDate), cancel_occurrence (cancel one occurrence, identified by rootId + occurrenceDate), schedule_workout (create a standalone or recurring root for templateId on date, optionally recurrenceRule), and change_series_rule (replace rootId's recurrence rule at scope whole_series or this_and_following \u2014 the latter requires cutoffDate and splits the series there). All root/template ids and dates come from get_planned_workouts. Rejects with a named cause \u2014 no network call \u2014 for an unknown root or template, an occurrenceDate that is not actually an occurrence of that root, a recurrence rule that fails allowlist validation, a root with no recurrence rule to change, or a recurrenceGroupId group that is not fully intact. Never mutates directly \u2014 the proposal is transported to the coach inbox for accept/reject.",
+      inputSchema: ProposePlannedUpdateSchema,
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
+    },
+    async (args) => {
+      try {
+        const typedArgs = args;
+        const sourceLlm = getSourceLlm(server2);
+        const result = await proposePlannedUpdate(typedArgs, { pat: pat2, keyB64: keyB642, serverUrl: serverUrl2, sourceLlm });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        if (err instanceof PlannedUpdateRejection) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: `${err.cause}: ${err.message}` }]
+          };
+        }
+        if (err instanceof HttpError) {
+          console.error(`propose_planned_update: server ${err.status}`);
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Server rejected proposal: HTTP ${err.status}` }]
+          };
+        }
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Propose planned update error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/get_suggestions.ts
+var DEFAULT_LIMIT = 200;
+var MIN_LIMIT = 1;
+var MAX_LIMIT = 500;
+function clampSuggestionsLimit(limit) {
+  if (limit === void 0) return DEFAULT_LIMIT;
+  return Math.min(MAX_LIMIT, Math.max(MIN_LIMIT, limit));
+}
+async function getSuggestions(args, cfg) {
+  return fetchSuggestions(cfg, args.status, clampSuggestionsLimit(args.limit));
+}
+function registerToolGetSuggestions(server2, cfg) {
+  server2.registerTool(
+    "get_suggestions",
+    {
+      title: "Get Coach Suggestions",
+      description: "List the coach's own proposals as cheap summary rows, newest first: id, type, status, created date, a human-readable target label, and a short rationale. No payload included. Call this first; call `get_suggestion` with one id only when you need the full proposal, including its outcome (`appliedPayload` for a modified accept). Optional `status` filter (pending, accepted, accepted_modified, rejected, expired, withdrawn, obsolete); optional `limit` (default 200, clamped to 1..500). Empty array, never an error, when you have no proposals.",
+      inputSchema: GetSuggestionsSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async (args) => {
+      try {
+        const result = await getSuggestions(args, cfg);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Get suggestions error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/get_suggestion.ts
+async function getSuggestion(args, cfg) {
+  return fetchSuggestion(cfg, args.id);
+}
+function registerToolGetSuggestion(server2, cfg) {
+  server2.registerTool(
+    "get_suggestion",
+    {
+      title: "Get Coach Suggestion",
+      description: "Return one of the coach's own proposals in full, including `payload` and \u2014 for a modified accept \u2014 `appliedPayload`. Pass an id from `get_suggestions`. Returns an error if the proposal is not found (unknown id, or an id that is not one of yours).",
+      inputSchema: GetSuggestionSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async (args) => {
+      try {
+        const typedArgs = args;
+        const result = await getSuggestion(typedArgs, cfg);
+        if (!result) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Suggestion not found: ${typedArgs.id}` }]
+          };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Get suggestion error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/withdraw_suggestion.ts
+var SuggestionNotWithdrawableError = class extends Error {
+  constructor() {
+    super("Suggestion not withdrawable: unknown, not yours, or no longer pending.");
+    this.name = "SuggestionNotWithdrawableError";
+  }
+};
+async function withdrawSuggestion(args, cfg) {
+  const outcome = await postWithdraw(cfg, args.id);
+  if (outcome === "not-withdrawable") {
+    throw new SuggestionNotWithdrawableError();
+  }
+  return { id: args.id, status: "withdrawn" };
+}
+function registerToolWithdrawSuggestion(server2, cfg) {
+  server2.registerTool(
+    "withdraw_suggestion",
+    {
+      title: "Withdraw Coach Suggestion",
+      description: "Retract one of your own proposals that is still pending \u2014 the single named exception to the propose-only boundary. Sets its status to withdrawn; the proposal is NOT deleted, its audit row survives and stays fully readable through `get_suggestion`. Withdrawing an already-withdrawn proposal is a harmless no-op. Fails with an error, worded identically regardless of cause, for an id that is unknown, not yours, or no longer pending (already accepted, rejected, or expired).",
+      inputSchema: WithdrawSuggestionSchema,
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true }
+    },
+    async (args) => {
+      try {
+        const typedArgs = args;
+        const result = await withdrawSuggestion(typedArgs, cfg);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        if (err instanceof SuggestionNotWithdrawableError) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: err.message }]
+          };
+        }
+        if (err instanceof HttpError) {
+          console.error(`withdraw_suggestion: server ${err.status}`);
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Server rejected withdraw: HTTP ${err.status}` }]
+          };
+        }
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Withdraw suggestion error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/get_coach_parameters.ts
+async function getCoachParameters(cfg) {
+  const { params, source } = await loadCoachParameters(cfg);
+  return describeCoachParameters(params, source);
+}
+function registerToolGetCoachParameters(server2, cfg) {
+  server2.registerTool(
+    "get_coach_parameters",
+    {
+      title: "Get Coach Parameters",
+      description: "Report the seven training-state tuning parameters: their default values, allowed ranges, and current values in one call. Call this BEFORE calling set_coach_parameters \u2014 it is the right first step to learn what can be set and what it currently is, rather than discovering the ranges by trial and error.",
+      inputSchema: GetCoachParametersSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      try {
+        const result = await getCoachParameters(cfg);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Coach parameters error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/set_coach_parameters.ts
+var CoachParametersValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CoachParametersValidationError";
+  }
+};
+var CoachParametersRejectedError = class extends Error {
+  constructor() {
+    super("Server rejected the coach-parameter update.");
+    this.name = "CoachParametersRejectedError";
+  }
+};
+async function setCoachParameters(args, cfg) {
+  const { params: current } = await loadCoachParameters(cfg);
+  const validation = coachParametersSchemaFor(current).safeParse(args);
+  if (!validation.success) {
+    const message = validation.error.issues.map((issue) => issue.message).join("; ");
+    throw new CoachParametersValidationError(message);
+  }
+  const outcome = await putCoachParameters(cfg, validation.data);
+  if (outcome === "rejected") {
+    throw new CoachParametersRejectedError();
+  }
+  return describeCoachParameters(mergeCoachParameters(outcome.params), "server");
+}
+function registerToolSetCoachParameters(server2, cfg) {
+  server2.registerTool(
+    "set_coach_parameters",
+    {
+      title: "Set Coach Parameters",
+      description: "Set one or more of the seven training-state tuning parameters. Call get_coach_parameters first to learn the defaults, allowed ranges, and current values. Rejects an out-of-range value or an invalid uncertainThreshold/matchThreshold combination before any change reaches the server. Returns the resulting overall parameter state.",
+      inputSchema: SetCoachParametersSchema,
+      annotations: { destructiveHint: false, idempotentHint: true }
+    },
+    async (args) => {
+      try {
+        const result = await setCoachParameters(args, cfg);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        if (err instanceof CoachParametersValidationError) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Invalid coach parameters: ${err.message}` }]
+          };
+        }
+        if (err instanceof CoachParametersRejectedError) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: err.message }]
+          };
+        }
+        if (err instanceof HttpError) {
+          console.error(`set_coach_parameters: server ${err.status}`);
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Server rejected coach parameters: HTTP ${err.status}` }]
+          };
+        }
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Set coach parameters error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/tools/get_adherence.ts
+function getAdherence(args, data, nowMs) {
+  const timeZoneId = resolveTimeZoneId(data.snapshot);
+  let from;
+  let to;
+  if (args.from !== void 0 && args.to !== void 0) {
+    from = args.from;
+    to = args.to;
+  } else {
+    to = toCalendarDay(nowMs, timeZoneId);
+    const weeks = args.windowWeeks ?? data.coachParameters.adherenceWindowWeeks;
+    from = formatIsoDate(plusDays(parseIsoDate(to), -weeks * 7));
+  }
+  const toleranceDays = args.toleranceDays ?? data.coachParameters.toleranceDays;
+  return computeAdherence(
+    {
+      from,
+      to,
+      toleranceDays,
+      matchThreshold: data.coachParameters.matchThreshold,
+      uncertainThreshold: data.coachParameters.uncertainThreshold
+    },
+    { snapshot: data.snapshot, catalog: data.catalog, timeZoneId }
+  );
+}
+function registerToolGetAdherence(server2, cfg) {
+  const { pat: pat2, keyB64: keyB642, serverUrl: serverUrl2 } = cfg;
+  server2.registerTool(
+    "get_adherence",
+    {
+      title: "Get Plan Adherence",
+      description: "Answer \"how well does the athlete keep to the plan\" over a window and tolerance you choose. Without `from`/`to`, the window ends today (the athlete's own calendar day) and spans back `windowWeeks` (default: the coach's own adherenceWindowWeeks parameter). `toleranceDays` and `windowWeeks` override the coach's persisted parameters for this one call only, without saving them. The result reports plannedCount, matchedCount, uncertainCount, missedCount, removedOccurrenceCount, adherenceRatio, the matched pairs (with their confidence and, for similarity-derived matches, the similarity value), the missed occurrences, and an explanation sentence describing what removedOccurrenceCount does and does NOT mean (verbatim: \"" + ADHERENCE_EXPLANATION + '"). Set `outputFile: true` to write the full pair/missed lists to a local file instead of returning them inline.',
+      inputSchema: GetAdherenceSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async (args) => {
+      try {
+        const data = await getSnapshot(pat2, keyB642, serverUrl2);
+        const { params, source } = await loadCoachParameters({ pat: pat2, serverUrl: serverUrl2 });
+        const result = getAdherence(
+          args,
+          { snapshot: data.snapshot, catalog: data.catalog, coachParameters: params },
+          Date.now()
+        );
+        const full = { ...result, parametersSource: source };
+        if (args.outputFile) {
+          const itemCount = result.matches.length + result.missed.length;
+          const handle = await writeExportFile(full, itemCount);
+          const summary = {
+            outputFile: { path: handle.path, bytes: handle.bytes, itemCount: handle.itemCount },
+            window: result.window,
+            toleranceDays: result.toleranceDays,
+            plannedCount: result.plannedCount,
+            matchedCount: result.matchedCount,
+            uncertainCount: result.uncertainCount,
+            missedCount: result.missedCount,
+            removedOccurrenceCount: result.removedOccurrenceCount,
+            adherenceRatio: result.adherenceRatio,
+            explanation: result.explanation,
+            parametersSource: source
+          };
+          return { content: [{ type: "text", text: JSON.stringify(summary) }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(full) }] };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Adherence error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/training-state/format-progress.ts
+function amrapSummary(rows, exercisesPerRound) {
+  const n = exercisesPerRound > 0 ? Math.floor(rows.length / exercisesPerRound) : 0;
+  const partial = rows.slice(n * exercisesPerRound);
+  const reps = partial.reduce((sum, r) => sum + (r.completedReps ?? 0), 0);
+  return { rounds: n, reps };
+}
+function deathBySummary(rows, roundCap) {
+  return { highestFullRound: rows.length, complete: rows.length >= roundCap };
+}
+function emomIntervals(rows) {
+  return rows.length;
+}
+var FORMAT_SUMMARY_TYPES = ["AMRAP", "DEATH_BY", "EMOM"];
+function parseAmrapExercisesPerRound(formatParams) {
+  if (formatParams == null) return 0;
+  try {
+    const parsed = JSON.parse(formatParams);
+    return Array.isArray(parsed.exercises) ? parsed.exercises.length : 0;
+  } catch {
+    return 0;
+  }
+}
+function parseDeathByRoundCap(formatParams) {
+  if (formatParams == null) return 30;
+  try {
+    const parsed = JSON.parse(formatParams);
+    return typeof parsed.roundCap === "number" ? parsed.roundCap : 30;
+  } catch {
+    return 30;
+  }
+}
+function computeFormatProgress(args, data) {
+  const { snapshot, timeZoneId } = data;
+  const templatesById = new Map(snapshot.templates.map((t) => [t.id, t]));
+  const setLogsBySessionId = /* @__PURE__ */ new Map();
+  for (const log of snapshot.setLogs) {
+    if (log.deletedAt !== void 0) continue;
+    const bucket = setLogsBySessionId.get(log.sessionId);
+    if (bucket) bucket.push(log);
+    else setLogsBySessionId.set(log.sessionId, [log]);
+  }
+  for (const rows of setLogsBySessionId.values()) {
+    rows.sort((a, b) => (a.startedAt ?? a.createdAt) - (b.startedAt ?? b.createdAt));
+  }
+  let skippedSessionCount = 0;
+  const sessionsByTemplateId = /* @__PURE__ */ new Map();
+  for (const session of snapshot.sessions) {
+    if (session.deletedAt !== void 0) continue;
+    if (session.endTime === void 0) continue;
+    if (session.templateId === void 0) continue;
+    const template = templatesById.get(session.templateId);
+    const workoutType = template?.workoutType;
+    const isKnownFormat = template !== void 0 && workoutType !== null && workoutType !== void 0 && FORMAT_SUMMARY_TYPES.includes(workoutType);
+    if (!isKnownFormat) {
+      skippedSessionCount += 1;
+      continue;
+    }
+    const bucket = sessionsByTemplateId.get(template.id);
+    if (bucket) bucket.push(session);
+    else sessionsByTemplateId.set(template.id, [session]);
+  }
+  const series = [];
+  for (const [templateId, sessions] of sessionsByTemplateId) {
+    if (args.templateId !== void 0 && templateId !== args.templateId) continue;
+    const template = templatesById.get(templateId);
+    if (template === void 0) continue;
+    const workoutType = template.workoutType;
+    const sortedSessions = [...sessions].sort((a, b) => a.startTime - b.startTime);
+    const points = sortedSessions.map((session) => {
+      const rows = setLogsBySessionId.get(session.id) ?? [];
+      const point = {
+        sessionId: session.id,
+        date: toCalendarDay(session.startTime, timeZoneId),
+        workoutType,
+        rounds: null,
+        reps: null,
+        intervals: null,
+        complete: null
+      };
+      if (workoutType === "AMRAP") {
+        const score = amrapSummary(rows, parseAmrapExercisesPerRound(template.formatParams));
+        point.rounds = score.rounds;
+        point.reps = score.reps;
+      } else if (workoutType === "DEATH_BY") {
+        const score = deathBySummary(rows, parseDeathByRoundCap(template.formatParams));
+        point.rounds = score.highestFullRound;
+        point.complete = score.complete;
+      } else if (workoutType === "EMOM") {
+        point.intervals = emomIntervals(rows);
+      }
+      return point;
+    });
+    const trimmedPoints = points.length > args.maxPoints ? points.slice(points.length - args.maxPoints) : points;
+    series.push({
+      templateId,
+      templateName: template.name,
+      workoutType,
+      points: trimmedPoints,
+      skippedSessionCount
+    });
+  }
+  return series;
+}
+
+// src/tools/get_progress.ts
+function getProgress(args, data) {
+  const timeZoneId = resolveTimeZoneId(data.snapshot);
+  const maxPoints = args.points ?? data.coachParameters.exerciseTrendPoints;
+  if (args.kind === "exercise") {
+    const series2 = computeExerciseProgress(
+      {
+        exerciseId: args.exerciseId,
+        maxPoints,
+        recentExerciseCount: data.coachParameters.recentExerciseCount
+      },
+      { snapshot: data.snapshot, catalog: data.catalog, timeZoneId }
+    );
+    return { kind: "exercise", series: series2 };
+  }
+  const series = computeFormatProgress(
+    { templateId: args.templateId, maxPoints },
+    { snapshot: data.snapshot, timeZoneId }
+  );
+  return { kind: "format", series };
+}
+function registerToolGetProgress(server2, cfg) {
+  const { pat: pat2, keyB64: keyB642, serverUrl: serverUrl2 } = cfg;
+  server2.registerTool(
+    "get_progress",
+    {
+      title: "Get Training Progress",
+      description: 'Two progress views in one tool, selected by `kind`. `kind: "exercise"` returns the per-exercise progress series across ALL sessions the exercise appears in (even sessions without a template) \u2014 each point carries the best single set AND the session total, in the metric appropriate to that exercise (e1RM for weighted exercises, reps or hold time for bodyweight exercises), plus a direction label with its own rule and the raw values it was computed from. Omit `exerciseId` to get the most recently trained exercises instead of one specific exercise. `kind: "format"` returns the format-specific progression (AMRAP rounds+reps, Death-By highest round, EMOM intervals) for one template, or all format templates if `templateId` is omitted. `points` overrides how many recent points each series returns (3-30) for this one call. A call with no matching data returns an empty series, never an error. Set `outputFile: true` to write the full point series to a local file instead of returning it inline.',
+      inputSchema: GetProgressSchema,
+      annotations: { readOnlyHint: true }
+    },
+    async (args) => {
+      try {
+        const data = await getSnapshot(pat2, keyB642, serverUrl2);
+        const { params, source } = await loadCoachParameters({ pat: pat2, serverUrl: serverUrl2 });
+        const result = getProgress(args, {
+          snapshot: data.snapshot,
+          catalog: data.catalog,
+          coachParameters: params
+        });
+        const full = { ...result, parametersSource: source };
+        if (args.outputFile) {
+          const itemCount = full.series.reduce((sum, s) => sum + s.points.length, 0);
+          const handle = await writeExportFile(full, itemCount);
+          const summary = full.kind === "exercise" ? {
+            kind: full.kind,
+            outputFile: { path: handle.path, bytes: handle.bytes, itemCount: handle.itemCount },
+            series: full.series.map((s) => ({
+              exerciseId: s.exerciseId,
+              exerciseName: s.exerciseName,
+              mode: s.mode,
+              usesWeight: s.usesWeight,
+              metric: s.metric,
+              bestSetDirection: s.bestSetDirection,
+              sessionTotalDirection: s.sessionTotalDirection,
+              rule: s.rule
+            })),
+            parametersSource: source
+          } : {
+            kind: full.kind,
+            outputFile: { path: handle.path, bytes: handle.bytes, itemCount: handle.itemCount },
+            series: full.series.map((s) => ({
+              templateId: s.templateId,
+              templateName: s.templateName,
+              workoutType: s.workoutType,
+              skippedSessionCount: s.skippedSessionCount
+            })),
+            parametersSource: source
+          };
+          return { content: [{ type: "text", text: JSON.stringify(summary) }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(full) }] };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Progress error: ${err.message}` }]
+        };
+      }
+    }
+  );
+}
+
+// src/index.ts
+var pat = process.env.CALICOMP_PAT;
+var keyB64 = process.env.CALICOMP_KEY;
+var serverUrl = process.env.CALICOMP_SERVER_URL ?? "https://api.calicompanion.de";
+if (!pat || !keyB64) {
+  console.error("[calicomp-mcp] FATAL: CALICOMP_PAT and CALICOMP_KEY must be set.");
+  process.exit(1);
+}
+var server = new McpServer({ name: "calicomp", version: "0.1.0" });
+var config = { pat, keyB64, serverUrl };
+registerToolGetHistory(server, config);
+registerToolGetStats(server, config);
+registerToolGetProfile(server, config);
+registerToolListTemplates(server, config);
+registerToolGetTemplate(server, config);
+registerToolGetExerciseCatalog(server, config);
+registerToolGetPlannedWorkouts(server, config);
+registerToolGetTrainingState(server, config);
+registerToolProposePlanUpdate(server, config);
+registerToolProposeNewPlan(server, config);
+registerToolProposeNewExercise(server, config);
+registerToolProposePlannedUpdate(server, config);
+registerToolGetSuggestions(server, config);
+registerToolGetSuggestion(server, config);
+registerToolWithdrawSuggestion(server, config);
+registerToolGetCoachParameters(server, config);
+registerToolSetCoachParameters(server, config);
+registerToolGetAdherence(server, config);
+registerToolGetProgress(server, config);
+await pruneExports();
+var transport = new StdioServerTransport();
+await server.connect(transport);