From 846d18f67fb1061cccb9783519970e84f6626e27 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 22:30:31 +0200
Subject: [PATCH 01/25] Add pre-competition protocol design spec

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 ...6-07-17-pre-competition-protocol-design.md | 255 ++++++++++++++++++
 1 file changed, 255 insertions(+)
 create mode 100644 docs/superpowers/specs/2026-07-17-pre-competition-protocol-design.md

diff --git a/docs/superpowers/specs/2026-07-17-pre-competition-protocol-design.md b/docs/superpowers/specs/2026-07-17-pre-competition-protocol-design.md
new file mode 100644
index 0000000..3357c38
--- /dev/null
+++ b/docs/superpowers/specs/2026-07-17-pre-competition-protocol-design.md
@@ -0,0 +1,255 @@
+# Pre-Competition Protocol — Design
+
+**Date:** 2026-07-17
+**Status:** validated with owner (conversation of 2026-07-17)
+**Depends on:** v0.8.0 (living evidence: mini-waves, `resolve_citations`, guidance
+rendering, documentation folder)
+
+## 1. Overview
+
+The coach plans seasons, programs and weeks, but goes quiet exactly when the athlete
+needs it most: the final days before a competition. This design adds the
+**competition protocol** — a versioned, per-event, day-by-day plan covering the
+window from J-N to race/meet/stage day (J0), delivered as a phone-ready offline HTML
+page the athlete can read on the morning of the event.
+
+The protocol is **sport-agnostic by construction**, like the performance model: no
+hard-coded per-sport playbook. What "getting the final days right" means for THIS
+event comes from a dedicated research mini-wave; the numbers that can be computed
+(carb loading, attempt selection, pacing splits, taper) come from the deterministic
+engine; everything else is sourced advice or labeled coaching judgment.
+
+## 2. Decisions taken with the owner
+
+1. **Any sport, one model.** The protocol structure is discipline-neutral; peak week
+   (physique), race week/day (endurance) and meet day (strength) are instances the
+   research fills in, not separate features.
+2. **Deliverable = versioned protocol + phone HTML.** A new per-event versioned
+   document family plus a standalone offline HTML page for J0 (same CSS/i18n
+   conventions as the session HTML). Not a program version, not conversational-only.
+3. **Dedicated research mini-wave.** The first protocol for an event triggers a
+   deep-research mini-wave scoped to "the final days before [this event] for [this
+   athlete]"; verified studies join the corpus and the protocol cites them with
+   evidence stars.
+4. **Engine scope: three new computations + existing taper.** Carb-loading targets,
+   attempt selection, pacing plan. Day-of meal/warm-up timing and logistics stay
+   advice — no fake precision.
+5. **Risky practices: documented advice with warnings, never engine-quantified.**
+   Peak-week practices (water/sodium manipulation, weight-cut tactics) ARE described
+   when the literature documents them — always carrying an evidence grade and an
+   explicit warning, never computed or dosed by the engine, never presented as
+   prescription. The existing red-flag protocol (medical conditions → refer out)
+   keeps precedence.
+6. **Adaptive trigger.** The protocol window is not a fixed J-14: it is computed
+   from the event's modality and priority (a marathon A opens earlier than a 5K B or
+   a meet-day weigh-in), reusing the individualized taper recommendation.
+
+## 3. The protocol model
+
+New schemas in `memory/schemas.py` (same conventions: `extra="forbid"`, strict
+fields, validators with readable messages):
+
+```
+ProtocolLine      text (1..300), time_hint (str|None, e.g. "07:30" or "T-45 min"),
+                  cite (str|None — corpus id), warning (bool, default False)
+ProtocolDay       day_offset (int, -21..0; 0 = event day), title (1..80),
+                  lines (list[ProtocolLine], min 1)
+PacingSegment     label (1..40), distance_m (float>0),
+                  target_pace_s_per_km (float>0), cumulative_time_s (float>0)
+AttemptPlan       lift (1..60), e1rm_kg (float>0), opener_kg, second_kg, third_kg
+                  (floats>0, strictly increasing), basis ("engine"|"agreed"),
+                  flags (list[str])
+FuelingPlan       carb_g_per_kg_low/high (floats>0, low<=high), window_hours (int>0),
+                  race_carb_g_per_h_low/high (floats>=0)|None, cite (str|None)
+DocumentedPractice name (1..80), summary (1..400), cite (str|None),
+                  warning (str, min 1 — REQUIRED, non-empty by schema)
+CompetitionProtocol schema_version=1, version (>=1), event_id (calendar id),
+                  event_date (date), goal_id, created_on, reason (str|None),
+                  window_days (int 1..21), days (list[ProtocolDay], min 1),
+                  pacing (list[PacingSegment], default []),
+                  attempts (list[AttemptPlan], default []),
+                  fueling (FuelingPlan|None), practices (list[DocumentedPractice]),
+                  checklist (list[str], default []), advice (list[Guidance])
+```
+
+Validators: `days` sorted by `day_offset`, unique offsets, last day is 0;
+`window_days >= -min(day_offset)`. `DocumentedPractice.warning` being schema-required
+is the structural encoding of decision 5: a practice cannot be stored without its
+warning. The engine never fills `practices` — only the skill does, from research.
+
+## 4. Engine — `engine/competition.py` (pure, no I/O)
+
+Four functions, all deterministic, all raising readable `ValueError` on bad input:
+
+1. `carb_loading_targets(body_mass_kg, event_duration_min) -> CarbLoadingTargets`
+   — evidence-based ranges: events ≥ 90 min → 8–12 g/kg/day over the final
+   36–48 h; 60–90 min → 6–8 g/kg/day; < 60 min → maintenance (no loading, the
+   result says so via `loading_required=False`). In-race fueling range from
+   duration: < 60 min → none needed, 1–2.5 h → 30–60 g/h, > 2.5 h → 60–90 g/h.
+   Guards: body mass 30–250 kg, duration 5 min–24 h. Returns g/kg AND absolute
+   g/day. The thresholds are corpus-cited priors (Burke/IOC consensus) recorded as
+   constants with their rationale.
+2. `select_attempts(e1rm_kg, goal_kg, rounding_kg) -> AttemptPlan` — opener at
+   90–92 % of e1RM, second at 95–97 %, third at `goal_kg` when it lies within
+   93–105 % of e1RM, else at 100–102 % with flag `goal_beyond_e1rm` (the honesty
+   gate: the plan never silently endorses a goal the data does not support; the
+   skill names the gap). All loads rounded to `rounding_kg` (default 2.5), strict
+   monotonicity enforced after rounding.
+3. `pacing_plan(distance_m, target_time_s, segment_m, strategy) -> list[PacingSegment]`
+   — splits the distance into segments of `segment_m` (last segment takes the
+   remainder), strategy `"even"` (uniform pace) or `"negative"` (first half +1 %
+   of mean pace, second half −1 %, halves balanced so cumulative time lands on
+   `target_time_s` within one second). Target time comes from the athlete's goal
+   or `predict_race_time` upstream — this function only distributes it.
+4. `protocol_window_days(taper_days, priority) -> int` — the adaptive trigger
+   window: priority A → `clamp(max(taper_days, 7), 7, 21)`; B →
+   `clamp(taper_days, 3, 10)`; C → 0 (never auto-surfaced). `taper_days` comes
+   from the individualized `recommend_taper` (modality- and history-aware), which
+   is how sport magnitude adapts the window.
+
+Purity: no imports outside stdlib + engine siblings (structural `Protocol` if a
+schema view is needed, as done for `ProgressionRule`).
+
+## 5. Persistence and deliverables
+
+Store additions (`memory/store.py`), mirroring the program trio (yaml source +
+rendered md + standalone html), but **per event**:
+
+- Directory `competition/`; files `protocol-<event_id>-vN.yaml` (structured source
+  of truth), `-vN.md` (rendered markdown), `-vN.html` (phone page). Versions
+  immutable; v2+ requires a `reason`.
+- `save_competition_protocol(base_dir, protocol, reason=None, today=None,
+  citations=None) -> (Path, int)` — validates that `event_id` exists in the
+  calendar and that `event_date` matches the calendar date (drift = error), stamps
+  version/created_on/reason, renders md, writes atomically.
+- `read_competition_protocol(base_dir, event_id, version=None)`,
+  `latest_competition_protocol_version(base_dir, event_id)`.
+
+Rendering (`programs/render_protocol_html.py` + md rendering in
+`programs/render.py` style):
+
+- Phone page: timeline of `days` (J0 open by default, previous days collapsed),
+  `time_hint` chips, pacing table with cumulative splits, attempt cards, fueling
+  numbers, checklist as tap-friendly list, practices section with the warning
+  visually flagged (⚠ + distinct style) and evidence stars, final Sources section
+  with DOI links. Same rules as the session HTML: inline CSS, zero JavaScript,
+  en/fr/es labels from `profile.locale`, no external requests.
+- Citations resolved server-side with the existing `resolve_citations` — an
+  unknown corpus id on any line/practice/advice aborts the save (anti-fabrication,
+  same lock as programs).
+
+## 6. Server — `server/competition_tools.py`
+
+Five tools (97 → 102):
+
+- `carb_loading_targets`, `select_attempts`, `pacing_plan` — thin wrappers over the
+  engine, docstrings teaching when each applies and that outputs are quoted, never
+  renegotiated upward.
+- `save_competition_protocol(protocol, reason=None)` — resolves citations (hard
+  gate), saves, renders md + HTML, returns `{path, version, html_path}`.
+- `read_competition_protocol(event_id, version=None)` — frontmatter + structured
+  protocol + markdown.
+
+## 7. Trigger — diligence
+
+- `memory/diligence.py` extracts, for each upcoming A/B calendar event within 21
+  days: its computed window (`protocol_window_days` fed by the stored program's
+  modality and `recommend_taper`) and whether a protocol exists for its id.
+- `engine/diligence.py` gains `competition_protocol` due actions: fires when
+  `days_until <= window` and no protocol exists; severity high when
+  `days_until <= 7`, medium otherwise; `ref` = event id. C events never fire.
+- `list_due_actions` docstring extended.
+
+## 8. Skills
+
+**New skill `pre-competition`** (15th): the protocol author. Ritual: open with
+`read_athlete` + `get_time_context` + `read_calendar` (quote days-until); check the
+taper actually planned (`read_program`, `recommend_taper`); run the dedicated
+mini-wave via deep-research rules (first protocol for the event) and
+`read_research_dossier`; build the day-by-day plan — engine numbers via
+`carb_loading_targets` / `select_attempts` / `pacing_plan` (and `predict_race_time`
+for the target), advice lines cited or labeled judgment, documented practices ONLY
+with grade + warning; walk it through with the athlete; pass the program-review
+protocol gate; save and hand over the HTML. Post-event: route to training-checkin
+for the debrief and `log_kpi_result` (feeds `fit_taper_response` for next time).
+Hard boundaries: never edits the program (taper structure changes route to
+program-adaptation); the engine's attempt/pacing numbers are quoted, the athlete
+may choose more conservative, never more aggressive.
+
+**Edited skills:**
+
+- `performance-coach` — routing: `competition_protocol` due action or "my
+  competition is in N days" → **pre-competition**; add tool `read_calendar` if not
+  declared.
+- `training-checkin` — surface the due action; day-after-event: debrief + KPI
+  logging duty.
+- `session-day` — when today is J0 and a protocol exists, open from the protocol
+  page instead of improvising.
+- `deep-research` — one line in the mini-wave section: the pre-competition wave is
+  a mini-wave whose question is the event's final days.
+- `program-review` — new deterministic section "Competition protocols": every
+  `DocumentedPractice` has grade + warning; every engine-attributed number matches
+  a tool recomputation; any dehydration/water-manipulation content that appears as
+  a computed or prescriptive line (rather than a warned practice) is an objection.
+  The gate is mandatory before `save_competition_protocol`, same APPROVED/RETURNED
+  contract.
+
+`tests/skills/test_structure.py`: EXPECTED_SKILLS + `pre-competition`; a protocol
+test asserting the needles (`save_competition_protocol`, `select_attempts`,
+`pacing_plan`, `carb_loading_targets`, `mini-wave`, `warning`, `program-review`,
+`never edits the program`, `session-day`); extended needles for the five edited
+skills.
+
+## 9. Error handling & edge cases
+
+- `event_id` not in calendar, or calendar date ≠ `event_date` → readable error at
+  save (protocols cannot outlive a rescheduled event silently; re-save v2 with
+  reason after the calendar moves).
+- Event in the past → error at save.
+- `select_attempts` without a usable e1RM upstream: the tool is pure — the skill
+  gets the e1RM from `estimate_1rm`/lift inventory; absent → no attempts section,
+  flag it conversationally (no invented openers).
+- `pacing_plan` with `segment_m > distance_m` → single segment; nonsensical inputs
+  (non-positive) → error.
+- Unknown citation id anywhere → save aborts before writing (existing lock).
+- v2+ without reason → error (audit trail).
+- Two events on the same day: protocols are per `event_id`, both can exist.
+- Legacy athletes (no structured program): window falls back to the population
+  taper for the goal's modality; the protocol itself does not require a structured
+  program.
+
+## 10. Testing
+
+Test-first per module, following the repo's invariants:
+
+- Engine: property tests — attempts strictly increasing and plate-rounded for all
+  valid inputs; `goal_beyond_e1rm` flag iff goal outside 93–105 %; pacing cumulative
+  time within 1 s of target for both strategies and any segmentation; carb ranges
+  monotone in duration class; window clamps and C→0. Purity test must stay green.
+- Store: per-event versioning (v1, v2+reason, immutability), calendar validation,
+  read round-trip.
+- Render: HTML has zero `<script>`, warnings rendered with ⚠ styling, stars +
+  DOI links present iff citations, en/fr/es labels, J0 open by default.
+- Server: save gate (unknown cite refused), read, tool wrappers.
+- Diligence: due action fires/holds around the window per priority.
+- Skills: structure + tool-reference invariants for the new and edited skills.
+
+## 11. Out of scope (this iteration)
+
+- Environment factors (altitude, heat acclimatization, jet-lag, competition-hour
+  shifting) — already on the roadmap as its own iteration.
+- Automatic program rescheduling around the event (program-adaptation owns program
+  changes).
+- Live in-race guidance and multi-attempt in-meet re-planning (the page is static;
+  the athlete talks to the coach between attempts if they want).
+- Outcome simulation (Monte Carlo on the fitted Banister model).
+- Team-sport match-week protocols beyond what the generic model already expresses.
+
+## 12. Tally
+
+| | before | after |
+|---|---|---|
+| MCP tools | 97 | 102 |
+| Skills | 14 | 15 (+5 edited) |
+| New engine modules | — | `engine/competition.py` |
+| New doc family | — | `competition/protocol-<event_id>-vN.{yaml,md,html}` |

From 4cce488dc87bbdeb57fdd26523cba58163ea53f0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 22:46:05 +0200
Subject: [PATCH 02/25] Add pre-competition protocol implementation plan

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../2026-07-17-pre-competition-protocol.md    | 2401 +++++++++++++++++
 1 file changed, 2401 insertions(+)
 create mode 100644 docs/superpowers/plans/2026-07-17-pre-competition-protocol.md

diff --git a/docs/superpowers/plans/2026-07-17-pre-competition-protocol.md b/docs/superpowers/plans/2026-07-17-pre-competition-protocol.md
new file mode 100644
index 0000000..517f9bf
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-17-pre-competition-protocol.md
@@ -0,0 +1,2401 @@
+# Pre-Competition Protocol Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Implement `docs/superpowers/specs/2026-07-17-pre-competition-protocol-design.md`: the per-event, day-by-day competition protocol — pure engine math (carb loading, attempts, pacing, trigger window), versioned `competition/` doc family with a phone-ready HTML page, five MCP tools, the `competition_protocol` due action, one new skill and five edited ones.
+
+**Architecture:** Engine stays pure (`engine/competition.py`, no memory imports). Schemas in `memory/schemas.py`, persistence in `memory/store.py` (yaml source + rendered md, like programs), rendering in `programs/render_protocol.py` (markdown) and `programs/render_protocol_html.py` (phone page). Citation resolution stays server-side (`server/competition_tools.py`). Diligence trigger uses the population `mixed` taper prior (no per-athlete modality is persisted — spec §9 fallback); the skill computes the individualized window at authoring time.
+
+**Tech Stack:** Python 3.13, uv, pydantic v2, FastMCP, pytest. Run everything with `uv run`. Run pytest as `rtk proxy uv run pytest …` (plain rtk swallows the output) and verify every commit landed with `git log --oneline -1`.
+
+**Branch:** work continues on `pre-competition-protocol-spec` (spec already committed). Version bump/release is NOT part of this plan.
+
+---
+
+## File structure
+
+| File | Status | Responsibility |
+|---|---|---|
+| `src/performance_agent/engine/competition.py` | create | Pure math: carb loading, attempt selection, pacing plan, trigger window |
+| `src/performance_agent/memory/schemas.py` | modify | Protocol schemas: `ProtocolLine`, `ProtocolDay`, `PacingSegment`, `AttemptPlan`, `FuelingPlan`, `DocumentedPractice`, `CompetitionProtocol` |
+| `src/performance_agent/programs/render_protocol.py` | create | `protocol_citation_ids`, deterministic markdown rendering |
+| `src/performance_agent/memory/store.py` | modify | `save_competition_protocol`, `read_competition_protocol`, `latest_competition_protocol_version` |
+| `src/performance_agent/programs/render_protocol_html.py` | create | Standalone offline phone page (no JS, en/fr/es, ⚠ warnings, starred sources) |
+| `src/performance_agent/server/competition_tools.py` | create | 5 MCP tools; citations resolved server-side |
+| `src/performance_agent/server/app.py` | modify | Register `competition_tools` |
+| `src/performance_agent/engine/diligence.py` | modify | `UpcomingEvent` protocol fields + `competition_protocol` due action |
+| `src/performance_agent/memory/diligence.py` | modify | Fill protocol window + has-protocol facts |
+| `src/performance_agent/server/memory_tools.py` | modify | `list_due_actions` docstring |
+| `skills/pre-competition/SKILL.md` | create | The protocol author ritual |
+| 5 existing `skills/*/SKILL.md` | modify | coach routing, checkin debrief, session-day J0, deep-research wave, review gate |
+| `tests/skills/test_structure.py` | modify | EXPECTED_SKILLS + protocol invariants |
+| `README.md` | modify | Tool/skill counts + feature bullet |
+
+---
+
+## Phase 1 — Engine
+
+### Task 1: `engine/competition.py` — carb-loading targets
+
+**Files:**
+- Create: `src/performance_agent/engine/competition.py`
+- Test: `tests/engine/test_competition.py`
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `tests/engine/test_competition.py`:
+
+```python
+"""Pure pre-competition math: carb loading, attempts, pacing, window."""
+
+import pytest
+
+from performance_agent.engine.competition import carb_loading_targets
+
+
+def test_long_event_loads_8_to_12_g_per_kg_over_48h():
+    result = carb_loading_targets(70.0, 180.0)
+    assert result.loading_required is True
+    assert (result.carb_g_per_kg_low, result.carb_g_per_kg_high) == (8.0, 12.0)
+    assert (result.carb_g_per_day_low, result.carb_g_per_day_high) == (560.0, 840.0)
+    assert result.window_hours == 48
+    assert (result.race_carb_g_per_h_low, result.race_carb_g_per_h_high) == (60.0, 90.0)
+
+
+def test_mid_event_loads_6_to_8_g_per_kg_over_24h():
+    result = carb_loading_targets(60.0, 75.0)
+    assert result.loading_required is True
+    assert (result.carb_g_per_kg_low, result.carb_g_per_kg_high) == (6.0, 8.0)
+    assert (result.carb_g_per_day_low, result.carb_g_per_day_high) == (360.0, 480.0)
+    assert result.window_hours == 24
+    assert (result.race_carb_g_per_h_low, result.race_carb_g_per_h_high) == (30.0, 60.0)
+
+
+def test_short_event_needs_no_loading_and_no_race_fuel():
+    result = carb_loading_targets(80.0, 45.0)
+    assert result.loading_required is False
+    assert result.carb_g_per_kg_low is None
+    assert result.carb_g_per_day_high is None
+    assert result.window_hours is None
+    assert result.race_carb_g_per_h_low is None
+
+
+def test_carb_guards_reject_out_of_range_inputs():
+    with pytest.raises(ValueError, match="body_mass_kg"):
+        carb_loading_targets(20.0, 180.0)
+    with pytest.raises(ValueError, match="event_duration_min"):
+        carb_loading_targets(70.0, 2.0)
+    with pytest.raises(ValueError, match="event_duration_min"):
+        carb_loading_targets(70.0, 2000.0)
+```
+
+- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py -q` — Expected: FAIL (`ModuleNotFoundError`)
+
+- [ ] **Step 3: Implement**
+
+Create `src/performance_agent/engine/competition.py`:
+
+```python
+"""Pre-competition math: carb loading, attempt selection, pacing, trigger window.
+
+Pure and deterministic — no I/O, no memory imports. Thresholds are corpus-cited
+priors (IOC/Burke carbohydrate consensus, powerlifting attempt-selection
+convention, the taper meta-analysis) recorded as constants with their rationale.
+Anything the literature does not quantify (meal timing, water/sodium
+manipulation, weight-cut tactics) deliberately has NO function here: it is
+sourced advice with warnings in the protocol document, never engine math.
+"""
+
+from dataclasses import dataclass
+
+_MIN_BODY_MASS_KG = 30.0
+_MAX_BODY_MASS_KG = 250.0
+_MIN_EVENT_MIN = 5.0
+_MAX_EVENT_MIN = 1440.0
+# Carb-loading priors (IOC consensus): events >= 90 min load 8-12 g/kg/day over
+# the final ~48 h; 60-90 min take 6-8 g/kg/day the day before; shorter events
+# need no loading. In-race: none under 60 min, 30-60 g/h up to ~2.5 h, 60-90 g/h
+# beyond (multiple transportable carbohydrates).
+_LONG_EVENT_MIN = 90.0
+_MID_EVENT_MIN = 60.0
+_RACE_FUEL_LONG_MIN = 150.0
+
+
+@dataclass(frozen=True)
+class CarbLoadingTargets:
+    """Evidence-based carbohydrate targets for the final window and the race."""
+
+    loading_required: bool
+    carb_g_per_kg_low: float | None = None
+    carb_g_per_kg_high: float | None = None
+    carb_g_per_day_low: float | None = None
+    carb_g_per_day_high: float | None = None
+    window_hours: int | None = None
+    race_carb_g_per_h_low: float | None = None
+    race_carb_g_per_h_high: float | None = None
+
+
+def carb_loading_targets(body_mass_kg: float, event_duration_min: float) -> CarbLoadingTargets:
+    """Carb-loading and in-race fueling ranges from body mass and event duration."""
+    if not _MIN_BODY_MASS_KG <= body_mass_kg <= _MAX_BODY_MASS_KG:
+        msg = (
+            f"body_mass_kg must be within [{_MIN_BODY_MASS_KG}, {_MAX_BODY_MASS_KG}], "
+            f"got {body_mass_kg!r}"
+        )
+        raise ValueError(msg)
+    if not _MIN_EVENT_MIN <= event_duration_min <= _MAX_EVENT_MIN:
+        msg = (
+            f"event_duration_min must be within [{_MIN_EVENT_MIN}, {_MAX_EVENT_MIN}], "
+            f"got {event_duration_min!r}"
+        )
+        raise ValueError(msg)
+    if event_duration_min < _MID_EVENT_MIN:
+        return CarbLoadingTargets(loading_required=False)
+    if event_duration_min >= _LONG_EVENT_MIN:
+        g_low, g_high, window = 8.0, 12.0, 48
+    else:
+        g_low, g_high, window = 6.0, 8.0, 24
+    if event_duration_min > _RACE_FUEL_LONG_MIN:
+        race_low, race_high = 60.0, 90.0
+    else:
+        race_low, race_high = 30.0, 60.0
+    return CarbLoadingTargets(
+        loading_required=True,
+        carb_g_per_kg_low=g_low,
+        carb_g_per_kg_high=g_high,
+        carb_g_per_day_low=round(g_low * body_mass_kg, 1),
+        carb_g_per_day_high=round(g_high * body_mass_kg, 1),
+        window_hours=window,
+        race_carb_g_per_h_low=race_low,
+        race_carb_g_per_h_high=race_high,
+    )
+```
+
+- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py tests/engine/test_engine_purity.py -q` — Expected: PASS (purity guard must stay green)
+
+- [ ] **Step 5: Lint + commit**
+
+```bash
+uv run ruff check src/performance_agent/engine/competition.py tests/engine/test_competition.py && uv run ty check
+git add src/performance_agent/engine/competition.py tests/engine/test_competition.py
+git commit -m "Add carb-loading targets to the competition engine
+
+Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+git log --oneline -1
+```
+
+### Task 2: `select_attempts`
+
+**Files:**
+- Modify: `src/performance_agent/engine/competition.py` (append)
+- Test: `tests/engine/test_competition.py` (append)
+
+- [ ] **Step 1: Write the failing tests** (append)
+
+```python
+from performance_agent.engine.competition import select_attempts
+
+
+def test_attempts_goal_within_range_becomes_third():
+    result = select_attempts(200.0, 205.0)
+    assert result.opener_kg == 182.5   # 0.91 * 200 = 182 -> 182.5
+    assert result.second_kg == 192.5   # 0.96 * 200 = 192 -> 192.5
+    assert result.third_kg == 205.0
+    assert result.flags == ()
+
+
+def test_attempts_goal_beyond_e1rm_is_flagged_and_capped():
+    result = select_attempts(200.0, 215.0)  # > 105% of e1RM
+    assert result.third_kg == 202.5         # 1.01 * 200 = 202 -> 202.5
+    assert "goal_beyond_e1rm" in result.flags
+
+
+def test_attempts_stay_strictly_increasing_after_rounding():
+    result = select_attempts(52.0, 50.0)
+    assert result.opener_kg < result.second_kg < result.third_kg
+
+
+def test_attempts_guards():
+    with pytest.raises(ValueError, match="e1rm_kg"):
+        select_attempts(10.0, 50.0)
+    with pytest.raises(ValueError, match="goal_kg"):
+        select_attempts(200.0, 0.0)
+    with pytest.raises(ValueError, match="rounding_kg"):
+        select_attempts(200.0, 205.0, rounding_kg=0.0)
+```
+
+- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py -q` — Expected: FAIL (`ImportError: select_attempts`)
+
+- [ ] **Step 3: Implement** (append to `engine/competition.py`)
+
+```python
+from performance_agent.engine.progression import round_to_increment
+
+_MIN_E1RM_KG = 20.0
+_MAX_E1RM_KG = 600.0
+# Attempt-selection convention (powerlifting coaching literature): opener ~91%
+# of e1RM (a weight you can triple), second ~96%, third at the goal when the
+# data supports it — 93-105% of e1RM — else a conservative ~101% PR attempt.
+_OPENER_PCT = 0.91
+_SECOND_PCT = 0.96
+_THIRD_FALLBACK_PCT = 1.01
+_GOAL_MIN_PCT = 0.93
+_GOAL_MAX_PCT = 1.05
+
+
+@dataclass(frozen=True)
+class AttemptSelection:
+    """Opening, second and third attempts for one lift on meet day."""
+
+    opener_kg: float
+    second_kg: float
+    third_kg: float
+    flags: tuple[str, ...] = ()
+
+
+def select_attempts(
+    e1rm_kg: float, goal_kg: float, rounding_kg: float = 2.5
+) -> AttemptSelection:
+    """Three meet-day attempts from the estimated 1RM and the athlete's goal.
+
+    The honesty gate lives here: a goal outside 93-105% of e1RM is never
+    silently endorsed — the third falls back to ~101% and the goal_beyond_e1rm
+    flag tells the skill to name the gap.
+    """
+    if not _MIN_E1RM_KG <= e1rm_kg <= _MAX_E1RM_KG:
+        msg = f"e1rm_kg must be within [{_MIN_E1RM_KG}, {_MAX_E1RM_KG}], got {e1rm_kg!r}"
+        raise ValueError(msg)
+    if goal_kg <= 0:
+        msg = f"goal_kg must be positive, got {goal_kg!r}"
+        raise ValueError(msg)
+    if rounding_kg <= 0:
+        msg = f"rounding_kg must be positive, got {rounding_kg!r}"
+        raise ValueError(msg)
+    opener = round_to_increment(_OPENER_PCT * e1rm_kg, rounding_kg)
+    second = round_to_increment(_SECOND_PCT * e1rm_kg, rounding_kg)
+    flags: tuple[str, ...] = ()
+    if _GOAL_MIN_PCT * e1rm_kg <= goal_kg <= _GOAL_MAX_PCT * e1rm_kg:
+        third = round_to_increment(goal_kg, rounding_kg)
+    else:
+        third = round_to_increment(_THIRD_FALLBACK_PCT * e1rm_kg, rounding_kg)
+        flags = ("goal_beyond_e1rm",)
+    if second <= opener:
+        second = opener + rounding_kg
+    if third <= second:
+        third = second + rounding_kg
+    return AttemptSelection(opener, second, third, flags)
+```
+
+(Move the `from performance_agent.engine.progression import round_to_increment` line up into the module's import block.)
+
+- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py tests/engine/test_engine_purity.py -q` — Expected: PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/performance_agent/engine/competition.py tests/engine/test_competition.py
+git commit -m "Add meet-day attempt selection with the e1RM honesty gate
+
+Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+git log --oneline -1
+```
+
+### Task 3: `pacing_plan` + `protocol_window_days`
+
+**Files:**
+- Modify: `src/performance_agent/engine/competition.py` (append)
+- Test: `tests/engine/test_competition.py` (append)
+
+- [ ] **Step 1: Write the failing tests** (append)
+
+```python
+from performance_agent.engine.competition import pacing_plan, protocol_window_days
+
+
+def test_even_pacing_splits_evenly_and_lands_on_target():
+    splits = pacing_plan(10000.0, 2400.0, segment_m=1000.0, strategy="even")
+    assert len(splits) == 10
+    assert all(s.target_pace_s_per_km == 240.0 for s in splits)
+    assert splits[-1].cumulative_time_s == pytest.approx(2400.0, abs=1.0)
+
+
+def test_negative_split_first_half_slower_lands_on_target():
+    splits = pacing_plan(10000.0, 2400.0, segment_m=1000.0, strategy="negative")
+    assert splits[0].target_pace_s_per_km > splits[-1].target_pace_s_per_km
+    assert splits[0].target_pace_s_per_km == pytest.approx(242.4, abs=0.01)
+    assert splits[-1].cumulative_time_s == pytest.approx(2400.0, abs=1.0)
+
+
+def test_pacing_remainder_becomes_last_short_segment():
+    splits = pacing_plan(10500.0, 2520.0, segment_m=1000.0, strategy="even")
+    assert len(splits) == 11
+    assert splits[-1].distance_m == pytest.approx(500.0)
+
+
+def test_pacing_oversized_segment_yields_single_split():
+    splits = pacing_plan(5000.0, 1200.0, segment_m=8000.0, strategy="even")
+    assert len(splits) == 1
+    assert splits[0].distance_m == pytest.approx(5000.0)
+
+
+def test_pacing_guards():
+    with pytest.raises(ValueError, match="distance_m"):
+        pacing_plan(0.0, 2400.0)
+    with pytest.raises(ValueError, match="target_time_s"):
+        pacing_plan(10000.0, -5.0)
+    with pytest.raises(ValueError, match="strategy"):
+        pacing_plan(10000.0, 2400.0, strategy="wild")
+
+
+def test_window_scales_with_priority():
+    assert protocol_window_days(10, "A") == 10
+    assert protocol_window_days(4, "A") == 7    # floor
+    assert protocol_window_days(25, "A") == 21  # ceiling
+    assert protocol_window_days(5, "B") == 5
+    assert protocol_window_days(2, "B") == 3    # floor
+    assert protocol_window_days(12, "B") == 10  # ceiling
+    assert protocol_window_days(10, "C") == 0   # never auto-surfaced
+
+
+def test_window_guards():
+    with pytest.raises(ValueError, match="taper_days"):
+        protocol_window_days(-1, "A")
+    with pytest.raises(ValueError, match="priority"):
+        protocol_window_days(10, "X")
+```
+
+- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py -q` — Expected: FAIL (`ImportError`)
+
+- [ ] **Step 3: Implement** (append to `engine/competition.py`)
+
+```python
+# Negative-split prior: first half ~1% slower than mean pace, second half
+# balanced exactly so the cumulative time lands on the target.
+_NEGATIVE_SPLIT_PCT = 0.01
+# Protocol windows per priority (spec §4): A events open with the taper but
+# never closer than a week nor further than three; B events get a short window;
+# C events are never auto-surfaced.
+_WINDOW_A_MIN, _WINDOW_A_MAX = 7, 21
+_WINDOW_B_MIN, _WINDOW_B_MAX = 3, 10
+
+
+@dataclass(frozen=True)
+class PacingSplit:
+    """One race segment: its target pace and the cumulative time at its end."""
+
+    label: str
+    distance_m: float
+    target_pace_s_per_km: float
+    cumulative_time_s: float
+
+
+def _segment_distances(distance_m: float, segment_m: float) -> list[float]:
+    full = int(distance_m // segment_m)
+    segments = [segment_m] * full
+    remainder = distance_m - full * segment_m
+    if remainder > 1.0:
+        segments.append(remainder)
+    elif not segments:
+        segments = [distance_m]
+    return segments
+
+
+def pacing_plan(
+    distance_m: float,
+    target_time_s: float,
+    segment_m: float = 1000.0,
+    strategy: str = "even",
+) -> list[PacingSplit]:
+    """Distribute a target time over segments (even or negative split).
+
+    The target comes from the athlete's goal or predict_race_time upstream —
+    this function only distributes it; cumulative time always lands on the
+    target within a second.
+    """
+    if distance_m <= 0:
+        msg = f"distance_m must be positive, got {distance_m!r}"
+        raise ValueError(msg)
+    if target_time_s <= 0:
+        msg = f"target_time_s must be positive, got {target_time_s!r}"
+        raise ValueError(msg)
+    if segment_m <= 0:
+        msg = f"segment_m must be positive, got {segment_m!r}"
+        raise ValueError(msg)
+    if strategy not in ("even", "negative"):
+        msg = f"strategy must be 'even' or 'negative', got {strategy!r}"
+        raise ValueError(msg)
+    distances = _segment_distances(distance_m, segment_m)
+    mean_pace = target_time_s / (distance_m / 1000.0)
+    halfway = distance_m / 2.0
+    paces: list[float]
+    if strategy == "even" or len(distances) == 1:
+        paces = [mean_pace] * len(distances)
+    else:
+        start = 0.0
+        first_half = []
+        for dist in distances:
+            first_half.append(start + dist / 2.0 < halfway)
+            start += dist
+        d1_km = sum(d for d, f in zip(distances, first_half, strict=True) if f) / 1000.0
+        d2_km = sum(d for d, f in zip(distances, first_half, strict=True) if not f) / 1000.0
+        pace_1 = mean_pace * (1 + _NEGATIVE_SPLIT_PCT)
+        pace_2 = (target_time_s - pace_1 * d1_km) / d2_km if d2_km else mean_pace
+        paces = [pace_1 if f else pace_2 for f in first_half]
+    splits: list[PacingSplit] = []
+    cumulative = 0.0
+    position = 0.0
+    for dist, pace in zip(distances, paces, strict=True):
+        cumulative += pace * dist / 1000.0
+        position += dist
+        splits.append(
+            PacingSplit(
+                label=f"{position / 1000.0:g} km",
+                distance_m=dist,
+                target_pace_s_per_km=round(pace, 1),
+                cumulative_time_s=round(cumulative, 1),
+            )
+        )
+    return splits
+
+
+def protocol_window_days(taper_days: int, priority: str) -> int:
+    """The adaptive due-action window: taper-driven, clamped per priority."""
+    if taper_days < 0:
+        msg = f"taper_days must be non-negative, got {taper_days!r}"
+        raise ValueError(msg)
+    if priority not in ("A", "B", "C"):
+        msg = f"priority must be A, B or C, got {priority!r}"
+        raise ValueError(msg)
+    if priority == "A":
+        return min(max(taper_days, _WINDOW_A_MIN), _WINDOW_A_MAX)
+    if priority == "B":
+        return min(max(taper_days, _WINDOW_B_MIN), _WINDOW_B_MAX)
+    return 0
+```
+
+- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py tests/engine/test_engine_purity.py -q` — Expected: PASS. Note the rounded paces mean cumulative sums drift by < 1 s — the tests use `abs=1.0`; never widen past one second.
+
+- [ ] **Step 5: Lint + commit**
+
+```bash
+uv run ruff check src/performance_agent/engine/competition.py tests/engine/test_competition.py && uv run ty check
+git add src/performance_agent/engine/competition.py tests/engine/test_competition.py
+git commit -m "Add pacing plan and adaptive protocol window to the engine
+
+Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+git log --oneline -1
+```
+
+---
+
+## Phase 2 — Schemas, rendering, store
+
+### Task 4: Protocol schemas
+
+**Files:**
+- Modify: `src/performance_agent/memory/schemas.py` (insert the whole block right BEFORE `class CalendarEvent`)
+- Test: `tests/memory/test_schemas_protocol.py`
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `tests/memory/test_schemas_protocol.py`:
+
+```python
+"""CompetitionProtocol schemas: structure and validator errors."""
+
+from datetime import date
+
+import pytest
+from pydantic import ValidationError
+
+from performance_agent.memory.schemas import (
+    AttemptPlan,
+    CompetitionProtocol,
+    DocumentedPractice,
+    FuelingPlan,
+    Guidance,
+    PacingSegment,
+    ProtocolDay,
+    ProtocolLine,
+)
+
+EVENT_DATE = date(2026, 8, 1)
+
+
+def _day(offset, title="Race day"):
+    return ProtocolDay(
+        day_offset=offset,
+        title=title,
+        lines=[ProtocolLine(text="Easy 20 min shakeout.", time_hint="07:30")],
+    )
+
+
+def _protocol(**overrides):
+    fields = {
+        "version": 1,
+        "event_id": "nationals",
+        "event_date": EVENT_DATE,
+        "goal_id": "sub-40-10k",
+        "created_on": date(2026, 7, 25),
+        "window_days": 7,
+        "days": [_day(-2, "Carb load"), _day(-1, "Rest"), _day(0)],
+    }
+    fields.update(overrides)
+    return CompetitionProtocol.model_validate(fields)
+
+
+def test_valid_protocol_with_all_sections():
+    protocol = _protocol(
+        pacing=[
+            PacingSegment(
+                label="1 km", distance_m=1000, target_pace_s_per_km=240, cumulative_time_s=240
+            )
+        ],
+        attempts=[
+            AttemptPlan(
+                lift="Squat", e1rm_kg=200, opener_kg=182.5, second_kg=192.5,
+                third_kg=205, basis="engine", flags=[],
+            )
+        ],
+        fueling=FuelingPlan(
+            carb_g_per_kg_low=8, carb_g_per_kg_high=12, window_hours=48,
+            race_carb_g_per_h_low=60, race_carb_g_per_h_high=90,
+        ),
+        practices=[
+            DocumentedPractice(
+                name="Water manipulation",
+                summary="Described in physique literature; effect sizes small.",
+                warning="Dehydration risk — never do this without supervision.",
+            )
+        ],
+        checklist=["Pin race bib", "Bottle in fridge"],
+        advice=[Guidance(text="Nothing new on race day.")],
+    )
+    assert protocol.days[-1].day_offset == 0
+    assert protocol.practices[0].warning.startswith("Dehydration")
+
+
+def test_days_must_be_sorted_unique_and_end_at_zero():
+    with pytest.raises(ValidationError, match="day_offset"):
+        _protocol(days=[_day(0), _day(-1)])
+    with pytest.raises(ValidationError, match="day_offset"):
+        _protocol(days=[_day(-1), _day(-1), _day(0)])
+    with pytest.raises(ValidationError, match="J0"):
+        _protocol(days=[_day(-2), _day(-1)])
+
+
+def test_window_must_cover_the_days_span():
+    with pytest.raises(ValidationError, match="window_days"):
+        _protocol(window_days=1, days=[_day(-5), _day(0)])
+
+
+def test_practice_requires_a_warning():
+    with pytest.raises(ValidationError):
+        DocumentedPractice(name="X", summary="Y", warning="")
+
+
+def test_attempts_must_strictly_increase():
+    with pytest.raises(ValidationError, match="increasing"):
+        AttemptPlan(
+            lift="Squat", e1rm_kg=200, opener_kg=190, second_kg=190,
+            third_kg=200, basis="engine",
+        )
+
+
+def test_fueling_low_cannot_exceed_high():
+    with pytest.raises(ValidationError, match="carb_g_per_kg"):
+        FuelingPlan(carb_g_per_kg_low=10, carb_g_per_kg_high=8, window_hours=48)
+```
+
+- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/memory/test_schemas_protocol.py -q` — Expected: FAIL (`ImportError`)
+
+- [ ] **Step 3: Implement** — in `src/performance_agent/memory/schemas.py`, insert immediately before `class CalendarEvent`:
+
+```python
+# --- Competition protocol (per-event final-days plan) ---------------------
+
+
+class ProtocolLine(BaseModel):
+    """One line of a protocol day: what to do, optionally when and why."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    text: str = Field(min_length=1, max_length=300)
+    time_hint: str | None = Field(default=None, max_length=20)
+    cite: str | None = None
+    warning: bool = False
+
+
+class ProtocolDay(BaseModel):
+    """One day of the pre-competition window; day_offset 0 is the event day."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    day_offset: int = Field(ge=-21, le=0)
+    title: str = Field(min_length=1, max_length=80)
+    lines: list[ProtocolLine] = Field(min_length=1)
+
+
+class PacingSegment(BaseModel):
+    """One race segment with its target pace and cumulative split."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    label: str = Field(min_length=1, max_length=40)
+    distance_m: float = Field(gt=0)
+    target_pace_s_per_km: float = Field(gt=0)
+    cumulative_time_s: float = Field(gt=0)
+
+
+class AttemptPlan(BaseModel):
+    """Meet-day attempts for one lift; engine-computed or athlete-agreed."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    lift: str = Field(min_length=1, max_length=60)
+    e1rm_kg: float = Field(gt=0)
+    opener_kg: float = Field(gt=0)
+    second_kg: float = Field(gt=0)
+    third_kg: float = Field(gt=0)
+    basis: Literal["engine", "agreed"]
+    flags: list[str] = Field(default_factory=list)
+
+    @model_validator(mode="after")
+    def _attempts_increase(self) -> Self:
+        if not self.opener_kg < self.second_kg < self.third_kg:
+            msg = (
+                f"{self.lift}: attempts must be strictly increasing, got "
+                f"{self.opener_kg}/{self.second_kg}/{self.third_kg}"
+            )
+            raise ValueError(msg)
+        return self
+
+
+class FuelingPlan(BaseModel):
+    """Engine-computed carbohydrate targets for the final window and the race."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    carb_g_per_kg_low: float = Field(gt=0)
+    carb_g_per_kg_high: float = Field(gt=0)
+    window_hours: int = Field(gt=0)
+    race_carb_g_per_h_low: float | None = Field(default=None, ge=0)
+    race_carb_g_per_h_high: float | None = Field(default=None, ge=0)
+    cite: str | None = None
+
+    @model_validator(mode="after")
+    def _low_not_above_high(self) -> Self:
+        if self.carb_g_per_kg_low > self.carb_g_per_kg_high:
+            msg = (
+                "carb_g_per_kg low must not exceed high, got "
+                f"{self.carb_g_per_kg_low} > {self.carb_g_per_kg_high}"
+            )
+            raise ValueError(msg)
+        return self
+
+
+class DocumentedPractice(BaseModel):
+    """A risky-but-documented practice: described with its grade, never dosed.
+
+    warning is schema-required and non-empty — a practice cannot be stored
+    without one (owner decision: labeled advice, never engine-quantified).
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    name: str = Field(min_length=1, max_length=80)
+    summary: str = Field(min_length=1, max_length=400)
+    cite: str | None = None
+    warning: str = Field(min_length=1, max_length=300)
+
+
+class CompetitionProtocol(BaseModel):
+    """The per-event final-days plan: days J-N to J0 plus computed sections."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    schema_version: Literal[1] = 1
+    version: int = Field(ge=1)
+    event_id: str = Field(pattern=r"^[a-z0-9][a-z0-9-]*$", max_length=64)
+    event_date: date
+    goal_id: str = Field(pattern=r"^[a-z0-9][a-z0-9-]*$", max_length=64)
+    created_on: date
+    reason: str | None = None
+    window_days: int = Field(ge=1, le=21)
+    days: list[ProtocolDay] = Field(min_length=1)
+    pacing: list[PacingSegment] = Field(default_factory=list)
+    attempts: list[AttemptPlan] = Field(default_factory=list)
+    fueling: FuelingPlan | None = None
+    practices: list[DocumentedPractice] = Field(default_factory=list)
+    checklist: list[str] = Field(default_factory=list)
+    advice: list[Guidance] = Field(default_factory=list)
+
+    @model_validator(mode="after")
+    def _days_cover_the_window(self) -> Self:
+        offsets = [day.day_offset for day in self.days]
+        if offsets != sorted(offsets) or len(set(offsets)) != len(offsets):
+            msg = f"day_offset values must be unique and increasing, got {offsets}"
+            raise ValueError(msg)
+        if offsets[-1] != 0:
+            msg = f"the last day must be J0 (day_offset 0), got {offsets[-1]}"
+            raise ValueError(msg)
+        if self.window_days < -offsets[0]:
+            msg = (
+                f"window_days ({self.window_days}) must cover the earliest day "
+                f"(J{offsets[0]})"
+            )
+            raise ValueError(msg)
+        return self
+```
+
+- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/memory/test_schemas_protocol.py tests/memory/ -q` — Expected: PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/performance_agent/memory/schemas.py tests/memory/test_schemas_protocol.py
+git commit -m "Add competition protocol schemas
+
+Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+git log --oneline -1
+```
+
+### Task 5: `programs/render_protocol.py` — citation ids + markdown
+
+**Files:**
+- Create: `src/performance_agent/programs/render_protocol.py`
+- Test: `tests/programs/test_render_protocol.py`
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `tests/programs/test_render_protocol.py`:
+
+```python
+"""Deterministic protocol markdown rendering and citation ordering."""
+
+from datetime import date
+
+from performance_agent.evidence.citations import ResolvedCitation
+from performance_agent.memory.schemas import (
+    AttemptPlan,
+    CompetitionProtocol,
+    DocumentedPractice,
+    FuelingPlan,
+    Guidance,
+    PacingSegment,
+    ProtocolDay,
+    ProtocolLine,
+)
+from performance_agent.programs.render_protocol import (
+    protocol_citation_ids,
+    render_protocol,
+)
+
+CITATIONS = {
+    "carb-2017": ResolvedCitation(
+        citation="Burke et al. (2017). Carbohydrates for training and competition. "
+        "DOI: 10.1080/02640414.2011.585473.",
+        stars="★★★★★",
+        doi="10.1080/02640414.2011.585473",
+        pmid=None,
+    )
+}
+
+
+def _full_protocol():
+    return CompetitionProtocol(
+        version=1,
+        event_id="nationals",
+        event_date=date(2026, 8, 1),
+        goal_id="sub-40-10k",
+        created_on=date(2026, 7, 25),
+        window_days=7,
+        advice=[Guidance(text="Nothing new on race day.", cite="carb-2017")],
+        days=[
+            ProtocolDay(
+                day_offset=-1,
+                title="Carb load",
+                lines=[ProtocolLine(text="8-12 g/kg carbs.", cite="carb-2017")],
+            ),
+            ProtocolDay(
+                day_offset=0,
+                title="Race day",
+                lines=[ProtocolLine(text="Breakfast 3 h before.", time_hint="06:00")],
+            ),
+        ],
+        pacing=[
+            PacingSegment(
+                label="1 km", distance_m=1000, target_pace_s_per_km=240, cumulative_time_s=240
+            )
+        ],
+        attempts=[
+            AttemptPlan(
+                lift="Squat", e1rm_kg=200, opener_kg=182.5, second_kg=192.5,
+                third_kg=205, basis="engine",
+            )
+        ],
+        fueling=FuelingPlan(carb_g_per_kg_low=8, carb_g_per_kg_high=12, window_hours=48),
+        practices=[
+            DocumentedPractice(
+                name="Water manipulation",
+                summary="Documented in physique prep; small effect sizes.",
+                warning="Dehydration risk; supervision required.",
+            )
+        ],
+        checklist=["Pin race bib"],
+    )
+
+
+def test_citation_ids_ordered_and_deduped():
+    assert protocol_citation_ids(_full_protocol()) == ["carb-2017"]
+
+
+def test_markdown_renders_all_sections():
+    text = render_protocol(_full_protocol(), citations=CITATIONS)
+    assert "# Competition protocol v1 — nationals — 2026-08-01" in text
+    assert "## J-1 — Carb load" in text
+    assert "## J0 — Race day" in text
+    assert "[06:00]" in text
+    assert "## Pacing" in text
+    assert "## Attempts" in text
+    assert "182.5 / 192.5 / 205" in text
+    assert "## Fueling" in text
+    assert "## Documented practices" in text
+    assert "⚠ Dehydration risk" in text
+    assert "## Checklist" in text
+    assert "## Sources" in text
+    assert "★★★★★" in text
+
+
+def test_markdown_without_optional_sections_is_lean():
+    protocol = CompetitionProtocol(
+        version=1,
+        event_id="local-5k",
+        event_date=date(2026, 8, 1),
+        goal_id="sub-20-5k",
+        created_on=date(2026, 7, 28),
+        window_days=3,
+        days=[
+            ProtocolDay(
+                day_offset=0, title="Race", lines=[ProtocolLine(text="Warm up 15 min.")]
+            )
+        ],
+    )
+    text = render_protocol(protocol)
+    assert "## Pacing" not in text
+    assert "## Attempts" not in text
+    assert "## Sources" not in text
+```
+
+- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/programs/test_render_protocol.py -q` — Expected: FAIL (module missing)
+
+- [ ] **Step 3: Implement**
+
+Create `src/performance_agent/programs/render_protocol.py`:
+
+```python
+"""Deterministic CompetitionProtocol -> markdown (the human/audit view).
+
+Generated at save time from the structured protocol, like the program markdown,
+so the document can never drift from the source of truth. Citation numbering
+order (advice, then day lines, then fueling, then practices) is shared with the
+HTML page via protocol_citation_ids.
+"""
+
+from collections.abc import Mapping
+
+from performance_agent.evidence.citations import ResolvedCitation
+from performance_agent.memory.schemas import CompetitionProtocol
+
+
+def protocol_citation_ids(protocol: CompetitionProtocol) -> list[str]:
+    """Every corpus id the protocol cites, in first-appearance order, deduplicated."""
+    ids: list[str] = []
+    seen: set[str] = set()
+
+    def add(cite: str | None) -> None:
+        if cite and cite not in seen:
+            seen.add(cite)
+            ids.append(cite)
+
+    for guidance in protocol.advice:
+        add(guidance.cite)
+    for day in protocol.days:
+        for line in day.lines:
+            add(line.cite)
+    if protocol.fueling is not None:
+        add(protocol.fueling.cite)
+    for practice in protocol.practices:
+        add(practice.cite)
+    return ids
+
+
+def _day_label(offset: int) -> str:
+    return "J0" if offset == 0 else f"J{offset}"
+
+
+def _num(value: float) -> str:
+    return f"{value:g}"
+
+
+def _line_text(text: str, time_hint: str | None, cite: str | None, warning: bool) -> str:
+    parts = []
+    if time_hint:
+        parts.append(f"[{time_hint}]")
+    parts.append(text)
+    if warning:
+        parts.append("⚠")
+    if cite:
+        parts.append(f"[{cite}]")
+    return "- " + " ".join(parts)
+
+
+def _sections(protocol: CompetitionProtocol) -> list[str]:
+    lines: list[str] = []
+    if protocol.advice:
+        lines += ["", "## Advice"]
+        for guidance in protocol.advice:
+            suffix = f" [{guidance.cite}]" if guidance.cite else ""
+            lines.append(f"- {guidance.text}{suffix}")
+    for day in protocol.days:
+        lines += ["", f"## {_day_label(day.day_offset)} — {day.title}"]
+        for line in day.lines:
+            lines.append(_line_text(line.text, line.time_hint, line.cite, line.warning))
+    if protocol.pacing:
+        lines += ["", "## Pacing", "", "| Segment | Distance | Pace | Cumulative |", "|---|---|---|---|"]
+        for seg in protocol.pacing:
+            minutes, seconds = divmod(round(seg.target_pace_s_per_km), 60)
+            total_min, total_s = divmod(round(seg.cumulative_time_s), 60)
+            lines.append(
+                f"| {seg.label} | {_num(seg.distance_m)} m | {minutes}:{seconds:02d}/km "
+                f"| {total_min}:{total_s:02d} |"
+            )
+    if protocol.attempts:
+        lines += ["", "## Attempts"]
+        for attempt in protocol.attempts:
+            flags = f" ({', '.join(attempt.flags)})" if attempt.flags else ""
+            lines.append(
+                f"- {attempt.lift}: {_num(attempt.opener_kg)} / {_num(attempt.second_kg)} "
+                f"/ {_num(attempt.third_kg)} kg — e1RM {_num(attempt.e1rm_kg)} kg, "
+                f"{attempt.basis}{flags}"
+            )
+    if protocol.fueling is not None:
+        fueling = protocol.fueling
+        lines += ["", "## Fueling"]
+        cite = f" [{fueling.cite}]" if fueling.cite else ""
+        lines.append(
+            f"- {_num(fueling.carb_g_per_kg_low)}-{_num(fueling.carb_g_per_kg_high)} g/kg/day "
+            f"carbs over the final {fueling.window_hours} h{cite}"
+        )
+        if fueling.race_carb_g_per_h_low is not None and fueling.race_carb_g_per_h_high is not None:
+            lines.append(
+                f"- In race: {_num(fueling.race_carb_g_per_h_low)}-"
+                f"{_num(fueling.race_carb_g_per_h_high)} g/h"
+            )
+    if protocol.practices:
+        lines += ["", "## Documented practices"]
+        for practice in protocol.practices:
+            cite = f" [{practice.cite}]" if practice.cite else ""
+            lines.append(f"- **{practice.name}** — {practice.summary}{cite}")
+            lines.append(f"  ⚠ {practice.warning}")
+    if protocol.checklist:
+        lines += ["", "## Checklist"]
+        lines += [f"- [ ] {item}" for item in protocol.checklist]
+    return lines
+
+
+def render_protocol(
+    protocol: CompetitionProtocol,
+    citations: Mapping[str, ResolvedCitation] | None = None,
+) -> str:
+    """Render the protocol to markdown (deterministic; Sources iff citations)."""
+    lines = [
+        f"# Competition protocol v{protocol.version} — {protocol.event_id} — "
+        f"{protocol.event_date.isoformat()}",
+        "",
+        f"- Window: J-{protocol.window_days} → J0",
+        f"- Goal: {protocol.goal_id}",
+    ]
+    if protocol.reason:
+        lines.append(f"- Reason: {protocol.reason}")
+    lines += _sections(protocol)
+    if citations is not None:
+        ids = [cid for cid in protocol_citation_ids(protocol) if cid in citations]
+        if ids:
+            lines += ["", "## Sources"]
+            for number, cid in enumerate(ids, start=1):
+                resolved = citations[cid]
+                lines.append(f"{number}. {resolved.stars} {resolved.citation}")
+    return "\n".join(lines).strip() + "\n"
+```
+
+- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/programs/test_render_protocol.py -q` — Expected: PASS
+
+- [ ] **Step 5: Lint + commit**
+
+```bash
+uv run ruff check src/performance_agent/programs/render_protocol.py tests/programs/test_render_protocol.py && uv run ty check
+git add src/performance_agent/programs/render_protocol.py tests/programs/test_render_protocol.py
+git commit -m "Render competition protocols to markdown
+
+Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+git log --oneline -1
+```
+
+### Task 6: Store — save/read/latest per event
+
+**Files:**
+- Modify: `src/performance_agent/memory/store.py` (constants + append at end)
+- Test: `tests/memory/test_store_protocol.py`
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `tests/memory/test_store_protocol.py`:
+
+```python
+"""Competition protocols: per-event immutable versions, calendar validation."""
+
+from datetime import date
+
+import pytest
+
+from performance_agent.memory import store
+from performance_agent.memory.schemas import (
+    CalendarEvent,
+    CompetitionProtocol,
+    ProtocolDay,
+    ProtocolLine,
+)
+
+TODAY = date(2026, 7, 25)
+EVENT_DATE = date(2026, 8, 1)
+
+
+def _seed_event(base, event_id="nationals", event_date=EVENT_DATE):
+    store.upsert_calendar_event(
+        base,
+        CalendarEvent(
+            id=event_id, date=event_date, kind="competition", priority="A", label="Nationals"
+        ),
+    )
+
+
+def _protocol(event_id="nationals", event_date=EVENT_DATE, **overrides):
+    fields = {
+        "version": 1,
+        "event_id": event_id,
+        "event_date": event_date,
+        "goal_id": "sub-40-10k",
+        "created_on": TODAY,
+        "window_days": 7,
+        "days": [
+            ProtocolDay(day_offset=0, title="Race", lines=[ProtocolLine(text="Warm up.")])
+        ],
+    }
+    fields.update(overrides)
+    return CompetitionProtocol.model_validate(fields)
+
+
+def test_save_and_read_roundtrip(tmp_path):
+    _seed_event(tmp_path)
+    path, version = store.save_competition_protocol(tmp_path, _protocol(), today=TODAY)
+    assert version == 1
+    assert path == tmp_path / "competition" / "protocol-nationals-v1.md"
+    assert (tmp_path / "competition" / "protocol-nationals-v1.yaml").exists()
+    stored = store.read_competition_protocol(tmp_path, "nationals")
+    assert stored is not None
+    assert stored.version == 1
+    assert stored.protocol.event_id == "nationals"
+    assert "# Competition protocol v1" in stored.markdown
+
+
+def test_v2_requires_reason_and_versions_are_per_event(tmp_path):
+    _seed_event(tmp_path)
+    _seed_event(tmp_path, event_id="tune-up", event_date=date(2026, 7, 30))
+    store.save_competition_protocol(tmp_path, _protocol(), today=TODAY)
+    with pytest.raises(ValueError, match="reason"):
+        store.save_competition_protocol(tmp_path, _protocol(), today=TODAY)
+    _, v2 = store.save_competition_protocol(
+        tmp_path, _protocol(), reason="taper adjusted", today=TODAY
+    )
+    assert v2 == 2
+    _, other = store.save_competition_protocol(
+        tmp_path,
+        _protocol(event_id="tune-up", event_date=date(2026, 7, 30)),
+        today=TODAY,
+    )
+    assert other == 1  # independent lineage per event
+
+
+def test_save_rejects_unknown_event_and_date_drift(tmp_path):
+    with pytest.raises(ValueError, match="calendar"):
+        store.save_competition_protocol(tmp_path, _protocol(), today=TODAY)
+    _seed_event(tmp_path)
+    with pytest.raises(ValueError, match="date"):
+        store.save_competition_protocol(
+            tmp_path, _protocol(event_date=date(2026, 8, 2)), today=TODAY
+        )
+
+
+def test_save_rejects_past_event(tmp_path):
+    _seed_event(tmp_path)
+    with pytest.raises(ValueError, match="past"):
+        store.save_competition_protocol(tmp_path, _protocol(), today=date(2026, 8, 5))
+
+
+def test_latest_version_none_when_empty(tmp_path):
+    assert store.latest_competition_protocol_version(tmp_path, "nationals") is None
+    assert store.read_competition_protocol(tmp_path, "nationals") is None
+```
+
+- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/memory/test_store_protocol.py -q` — Expected: FAIL (`AttributeError`)
+
+- [ ] **Step 3: Implement**
+
+In `src/performance_agent/memory/store.py`:
+
+Add to the constants block (after `WATCH_DIR = "watch"`):
+
+```python
+COMPETITION_DIR = "competition"
+```
+
+Add the imports (merge into the existing import lines): `CompetitionProtocol` into the `from performance_agent.memory.schemas import (...)` block, and
+
+```python
+from performance_agent.programs.render_protocol import render_protocol
+```
+
+Append at the end of the file:
+
+```python
+@dataclass(frozen=True)
+class ProtocolRead:
+    """A stored competition-protocol version: structured plan plus its markdown."""
+
+    version: int
+    event_id: str
+    goal_id: str
+    created_on: str
+    reason: str | None
+    markdown: str
+    protocol: CompetitionProtocol
+
+
+def _protocol_prefix(event_id: str) -> str:
+    return f"protocol-{event_id}"
+
+
+def latest_competition_protocol_version(base_dir: Path, event_id: str) -> int | None:
+    """Highest stored protocol version for this event, or None."""
+    return _latest_doc_version(base_dir, COMPETITION_DIR, _protocol_prefix(event_id))
+
+
+def save_competition_protocol(
+    base_dir: Path,
+    protocol: CompetitionProtocol,
+    reason: str | None = None,
+    today: date | None = None,
+    citations: "Mapping[str, ResolvedCitation] | None" = None,
+) -> tuple[Path, int]:
+    """Validate against the calendar and write the next protocol version.
+
+    The event must exist in calendar.yaml with the same date (a rescheduled
+    event needs a v2 with a reason, never a silent drift) and must not be in
+    the past. yaml is the source of truth, markdown the rendered view; both
+    are immutable once written. citations maps corpus ids to their resolved
+    rendering (the server resolves them; None keeps a citation-less render).
+    """
+    current = today or date.today()
+    event = next(
+        (e for e in read_calendar(base_dir).events if e.id == protocol.event_id), None
+    )
+    if event is None:
+        msg = f"event {protocol.event_id!r} is not in the calendar; add it first"
+        raise ValueError(msg)
+    if event.date != protocol.event_date:
+        msg = (
+            f"protocol event_date {protocol.event_date} does not match the calendar "
+            f"date {event.date} for {protocol.event_id!r}"
+        )
+        raise ValueError(msg)
+    if event.date < current:
+        msg = f"event {protocol.event_id!r} ({event.date}) is in the past"
+        raise ValueError(msg)
+    prefix = _protocol_prefix(protocol.event_id)
+    latest = latest_competition_protocol_version(base_dir, protocol.event_id)
+    version = 1 if latest is None else latest + 1
+    if version > 1 and not reason:
+        msg = (
+            f"adapting protocol v{latest} to v{version} for {protocol.event_id!r} "
+            "requires a reason (audit trail)"
+        )
+        raise ValueError(msg)
+    stamped = protocol.model_copy(
+        update={"version": version, "reason": reason, "created_on": current}
+    )
+    frontmatter = {
+        "version": version,
+        "event_id": stamped.event_id,
+        "goal_id": stamped.goal_id,
+        "created_on": current.isoformat(),
+        "reason": reason,
+    }
+    md_path = base_dir / COMPETITION_DIR / f"{prefix}-v{version}.md"
+    yaml_path = md_path.with_suffix(".yaml")
+    content = (
+        "---\n"
+        + _to_yaml(frontmatter)
+        + "---\n\n"
+        + render_protocol(stamped, citations=citations).strip()
+        + "\n"
+    )
+    _atomic_write(yaml_path, _to_yaml(stamped.model_dump(mode="json")))
+    try:
+        _atomic_write(md_path, content)
+    except OSError:
+        yaml_path.unlink(missing_ok=True)
+        raise
+    return md_path, version
+
+
+def read_competition_protocol(
+    base_dir: Path, event_id: str, version: int | None = None
+) -> ProtocolRead | None:
+    """Return the given or latest protocol for an event; None when none exists."""
+    target = (
+        version
+        if version is not None
+        else latest_competition_protocol_version(base_dir, event_id)
+    )
+    if target is None:
+        return None
+    prefix = _protocol_prefix(event_id)
+    md_path = base_dir / COMPETITION_DIR / f"{prefix}-v{target}.md"
+    yaml_path = md_path.with_suffix(".yaml")
+    if not md_path.exists() or not yaml_path.exists():
+        msg = f"protocol v{target} for {event_id!r} does not exist"
+        raise ValueError(msg)
+    frontmatter, markdown = _split_frontmatter(md_path, md_path.read_text(encoding="utf-8"))
+    protocol = _validated(
+        yaml_path,
+        lambda: CompetitionProtocol.model_validate(_load_yaml(yaml_path) or {}),
+    )
+    return ProtocolRead(
+        version=target,
+        event_id=event_id,
+        goal_id=str(frontmatter["goal_id"]),
+        created_on=str(frontmatter["created_on"]),
+        reason=str(frontmatter["reason"]) if frontmatter.get("reason") is not None else None,
+        markdown=markdown,
+        protocol=protocol,
+    )
+```
+
+(`Mapping` and `ResolvedCitation` are already imported since v0.8.0 — check the import block; if `ResolvedCitation` appears only in the quoted annotation, keep the existing import as is.)
+
+- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/memory/test_store_protocol.py tests/memory/ -q` — Expected: PASS
+
+- [ ] **Step 5: Commit**
+
+```bash
+uv run ruff check src/performance_agent/memory/store.py tests/memory/test_store_protocol.py && uv run ty check
+git add src/performance_agent/memory/store.py tests/memory/test_store_protocol.py
+git commit -m "Add per-event competition protocol store
+
+Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+git log --oneline -1
+```
+
+### Task 7: `programs/render_protocol_html.py` — phone page
+
+**Files:**
+- Create: `src/performance_agent/programs/render_protocol_html.py`
+- Test: `tests/programs/test_render_protocol_html.py`
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `tests/programs/test_render_protocol_html.py`:
+
+```python
+"""Protocol phone page: offline, no JS, warnings flagged, starred sources."""
+
+from datetime import date
+
+from performance_agent.evidence.citations import ResolvedCitation
+from performance_agent.memory.schemas import (
+    CompetitionProtocol,
+    DocumentedPractice,
+    PacingSegment,
+    ProtocolDay,
+    ProtocolLine,
+)
+from performance_agent.programs.render_protocol_html import render_protocol_html
+
+CITATIONS = {
+    "carb-2017": ResolvedCitation(
+        citation="Burke et al. (2017). Carbohydrates for training and competition. "
+        "DOI: 10.1080/02640414.2011.585473.",
+        stars="★★★★★",
+        doi="10.1080/02640414.2011.585473",
+        pmid=None,
+    )
+}
+
+
+def _protocol():
+    return CompetitionProtocol(
+        version=1,
+        event_id="nationals",
+        event_date=date(2026, 8, 1),
+        goal_id="sub-40-10k",
+        created_on=date(2026, 7, 25),
+        window_days=7,
+        days=[
+            ProtocolDay(
+                day_offset=-1,
+                title="Veille",
+                lines=[ProtocolLine(text="8-12 g/kg carbs.", cite="carb-2017")],
+            ),
+            ProtocolDay(
+                day_offset=0,
+                title="Race day",
+                lines=[
+                    ProtocolLine(text="Breakfast.", time_hint="06:00"),
+                    ProtocolLine(text="No new shoes.", warning=True),
+                ],
+            ),
+        ],
+        pacing=[
+            PacingSegment(
+                label="1 km", distance_m=1000, target_pace_s_per_km=240, cumulative_time_s=240
+            )
+        ],
+        practices=[
+            DocumentedPractice(
+                name="Water manipulation",
+                summary="Documented in physique prep.",
+                warning="Dehydration risk; supervision required.",
+            )
+        ],
+        checklist=["Pin race bib"],
+    )
+
+
+def test_page_is_selfcontained_and_scriptless():
+    page = render_protocol_html(_protocol(), citations=CITATIONS)
+    assert page.startswith("<!doctype html>")
+    assert "<script" not in page
+    assert "http" not in page.replace("https://doi.org/", "")
+
+
+def test_event_day_open_warnings_and_sources_rendered():
+    page = render_protocol_html(_protocol(), citations=CITATIONS)
+    assert "<details" in page and "open" in page
+    assert "⚠" in page
+    assert "Dehydration risk" in page
+    assert "★★★★★" in page
+    assert "https://doi.org/10.1080/02640414.2011.585473" in page
+    assert "[1]" in page
+
+
+def test_french_labels():
+    page = render_protocol_html(_protocol(), locale="fr", citations=CITATIONS)
+    assert "Jour J" in page
+    assert "Allures" in page
+```
+
+- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/programs/test_render_protocol_html.py -q` — Expected: FAIL (module missing)
+
+- [ ] **Step 3: Implement**
+
+Create `src/performance_agent/programs/render_protocol_html.py`:
+
+```python
+"""Deterministic CompetitionProtocol -> standalone phone page for the event.
+
+Same rules as the session HTML: fully self-contained (inline CSS, zero
+JavaScript, no external requests except DOI links), phone-first, en/fr/es
+labels from the athlete's locale. J0 renders open, earlier days collapsed.
+Practice warnings are visually flagged — the page never softens them.
+"""
+
+import html
+from collections.abc import Mapping
+
+from performance_agent.evidence.citations import ResolvedCitation
+from performance_agent.memory.schemas import CompetitionProtocol, ProtocolDay
+from performance_agent.programs.render_protocol import protocol_citation_ids
+
+_LABELS = {
+    "en": {
+        "protocol": "Competition protocol",
+        "window": "Window",
+        "goal": "Goal",
+        "event_day": "Event day",
+        "day": "Day",
+        "advice": "Advice",
+        "pacing": "Pacing",
+        "segment": "Segment",
+        "pace": "Pace",
+        "cumulative": "Cumulative",
+        "attempts": "Attempts",
+        "fueling": "Fueling",
+        "in_race": "In race",
+        "practices": "Documented practices",
+        "checklist": "Checklist",
+        "sources": "Sources",
+    },
+    "fr": {
+        "protocol": "Protocole de compétition",
+        "window": "Fenêtre",
+        "goal": "Objectif",
+        "event_day": "Jour J",
+        "day": "Jour",
+        "advice": "Conseils",
+        "pacing": "Allures",
+        "segment": "Segment",
+        "pace": "Allure",
+        "cumulative": "Cumulé",
+        "attempts": "Tentatives",
+        "fueling": "Ravitaillement",
+        "in_race": "En course",
+        "practices": "Pratiques documentées",
+        "checklist": "Checklist",
+        "sources": "Sources",
+    },
+    "es": {
+        "protocol": "Protocolo de competición",
+        "window": "Ventana",
+        "goal": "Objetivo",
+        "event_day": "Día D",
+        "day": "Día",
+        "advice": "Consejos",
+        "pacing": "Ritmos",
+        "segment": "Segmento",
+        "pace": "Ritmo",
+        "cumulative": "Acumulado",
+        "attempts": "Intentos",
+        "fueling": "Avituallamiento",
+        "in_race": "En carrera",
+        "practices": "Prácticas documentadas",
+        "checklist": "Checklist",
+        "sources": "Fuentes",
+    },
+}
+
+_CSS = """
+:root { --bg: #f6f7f9; --card: #ffffff; --ink: #1c2330; --muted: #5b6472;
+  --line: #e3e6eb; --accent: #2563eb; --chip: #eef2f8; --warn: #b45309;
+  --warnbg: #fef3c7; }
+@media (prefers-color-scheme: dark) {
+  :root { --bg: #10141b; --card: #1a202b; --ink: #e8ecf2; --muted: #9aa4b2;
+    --line: #2a3140; --accent: #7aa2ff; --chip: #232b39; --warn: #fbbf24;
+    --warnbg: #3a2f14; } }
+* { box-sizing: border-box; }
+body { margin: 0; background: var(--bg); color: var(--ink); line-height: 1.5;
+  font: 16px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; }
+main { max-width: 46rem; margin: 0 auto; padding: 1rem 1rem 4rem; }
+header.top h1 { margin: 1.5rem 0 0.25rem; font-size: 1.4rem; }
+header.top p { margin: 0.15rem 0; color: var(--muted); }
+h2 { font-size: 1.1rem; margin: 1.5rem 0 0.5rem; }
+details.day { background: var(--card); border: 1px solid var(--line);
+  border-radius: 12px; margin: 0.6rem 0; overflow: hidden; }
+details.day > summary { cursor: pointer; padding: 0.8rem 1rem; font-weight: 600;
+  list-style: none; }
+details.day > summary::-webkit-details-marker { display: none; }
+details.day ul { margin: 0 0 0.8rem; padding: 0 1rem 0 2rem; }
+details.day li { margin: 0.35rem 0; }
+.hint { display: inline-block; background: var(--chip); border-radius: 999px;
+  padding: 0 0.5rem; font-size: 0.85rem; margin-right: 0.3rem; }
+li.warn { background: var(--warnbg); border-radius: 8px; padding: 0.25rem 0.5rem;
+  list-style: none; margin-left: -1rem; }
+.warnmark { color: var(--warn); font-weight: 700; }
+sup.cite { color: var(--accent); font-weight: 600; }
+table { border-collapse: collapse; width: 100%; background: var(--card);
+  border-radius: 12px; overflow: hidden; }
+th, td { border-bottom: 1px solid var(--line); padding: 0.45rem 0.7rem;
+  text-align: left; font-size: 0.95rem; }
+.practice { background: var(--warnbg); border-radius: 12px; padding: 0.7rem 1rem;
+  margin: 0.6rem 0; }
+.practice p { margin: 0.25rem 0; }
+.practice .warnline { color: var(--warn); font-weight: 600; }
+ul.checklist { padding-left: 1.2rem; }
+section.sources ol { padding-left: 1.2rem; }
+section.sources li { margin: 0.35rem 0; font-size: 0.9rem; }
+section.sources .stars { color: var(--accent); letter-spacing: 0.05em; }
+"""
+
+
+def _t(locale: str, key: str) -> str:
+    return _LABELS.get(locale, _LABELS["en"])[key]
+
+
+def _marker(numbers: dict[str, int], cite: str | None) -> str:
+    if cite is None or cite not in numbers:
+        return ""
+    return f'<sup class="cite">[{numbers[cite]}]</sup>'
+
+
+def _pace(value: float) -> str:
+    minutes, seconds = divmod(round(value), 60)
+    return f"{minutes}:{seconds:02d}/km"
+
+
+def _clock(value: float) -> str:
+    minutes, seconds = divmod(round(value), 60)
+    return f"{minutes}:{seconds:02d}"
+
+
+def _day_html(day: ProtocolDay, numbers: dict[str, int], locale: str) -> str:
+    title = (
+        _t(locale, "event_day")
+        if day.day_offset == 0
+        else f"{_t(locale, 'day')} J{day.day_offset}"
+    )
+    items = []
+    for line in day.lines:
+        hint = f'<span class="hint">{html.escape(line.time_hint)}</span>' if line.time_hint else ""
+        warn = '<span class="warnmark">⚠ </span>' if line.warning else ""
+        css = ' class="warn"' if line.warning else ""
+        items.append(
+            f"<li{css}>{hint}{warn}{html.escape(line.text)}{_marker(numbers, line.cite)}</li>"
+        )
+    is_open = " open" if day.day_offset == 0 else ""
+    return (
+        f'<details class="day"{is_open}><summary>{title} — {html.escape(day.title)}</summary>'
+        f"<ul>{''.join(items)}</ul></details>"
+    )
+
+
+def _pacing_html(protocol: CompetitionProtocol, locale: str) -> str:
+    if not protocol.pacing:
+        return ""
+    rows = "".join(
+        f"<tr><td>{html.escape(seg.label)}</td><td>{seg.distance_m:g} m</td>"
+        f"<td>{_pace(seg.target_pace_s_per_km)}</td><td>{_clock(seg.cumulative_time_s)}</td></tr>"
+        for seg in protocol.pacing
+    )
+    return (
+        f"<h2>🏁 {_t(locale, 'pacing')}</h2><table><tr><th>{_t(locale, 'segment')}</th>"
+        f"<th></th><th>{_t(locale, 'pace')}</th><th>{_t(locale, 'cumulative')}</th></tr>"
+        f"{rows}</table>"
+    )
+
+
+def _attempts_html(protocol: CompetitionProtocol, locale: str) -> str:
+    if not protocol.attempts:
+        return ""
+    rows = "".join(
+        f"<tr><td>{html.escape(a.lift)}</td><td>{a.opener_kg:g}</td>"
+        f"<td>{a.second_kg:g}</td><td>{a.third_kg:g}</td></tr>"
+        for a in protocol.attempts
+    )
+    return (
+        f"<h2>🏋️ {_t(locale, 'attempts')}</h2><table><tr><th></th><th>1</th><th>2</th>"
+        f"<th>3</th></tr>{rows}</table>"
+    )
+
+
+def _fueling_html(protocol: CompetitionProtocol, numbers: dict[str, int], locale: str) -> str:
+    fueling = protocol.fueling
+    if fueling is None:
+        return ""
+    lines = [
+        f"<li>{fueling.carb_g_per_kg_low:g}-{fueling.carb_g_per_kg_high:g} g/kg/day — "
+        f"{fueling.window_hours} h{_marker(numbers, fueling.cite)}</li>"
+    ]
+    if fueling.race_carb_g_per_h_low is not None and fueling.race_carb_g_per_h_high is not None:
+        lines.append(
+            f"<li>{_t(locale, 'in_race')}: {fueling.race_carb_g_per_h_low:g}-"
+            f"{fueling.race_carb_g_per_h_high:g} g/h</li>"
+        )
+    return f"<h2>🍝 {_t(locale, 'fueling')}</h2><ul>{''.join(lines)}</ul>"
+
+
+def _practices_html(protocol: CompetitionProtocol, numbers: dict[str, int], locale: str) -> str:
+    if not protocol.practices:
+        return ""
+    cards = "".join(
+        f'<div class="practice"><p><strong>{html.escape(p.name)}</strong> — '
+        f"{html.escape(p.summary)}{_marker(numbers, p.cite)}</p>"
+        f'<p class="warnline">⚠ {html.escape(p.warning)}</p></div>'
+        for p in protocol.practices
+    )
+    return f"<h2>⚠️ {_t(locale, 'practices')}</h2>{cards}"
+
+
+def _sources_html(
+    citations: Mapping[str, ResolvedCitation], numbers: dict[str, int], locale: str
+) -> str:
+    ordered = sorted((cid for cid in numbers if cid in citations), key=lambda cid: numbers[cid])
+    if not ordered:
+        return ""
+    rows = []
+    for cid in ordered:
+        resolved = citations[cid]
+        link = (
+            f' <a href="https://doi.org/{html.escape(resolved.doi)}">DOI</a>'
+            if resolved.doi
+            else ""
+        )
+        rows.append(
+            f'<li><span class="stars">{resolved.stars}</span> '
+            f"{html.escape(resolved.citation)}{link}</li>"
+        )
+    return (
+        f'<section class="sources"><h2>📚 {_t(locale, "sources")}</h2>'
+        f"<ol>{''.join(rows)}</ol></section>"
+    )
+
+
+def render_protocol_html(
+    protocol: CompetitionProtocol,
+    locale: str = "en",
+    citations: Mapping[str, ResolvedCitation] | None = None,
+) -> str:
+    """Render the protocol to a standalone, offline-ready phone page."""
+    numbers = (
+        {cid: i for i, cid in enumerate(protocol_citation_ids(protocol), start=1)}
+        if citations
+        else {}
+    )
+    advice = ""
+    if protocol.advice:
+        rows = "".join(
+            f"<li>{html.escape(g.text)}{_marker(numbers, g.cite)}</li>" for g in protocol.advice
+        )
+        advice = f"<h2>💡 {_t(locale, 'advice')}</h2><ul>{rows}</ul>"
+    days = "".join(_day_html(day, numbers, locale) for day in protocol.days)
+    checklist = ""
+    if protocol.checklist:
+        items = "".join(f"<li>☐ {html.escape(item)}</li>" for item in protocol.checklist)
+        checklist = f"<h2>🎒 {_t(locale, 'checklist')}</h2><ul class='checklist'>{items}</ul>"
+    title = (
+        f"{_t(locale, 'protocol')} v{protocol.version} — {html.escape(protocol.event_id)} — "
+        f"{protocol.event_date.isoformat()}"
+    )
+    header = (
+        f'<header class="top"><h1>{title}</h1>'
+        f"<p>{_t(locale, 'window')}: J-{protocol.window_days} → J0 · "
+        f"{_t(locale, 'goal')}: {html.escape(protocol.goal_id)}</p></header>"
+    )
+    return (
+        f'<!doctype html><html lang="{locale}"><head><meta charset="utf-8">'
+        '<meta name="viewport" content="width=device-width, initial-scale=1">'
+        f"<title>{title}</title><style>{_CSS}</style></head><body><main>"
+        f"{header}{advice}{days}{_pacing_html(protocol, locale)}"
+        f"{_attempts_html(protocol, locale)}{_fueling_html(protocol, numbers, locale)}"
+        f"{_practices_html(protocol, numbers, locale)}{checklist}"
+        f"{_sources_html(citations or {}, numbers, locale)}</main></body></html>"
+    )
+```
+
+- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/programs/ -q` — Expected: PASS
+
+- [ ] **Step 5: Lint + commit**
+
+```bash
+uv run ruff check src/performance_agent/programs/render_protocol_html.py tests/programs/test_render_protocol_html.py && uv run ty check
+git add src/performance_agent/programs/render_protocol_html.py tests/programs/test_render_protocol_html.py
+git commit -m "Render the competition protocol phone page
+
+Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+git log --oneline -1
+```
+
+---
+
+## Phase 3 — Server + diligence
+
+### Task 8: `server/competition_tools.py` + registration
+
+**Files:**
+- Create: `src/performance_agent/server/competition_tools.py`
+- Modify: `src/performance_agent/server/app.py`
+- Test: `tests/server/test_competition_tools.py`
+
+- [ ] **Step 1: Write the failing tests**
+
+Create `tests/server/test_competition_tools.py`:
+
+```python
+"""MCP wrappers for the pre-competition protocol."""
+
+from datetime import date
+from pathlib import Path
+
+import pytest
+
+from performance_agent.memory import store
+from performance_agent.memory.schemas import (
+    CalendarEvent,
+    CompetitionProtocol,
+    Guidance,
+    Profile,
+    ProtocolDay,
+    ProtocolLine,
+)
+from performance_agent.server import competition_tools
+
+TODAY = date.today()
+
+
+@pytest.fixture
+def athlete_dir(monkeypatch, tmp_path):
+    monkeypatch.setenv("PERFORMANCE_AGENT_HOME", str(tmp_path))
+    store.write_profile(tmp_path, Profile())
+    store.upsert_calendar_event(
+        tmp_path,
+        CalendarEvent(
+            id="nationals",
+            date=TODAY.replace(year=TODAY.year + 1),
+            kind="competition",
+            priority="A",
+            label="Nationals",
+        ),
+    )
+    return tmp_path
+
+
+def _protocol(**overrides):
+    fields = {
+        "version": 1,
+        "event_id": "nationals",
+        "event_date": TODAY.replace(year=TODAY.year + 1),
+        "goal_id": "sub-40-10k",
+        "created_on": TODAY,
+        "window_days": 7,
+        "days": [
+            ProtocolDay(day_offset=0, title="Race", lines=[ProtocolLine(text="Warm up.")])
+        ],
+    }
+    fields.update(overrides)
+    return CompetitionProtocol.model_validate(fields)
+
+
+def test_engine_wrappers_quote_engine_numbers(athlete_dir):
+    carbs = competition_tools.carb_loading_targets(70.0, 180.0)
+    assert carbs["carb_g_per_day_high"] == 840.0
+    attempts = competition_tools.select_attempts("Squat", 200.0, 205.0)
+    assert attempts["lift"] == "Squat"
+    assert attempts["third_kg"] == 205.0
+    splits = competition_tools.pacing_plan(10000.0, 2400.0)
+    assert len(splits) == 10
+
+
+def test_save_renders_html_and_read_roundtrips(athlete_dir):
+    result = competition_tools.save_competition_protocol(_protocol())
+    assert result["version"] == 1
+    page = Path(result["html_path"]).read_text(encoding="utf-8")
+    assert "<script" not in page
+    view = competition_tools.read_competition_protocol("nationals")
+    assert view["version"] == 1
+    assert view["protocol"]["event_id"] == "nationals"
+
+
+def test_save_rejects_unknown_citation(athlete_dir):
+    protocol = _protocol(advice=[Guidance(text="Fake.", cite="phantom-id")])
+    with pytest.raises(ValueError, match="phantom-id"):
+        competition_tools.save_competition_protocol(protocol)
+
+
+def test_read_without_protocol_raises(athlete_dir):
+    with pytest.raises(ValueError, match="no protocol"):
+        competition_tools.read_competition_protocol("nationals")
+```
+
+- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/server/test_competition_tools.py -q` — Expected: FAIL (module missing)
+
+- [ ] **Step 3: Implement**
+
+Create `src/performance_agent/server/competition_tools.py`:
+
+```python
+"""MCP tools for the pre-competition protocol.
+
+Engine numbers are quoted, never renegotiated upward; the athlete may always
+choose the more conservative option. The save gate resolves every citation id
+against the corpus — an unknown id aborts before anything is written.
+"""
+
+from dataclasses import asdict
+from typing import Any, TypedDict
+
+from mcp.server.fastmcp import FastMCP
+
+from performance_agent.engine import competition as competition_engine
+from performance_agent.evidence.citations import resolve_citations
+from performance_agent.memory import store
+from performance_agent.memory.paths import resolve_athlete_dir
+from performance_agent.memory.schemas import CompetitionProtocol
+from performance_agent.programs.render_protocol import protocol_citation_ids
+from performance_agent.programs.render_protocol_html import render_protocol_html
+
+
+class AttemptView(TypedDict):
+    """Meet-day attempts for one lift, engine-computed."""
+
+    lift: str
+    e1rm_kg: float
+    opener_kg: float
+    second_kg: float
+    third_kg: float
+    flags: list[str]
+
+
+class ProtocolSaved(TypedDict):
+    """Result of writing a protocol version (markdown + phone page)."""
+
+    path: str
+    version: int
+    html_path: str
+
+
+class ProtocolView(TypedDict):
+    """A stored protocol version: structured plan plus rendered markdown."""
+
+    version: int
+    event_id: str
+    goal_id: str
+    created_on: str
+    reason: str | None
+    markdown: str
+    protocol: dict[str, Any]
+
+
+def carb_loading_targets(body_mass_kg: float, event_duration_min: float) -> dict[str, Any]:
+    """Carb-loading and in-race fueling ranges for an event (evidence-based).
+
+    Events >= 90 min: 8-12 g/kg/day over the final 48 h; 60-90 min: 6-8 g/kg/day
+    over 24 h; shorter: loading_required=false (say so, don't invent a load).
+    In-race: none under 60 min, 30-60 g/h up to ~2.5 h, 60-90 g/h beyond. Quote
+    the ranges as ranges — food choices and timing are coaching conversation.
+    """
+    return asdict(competition_engine.carb_loading_targets(body_mass_kg, event_duration_min))
+
+
+def select_attempts(
+    lift: str, e1rm_kg: float, goal_kg: float, rounding_kg: float = 2.5
+) -> AttemptView:
+    """Three meet-day attempts from the e1RM (get it from estimate_1rm first).
+
+    Opener ~91% (a confident triple), second ~96%, third at the goal when it
+    lies within 93-105% of e1RM — else ~101% with flag goal_beyond_e1rm: name
+    the gap honestly, never pretend the goal is on the bar. The athlete may
+    always call lighter attempts; never push heavier than the engine's numbers.
+    """
+    selection = competition_engine.select_attempts(e1rm_kg, goal_kg, rounding_kg)
+    return AttemptView(
+        lift=lift,
+        e1rm_kg=e1rm_kg,
+        opener_kg=selection.opener_kg,
+        second_kg=selection.second_kg,
+        third_kg=selection.third_kg,
+        flags=list(selection.flags),
+    )
+
+
+def pacing_plan(
+    distance_m: float,
+    target_time_s: float,
+    segment_m: float = 1000.0,
+    strategy: str = "even",
+) -> list[dict[str, Any]]:
+    """Per-segment target paces and cumulative splits for a race plan.
+
+    target_time_s comes from the athlete's goal or predict_race_time — this
+    only distributes it. strategy 'even' or 'negative' (first half ~1% slower,
+    second half balanced so the total lands on target).
+    """
+    return [
+        asdict(split)
+        for split in competition_engine.pacing_plan(
+            distance_m, target_time_s, segment_m, strategy
+        )
+    ]
+
+
+def save_competition_protocol(
+    protocol: CompetitionProtocol, reason: str | None = None
+) -> ProtocolSaved:
+    """Write the NEXT protocol version for its event (immutable audit trail).
+
+    The event must exist in the calendar with a matching, non-past date.
+    Version 1 needs no reason; v2+ requires one naming the trigger. Every cite
+    (advice, day lines, fueling, practices) must be a real corpus id — an
+    unknown id aborts the save (anti-fabrication). Every documented practice
+    carries its warning by schema. Alongside the markdown, a standalone phone
+    page is written — hand that file to the athlete for the event.
+    MANDATORY: pass the draft through program-review's protocol gate BEFORE
+    saving; only an APPROVED verdict saves.
+    """
+    base = resolve_athlete_dir()
+    citations = resolve_citations(protocol_citation_ids(protocol))
+    path, version = store.save_competition_protocol(base, protocol, reason, citations=citations)
+    stored = store.read_competition_protocol(base, protocol.event_id, version)
+    if stored is None:  # pragma: no cover - just written above
+        msg = f"protocol v{version} vanished after save"
+        raise ValueError(msg)
+    locale = store.read_profile(base).locale
+    page = render_protocol_html(stored.protocol, locale=locale, citations=citations)
+    html_path = path.with_suffix(".html")
+    html_path.write_text(page, encoding="utf-8")
+    return ProtocolSaved(path=str(path), version=version, html_path=str(html_path))
+
+
+def read_competition_protocol(event_id: str, version: int | None = None) -> ProtocolView:
+    """Return the latest (or a specific) protocol version for an event."""
+    stored = store.read_competition_protocol(resolve_athlete_dir(), event_id, version)
+    if stored is None:
+        msg = f"no protocol saved for event {event_id!r}; save_competition_protocol first"
+        raise ValueError(msg)
+    return ProtocolView(
+        version=stored.version,
+        event_id=stored.event_id,
+        goal_id=stored.goal_id,
+        created_on=stored.created_on,
+        reason=stored.reason,
+        markdown=stored.markdown,
+        protocol=stored.protocol.model_dump(mode="json"),
+    )
+
+
+def register(mcp: FastMCP) -> None:
+    """Register the competition tools on the server."""
+    for tool in (
+        carb_loading_targets,
+        select_attempts,
+        pacing_plan,
+        save_competition_protocol,
+        read_competition_protocol,
+    ):
+        mcp.tool()(tool)
+```
+
+In `src/performance_agent/server/app.py`: add `competition_tools,` to the import tuple (alphabetical, after `autoregulation_tools`) and `competition_tools.register(mcp)` after `followup_tools.register(mcp)`.
+
+- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/server/ -q` — Expected: PASS
+
+- [ ] **Step 5: Lint + commit**
+
+```bash
+uv run ruff check src/performance_agent/server/competition_tools.py src/performance_agent/server/app.py tests/server/test_competition_tools.py && uv run ty check
+git add src/performance_agent/server/competition_tools.py src/performance_agent/server/app.py tests/server/test_competition_tools.py
+git commit -m "Add the five pre-competition MCP tools
+
+Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+git log --oneline -1
+```
+
+### Task 9: Diligence — `competition_protocol` due action
+
+**Files:**
+- Modify: `src/performance_agent/engine/diligence.py`
+- Modify: `src/performance_agent/memory/diligence.py`
+- Modify: `src/performance_agent/server/memory_tools.py` (docstring)
+- Test: `tests/engine/test_diligence.py` (append), `tests/memory/test_diligence.py` (append)
+
+- [ ] **Step 1: Write the failing tests**
+
+Append to `tests/engine/test_diligence.py`:
+
+```python
+def test_competition_protocol_due_inside_window_without_protocol():
+    facts = _facts(
+        upcoming_events=(
+            UpcomingEvent(
+                event_id="nationals", priority="A", days_until=8,
+                protocol_window_days=10, has_protocol=False,
+            ),
+        )
+    )
+    action = next(a for a in list_due_actions(facts) if a.kind == "competition_protocol")
+    assert action.severity == "medium"
+    assert action.due_in_days == 8
+    assert action.ref == "nationals"
+
+
+def test_competition_protocol_high_when_event_is_close():
+    facts = _facts(
+        upcoming_events=(
+            UpcomingEvent(
+                event_id="nationals", priority="A", days_until=5,
+                protocol_window_days=10, has_protocol=False,
+            ),
+        )
+    )
+    action = next(a for a in list_due_actions(facts) if a.kind == "competition_protocol")
+    assert action.severity == "high"
+
+
+def test_competition_protocol_quiet_outside_window_or_covered():
+    outside = _facts(
+        upcoming_events=(
+            UpcomingEvent(
+                event_id="nationals", priority="A", days_until=15,
+                protocol_window_days=10, has_protocol=False,
+            ),
+        )
+    )
+    covered = _facts(
+        upcoming_events=(
+            UpcomingEvent(
+                event_id="nationals", priority="A", days_until=5,
+                protocol_window_days=10, has_protocol=True,
+            ),
+        )
+    )
+    for facts in (outside, covered):
+        kinds = {a.kind for a in list_due_actions(facts)}
+        assert "competition_protocol" not in kinds
+```
+
+Append to `tests/memory/test_diligence.py`:
+
+```python
+def test_a_event_without_protocol_surfaces_competition_protocol(tmp_path):
+    upsert_calendar_event(
+        tmp_path,
+        CalendarEvent(
+            id="nationals",
+            date=TODAY + timedelta(days=6),
+            kind="competition",
+            priority="A",
+            label="Nationals",
+        ),
+    )
+    action = _action(tmp_path, "competition_protocol")
+    assert action["ref"] == "nationals"
+    assert action["due_in_days"] == 6
+```
+
+- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/engine/test_diligence.py tests/memory/test_diligence.py -q` — Expected: FAIL (`unexpected keyword argument 'protocol_window_days'`)
+
+- [ ] **Step 3: Implement**
+
+In `src/performance_agent/engine/diligence.py`:
+
+Add to the thresholds block (after `_WATCH_DUE_DAYS = 14`):
+
+```python
+# Inside a week of the event, a missing protocol is urgent.
+_PROTOCOL_URGENT_DAYS = 7
+```
+
+Extend `UpcomingEvent` (append two defaulted fields — existing constructions stay valid):
+
+```python
+    protocol_window_days: int = 0
+    has_protocol: bool = True
+```
+
+(and extend its docstring with: `protocol_window_days is the taper-derived due window for a pre-competition protocol; has_protocol says whether one exists for this event.`)
+
+Add the action builder (after `_watch_action`):
+
+```python
+def _protocol_action(event: UpcomingEvent) -> DueAction | None:
+    if event.has_protocol or event.protocol_window_days <= 0:
+        return None
+    if event.days_until > event.protocol_window_days:
+        return None
+    severity: Severity = "high" if event.days_until <= _PROTOCOL_URGENT_DAYS else "medium"
+    return DueAction(
+        "competition_protocol",
+        severity,
+        "competition_protocol_due",
+        due_in_days=event.days_until,
+        ref=event.event_id,
+    )
+```
+
+Register it inside `list_due_actions`, right after the existing `candidates.extend(_event_action(event) for event in facts.upcoming_events)` line:
+
+```python
+    candidates.extend(_protocol_action(event) for event in facts.upcoming_events)
+```
+
+In `src/performance_agent/memory/diligence.py`:
+
+Add imports: `from performance_agent.engine.competition import protocol_window_days` and `from performance_agent.engine.season import recommend_taper_length` (merged with existing imports).
+
+Add after the module's threshold constants:
+
+```python
+# The due-action window uses the population mixed-modality taper prior — no
+# per-athlete modality is persisted; the skill computes the individualized
+# window (recommend_taper) when it actually authors the protocol.
+_NEUTRAL_BUILDUP_WEEKS = 8
+```
+
+Replace `_upcoming_events` with (it gains `base_dir` and fills the two new fields):
+
+```python
+def _upcoming_events(base_dir: Path, context: TimeContext) -> tuple[UpcomingEvent, ...]:
+    events = []
+    for event in context["next_events"]:
+        if event["priority"] not in ("A", "B") or not 0 <= event["days_until"] <= _EVENT_HORIZON_DAYS:
+            continue
+        taper_days = recommend_taper_length(_NEUTRAL_BUILDUP_WEEKS, "mixed", event["priority"])
+        events.append(
+            UpcomingEvent(
+                event_id=event["event_id"],
+                priority=event["priority"],
+                days_until=event["days_until"],
+                protocol_window_days=protocol_window_days(taper_days, event["priority"]),
+                has_protocol=store.latest_competition_protocol_version(
+                    base_dir, event["event_id"]
+                )
+                is not None,
+            )
+        )
+    return tuple(events)
+```
+
+and update its call site in `_build_facts` to `upcoming_events=_upcoming_events(base_dir, context),`.
+
+In `src/performance_agent/server/memory_tools.py`, extend the `list_due_actions` docstring list with: `an A/B event inside its protocol window with no pre-competition protocol saved`.
+
+- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/engine/test_diligence.py tests/memory/ tests/server/ -q` — Expected: PASS. If `test_imminent_a_event_is_high`-style existing tests now ALSO see a `competition_protocol` action, that is correct behavior — fix only tests that assert exact action lists (add the new kind or a protocol), never the engine.
+
+- [ ] **Step 5: Commit**
+
+```bash
+uv run ruff check src tests && uv run ty check
+git add src/performance_agent/engine/diligence.py src/performance_agent/memory/diligence.py src/performance_agent/server/memory_tools.py tests/engine/test_diligence.py tests/memory/test_diligence.py
+git commit -m "Surface the competition-protocol due action
+
+Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+git log --oneline -1
+```
+
+### Task 10: Phase gate
+
+- [ ] **Step 1:** Run: `rtk proxy uv run pytest -q >/dev/null 2>&1; echo "exit=$?"` — Expected: `exit=0`
+- [ ] **Step 2:** Run: `uv run ruff check src tests && uv run ty check` — Expected: clean. Fix anything before Phase 4.
+
+---
+
+## Phase 4 — Skills + README
+
+### Task 11: New skill `pre-competition`
+
+**Files:**
+- Create: `skills/pre-competition/SKILL.md`
+
+- [ ] **Step 1: Write the skill**
+
+````markdown
+---
+name: pre-competition
+description: Use when a competition_protocol due action fires or the athlete says
+  their competition is coming up. Authors the per-event, day-by-day protocol for
+  the final days (J-N to J0) and delivers the phone page for the event.
+tools: [read_athlete, get_time_context, read_calendar, read_program, read_sessions,
+  read_research_dossier, recommend_taper, predict_race_time, estimate_1rm,
+  carb_loading_targets, select_attempts, pacing_plan, get_citation,
+  save_competition_protocol, read_competition_protocol, log_kpi_result]
+---
+
+# Pre-competition
+
+The protocol author: the final days before a competition, planned day by day and
+handed over as a phone page the athlete reads on the morning of the event. Sport
+comes from the research, numbers come from the engine, and this skill NEVER
+edits the program — taper structure changes route to program-adaptation.
+
+## Ritual
+
+1. Open with `read_athlete` + `get_time_context` (quote its dates) and
+   `read_calendar`; name the event, its priority, and days until. `read_program`
+   for the planned taper; sanity-check it against `recommend_taper` (say the
+   basis — individual or population).
+2. First protocol for this event → run the dedicated mini-wave (deep-research
+   rules): ONE question — "the final days before [this event] for [this
+   athlete]" — verified studies join the corpus, the dossier gets a v+1.
+   `read_research_dossier` for what is already known.
+3. Build the day-by-day plan from J-window to J0, engine first:
+   - Endurance: target from the goal or `predict_race_time`; `pacing_plan` for
+     the splits; `carb_loading_targets` for fueling (quote ranges as ranges).
+   - Strength: e1RM via `estimate_1rm` (recent best sets); `select_attempts`
+     per lift. `goal_beyond_e1rm` flag → name the gap honestly; the athlete may
+     call lighter, never heavier than the engine's numbers.
+   - Everything else (meal timing, warm-up, logistics, checklist) is advice:
+     cited (`get_citation`) or plainly labeled coaching judgment.
+4. Documented practices (peak-week water/sodium, weight-cut tactics): describe
+   ONLY what the literature documents, each with its evidence grade and an
+   explicit warning — never a dose, never a schedule, never engine math. Red
+   flags and medical conditions keep precedence: refer out.
+5. Walk the draft through with the athlete, then submit it to program-review's
+   protocol gate. Only an APPROVED verdict saves: `save_competition_protocol`
+   (v2+ reason = the trigger). Hand the athlete the html_path — that page is
+   their event-day companion.
+6. Day J-0 to J+2: route the debrief to training-checkin and log the result
+   with `log_kpi_result` — the outcome feeds fit_taper_response for next time.
+````
+
+- [ ] **Step 2: Verify** — Run: `rtk proxy uv run pytest tests/skills/ -q` — Expected: only `test_all_expected_skills_exist` fails (fixed in Task 12). If `test_tool_references` fails, fix the frontmatter now.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add skills/pre-competition/SKILL.md
+git commit -m "Add pre-competition skill
+
+Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+git log --oneline -1
+```
+
+### Task 12: Edit the five existing skills + test invariants
+
+**Files:**
+- Modify: `skills/performance-coach/SKILL.md`, `skills/training-checkin/SKILL.md`, `skills/session-day/SKILL.md`, `skills/deep-research/SKILL.md`, `skills/program-review/SKILL.md`
+- Modify: `tests/skills/test_structure.py`
+
+- [ ] **Step 1: Update the invariants first (they drive the edits)**
+
+In `tests/skills/test_structure.py`:
+
+Add to `EXPECTED_SKILLS`: `"pre-competition",`
+
+Append the protocol test:
+
+```python
+def test_pre_competition_skill_protocol(skills):
+    precomp = next(s for s in skills if s.frontmatter["name"] == "pre-competition")
+    body = precomp.body.casefold()
+    for needle in (
+        "save_competition_protocol",
+        "carb_loading_targets",
+        "select_attempts",
+        "pacing_plan",
+        "recommend_taper",
+        "mini-wave",
+        "warning",
+        "program-review",
+        "never edits the program",
+        "log_kpi_result",
+        "coaching judgment",
+    ):
+        assert needle in body, f"pre-competition skill lost: {needle}"
+```
+
+Extend existing needle tuples (append to each):
+- `test_coach_skill_carries_the_global_rules` (the test that asserts coach body content, ~line 37): `"pre-competition"`
+- `test_checkin_skill_protocol`: `"debrief"`
+- `test_review_skill_protocol`: `"protocol"` and `"warning"` (both appear in the Task 12 Step 6 checklist block)
+
+Run: `rtk proxy uv run pytest tests/skills/ -q` — Expected: FAIL on exactly these invariants.
+
+**Beware line wrap:** every needle must appear UNBROKEN on one line in the skill body (casefolded). Reflow sentences if needed.
+
+- [ ] **Step 2: `skills/performance-coach/SKILL.md`**
+
+In the routing section, after the next-week-loads / program-watch lines added in v0.8.0, add:
+
+```markdown
+- competition_protocol action fires, or "my competition is in N days" →
+  **pre-competition** (authors the final-days protocol and the event-day page).
+```
+
+- [ ] **Step 3: `skills/training-checkin/SKILL.md`**
+
+In the "Mesocycle boundary duties" section (or right after it), add:
+
+```markdown
+## Around a competition
+
+A competition_protocol due action routes to pre-competition. The first check-in
+AFTER an event owns the debrief: how it went vs the protocol, log the result
+with log_kpi_result (it feeds the individual taper response), and any pain or
+red flag follows the normal rules.
+```
+
+Frontmatter: add `log_kpi_result` to `tools` if not already declared.
+
+- [ ] **Step 4: `skills/session-day/SKILL.md`**
+
+Add near the top of the protocol/ritual section:
+
+```markdown
+If today is an event day (J0) and a saved protocol exists
+(read_competition_protocol for the calendar event), open FROM the protocol page
+instead of improvising: quote its timeline, paces or attempts as written.
+Adjustments follow the protocol's fallbacks, never a rewrite an hour before.
+```
+
+Frontmatter: add `read_competition_protocol` to `tools`.
+
+- [ ] **Step 5: `skills/deep-research/SKILL.md`**
+
+In the "Mini-waves and the incremental watch" section, append one line to the mini-wave paragraph:
+
+```markdown
+The pre-competition wave is a mini-wave whose single question is the final days
+before a named event (taper execution, fueling, pacing or attempts, weigh-in).
+```
+
+- [ ] **Step 6: `skills/program-review/SKILL.md`**
+
+Append to the deterministic compliance checklist (after the v0.8.0 structured-progression/guidance items):
+
+```markdown
+- Competition protocols (when the draft is a protocol, not a program): every
+  documented practice carries an evidence grade (verify cites with
+  get_citation) and an explicit warning; every engine-attributed number
+  (attempts, paces, carb targets) matches a tool recomputation; dehydration or
+  water-manipulation content stated as a computed or prescriptive line — rather
+  than a warned, graded practice — is an objection.
+```
+
+- [ ] **Step 7: Run the full skills suite** — `rtk proxy uv run pytest tests/skills/ -q` — Expected: PASS. If `test_bodies_do_not_reference_undeclared_tools` fails, add the mentioned tool to that skill's frontmatter `tools`.
+
+- [ ] **Step 8: Commit**
+
+```bash
+git add skills/ tests/skills/test_structure.py
+git commit -m "Wire the pre-competition protocol into the skills
+
+Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+git log --oneline -1
+```
+
+### Task 13: README + final gate
+
+**Files:**
+- Modify: `README.md`
+
+- [ ] **Step 1: Update README** — replace `You should see 97 tools.` with `You should see 102 tools.`; replace `97 MCP` with `102 MCP`; replace `fourteen coaching skills` with `fifteen coaching skills`; add one feature bullet after the "Science on the gym page" bullet:
+
+```markdown
+- **Pre-competition protocol** — the final days before any competition planned
+  day by day (engine-computed attempts, pacing splits and carb loading; risky
+  peak-week practices described only with evidence grade + explicit warning),
+  delivered as a versioned document and an offline phone page for the event.
+```
+
+Then recount the suite and update the test count: run `rtk proxy uv run python -m pytest --collect-only -q 2>/dev/null | awk -F': ' '{s+=$2} END {print s}'` and replace the `1339 tests` figure with the new number.
+
+- [ ] **Step 2: Full suite + linters** — Run: `rtk proxy uv run pytest -q >/dev/null 2>&1; echo "exit=$?"` then `uv run ruff check src tests && uv run ty check` — Expected: exit=0, everything clean.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add README.md
+git commit -m "Document the pre-competition protocol
+
+Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
+git log --oneline -1
+```
+
+- [ ] **Step 4: NOT in this plan** — version bump, CHANGELOG, PyPI release.
+
+---
+
+## Plan self-review notes
+
+- Spec coverage: §3 → Task 4; §4 → Tasks 1-3; §5 → Tasks 5-7; §6 → Task 8; §7 → Task 9; §8 → Tasks 11-12; §9 (errors) → distributed into module tests; §10 → every task test-first; §11 out-of-scope respected.
+- Known deviation from spec §7 wording: the diligence window uses the population `mixed` taper prior (`recommend_taper_length(8, "mixed", priority)`) because no per-athlete modality is persisted; the individualized window (spec's `recommend_taper`) is computed by the skill at authoring time. This matches spec §9's fallback and avoids inventing a modality.
+- Type consistency: `CarbLoadingTargets`/`AttemptSelection`/`PacingSplit` (engine, Tasks 1-3) vs `FuelingPlan`/`AttemptPlan`/`PacingSegment` (schemas, Task 4) are deliberately separate layers — the skill/server map between them; `ProtocolRead` (Task 6) feeds `ProtocolView` (Task 8); `protocol_citation_ids` shared by Tasks 5, 7, 8.
+- Execution lessons carried from the v0.8.0 run: run pytest via `rtk proxy`; verify every commit with `git log --oneline -1` (prek hook failures hide behind rtk's "ok"); move test imports to module level (PLC0415); pytest `match=` strings with dots need raw-escaped patterns (RUF043).

From 8c12995176363614175395acfa58c825eea45e2a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 22:49:46 +0200
Subject: [PATCH 03/25] Add carb-loading targets to the competition engine

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/performance_agent/engine/competition.py | 73 +++++++++++++++++++++
 tests/engine/test_competition.py            | 41 ++++++++++++
 2 files changed, 114 insertions(+)
 create mode 100644 src/performance_agent/engine/competition.py
 create mode 100644 tests/engine/test_competition.py

diff --git a/src/performance_agent/engine/competition.py b/src/performance_agent/engine/competition.py
new file mode 100644
index 0000000..b3f78e7
--- /dev/null
+++ b/src/performance_agent/engine/competition.py
@@ -0,0 +1,73 @@
+"""Pre-competition math: carb loading, attempt selection, pacing, trigger window.
+
+Pure and deterministic — no I/O, no memory imports. Thresholds are corpus-cited
+priors (IOC/Burke carbohydrate consensus, powerlifting attempt-selection
+convention, the taper meta-analysis) recorded as constants with their rationale.
+Anything the literature does not quantify (meal timing, water/sodium
+manipulation, weight-cut tactics) deliberately has NO function here: it is
+sourced advice with warnings in the protocol document, never engine math.
+"""
+
+from dataclasses import dataclass
+
+_MIN_BODY_MASS_KG = 30.0
+_MAX_BODY_MASS_KG = 250.0
+_MIN_EVENT_MIN = 5.0
+_MAX_EVENT_MIN = 1440.0
+# Carb-loading priors (IOC consensus): events >= 90 min load 8-12 g/kg/day over
+# the final ~48 h; 60-90 min take 6-8 g/kg/day the day before; shorter events
+# need no loading. In-race: none under 60 min, 30-60 g/h up to ~2.5 h, 60-90 g/h
+# beyond (multiple transportable carbohydrates).
+_LONG_EVENT_MIN = 90.0
+_MID_EVENT_MIN = 60.0
+_RACE_FUEL_LONG_MIN = 150.0
+
+
+@dataclass(frozen=True)
+class CarbLoadingTargets:
+    """Evidence-based carbohydrate targets for the final window and the race."""
+
+    loading_required: bool
+    carb_g_per_kg_low: float | None = None
+    carb_g_per_kg_high: float | None = None
+    carb_g_per_day_low: float | None = None
+    carb_g_per_day_high: float | None = None
+    window_hours: int | None = None
+    race_carb_g_per_h_low: float | None = None
+    race_carb_g_per_h_high: float | None = None
+
+
+def carb_loading_targets(body_mass_kg: float, event_duration_min: float) -> CarbLoadingTargets:
+    """Carb-loading and in-race fueling ranges from body mass and event duration."""
+    if not _MIN_BODY_MASS_KG <= body_mass_kg <= _MAX_BODY_MASS_KG:
+        msg = (
+            f"body_mass_kg must be within [{_MIN_BODY_MASS_KG}, {_MAX_BODY_MASS_KG}], "
+            f"got {body_mass_kg!r}"
+        )
+        raise ValueError(msg)
+    if not _MIN_EVENT_MIN <= event_duration_min <= _MAX_EVENT_MIN:
+        msg = (
+            f"event_duration_min must be within [{_MIN_EVENT_MIN}, {_MAX_EVENT_MIN}], "
+            f"got {event_duration_min!r}"
+        )
+        raise ValueError(msg)
+    if event_duration_min < _MID_EVENT_MIN:
+        return CarbLoadingTargets(loading_required=False)
+    if event_duration_min >= _LONG_EVENT_MIN:
+        g_low, g_high, window = 8.0, 12.0, 48
+    else:
+        g_low, g_high, window = 6.0, 8.0, 24
+    if event_duration_min > _RACE_FUEL_LONG_MIN:
+        race_low, race_high = 60.0, 90.0
+    else:
+        race_low, race_high = 30.0, 60.0
+    return CarbLoadingTargets(
+        loading_required=True,
+        carb_g_per_kg_low=g_low,
+        carb_g_per_kg_high=g_high,
+        carb_g_per_day_low=round(g_low * body_mass_kg, 1),
+        carb_g_per_day_high=round(g_high * body_mass_kg, 1),
+        window_hours=window,
+        race_carb_g_per_h_low=race_low,
+        race_carb_g_per_h_high=race_high,
+    )
diff --git a/tests/engine/test_competition.py b/tests/engine/test_competition.py
new file mode 100644
index 0000000..843f690
--- /dev/null
+++ b/tests/engine/test_competition.py
@@ -0,0 +1,41 @@
+"""Pure pre-competition math: carb loading, attempts, pacing, window."""
+
+import pytest
+
+from performance_agent.engine.competition import carb_loading_targets
+
+
+def test_long_event_loads_8_to_12_g_per_kg_over_48h():
+    result = carb_loading_targets(70.0, 180.0)
+    assert result.loading_required is True
+    assert (result.carb_g_per_kg_low, result.carb_g_per_kg_high) == (8.0, 12.0)
+    assert (result.carb_g_per_day_low, result.carb_g_per_day_high) == (560.0, 840.0)
+    assert result.window_hours == 48
+    assert (result.race_carb_g_per_h_low, result.race_carb_g_per_h_high) == (60.0, 90.0)
+
+
+def test_mid_event_loads_6_to_8_g_per_kg_over_24h():
+    result = carb_loading_targets(60.0, 75.0)
+    assert result.loading_required is True
+    assert (result.carb_g_per_kg_low, result.carb_g_per_kg_high) == (6.0, 8.0)
+    assert (result.carb_g_per_day_low, result.carb_g_per_day_high) == (360.0, 480.0)
+    assert result.window_hours == 24
+    assert (result.race_carb_g_per_h_low, result.race_carb_g_per_h_high) == (30.0, 60.0)
+
+
+def test_short_event_needs_no_loading_and_no_race_fuel():
+    result = carb_loading_targets(80.0, 45.0)
+    assert result.loading_required is False
+    assert result.carb_g_per_kg_low is None
+    assert result.carb_g_per_day_high is None
+    assert result.window_hours is None
+    assert result.race_carb_g_per_h_low is None
+
+
+def test_carb_guards_reject_out_of_range_inputs():
+    with pytest.raises(ValueError, match="body_mass_kg"):
+        carb_loading_targets(20.0, 180.0)
+    with pytest.raises(ValueError, match="event_duration_min"):
+        carb_loading_targets(70.0, 2.0)
+    with pytest.raises(ValueError, match="event_duration_min"):
+        carb_loading_targets(70.0, 2000.0)

From 50df6ebaaaee158c1857ba6db232fb526092f226 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 22:50:32 +0200
Subject: [PATCH 04/25] Add meet-day attempt selection with the e1RM honesty
 gate

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/performance_agent/engine/competition.py | 55 +++++++++++++++++++++
 tests/engine/test_competition.py            | 30 ++++++++++-
 2 files changed, 84 insertions(+), 1 deletion(-)

diff --git a/src/performance_agent/engine/competition.py b/src/performance_agent/engine/competition.py
index b3f78e7..8105c55 100644
--- a/src/performance_agent/engine/competition.py
+++ b/src/performance_agent/engine/competition.py
@@ -10,6 +10,8 @@
 
 from dataclasses import dataclass
 
+from performance_agent.engine.progression import round_to_increment
+
 _MIN_BODY_MASS_KG = 30.0
 _MAX_BODY_MASS_KG = 250.0
 _MIN_EVENT_MIN = 5.0
@@ -71,3 +73,56 @@ def carb_loading_targets(body_mass_kg: float, event_duration_min: float) -> Carb
         race_carb_g_per_h_low=race_low,
         race_carb_g_per_h_high=race_high,
     )
+
+
+_MIN_E1RM_KG = 20.0
+_MAX_E1RM_KG = 600.0
+# Attempt-selection convention (powerlifting coaching literature): opener ~91%
+# of e1RM (a weight you can triple), second ~96%, third at the goal when the
+# data supports it — 93-105% of e1RM — else a conservative ~101% PR attempt.
+_OPENER_PCT = 0.91
+_SECOND_PCT = 0.96
+_THIRD_FALLBACK_PCT = 1.01
+_GOAL_MIN_PCT = 0.93
+_GOAL_MAX_PCT = 1.05
+
+
+@dataclass(frozen=True)
+class AttemptSelection:
+    """Opening, second and third attempts for one lift on meet day."""
+
+    opener_kg: float
+    second_kg: float
+    third_kg: float
+    flags: tuple[str, ...] = ()
+
+
+def select_attempts(e1rm_kg: float, goal_kg: float, rounding_kg: float = 2.5) -> AttemptSelection:
+    """Three meet-day attempts from the estimated 1RM and the athlete's goal.
+
+    The honesty gate lives here: a goal outside 93-105% of e1RM is never
+    silently endorsed — the third falls back to ~101% and the goal_beyond_e1rm
+    flag tells the skill to name the gap.
+    """
+    if not _MIN_E1RM_KG <= e1rm_kg <= _MAX_E1RM_KG:
+        msg = f"e1rm_kg must be within [{_MIN_E1RM_KG}, {_MAX_E1RM_KG}], got {e1rm_kg!r}"
+        raise ValueError(msg)
+    if goal_kg <= 0:
+        msg = f"goal_kg must be positive, got {goal_kg!r}"
+        raise ValueError(msg)
+    if rounding_kg <= 0:
+        msg = f"rounding_kg must be positive, got {rounding_kg!r}"
+        raise ValueError(msg)
+    opener = round_to_increment(_OPENER_PCT * e1rm_kg, rounding_kg)
+    second = round_to_increment(_SECOND_PCT * e1rm_kg, rounding_kg)
+    flags: tuple[str, ...] = ()
+    if _GOAL_MIN_PCT * e1rm_kg <= goal_kg <= _GOAL_MAX_PCT * e1rm_kg:
+        third = round_to_increment(goal_kg, rounding_kg)
+    else:
+        third = round_to_increment(_THIRD_FALLBACK_PCT * e1rm_kg, rounding_kg)
+        flags = ("goal_beyond_e1rm",)
+    if second <= opener:
+        second = opener + rounding_kg
+    if third <= second:
+        third = second + rounding_kg
+    return AttemptSelection(opener, second, third, flags)
diff --git a/tests/engine/test_competition.py b/tests/engine/test_competition.py
index 843f690..bbe72d9 100644
--- a/tests/engine/test_competition.py
+++ b/tests/engine/test_competition.py
@@ -2,7 +2,7 @@
 
 import pytest
 
-from performance_agent.engine.competition import carb_loading_targets
+from performance_agent.engine.competition import carb_loading_targets, select_attempts
 
 
 def test_long_event_loads_8_to_12_g_per_kg_over_48h():
@@ -39,3 +39,31 @@ def test_carb_guards_reject_out_of_range_inputs():
         carb_loading_targets(70.0, 2.0)
     with pytest.raises(ValueError, match="event_duration_min"):
         carb_loading_targets(70.0, 2000.0)
+
+
+def test_attempts_goal_within_range_becomes_third():
+    result = select_attempts(200.0, 205.0)
+    assert result.opener_kg == 182.5  # 0.91 * 200 = 182 -> 182.5
+    assert result.second_kg == 192.5  # 0.96 * 200 = 192 -> 192.5
+    assert result.third_kg == 205.0
+    assert result.flags == ()
+
+
+def test_attempts_goal_beyond_e1rm_is_flagged_and_capped():
+    result = select_attempts(200.0, 215.0)  # > 105% of e1RM
+    assert result.third_kg == 202.5  # 1.01 * 200 = 202 -> 202.5
+    assert "goal_beyond_e1rm" in result.flags
+
+
+def test_attempts_stay_strictly_increasing_after_rounding():
+    result = select_attempts(52.0, 50.0)
+    assert result.opener_kg < result.second_kg < result.third_kg
+
+
+def test_attempts_guards():
+    with pytest.raises(ValueError, match="e1rm_kg"):
+        select_attempts(10.0, 50.0)
+    with pytest.raises(ValueError, match="goal_kg"):
+        select_attempts(200.0, 0.0)
+    with pytest.raises(ValueError, match="rounding_kg"):
+        select_attempts(200.0, 205.0, rounding_kg=0.0)

From eb89173a9d5d42455959eef19fa9140d7fb9f6fb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 22:51:22 +0200
Subject: [PATCH 05/25] Add pacing plan and adaptive protocol window to the
 engine

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/performance_agent/engine/competition.py | 104 ++++++++++++++++++++
 tests/engine/test_competition.py            |  59 ++++++++++-
 2 files changed, 162 insertions(+), 1 deletion(-)

diff --git a/src/performance_agent/engine/competition.py b/src/performance_agent/engine/competition.py
index 8105c55..e242df0 100644
--- a/src/performance_agent/engine/competition.py
+++ b/src/performance_agent/engine/competition.py
@@ -126,3 +126,107 @@ def select_attempts(e1rm_kg: float, goal_kg: float, rounding_kg: float = 2.5) ->
     if third <= second:
         third = second + rounding_kg
     return AttemptSelection(opener, second, third, flags)
+
+
+# Negative-split prior: first half ~1% slower than mean pace, second half
+# balanced exactly so the cumulative time lands on the target.
+_NEGATIVE_SPLIT_PCT = 0.01
+# Protocol windows per priority (spec §4): A events open with the taper but
+# never closer than a week nor further than three; B events get a short window;
+# C events are never auto-surfaced.
+_WINDOW_A_MIN, _WINDOW_A_MAX = 7, 21
+_WINDOW_B_MIN, _WINDOW_B_MAX = 3, 10
+
+
+@dataclass(frozen=True)
+class PacingSplit:
+    """One race segment: its target pace and the cumulative time at its end."""
+
+    label: str
+    distance_m: float
+    target_pace_s_per_km: float
+    cumulative_time_s: float
+
+
+def _segment_distances(distance_m: float, segment_m: float) -> list[float]:
+    full = int(distance_m // segment_m)
+    segments = [segment_m] * full
+    remainder = distance_m - full * segment_m
+    if remainder > 1.0:
+        segments.append(remainder)
+    elif not segments:
+        segments = [distance_m]
+    return segments
+
+
+def pacing_plan(
+    distance_m: float,
+    target_time_s: float,
+    segment_m: float = 1000.0,
+    strategy: str = "even",
+) -> list[PacingSplit]:
+    """Distribute a target time over segments (even or negative split).
+
+    The target comes from the athlete's goal or predict_race_time upstream —
+    this function only distributes it; cumulative time always lands on the
+    target within a second.
+    """
+    if distance_m <= 0:
+        msg = f"distance_m must be positive, got {distance_m!r}"
+        raise ValueError(msg)
+    if target_time_s <= 0:
+        msg = f"target_time_s must be positive, got {target_time_s!r}"
+        raise ValueError(msg)
+    if segment_m <= 0:
+        msg = f"segment_m must be positive, got {segment_m!r}"
+        raise ValueError(msg)
+    if strategy not in ("even", "negative"):
+        msg = f"strategy must be 'even' or 'negative', got {strategy!r}"
+        raise ValueError(msg)
+    distances = _segment_distances(distance_m, segment_m)
+    mean_pace = target_time_s / (distance_m / 1000.0)
+    halfway = distance_m / 2.0
+    paces: list[float]
+    if strategy == "even" or len(distances) == 1:
+        paces = [mean_pace] * len(distances)
+    else:
+        start = 0.0
+        first_half = []
+        for dist in distances:
+            first_half.append(start + dist / 2.0 < halfway)
+            start += dist
+        d1_km = sum(d for d, f in zip(distances, first_half, strict=True) if f) / 1000.0
+        d2_km = sum(d for d, f in zip(distances, first_half, strict=True) if not f) / 1000.0
+        pace_1 = mean_pace * (1 + _NEGATIVE_SPLIT_PCT)
+        pace_2 = (target_time_s - pace_1 * d1_km) / d2_km if d2_km else mean_pace
+        paces = [pace_1 if f else pace_2 for f in first_half]
+    splits: list[PacingSplit] = []
+    cumulative = 0.0
+    position = 0.0
+    for dist, pace in zip(distances, paces, strict=True):
+        cumulative += pace * dist / 1000.0
+        position += dist
+        splits.append(
+            PacingSplit(
+                label=f"{position / 1000.0:g} km",
+                distance_m=dist,
+                target_pace_s_per_km=round(pace, 1),
+                cumulative_time_s=round(cumulative, 1),
+            )
+        )
+    return splits
+
+
+def protocol_window_days(taper_days: int, priority: str) -> int:
+    """The adaptive due-action window: taper-driven, clamped per priority."""
+    if taper_days < 0:
+        msg = f"taper_days must be non-negative, got {taper_days!r}"
+        raise ValueError(msg)
+    if priority not in ("A", "B", "C"):
+        msg = f"priority must be A, B or C, got {priority!r}"
+        raise ValueError(msg)
+    if priority == "A":
+        return min(max(taper_days, _WINDOW_A_MIN), _WINDOW_A_MAX)
+    if priority == "B":
+        return min(max(taper_days, _WINDOW_B_MIN), _WINDOW_B_MAX)
+    return 0
diff --git a/tests/engine/test_competition.py b/tests/engine/test_competition.py
index bbe72d9..ac3aec7 100644
--- a/tests/engine/test_competition.py
+++ b/tests/engine/test_competition.py
@@ -2,7 +2,12 @@
 
 import pytest
 
-from performance_agent.engine.competition import carb_loading_targets, select_attempts
+from performance_agent.engine.competition import (
+    carb_loading_targets,
+    pacing_plan,
+    protocol_window_days,
+    select_attempts,
+)
 
 
 def test_long_event_loads_8_to_12_g_per_kg_over_48h():
@@ -67,3 +72,55 @@ def test_attempts_guards():
         select_attempts(200.0, 0.0)
     with pytest.raises(ValueError, match="rounding_kg"):
         select_attempts(200.0, 205.0, rounding_kg=0.0)
+
+
+def test_even_pacing_splits_evenly_and_lands_on_target():
+    splits = pacing_plan(10000.0, 2400.0, segment_m=1000.0, strategy="even")
+    assert len(splits) == 10
+    assert all(s.target_pace_s_per_km == 240.0 for s in splits)
+    assert splits[-1].cumulative_time_s == pytest.approx(2400.0, abs=1.0)
+
+
+def test_negative_split_first_half_slower_lands_on_target():
+    splits = pacing_plan(10000.0, 2400.0, segment_m=1000.0, strategy="negative")
+    assert splits[0].target_pace_s_per_km > splits[-1].target_pace_s_per_km
+    assert splits[0].target_pace_s_per_km == pytest.approx(242.4, abs=0.01)
+    assert splits[-1].cumulative_time_s == pytest.approx(2400.0, abs=1.0)
+
+
+def test_pacing_remainder_becomes_last_short_segment():
+    splits = pacing_plan(10500.0, 2520.0, segment_m=1000.0, strategy="even")
+    assert len(splits) == 11
+    assert splits[-1].distance_m == pytest.approx(500.0)
+
+
+def test_pacing_oversized_segment_yields_single_split():
+    splits = pacing_plan(5000.0, 1200.0, segment_m=8000.0, strategy="even")
+    assert len(splits) == 1
+    assert splits[0].distance_m == pytest.approx(5000.0)
+
+
+def test_pacing_guards():
+    with pytest.raises(ValueError, match="distance_m"):
+        pacing_plan(0.0, 2400.0)
+    with pytest.raises(ValueError, match="target_time_s"):
+        pacing_plan(10000.0, -5.0)
+    with pytest.raises(ValueError, match="strategy"):
+        pacing_plan(10000.0, 2400.0, strategy="wild")
+
+
+def test_window_scales_with_priority():
+    assert protocol_window_days(10, "A") == 10
+    assert protocol_window_days(4, "A") == 7  # floor
+    assert protocol_window_days(25, "A") == 21  # ceiling
+    assert protocol_window_days(5, "B") == 5
+    assert protocol_window_days(2, "B") == 3  # floor
+    assert protocol_window_days(12, "B") == 10  # ceiling
+    assert protocol_window_days(10, "C") == 0  # never auto-surfaced
+
+
+def test_window_guards():
+    with pytest.raises(ValueError, match="taper_days"):
+        protocol_window_days(-1, "A")
+    with pytest.raises(ValueError, match="priority"):
+        protocol_window_days(10, "X")

From bd7f16fc0f2d7ebf03fa1a5fd9c639f2f7110370 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 22:58:16 +0200
Subject: [PATCH 06/25] Harden competition engine edges after review

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/performance_agent/engine/competition.py | 49 +++++++++++++++------
 tests/engine/test_competition.py            | 36 +++++++++++++++
 2 files changed, 71 insertions(+), 14 deletions(-)

diff --git a/src/performance_agent/engine/competition.py b/src/performance_agent/engine/competition.py
index e242df0..4948fa3 100644
--- a/src/performance_agent/engine/competition.py
+++ b/src/performance_agent/engine/competition.py
@@ -80,6 +80,8 @@ def carb_loading_targets(body_mass_kg: float, event_duration_min: float) -> Carb
 # Attempt-selection convention (powerlifting coaching literature): opener ~91%
 # of e1RM (a weight you can triple), second ~96%, third at the goal when the
 # data supports it — 93-105% of e1RM — else a conservative ~101% PR attempt.
+# A goal outside that band is flagged by direction so the skill can say
+# whether the athlete is sandbagging or overreaching.
 _OPENER_PCT = 0.91
 _SECOND_PCT = 0.96
 _THIRD_FALLBACK_PCT = 1.01
@@ -101,8 +103,8 @@ def select_attempts(e1rm_kg: float, goal_kg: float, rounding_kg: float = 2.5) ->
     """Three meet-day attempts from the estimated 1RM and the athlete's goal.
 
     The honesty gate lives here: a goal outside 93-105% of e1RM is never
-    silently endorsed — the third falls back to ~101% and the goal_beyond_e1rm
-    flag tells the skill to name the gap.
+    silently endorsed — the third falls back to ~101% and a directional flag
+    (goal_beyond_e1rm or goal_below_e1rm_range) tells the skill to name the gap.
     """
     if not _MIN_E1RM_KG <= e1rm_kg <= _MAX_E1RM_KG:
         msg = f"e1rm_kg must be within [{_MIN_E1RM_KG}, {_MAX_E1RM_KG}], got {e1rm_kg!r}"
@@ -120,7 +122,10 @@ def select_attempts(e1rm_kg: float, goal_kg: float, rounding_kg: float = 2.5) ->
         third = round_to_increment(goal_kg, rounding_kg)
     else:
         third = round_to_increment(_THIRD_FALLBACK_PCT * e1rm_kg, rounding_kg)
-        flags = ("goal_beyond_e1rm",)
+        if goal_kg > _GOAL_MAX_PCT * e1rm_kg:
+            flags = ("goal_beyond_e1rm",)
+        else:
+            flags = ("goal_below_e1rm_range",)
     if second <= opener:
         second = opener + rounding_kg
     if third <= second:
@@ -136,6 +141,8 @@ def select_attempts(e1rm_kg: float, goal_kg: float, rounding_kg: float = 2.5) ->
 # C events are never auto-surfaced.
 _WINDOW_A_MIN, _WINDOW_A_MAX = 7, 21
 _WINDOW_B_MIN, _WINDOW_B_MAX = 3, 10
+# sub-metre remainders are float noise, not a real segment
+_MIN_REMAINDER_M = 1.0
 
 
 @dataclass(frozen=True)
@@ -152,13 +159,36 @@ def _segment_distances(distance_m: float, segment_m: float) -> list[float]:
     full = int(distance_m // segment_m)
     segments = [segment_m] * full
     remainder = distance_m - full * segment_m
-    if remainder > 1.0:
+    if remainder > _MIN_REMAINDER_M:
         segments.append(remainder)
     elif not segments:
         segments = [distance_m]
     return segments
 
 
+def _negative_split_paces(
+    distances: list[float], target_time_s: float, mean_pace: float, halfway: float
+) -> list[float]:
+    """Per-segment paces for the negative-split strategy.
+
+    Falls back to even pacing whenever the second half is degenerate (too
+    short, or too fast a first half would force a negative pace on it) — a
+    negative pace is physically meaningless and must never reach the athlete.
+    """
+    start = 0.0
+    first_half = []
+    for dist in distances:
+        first_half.append(start + dist / 2.0 < halfway)
+        start += dist
+    d1_km = sum(d for d, f in zip(distances, first_half, strict=True) if f) / 1000.0
+    d2_km = sum(d for d, f in zip(distances, first_half, strict=True) if not f) / 1000.0
+    pace_1 = mean_pace * (1 + _NEGATIVE_SPLIT_PCT)
+    pace_2 = (target_time_s - pace_1 * d1_km) / d2_km if d2_km else mean_pace
+    if d2_km <= 0 or pace_2 <= 0:
+        return [mean_pace] * len(distances)
+    return [pace_1 if f else pace_2 for f in first_half]
+
+
 def pacing_plan(
     distance_m: float,
     target_time_s: float,
@@ -190,16 +220,7 @@ def pacing_plan(
     if strategy == "even" or len(distances) == 1:
         paces = [mean_pace] * len(distances)
     else:
-        start = 0.0
-        first_half = []
-        for dist in distances:
-            first_half.append(start + dist / 2.0 < halfway)
-            start += dist
-        d1_km = sum(d for d, f in zip(distances, first_half, strict=True) if f) / 1000.0
-        d2_km = sum(d for d, f in zip(distances, first_half, strict=True) if not f) / 1000.0
-        pace_1 = mean_pace * (1 + _NEGATIVE_SPLIT_PCT)
-        pace_2 = (target_time_s - pace_1 * d1_km) / d2_km if d2_km else mean_pace
-        paces = [pace_1 if f else pace_2 for f in first_half]
+        paces = _negative_split_paces(distances, target_time_s, mean_pace, halfway)
     splits: list[PacingSplit] = []
     cumulative = 0.0
     position = 0.0
diff --git a/tests/engine/test_competition.py b/tests/engine/test_competition.py
index ac3aec7..f779358 100644
--- a/tests/engine/test_competition.py
+++ b/tests/engine/test_competition.py
@@ -46,6 +46,26 @@ def test_carb_guards_reject_out_of_range_inputs():
         carb_loading_targets(70.0, 2000.0)
 
 
+def test_carb_guards_reject_body_mass_above_upper_bound():
+    with pytest.raises(ValueError, match="body_mass_kg"):
+        carb_loading_targets(260.0, 180.0)
+
+
+def test_carb_mid_band_starts_at_60_minutes_inclusive():
+    result = carb_loading_targets(70.0, 60.0)
+    assert (result.carb_g_per_kg_low, result.carb_g_per_kg_high) == (6.0, 8.0)
+
+
+def test_carb_long_band_starts_at_90_minutes_inclusive():
+    result = carb_loading_targets(70.0, 90.0)
+    assert (result.carb_g_per_kg_low, result.carb_g_per_kg_high) == (8.0, 12.0)
+
+
+def test_carb_race_fuel_long_band_starts_above_150_minutes():
+    result = carb_loading_targets(70.0, 150.0)
+    assert (result.race_carb_g_per_h_low, result.race_carb_g_per_h_high) == (30.0, 60.0)
+
+
 def test_attempts_goal_within_range_becomes_third():
     result = select_attempts(200.0, 205.0)
     assert result.opener_kg == 182.5  # 0.91 * 200 = 182 -> 182.5
@@ -60,6 +80,13 @@ def test_attempts_goal_beyond_e1rm_is_flagged_and_capped():
     assert "goal_beyond_e1rm" in result.flags
 
 
+def test_attempts_goal_below_range_is_flagged_not_beyond():
+    result = select_attempts(200.0, 150.0)  # < 93% of e1RM
+    assert result.third_kg == 202.5  # 1.01 * 200 = 202 -> 202.5
+    assert "goal_below_e1rm_range" in result.flags
+    assert "goal_beyond_e1rm" not in result.flags
+
+
 def test_attempts_stay_strictly_increasing_after_rounding():
     result = select_attempts(52.0, 50.0)
     assert result.opener_kg < result.second_kg < result.third_kg
@@ -107,6 +134,15 @@ def test_pacing_guards():
         pacing_plan(10000.0, -5.0)
     with pytest.raises(ValueError, match="strategy"):
         pacing_plan(10000.0, 2400.0, strategy="wild")
+    with pytest.raises(ValueError, match="segment_m"):
+        pacing_plan(10000.0, 2400.0, segment_m=0.0)
+
+
+def test_negative_split_degenerate_second_half_falls_back_to_even():
+    splits = pacing_plan(1005.0, 241.0, segment_m=1000.0, strategy="negative")
+    assert all(s.target_pace_s_per_km > 0 for s in splits)
+    paces = {s.target_pace_s_per_km for s in splits}
+    assert len(paces) == 1
 
 
 def test_window_scales_with_priority():

From 49d420e291c5217410ae4af7117e022a2b3f4740 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 23:01:37 +0200
Subject: [PATCH 07/25] Add competition protocol schemas

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/performance_agent/memory/schemas.py | 133 ++++++++++++++++++++++++
 tests/memory/test_schemas_protocol.py   | 116 +++++++++++++++++++++
 2 files changed, 249 insertions(+)
 create mode 100644 tests/memory/test_schemas_protocol.py

diff --git a/src/performance_agent/memory/schemas.py b/src/performance_agent/memory/schemas.py
index b0206b3..c01ff03 100644
--- a/src/performance_agent/memory/schemas.py
+++ b/src/performance_agent/memory/schemas.py
@@ -530,6 +530,139 @@ def _week_indices_are_globally_increasing(self) -> Self:
         return self
 
 
+# --- Competition protocol (per-event final-days plan) ---------------------
+
+
+class ProtocolLine(BaseModel):
+    """One line of a protocol day: what to do, optionally when and why."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    text: str = Field(min_length=1, max_length=300)
+    time_hint: str | None = Field(default=None, max_length=20)
+    cite: str | None = None
+    warning: bool = False
+
+
+class ProtocolDay(BaseModel):
+    """One day of the pre-competition window; day_offset 0 is the event day."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    day_offset: int = Field(ge=-21, le=0)
+    title: str = Field(min_length=1, max_length=80)
+    lines: list[ProtocolLine] = Field(min_length=1)
+
+
+class PacingSegment(BaseModel):
+    """One race segment with its target pace and cumulative split."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    label: str = Field(min_length=1, max_length=40)
+    distance_m: float = Field(gt=0)
+    target_pace_s_per_km: float = Field(gt=0)
+    cumulative_time_s: float = Field(gt=0)
+
+
+class AttemptPlan(BaseModel):
+    """Meet-day attempts for one lift; engine-computed or athlete-agreed."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    lift: str = Field(min_length=1, max_length=60)
+    e1rm_kg: float = Field(gt=0)
+    opener_kg: float = Field(gt=0)
+    second_kg: float = Field(gt=0)
+    third_kg: float = Field(gt=0)
+    basis: Literal["engine", "agreed"]
+    flags: list[str] = Field(default_factory=list)
+
+    @model_validator(mode="after")
+    def _attempts_increase(self) -> Self:
+        if not self.opener_kg < self.second_kg < self.third_kg:
+            msg = (
+                f"{self.lift}: attempts must be strictly increasing, got "
+                f"{self.opener_kg}/{self.second_kg}/{self.third_kg}"
+            )
+            raise ValueError(msg)
+        return self
+
+
+class FuelingPlan(BaseModel):
+    """Engine-computed carbohydrate targets for the final window and the race."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    carb_g_per_kg_low: float = Field(gt=0)
+    carb_g_per_kg_high: float = Field(gt=0)
+    window_hours: int = Field(gt=0)
+    race_carb_g_per_h_low: float | None = Field(default=None, ge=0)
+    race_carb_g_per_h_high: float | None = Field(default=None, ge=0)
+    cite: str | None = None
+
+    @model_validator(mode="after")
+    def _low_not_above_high(self) -> Self:
+        if self.carb_g_per_kg_low > self.carb_g_per_kg_high:
+            msg = (
+                "carb_g_per_kg low must not exceed high, got "
+                f"{self.carb_g_per_kg_low} > {self.carb_g_per_kg_high}"
+            )
+            raise ValueError(msg)
+        return self
+
+
+class DocumentedPractice(BaseModel):
+    """A risky-but-documented practice: described with its grade, never dosed.
+
+    warning is schema-required and non-empty — a practice cannot be stored
+    without one (owner decision: labeled advice, never engine-quantified).
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    name: str = Field(min_length=1, max_length=80)
+    summary: str = Field(min_length=1, max_length=400)
+    cite: str | None = None
+    warning: str = Field(min_length=1, max_length=300)
+
+
+class CompetitionProtocol(BaseModel):
+    """The per-event final-days plan: days J-N to J0 plus computed sections."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    schema_version: Literal[1] = 1
+    version: int = Field(ge=1)
+    event_id: str = Field(pattern=r"^[a-z0-9][a-z0-9-]*$", max_length=64)
+    event_date: date
+    goal_id: str = Field(pattern=r"^[a-z0-9][a-z0-9-]*$", max_length=64)
+    created_on: date
+    reason: str | None = None
+    window_days: int = Field(ge=1, le=21)
+    days: list[ProtocolDay] = Field(min_length=1)
+    pacing: list[PacingSegment] = Field(default_factory=list)
+    attempts: list[AttemptPlan] = Field(default_factory=list)
+    fueling: FuelingPlan | None = None
+    practices: list[DocumentedPractice] = Field(default_factory=list)
+    checklist: list[str] = Field(default_factory=list)
+    advice: list[Guidance] = Field(default_factory=list)
+
+    @model_validator(mode="after")
+    def _days_cover_the_window(self) -> Self:
+        offsets = [day.day_offset for day in self.days]
+        if offsets != sorted(offsets) or len(set(offsets)) != len(offsets):
+            msg = f"day_offset values must be unique and increasing, got {offsets}"
+            raise ValueError(msg)
+        if offsets[-1] != 0:
+            msg = f"the last day must be J0 (day_offset 0), got {offsets[-1]}"
+            raise ValueError(msg)
+        if self.window_days < -offsets[0]:
+            msg = f"window_days ({self.window_days}) must cover the earliest day (J{offsets[0]})"
+            raise ValueError(msg)
+        return self
+
+
 # --- Season calendar (dated events + weekly recurring constraints) --------
 #
 # calendar.yaml is the scheduling source of truth; the season planner reads it
diff --git a/tests/memory/test_schemas_protocol.py b/tests/memory/test_schemas_protocol.py
new file mode 100644
index 0000000..6c58191
--- /dev/null
+++ b/tests/memory/test_schemas_protocol.py
@@ -0,0 +1,116 @@
+"""CompetitionProtocol schemas: structure and validator errors."""
+
+from datetime import date
+
+import pytest
+from pydantic import ValidationError
+
+from performance_agent.memory.schemas import (
+    AttemptPlan,
+    CompetitionProtocol,
+    DocumentedPractice,
+    FuelingPlan,
+    Guidance,
+    PacingSegment,
+    ProtocolDay,
+    ProtocolLine,
+)
+
+EVENT_DATE = date(2026, 8, 1)
+
+
+def _day(offset, title="Race day"):
+    return ProtocolDay(
+        day_offset=offset,
+        title=title,
+        lines=[ProtocolLine(text="Easy 20 min shakeout.", time_hint="07:30")],
+    )
+
+
+def _protocol(**overrides):
+    fields = {
+        "version": 1,
+        "event_id": "nationals",
+        "event_date": EVENT_DATE,
+        "goal_id": "sub-40-10k",
+        "created_on": date(2026, 7, 25),
+        "window_days": 7,
+        "days": [_day(-2, "Carb load"), _day(-1, "Rest"), _day(0)],
+    }
+    fields.update(overrides)
+    return CompetitionProtocol.model_validate(fields)
+
+
+def test_valid_protocol_with_all_sections():
+    protocol = _protocol(
+        pacing=[
+            PacingSegment(
+                label="1 km", distance_m=1000, target_pace_s_per_km=240, cumulative_time_s=240
+            )
+        ],
+        attempts=[
+            AttemptPlan(
+                lift="Squat",
+                e1rm_kg=200,
+                opener_kg=182.5,
+                second_kg=192.5,
+                third_kg=205,
+                basis="engine",
+                flags=[],
+            )
+        ],
+        fueling=FuelingPlan(
+            carb_g_per_kg_low=8,
+            carb_g_per_kg_high=12,
+            window_hours=48,
+            race_carb_g_per_h_low=60,
+            race_carb_g_per_h_high=90,
+        ),
+        practices=[
+            DocumentedPractice(
+                name="Water manipulation",
+                summary="Described in physique literature; effect sizes small.",
+                warning="Dehydration risk — never do this without supervision.",
+            )
+        ],
+        checklist=["Pin race bib", "Bottle in fridge"],
+        advice=[Guidance(text="Nothing new on race day.")],
+    )
+    assert protocol.days[-1].day_offset == 0
+    assert protocol.practices[0].warning.startswith("Dehydration")
+
+
+def test_days_must_be_sorted_unique_and_end_at_zero():
+    with pytest.raises(ValidationError, match="day_offset"):
+        _protocol(days=[_day(0), _day(-1)])
+    with pytest.raises(ValidationError, match="day_offset"):
+        _protocol(days=[_day(-1), _day(-1), _day(0)])
+    with pytest.raises(ValidationError, match="J0"):
+        _protocol(days=[_day(-2), _day(-1)])
+
+
+def test_window_must_cover_the_days_span():
+    with pytest.raises(ValidationError, match="window_days"):
+        _protocol(window_days=1, days=[_day(-5), _day(0)])
+
+
+def test_practice_requires_a_warning():
+    with pytest.raises(ValidationError):
+        DocumentedPractice(name="X", summary="Y", warning="")
+
+
+def test_attempts_must_strictly_increase():
+    with pytest.raises(ValidationError, match="increasing"):
+        AttemptPlan(
+            lift="Squat",
+            e1rm_kg=200,
+            opener_kg=190,
+            second_kg=190,
+            third_kg=200,
+            basis="engine",
+        )
+
+
+def test_fueling_low_cannot_exceed_high():
+    with pytest.raises(ValidationError, match="carb_g_per_kg"):
+        FuelingPlan(carb_g_per_kg_low=10, carb_g_per_kg_high=8, window_hours=48)

From 795970e3bdb40655839e99574f0cbe924ca9a38c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 23:02:51 +0200
Subject: [PATCH 08/25] Render competition protocols to markdown

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../programs/render_protocol.py               | 177 ++++++++++++++++++
 tests/programs/test_render_protocol.py        | 116 ++++++++++++
 2 files changed, 293 insertions(+)
 create mode 100644 src/performance_agent/programs/render_protocol.py
 create mode 100644 tests/programs/test_render_protocol.py

diff --git a/src/performance_agent/programs/render_protocol.py b/src/performance_agent/programs/render_protocol.py
new file mode 100644
index 0000000..d638b4c
--- /dev/null
+++ b/src/performance_agent/programs/render_protocol.py
@@ -0,0 +1,177 @@
+"""Deterministic CompetitionProtocol -> markdown (the human/audit view).
+
+Generated at save time from the structured protocol, like the program markdown,
+so the document can never drift from the source of truth. Citation numbering
+order (advice, then day lines, then fueling, then practices) is shared with the
+HTML page via protocol_citation_ids.
+"""
+
+from collections.abc import Mapping
+
+from performance_agent.evidence.citations import ResolvedCitation
+from performance_agent.memory.schemas import CompetitionProtocol, FuelingPlan
+
+
+def protocol_citation_ids(protocol: CompetitionProtocol) -> list[str]:
+    """Every corpus id the protocol cites, in first-appearance order, deduplicated."""
+    ids: list[str] = []
+    seen: set[str] = set()
+
+    def add(cite: str | None) -> None:
+        if cite and cite not in seen:
+            seen.add(cite)
+            ids.append(cite)
+
+    for guidance in protocol.advice:
+        add(guidance.cite)
+    for day in protocol.days:
+        for line in day.lines:
+            add(line.cite)
+    if protocol.fueling is not None:
+        add(protocol.fueling.cite)
+    for practice in protocol.practices:
+        add(practice.cite)
+    return ids
+
+
+def _day_label(offset: int) -> str:
+    return "J0" if offset == 0 else f"J{offset}"
+
+
+def _num(value: float) -> str:
+    return f"{value:g}"
+
+
+def _line_text(text: str, time_hint: str | None, cite: str | None, warning: bool) -> str:
+    parts = []
+    if time_hint:
+        parts.append(f"[{time_hint}]")
+    parts.append(text)
+    if warning:
+        parts.append("⚠")
+    if cite:
+        parts.append(f"[{cite}]")
+    return "- " + " ".join(parts)
+
+
+def _advice_lines(protocol: CompetitionProtocol) -> list[str]:
+    lines: list[str] = ["", "## Advice"]
+    for guidance in protocol.advice:
+        suffix = f" [{guidance.cite}]" if guidance.cite else ""
+        lines.append(f"- {guidance.text}{suffix}")
+    return lines
+
+
+def _days_lines(protocol: CompetitionProtocol) -> list[str]:
+    lines: list[str] = []
+    for day in protocol.days:
+        lines += ["", f"## {_day_label(day.day_offset)} — {day.title}"]
+        for line in day.lines:
+            lines.append(_line_text(line.text, line.time_hint, line.cite, line.warning))
+    return lines
+
+
+def _pacing_lines(protocol: CompetitionProtocol) -> list[str]:
+    lines: list[str] = [
+        "",
+        "## Pacing",
+        "",
+        "| Segment | Distance | Pace | Cumulative |",
+        "|---|---|---|---|",
+    ]
+    for seg in protocol.pacing:
+        minutes, seconds = divmod(round(seg.target_pace_s_per_km), 60)
+        total_min, total_s = divmod(round(seg.cumulative_time_s), 60)
+        lines.append(
+            f"| {seg.label} | {_num(seg.distance_m)} m | {minutes}:{seconds:02d}/km "
+            f"| {total_min}:{total_s:02d} |"
+        )
+    return lines
+
+
+def _attempts_lines(protocol: CompetitionProtocol) -> list[str]:
+    lines: list[str] = ["", "## Attempts"]
+    for attempt in protocol.attempts:
+        flags = f" ({', '.join(attempt.flags)})" if attempt.flags else ""
+        lines.append(
+            f"- {attempt.lift}: {_num(attempt.opener_kg)} / {_num(attempt.second_kg)} "
+            f"/ {_num(attempt.third_kg)} kg — e1RM {_num(attempt.e1rm_kg)} kg, "
+            f"{attempt.basis}{flags}"
+        )
+    return lines
+
+
+def _fueling_lines(fueling: FuelingPlan) -> list[str]:
+    lines: list[str] = ["", "## Fueling"]
+    cite = f" [{fueling.cite}]" if fueling.cite else ""
+    lines.append(
+        f"- {_num(fueling.carb_g_per_kg_low)}-{_num(fueling.carb_g_per_kg_high)} g/kg/day "
+        f"carbs over the final {fueling.window_hours} h{cite}"
+    )
+    has_race_range = (
+        fueling.race_carb_g_per_h_low is not None and fueling.race_carb_g_per_h_high is not None
+    )
+    if has_race_range:
+        lines.append(
+            f"- In race: {_num(fueling.race_carb_g_per_h_low)}-"
+            f"{_num(fueling.race_carb_g_per_h_high)} g/h"
+        )
+    return lines
+
+
+def _practices_lines(protocol: CompetitionProtocol) -> list[str]:
+    lines: list[str] = ["", "## Documented practices"]
+    for practice in protocol.practices:
+        cite = f" [{practice.cite}]" if practice.cite else ""
+        lines.append(f"- **{practice.name}** — {practice.summary}{cite}")
+        lines.append(f"  ⚠ {practice.warning}")
+    return lines
+
+
+def _checklist_lines(protocol: CompetitionProtocol) -> list[str]:
+    lines: list[str] = ["", "## Checklist"]
+    lines += [f"- [ ] {item}" for item in protocol.checklist]
+    return lines
+
+
+def _sections(protocol: CompetitionProtocol) -> list[str]:
+    lines: list[str] = []
+    if protocol.advice:
+        lines += _advice_lines(protocol)
+    lines += _days_lines(protocol)
+    if protocol.pacing:
+        lines += _pacing_lines(protocol)
+    if protocol.attempts:
+        lines += _attempts_lines(protocol)
+    if protocol.fueling is not None:
+        lines += _fueling_lines(protocol.fueling)
+    if protocol.practices:
+        lines += _practices_lines(protocol)
+    if protocol.checklist:
+        lines += _checklist_lines(protocol)
+    return lines
+
+
+def render_protocol(
+    protocol: CompetitionProtocol,
+    citations: Mapping[str, ResolvedCitation] | None = None,
+) -> str:
+    """Render the protocol to markdown (deterministic; Sources iff citations)."""
+    lines = [
+        f"# Competition protocol v{protocol.version} — {protocol.event_id} — "
+        f"{protocol.event_date.isoformat()}",
+        "",
+        f"- Window: J-{protocol.window_days} → J0",
+        f"- Goal: {protocol.goal_id}",
+    ]
+    if protocol.reason:
+        lines.append(f"- Reason: {protocol.reason}")
+    lines += _sections(protocol)
+    if citations is not None:
+        ids = [cid for cid in protocol_citation_ids(protocol) if cid in citations]
+        if ids:
+            lines += ["", "## Sources"]
+            for number, cid in enumerate(ids, start=1):
+                resolved = citations[cid]
+                lines.append(f"{number}. {resolved.stars} {resolved.citation}")
+    return "\n".join(lines).strip() + "\n"
diff --git a/tests/programs/test_render_protocol.py b/tests/programs/test_render_protocol.py
new file mode 100644
index 0000000..49ea5a7
--- /dev/null
+++ b/tests/programs/test_render_protocol.py
@@ -0,0 +1,116 @@
+"""Deterministic protocol markdown rendering and citation ordering."""
+
+from datetime import date
+
+from performance_agent.evidence.citations import ResolvedCitation
+from performance_agent.memory.schemas import (
+    AttemptPlan,
+    CompetitionProtocol,
+    DocumentedPractice,
+    FuelingPlan,
+    Guidance,
+    PacingSegment,
+    ProtocolDay,
+    ProtocolLine,
+)
+from performance_agent.programs.render_protocol import (
+    protocol_citation_ids,
+    render_protocol,
+)
+
+CITATIONS = {
+    "carb-2017": ResolvedCitation(
+        citation="Burke et al. (2017). Carbohydrates for training and competition. "
+        "DOI: 10.1080/02640414.2011.585473.",
+        stars="★★★★★",
+        doi="10.1080/02640414.2011.585473",
+        pmid=None,
+    )
+}
+
+
+def _full_protocol():
+    return CompetitionProtocol(
+        version=1,
+        event_id="nationals",
+        event_date=date(2026, 8, 1),
+        goal_id="sub-40-10k",
+        created_on=date(2026, 7, 25),
+        window_days=7,
+        advice=[Guidance(text="Nothing new on race day.", cite="carb-2017")],
+        days=[
+            ProtocolDay(
+                day_offset=-1,
+                title="Carb load",
+                lines=[ProtocolLine(text="8-12 g/kg carbs.", cite="carb-2017")],
+            ),
+            ProtocolDay(
+                day_offset=0,
+                title="Race day",
+                lines=[ProtocolLine(text="Breakfast 3 h before.", time_hint="06:00")],
+            ),
+        ],
+        pacing=[
+            PacingSegment(
+                label="1 km", distance_m=1000, target_pace_s_per_km=240, cumulative_time_s=240
+            )
+        ],
+        attempts=[
+            AttemptPlan(
+                lift="Squat",
+                e1rm_kg=200,
+                opener_kg=182.5,
+                second_kg=192.5,
+                third_kg=205,
+                basis="engine",
+            )
+        ],
+        fueling=FuelingPlan(carb_g_per_kg_low=8, carb_g_per_kg_high=12, window_hours=48),
+        practices=[
+            DocumentedPractice(
+                name="Water manipulation",
+                summary="Documented in physique prep; small effect sizes.",
+                warning="Dehydration risk; supervision required.",
+            )
+        ],
+        checklist=["Pin race bib"],
+    )
+
+
+def test_citation_ids_ordered_and_deduped():
+    assert protocol_citation_ids(_full_protocol()) == ["carb-2017"]
+
+
+def test_markdown_renders_all_sections():
+    text = render_protocol(_full_protocol(), citations=CITATIONS)
+    assert "# Competition protocol v1 — nationals — 2026-08-01" in text
+    assert "## J-1 — Carb load" in text
+    assert "## J0 — Race day" in text
+    assert "[06:00]" in text
+    assert "## Pacing" in text
+    assert "## Attempts" in text
+    assert "182.5 / 192.5 / 205" in text
+    assert "## Fueling" in text
+    assert "## Documented practices" in text
+    assert "⚠ Dehydration risk" in text
+    assert "## Checklist" in text
+    assert "## Sources" in text
+    assert "★★★★★" in text
+
+
+def test_markdown_without_optional_sections_is_lean():
+    protocol = CompetitionProtocol(
+        version=1,
+        event_id="local-5k",
+        event_date=date(2026, 8, 1),
+        goal_id="sub-20-5k",
+        created_on=date(2026, 7, 28),
+        window_days=3,
+        days=[
+            ProtocolDay(day_offset=0, title="Race", lines=[ProtocolLine(text="Warm up 15 min.")])
+        ],
+    )
+    text = render_protocol(protocol)
+    assert "## Pacing" not in text
+    assert "## Attempts" not in text
+    assert "## Sources" not in text

From bb9165aa9fef916180af6ff4874f0791cf7bf033 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 23:11:14 +0200
Subject: [PATCH 09/25] Tighten fueling validation and renderer reuse after
 review

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/performance_agent/memory/schemas.py       | 16 +++++-
 .../programs/render_protocol.py               | 50 +++++++++++--------
 tests/memory/test_schemas_protocol.py         | 26 ++++++++++
 tests/programs/test_render_protocol.py        | 14 ++++++
 4 files changed, 84 insertions(+), 22 deletions(-)

diff --git a/src/performance_agent/memory/schemas.py b/src/performance_agent/memory/schemas.py
index c01ff03..1d0a116 100644
--- a/src/performance_agent/memory/schemas.py
+++ b/src/performance_agent/memory/schemas.py
@@ -611,6 +611,20 @@ def _low_not_above_high(self) -> Self:
             raise ValueError(msg)
         return self
 
+    @model_validator(mode="after")
+    def _race_range_is_well_formed(self) -> Self:
+        low, high = self.race_carb_g_per_h_low, self.race_carb_g_per_h_high
+        if (low is None) != (high is None):
+            msg = (
+                "race_carb_g_per_h_low and race_carb_g_per_h_high must both be set "
+                f"or both be None, got low={low}, high={high}"
+            )
+            raise ValueError(msg)
+        if low is not None and high is not None and low > high:
+            msg = f"race_carb_g_per_h low must not exceed high, got {low} > {high}"
+            raise ValueError(msg)
+        return self
+
 
 class DocumentedPractice(BaseModel):
     """A risky-but-documented practice: described with its grade, never dosed.
@@ -645,7 +659,7 @@ class CompetitionProtocol(BaseModel):
     attempts: list[AttemptPlan] = Field(default_factory=list)
     fueling: FuelingPlan | None = None
     practices: list[DocumentedPractice] = Field(default_factory=list)
-    checklist: list[str] = Field(default_factory=list)
+    checklist: list[Annotated[str, StringConstraints(min_length=1)]] = Field(default_factory=list)
     advice: list[Guidance] = Field(default_factory=list)
 
     @model_validator(mode="after")
diff --git a/src/performance_agent/programs/render_protocol.py b/src/performance_agent/programs/render_protocol.py
index d638b4c..5538489 100644
--- a/src/performance_agent/programs/render_protocol.py
+++ b/src/performance_agent/programs/render_protocol.py
@@ -9,7 +9,10 @@
 from collections.abc import Mapping
 
 from performance_agent.evidence.citations import ResolvedCitation
-from performance_agent.memory.schemas import CompetitionProtocol, FuelingPlan
+from performance_agent.memory.schemas import CompetitionProtocol, FuelingPlan, ProtocolLine
+from performance_agent.programs.render import num_label, pace_label
+
+_SECONDS_PER_HOUR = 3600
 
 
 def protocol_citation_ids(protocol: CompetitionProtocol) -> list[str]:
@@ -38,19 +41,25 @@ def _day_label(offset: int) -> str:
     return "J0" if offset == 0 else f"J{offset}"
 
 
-def _num(value: float) -> str:
-    return f"{value:g}"
+def _cumulative_label(seconds: float) -> str:
+    total = round(seconds)
+    if total >= _SECONDS_PER_HOUR:
+        hours, remainder = divmod(total, _SECONDS_PER_HOUR)
+        minutes, secs = divmod(remainder, 60)
+        return f"{hours}:{minutes:02d}:{secs:02d}"
+    minutes, secs = divmod(total, 60)
+    return f"{minutes}:{secs:02d}"
 
 
-def _line_text(text: str, time_hint: str | None, cite: str | None, warning: bool) -> str:
+def _line_text(line: ProtocolLine) -> str:
     parts = []
-    if time_hint:
-        parts.append(f"[{time_hint}]")
-    parts.append(text)
-    if warning:
+    if line.time_hint:
+        parts.append(f"[{line.time_hint}]")
+    parts.append(line.text)
+    if line.warning:
         parts.append("⚠")
-    if cite:
-        parts.append(f"[{cite}]")
+    if line.cite:
+        parts.append(f"[{line.cite}]")
     return "- " + " ".join(parts)
 
 
@@ -67,7 +76,7 @@ def _days_lines(protocol: CompetitionProtocol) -> list[str]:
     for day in protocol.days:
         lines += ["", f"## {_day_label(day.day_offset)} — {day.title}"]
         for line in day.lines:
-            lines.append(_line_text(line.text, line.time_hint, line.cite, line.warning))
+            lines.append(_line_text(line))
     return lines
 
 
@@ -80,11 +89,10 @@ def _pacing_lines(protocol: CompetitionProtocol) -> list[str]:
         "|---|---|---|---|",
     ]
     for seg in protocol.pacing:
-        minutes, seconds = divmod(round(seg.target_pace_s_per_km), 60)
-        total_min, total_s = divmod(round(seg.cumulative_time_s), 60)
         lines.append(
-            f"| {seg.label} | {_num(seg.distance_m)} m | {minutes}:{seconds:02d}/km "
-            f"| {total_min}:{total_s:02d} |"
+            f"| {seg.label} | {num_label(seg.distance_m)} m "
+            f"| {pace_label(seg.target_pace_s_per_km)} "
+            f"| {_cumulative_label(seg.cumulative_time_s)} |"
         )
     return lines
 
@@ -94,8 +102,8 @@ def _attempts_lines(protocol: CompetitionProtocol) -> list[str]:
     for attempt in protocol.attempts:
         flags = f" ({', '.join(attempt.flags)})" if attempt.flags else ""
         lines.append(
-            f"- {attempt.lift}: {_num(attempt.opener_kg)} / {_num(attempt.second_kg)} "
-            f"/ {_num(attempt.third_kg)} kg — e1RM {_num(attempt.e1rm_kg)} kg, "
+            f"- {attempt.lift}: {num_label(attempt.opener_kg)} / {num_label(attempt.second_kg)} "
+            f"/ {num_label(attempt.third_kg)} kg — e1RM {num_label(attempt.e1rm_kg)} kg, "
             f"{attempt.basis}{flags}"
         )
     return lines
@@ -105,16 +113,16 @@ def _fueling_lines(fueling: FuelingPlan) -> list[str]:
     lines: list[str] = ["", "## Fueling"]
     cite = f" [{fueling.cite}]" if fueling.cite else ""
     lines.append(
-        f"- {_num(fueling.carb_g_per_kg_low)}-{_num(fueling.carb_g_per_kg_high)} g/kg/day "
-        f"carbs over the final {fueling.window_hours} h{cite}"
+        f"- {num_label(fueling.carb_g_per_kg_low)}-{num_label(fueling.carb_g_per_kg_high)} "
+        f"g/kg/day carbs over the final {fueling.window_hours} h{cite}"
     )
     has_race_range = (
         fueling.race_carb_g_per_h_low is not None and fueling.race_carb_g_per_h_high is not None
     )
     if has_race_range:
         lines.append(
-            f"- In race: {_num(fueling.race_carb_g_per_h_low)}-"
-            f"{_num(fueling.race_carb_g_per_h_high)} g/h"
+            f"- In race: {num_label(fueling.race_carb_g_per_h_low)}-"
+            f"{num_label(fueling.race_carb_g_per_h_high)} g/h"
         )
     return lines
 
diff --git a/tests/memory/test_schemas_protocol.py b/tests/memory/test_schemas_protocol.py
index 6c58191..2491b3d 100644
--- a/tests/memory/test_schemas_protocol.py
+++ b/tests/memory/test_schemas_protocol.py
@@ -114,3 +114,29 @@ def test_attempts_must_strictly_increase():
 def test_fueling_low_cannot_exceed_high():
     with pytest.raises(ValidationError, match="carb_g_per_kg"):
         FuelingPlan(carb_g_per_kg_low=10, carb_g_per_kg_high=8, window_hours=48)
+
+
+def test_fueling_race_range_cannot_be_half_specified():
+    with pytest.raises(ValidationError, match="race_carb_g_per_h"):
+        FuelingPlan(
+            carb_g_per_kg_low=8,
+            carb_g_per_kg_high=12,
+            window_hours=48,
+            race_carb_g_per_h_low=60,
+        )
+
+
+def test_fueling_race_low_cannot_exceed_high():
+    with pytest.raises(ValidationError, match="race_carb_g_per_h"):
+        FuelingPlan(
+            carb_g_per_kg_low=8,
+            carb_g_per_kg_high=12,
+            window_hours=48,
+            race_carb_g_per_h_low=90,
+            race_carb_g_per_h_high=60,
+        )
+
+
+def test_checklist_item_cannot_be_empty():
+    with pytest.raises(ValidationError):
+        _protocol(checklist=["Pin race bib", ""])
diff --git a/tests/programs/test_render_protocol.py b/tests/programs/test_render_protocol.py
index 49ea5a7..1d93ecd 100644
--- a/tests/programs/test_render_protocol.py
+++ b/tests/programs/test_render_protocol.py
@@ -98,6 +98,20 @@ def test_markdown_renders_all_sections():
     assert "★★★★★" in text
 
 
+def test_cumulative_time_over_an_hour_renders_as_hms():
+    protocol = _full_protocol()
+    protocol.pacing.append(
+        PacingSegment(
+            label="Marathon finish",
+            distance_m=42195,
+            target_pace_s_per_km=250,
+            cumulative_time_s=10500,
+        )
+    )
+    text = render_protocol(protocol)
+    assert "2:55:00" in text
+
+
 def test_markdown_without_optional_sections_is_lean():
     protocol = CompetitionProtocol(
         version=1,

From 6cb39da37cb4fb05cb4c40d1e23359208565ad68 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 23:15:29 +0200
Subject: [PATCH 10/25] Add per-event competition protocol store

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/performance_agent/memory/store.py | 126 ++++++++++++++++++++++++++
 tests/memory/test_store_protocol.py   |  91 +++++++++++++++++++
 2 files changed, 217 insertions(+)
 create mode 100644 tests/memory/test_store_protocol.py

diff --git a/src/performance_agent/memory/store.py b/src/performance_agent/memory/store.py
index f00aaa8..e218d6c 100644
--- a/src/performance_agent/memory/store.py
+++ b/src/performance_agent/memory/store.py
@@ -19,6 +19,7 @@
     Calendar,
     CalendarEvent,
     CheckinEntry,
+    CompetitionProtocol,
     ExerciseLibrary,
     Goal,
     KpiResult,
@@ -34,6 +35,7 @@
     SessionPlan,
 )
 from performance_agent.programs.render import render_program
+from performance_agent.programs.render_protocol import render_protocol
 
 PROFILE_FILE = "profile.yaml"
 GOALS_FILE = "goals.yaml"
@@ -56,6 +58,7 @@
 EXERCISES_DIR = "exercises"
 EXERCISE_LIBRARY_FILE = "library.yaml"
 WATCH_DIR = "watch"
+COMPETITION_DIR = "competition"
 _FRONTMATTER_DELIMITER = "---\n"
 _FRONTMATTER_DELIMITER_COUNT = 2
 
@@ -859,3 +862,126 @@ def read_watch_report(
         label="watch report",
         version=version,
     )
+
+
+@dataclass(frozen=True)
+class ProtocolRead:
+    """A stored competition-protocol version: structured plan plus its markdown."""
+
+    version: int
+    event_id: str
+    goal_id: str
+    created_on: str
+    reason: str | None
+    markdown: str
+    protocol: CompetitionProtocol
+
+
+def _protocol_prefix(event_id: str) -> str:
+    return f"protocol-{event_id}"
+
+
+def latest_competition_protocol_version(base_dir: Path, event_id: str) -> int | None:
+    """Highest stored protocol version for this event, or None."""
+    return _latest_doc_version(base_dir, COMPETITION_DIR, _protocol_prefix(event_id))
+
+
+def _validated_calendar_event(base_dir: Path, protocol: CompetitionProtocol, current: date) -> None:
+    event = next((e for e in read_calendar(base_dir).events if e.id == protocol.event_id), None)
+    if event is None:
+        msg = f"event {protocol.event_id!r} is not in the calendar; add it first"
+        raise ValueError(msg)
+    if event.date != protocol.event_date:
+        msg = (
+            f"protocol event_date {protocol.event_date} does not match the calendar "
+            f"date {event.date} for {protocol.event_id!r}"
+        )
+        raise ValueError(msg)
+    if event.date < current:
+        msg = f"event {protocol.event_id!r} ({event.date}) is in the past"
+        raise ValueError(msg)
+
+
+def save_competition_protocol(
+    base_dir: Path,
+    protocol: CompetitionProtocol,
+    reason: str | None = None,
+    today: date | None = None,
+    citations: Mapping[str, ResolvedCitation] | None = None,
+) -> tuple[Path, int]:
+    """Validate against the calendar and write the next protocol version.
+
+    The event must exist in calendar.yaml with the same date (a rescheduled
+    event needs a v2 with a reason, never a silent drift) and must not be in
+    the past. yaml is the source of truth, markdown the rendered view; both
+    are immutable once written. citations maps corpus ids to their resolved
+    rendering (the server resolves them; None keeps a citation-less render).
+    """
+    current = today or date.today()
+    _validated_calendar_event(base_dir, protocol, current)
+    prefix = _protocol_prefix(protocol.event_id)
+    latest = latest_competition_protocol_version(base_dir, protocol.event_id)
+    version = 1 if latest is None else latest + 1
+    if version > 1 and not reason:
+        msg = (
+            f"adapting protocol v{latest} to v{version} for {protocol.event_id!r} "
+            "requires a reason (audit trail)"
+        )
+        raise ValueError(msg)
+    stamped = protocol.model_copy(
+        update={"version": version, "reason": reason, "created_on": current}
+    )
+    frontmatter = {
+        "version": version,
+        "event_id": stamped.event_id,
+        "goal_id": stamped.goal_id,
+        "created_on": current.isoformat(),
+        "reason": reason,
+    }
+    md_path = base_dir / COMPETITION_DIR / f"{prefix}-v{version}.md"
+    yaml_path = md_path.with_suffix(".yaml")
+    content = (
+        "---\n"
+        + _to_yaml(frontmatter)
+        + "---\n\n"
+        + render_protocol(stamped, citations=citations).strip()
+        + "\n"
+    )
+    _atomic_write(yaml_path, _to_yaml(stamped.model_dump(mode="json")))
+    try:
+        _atomic_write(md_path, content)
+    except OSError:
+        yaml_path.unlink(missing_ok=True)
+        raise
+    return md_path, version
+
+
+def read_competition_protocol(
+    base_dir: Path, event_id: str, version: int | None = None
+) -> ProtocolRead | None:
+    """Return the given or latest protocol for an event; None when none exists."""
+    target = (
+        version if version is not None else latest_competition_protocol_version(base_dir, event_id)
+    )
+    if target is None:
+        return None
+    prefix = _protocol_prefix(event_id)
+    md_path = base_dir / COMPETITION_DIR / f"{prefix}-v{target}.md"
+    yaml_path = md_path.with_suffix(".yaml")
+    if not md_path.exists() or not yaml_path.exists():
+        msg = f"protocol v{target} for {event_id!r} does not exist"
+        raise ValueError(msg)
+    frontmatter, markdown = _split_frontmatter(md_path, md_path.read_text(encoding="utf-8"))
+    protocol = _validated(
+        yaml_path,
+        lambda: CompetitionProtocol.model_validate(_load_yaml(yaml_path) or {}),
+    )
+    return ProtocolRead(
+        version=target,
+        event_id=event_id,
+        goal_id=str(frontmatter["goal_id"]),
+        created_on=str(frontmatter["created_on"]),
+        reason=str(frontmatter["reason"]) if frontmatter.get("reason") is not None else None,
+        markdown=markdown,
+        protocol=protocol,
+    )
diff --git a/tests/memory/test_store_protocol.py b/tests/memory/test_store_protocol.py
new file mode 100644
index 0000000..3b87d5f
--- /dev/null
+++ b/tests/memory/test_store_protocol.py
@@ -0,0 +1,91 @@
+"""Competition protocols: per-event immutable versions, calendar validation."""
+
+from datetime import date
+
+import pytest
+
+from performance_agent.memory import store
+from performance_agent.memory.schemas import (
+    CalendarEvent,
+    CompetitionProtocol,
+    ProtocolDay,
+    ProtocolLine,
+)
+
+TODAY = date(2026, 7, 25)
+EVENT_DATE = date(2026, 8, 1)
+
+
+def _seed_event(base, event_id="nationals", event_date=EVENT_DATE):
+    store.upsert_calendar_event(
+        base,
+        CalendarEvent(
+            id=event_id, date=event_date, kind="competition", priority="A", label="Nationals"
+        ),
+    )
+
+
+def _protocol(event_id="nationals", event_date=EVENT_DATE, **overrides):
+    fields = {
+        "version": 1,
+        "event_id": event_id,
+        "event_date": event_date,
+        "goal_id": "sub-40-10k",
+        "created_on": TODAY,
+        "window_days": 7,
+        "days": [ProtocolDay(day_offset=0, title="Race", lines=[ProtocolLine(text="Warm up.")])],
+    }
+    fields.update(overrides)
+    return CompetitionProtocol.model_validate(fields)
+
+
+def test_save_and_read_roundtrip(tmp_path):
+    _seed_event(tmp_path)
+    path, version = store.save_competition_protocol(tmp_path, _protocol(), today=TODAY)
+    assert version == 1
+    assert path == tmp_path / "competition" / "protocol-nationals-v1.md"
+    assert (tmp_path / "competition" / "protocol-nationals-v1.yaml").exists()
+    stored = store.read_competition_protocol(tmp_path, "nationals")
+    assert stored is not None
+    assert stored.version == 1
+    assert stored.protocol.event_id == "nationals"
+    assert "# Competition protocol v1" in stored.markdown
+
+
+def test_v2_requires_reason_and_versions_are_per_event(tmp_path):
+    _seed_event(tmp_path)
+    _seed_event(tmp_path, event_id="tune-up", event_date=date(2026, 7, 30))
+    store.save_competition_protocol(tmp_path, _protocol(), today=TODAY)
+    with pytest.raises(ValueError, match="reason"):
+        store.save_competition_protocol(tmp_path, _protocol(), today=TODAY)
+    _, v2 = store.save_competition_protocol(
+        tmp_path, _protocol(), reason="taper adjusted", today=TODAY
+    )
+    assert v2 == 2
+    _, other = store.save_competition_protocol(
+        tmp_path,
+        _protocol(event_id="tune-up", event_date=date(2026, 7, 30)),
+        today=TODAY,
+    )
+    assert other == 1  # independent lineage per event
+
+
+def test_save_rejects_unknown_event_and_date_drift(tmp_path):
+    with pytest.raises(ValueError, match="calendar"):
+        store.save_competition_protocol(tmp_path, _protocol(), today=TODAY)
+    _seed_event(tmp_path)
+    with pytest.raises(ValueError, match="date"):
+        store.save_competition_protocol(
+            tmp_path, _protocol(event_date=date(2026, 8, 2)), today=TODAY
+        )
+
+
+def test_save_rejects_past_event(tmp_path):
+    _seed_event(tmp_path)
+    with pytest.raises(ValueError, match="past"):
+        store.save_competition_protocol(tmp_path, _protocol(), today=date(2026, 8, 5))
+
+
+def test_latest_version_none_when_empty(tmp_path):
+    assert store.latest_competition_protocol_version(tmp_path, "nationals") is None
+    assert store.read_competition_protocol(tmp_path, "nationals") is None

From 7c8052e6fb6f17ce33ea1ed207a9f4b471c4aba5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 23:17:23 +0200
Subject: [PATCH 11/25] Render the competition protocol phone page

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../programs/render_protocol_html.py          | 278 ++++++++++++++++++
 tests/programs/test_render_protocol_html.py   | 102 +++++++
 2 files changed, 380 insertions(+)
 create mode 100644 src/performance_agent/programs/render_protocol_html.py
 create mode 100644 tests/programs/test_render_protocol_html.py

diff --git a/src/performance_agent/programs/render_protocol_html.py b/src/performance_agent/programs/render_protocol_html.py
new file mode 100644
index 0000000..1bfbace
--- /dev/null
+++ b/src/performance_agent/programs/render_protocol_html.py
@@ -0,0 +1,278 @@
+"""Deterministic CompetitionProtocol -> standalone phone page for the event.
+
+Same rules as the session HTML: fully self-contained (inline CSS, zero
+JavaScript, no external requests except DOI links), phone-first, en/fr/es
+labels from the athlete's locale. J0 renders open, earlier days collapsed.
+Practice warnings are visually flagged — the page never softens them.
+"""
+
+import html
+from collections.abc import Mapping
+
+from performance_agent.evidence.citations import ResolvedCitation
+from performance_agent.memory.schemas import CompetitionProtocol, ProtocolDay
+from performance_agent.programs.render import pace_label
+from performance_agent.programs.render_protocol import protocol_citation_ids
+
+_SECONDS_PER_HOUR = 3600
+
+_LABELS = {
+    "en": {
+        "protocol": "Competition protocol",
+        "window": "Window",
+        "goal": "Goal",
+        "event_day": "Event day",
+        "day": "Day",
+        "advice": "Advice",
+        "pacing": "Pacing",
+        "segment": "Segment",
+        "pace": "Pace",
+        "cumulative": "Cumulative",
+        "attempts": "Attempts",
+        "fueling": "Fueling",
+        "in_race": "In race",
+        "practices": "Documented practices",
+        "checklist": "Checklist",
+        "sources": "Sources",
+    },
+    "fr": {
+        "protocol": "Protocole de compétition",
+        "window": "Fenêtre",
+        "goal": "Objectif",
+        "event_day": "Jour J",
+        "day": "Jour",
+        "advice": "Conseils",
+        "pacing": "Allures",
+        "segment": "Segment",
+        "pace": "Allure",
+        "cumulative": "Cumulé",
+        "attempts": "Tentatives",
+        "fueling": "Ravitaillement",
+        "in_race": "En course",
+        "practices": "Pratiques documentées",
+        "checklist": "Checklist",
+        "sources": "Sources",
+    },
+    "es": {
+        "protocol": "Protocolo de competición",
+        "window": "Ventana",
+        "goal": "Objetivo",
+        "event_day": "Día D",
+        "day": "Día",
+        "advice": "Consejos",
+        "pacing": "Ritmos",
+        "segment": "Segmento",
+        "pace": "Ritmo",
+        "cumulative": "Acumulado",
+        "attempts": "Intentos",
+        "fueling": "Avituallamiento",
+        "in_race": "En carrera",
+        "practices": "Prácticas documentadas",
+        "checklist": "Checklist",
+        "sources": "Fuentes",
+    },
+}
+
+_CSS = """
+:root { --bg: #f6f7f9; --card: #ffffff; --ink: #1c2330; --muted: #5b6472;
+  --line: #e3e6eb; --accent: #2563eb; --chip: #eef2f8; --warn: #b45309;
+  --warnbg: #fef3c7; }
+@media (prefers-color-scheme: dark) {
+  :root { --bg: #10141b; --card: #1a202b; --ink: #e8ecf2; --muted: #9aa4b2;
+    --line: #2a3140; --accent: #7aa2ff; --chip: #232b39; --warn: #fbbf24;
+    --warnbg: #3a2f14; } }
+* { box-sizing: border-box; }
+body { margin: 0; background: var(--bg); color: var(--ink); line-height: 1.5;
+  font: 16px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif; }
+main { max-width: 46rem; margin: 0 auto; padding: 1rem 1rem 4rem; }
+header.top h1 { margin: 1.5rem 0 0.25rem; font-size: 1.4rem; }
+header.top p { margin: 0.15rem 0; color: var(--muted); }
+h2 { font-size: 1.1rem; margin: 1.5rem 0 0.5rem; }
+details.day { background: var(--card); border: 1px solid var(--line);
+  border-radius: 12px; margin: 0.6rem 0; overflow: hidden; }
+details.day > summary { cursor: pointer; padding: 0.8rem 1rem; font-weight: 600;
+  list-style: none; }
+details.day > summary::-webkit-details-marker { display: none; }
+details.day ul { margin: 0 0 0.8rem; padding: 0 1rem 0 2rem; }
+details.day li { margin: 0.35rem 0; }
+.hint { display: inline-block; background: var(--chip); border-radius: 999px;
+  padding: 0 0.5rem; font-size: 0.85rem; margin-right: 0.3rem; }
+li.warn { background: var(--warnbg); border-radius: 8px; padding: 0.25rem 0.5rem;
+  list-style: none; margin-left: -1rem; }
+.warnmark { color: var(--warn); font-weight: 700; }
+sup.cite { color: var(--accent); font-weight: 600; }
+table { border-collapse: collapse; width: 100%; background: var(--card);
+  border-radius: 12px; overflow: hidden; }
+th, td { border-bottom: 1px solid var(--line); padding: 0.45rem 0.7rem;
+  text-align: left; font-size: 0.95rem; }
+.practice { background: var(--warnbg); border-radius: 12px; padding: 0.7rem 1rem;
+  margin: 0.6rem 0; }
+.practice p { margin: 0.25rem 0; }
+.practice .warnline { color: var(--warn); font-weight: 600; }
+ul.checklist { padding-left: 1.2rem; }
+section.sources ol { padding-left: 1.2rem; }
+section.sources li { margin: 0.35rem 0; font-size: 0.9rem; }
+section.sources .stars { color: var(--accent); letter-spacing: 0.05em; }
+"""
+
+
+def _t(locale: str, key: str) -> str:
+    return _LABELS.get(locale, _LABELS["en"])[key]
+
+
+def _marker(numbers: dict[str, int], cite: str | None) -> str:
+    if cite is None or cite not in numbers:
+        return ""
+    return f'<sup class="cite">[{numbers[cite]}]</sup>'
+
+
+def _clock(value: float) -> str:
+    total = round(value)
+    if total >= _SECONDS_PER_HOUR:
+        hours, remainder = divmod(total, _SECONDS_PER_HOUR)
+        minutes, seconds = divmod(remainder, 60)
+        return f"{hours}:{minutes:02d}:{seconds:02d}"
+    minutes, seconds = divmod(total, 60)
+    return f"{minutes}:{seconds:02d}"
+
+
+def _day_html(day: ProtocolDay, numbers: dict[str, int], locale: str) -> str:
+    title = (
+        _t(locale, "event_day") if day.day_offset == 0 else f"{_t(locale, 'day')} J{day.day_offset}"
+    )
+    items = []
+    for line in day.lines:
+        hint = f'<span class="hint">{html.escape(line.time_hint)}</span>' if line.time_hint else ""
+        warn = '<span class="warnmark">⚠ </span>' if line.warning else ""
+        css = ' class="warn"' if line.warning else ""
+        items.append(
+            f"<li{css}>{hint}{warn}{html.escape(line.text)}{_marker(numbers, line.cite)}</li>"
+        )
+    is_open = " open" if day.day_offset == 0 else ""
+    return (
+        f'<details class="day"{is_open}><summary>{title} — {html.escape(day.title)}</summary>'
+        f"<ul>{''.join(items)}</ul></details>"
+    )
+
+
+def _pacing_html(protocol: CompetitionProtocol, locale: str) -> str:
+    if not protocol.pacing:
+        return ""
+    rows = "".join(
+        f"<tr><td>{html.escape(seg.label)}</td><td>{seg.distance_m:g} m</td>"
+        f"<td>{pace_label(seg.target_pace_s_per_km)}</td><td>{_clock(seg.cumulative_time_s)}</td></tr>"
+        for seg in protocol.pacing
+    )
+    return (
+        f"<h2>🏁 {_t(locale, 'pacing')}</h2><table><tr><th>{_t(locale, 'segment')}</th>"
+        f"<th></th><th>{_t(locale, 'pace')}</th><th>{_t(locale, 'cumulative')}</th></tr>"
+        f"{rows}</table>"
+    )
+
+
+def _attempts_html(protocol: CompetitionProtocol, locale: str) -> str:
+    if not protocol.attempts:
+        return ""
+    rows = "".join(
+        f"<tr><td>{html.escape(a.lift)}</td><td>{a.opener_kg:g}</td>"
+        f"<td>{a.second_kg:g}</td><td>{a.third_kg:g}</td></tr>"
+        for a in protocol.attempts
+    )
+    return (
+        f"<h2>🏋️ {_t(locale, 'attempts')}</h2><table><tr><th></th><th>1</th><th>2</th>"
+        f"<th>3</th></tr>{rows}</table>"
+    )
+
+
+def _fueling_html(protocol: CompetitionProtocol, numbers: dict[str, int], locale: str) -> str:
+    fueling = protocol.fueling
+    if fueling is None:
+        return ""
+    lines = [
+        f"<li>{fueling.carb_g_per_kg_low:g}-{fueling.carb_g_per_kg_high:g} g/kg/day — "
+        f"{fueling.window_hours} h{_marker(numbers, fueling.cite)}</li>"
+    ]
+    if fueling.race_carb_g_per_h_low is not None and fueling.race_carb_g_per_h_high is not None:
+        lines.append(
+            f"<li>{_t(locale, 'in_race')}: {fueling.race_carb_g_per_h_low:g}-"
+            f"{fueling.race_carb_g_per_h_high:g} g/h</li>"
+        )
+    return f"<h2>🍝 {_t(locale, 'fueling')}</h2><ul>{''.join(lines)}</ul>"
+
+
+def _practices_html(protocol: CompetitionProtocol, numbers: dict[str, int], locale: str) -> str:
+    if not protocol.practices:
+        return ""
+    cards = "".join(
+        f'<div class="practice"><p><strong>{html.escape(p.name)}</strong> — '
+        f"{html.escape(p.summary)}{_marker(numbers, p.cite)}</p>"
+        f'<p class="warnline">⚠ {html.escape(p.warning)}</p></div>'
+        for p in protocol.practices
+    )
+    return f"<h2>⚠️ {_t(locale, 'practices')}</h2>{cards}"
+
+
+def _sources_html(
+    citations: Mapping[str, ResolvedCitation], numbers: dict[str, int], locale: str
+) -> str:
+    ordered = sorted((cid for cid in numbers if cid in citations), key=lambda cid: numbers[cid])
+    if not ordered:
+        return ""
+    rows = []
+    for cid in ordered:
+        resolved = citations[cid]
+        link = (
+            f' <a href="https://doi.org/{html.escape(resolved.doi)}">DOI</a>'
+            if resolved.doi
+            else ""
+        )
+        rows.append(
+            f'<li><span class="stars">{resolved.stars}</span> '
+            f"{html.escape(resolved.citation)}{link}</li>"
+        )
+    return (
+        f'<section class="sources"><h2>📚 {_t(locale, "sources")}</h2>'
+        f"<ol>{''.join(rows)}</ol></section>"
+    )
+
+
+def render_protocol_html(
+    protocol: CompetitionProtocol,
+    locale: str = "en",
+    citations: Mapping[str, ResolvedCitation] | None = None,
+) -> str:
+    """Render the protocol to a standalone, offline-ready phone page."""
+    numbers = (
+        {cid: i for i, cid in enumerate(protocol_citation_ids(protocol), start=1)}
+        if citations
+        else {}
+    )
+    advice = ""
+    if protocol.advice:
+        rows = "".join(
+            f"<li>{html.escape(g.text)}{_marker(numbers, g.cite)}</li>" for g in protocol.advice
+        )
+        advice = f"<h2>💡 {_t(locale, 'advice')}</h2><ul>{rows}</ul>"
+    days = "".join(_day_html(day, numbers, locale) for day in protocol.days)
+    checklist = ""
+    if protocol.checklist:
+        items = "".join(f"<li>☐ {html.escape(item)}</li>" for item in protocol.checklist)
+        checklist = f"<h2>🎒 {_t(locale, 'checklist')}</h2><ul class='checklist'>{items}</ul>"
+    title = (
+        f"{_t(locale, 'protocol')} v{protocol.version} — {html.escape(protocol.event_id)} — "
+        f"{protocol.event_date.isoformat()}"
+    )
+    header = (
+        f'<header class="top"><h1>{title}</h1>'
+        f"<p>{_t(locale, 'window')}: J-{protocol.window_days} → J0 · "
+        f"{_t(locale, 'goal')}: {html.escape(protocol.goal_id)}</p></header>"
+    )
+    return (
+        f'<!doctype html><html lang="{locale}"><head><meta charset="utf-8">'
+        '<meta name="viewport" content="width=device-width, initial-scale=1">'
+        f"<title>{title}</title><style>{_CSS}</style></head><body><main>"
+        f"{header}{advice}{days}{_pacing_html(protocol, locale)}"
+        f"{_attempts_html(protocol, locale)}{_fueling_html(protocol, numbers, locale)}"
+        f"{_practices_html(protocol, numbers, locale)}{checklist}"
+        f"{_sources_html(citations or {}, numbers, locale)}</main></body></html>"
+    )
diff --git a/tests/programs/test_render_protocol_html.py b/tests/programs/test_render_protocol_html.py
new file mode 100644
index 0000000..136fc08
--- /dev/null
+++ b/tests/programs/test_render_protocol_html.py
@@ -0,0 +1,102 @@
+"""Protocol phone page: offline, no JS, warnings flagged, starred sources."""
+
+from datetime import date
+
+from performance_agent.evidence.citations import ResolvedCitation
+from performance_agent.memory.schemas import (
+    CompetitionProtocol,
+    DocumentedPractice,
+    PacingSegment,
+    ProtocolDay,
+    ProtocolLine,
+)
+from performance_agent.programs.render_protocol_html import render_protocol_html
+
+CITATIONS = {
+    "carb-2017": ResolvedCitation(
+        citation="Burke et al. (2017). Carbohydrates for training and competition. "
+        "DOI: 10.1080/02640414.2011.585473.",
+        stars="★★★★★",
+        doi="10.1080/02640414.2011.585473",
+        pmid=None,
+    )
+}
+
+
+def _protocol():
+    return CompetitionProtocol(
+        version=1,
+        event_id="nationals",
+        event_date=date(2026, 8, 1),
+        goal_id="sub-40-10k",
+        created_on=date(2026, 7, 25),
+        window_days=7,
+        days=[
+            ProtocolDay(
+                day_offset=-1,
+                title="Veille",
+                lines=[ProtocolLine(text="8-12 g/kg carbs.", cite="carb-2017")],
+            ),
+            ProtocolDay(
+                day_offset=0,
+                title="Race day",
+                lines=[
+                    ProtocolLine(text="Breakfast.", time_hint="06:00"),
+                    ProtocolLine(text="No new shoes.", warning=True),
+                ],
+            ),
+        ],
+        pacing=[
+            PacingSegment(
+                label="1 km", distance_m=1000, target_pace_s_per_km=240, cumulative_time_s=240
+            )
+        ],
+        practices=[
+            DocumentedPractice(
+                name="Water manipulation",
+                summary="Documented in physique prep.",
+                warning="Dehydration risk; supervision required.",
+            )
+        ],
+        checklist=["Pin race bib"],
+    )
+
+
+def test_page_is_selfcontained_and_scriptless():
+    page = render_protocol_html(_protocol(), citations=CITATIONS)
+    assert page.startswith("<!doctype html>")
+    assert "<script" not in page
+    assert "http" not in page.replace("https://doi.org/", "")
+
+
+def test_event_day_open_warnings_and_sources_rendered():
+    page = render_protocol_html(_protocol(), citations=CITATIONS)
+    assert "<details" in page and "open" in page
+    assert "⚠" in page
+    assert "Dehydration risk" in page
+    assert "★★★★★" in page
+    assert "https://doi.org/10.1080/02640414.2011.585473" in page
+    assert "[1]" in page
+
+
+def test_french_labels():
+    page = render_protocol_html(_protocol(), locale="fr", citations=CITATIONS)
+    assert "Jour J" in page
+    assert "Allures" in page
+
+
+def test_cumulative_time_over_one_hour_uses_hms():
+    protocol = _protocol().model_copy(
+        update={
+            "pacing": [
+                PacingSegment(
+                    label="42 km",
+                    distance_m=42195,
+                    target_pace_s_per_km=249,
+                    cumulative_time_s=10500,
+                )
+            ]
+        }
+    )
+    page = render_protocol_html(protocol)
+    assert "2:55:00" in page

From 46359d4c5c14fa5e956ef364a7aa9799f58aba2d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 23:27:11 +0200
Subject: [PATCH 12/25] Align citation numbering and harden protocol reads
 after review

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/performance_agent/memory/store.py         | 30 +++++++++++++-
 src/performance_agent/programs/render.py      | 12 ++++++
 .../programs/render_protocol.py               | 16 +-------
 .../programs/render_protocol_html.py          | 24 +++--------
 tests/memory/test_store_protocol.py           | 16 ++++++++
 tests/programs/test_render_protocol_html.py   | 40 ++++++++++++++++++-
 6 files changed, 102 insertions(+), 36 deletions(-)

diff --git a/src/performance_agent/memory/store.py b/src/performance_agent/memory/store.py
index e218d6c..d6c5bc5 100644
--- a/src/performance_agent/memory/store.py
+++ b/src/performance_agent/memory/store.py
@@ -886,7 +886,7 @@ def latest_competition_protocol_version(base_dir: Path, event_id: str) -> int |
     return _latest_doc_version(base_dir, COMPETITION_DIR, _protocol_prefix(event_id))
 
 
-def _validated_calendar_event(base_dir: Path, protocol: CompetitionProtocol, current: date) -> None:
+def _validate_calendar_event(base_dir: Path, protocol: CompetitionProtocol, current: date) -> None:
     event = next((e for e in read_calendar(base_dir).events if e.id == protocol.event_id), None)
     if event is None:
         msg = f"event {protocol.event_id!r} is not in the calendar; add it first"
@@ -918,7 +918,7 @@ def save_competition_protocol(
     rendering (the server resolves them; None keeps a citation-less render).
     """
     current = today or date.today()
-    _validated_calendar_event(base_dir, protocol, current)
+    _validate_calendar_event(base_dir, protocol, current)
     prefix = _protocol_prefix(protocol.event_id)
     latest = latest_competition_protocol_version(base_dir, protocol.event_id)
     version = 1 if latest is None else latest + 1
@@ -956,6 +956,31 @@ def save_competition_protocol(
     return md_path, version
 
 
+def _validate_stored_protocol(
+    md_path: Path,
+    frontmatter: Mapping[str, object],
+    protocol: CompetitionProtocol,
+    event_id: str,
+    target: int,
+) -> None:
+    yaml_path = md_path.with_suffix(".yaml")
+    if frontmatter.get("version") != target:
+        msg = (
+            f"{md_path} frontmatter declares version {frontmatter.get('version')} "
+            f"but the filename says {target}"
+        )
+        raise ValueError(msg)
+    if protocol.event_id != event_id:
+        msg = (
+            f"{yaml_path} declares event_id {protocol.event_id!r} "
+            f"but was read for event_id {event_id!r}"
+        )
+        raise ValueError(msg)
+    if protocol.version != target:
+        msg = f"{yaml_path} declares version {protocol.version} but the filename says {target}"
+        raise ValueError(msg)
+
+
 def read_competition_protocol(
     base_dir: Path, event_id: str, version: int | None = None
 ) -> ProtocolRead | None:
@@ -976,6 +1001,7 @@ def read_competition_protocol(
         yaml_path,
         lambda: CompetitionProtocol.model_validate(_load_yaml(yaml_path) or {}),
     )
+    _validate_stored_protocol(md_path, frontmatter, protocol, event_id, target)
     return ProtocolRead(
         version=target,
         event_id=event_id,
diff --git a/src/performance_agent/programs/render.py b/src/performance_agent/programs/render.py
index 6dbc838..9b3cd6b 100644
--- a/src/performance_agent/programs/render.py
+++ b/src/performance_agent/programs/render.py
@@ -18,6 +18,7 @@
 )
 
 _METERS_PER_KM = 1000
+_SECONDS_PER_HOUR = 3600
 
 _WEEKDAYS = (
     "Monday",
@@ -41,6 +42,17 @@ def pace_label(seconds_per_km: float) -> str:
     return f"{minutes}:{secs:02d}/km"
 
 
+def clock_label(seconds: float) -> str:
+    """Format a duration as m:ss, or h:mm:ss once it reaches an hour."""
+    total = round(seconds)
+    if total >= _SECONDS_PER_HOUR:
+        hours, remainder = divmod(total, _SECONDS_PER_HOUR)
+        minutes, secs = divmod(remainder, 60)
+        return f"{hours}:{minutes:02d}:{secs:02d}"
+    minutes, secs = divmod(total, 60)
+    return f"{minutes}:{secs:02d}"
+
+
 def volume_label(block: ExerciseBlock) -> str:
     """Format a block's volume prescription (sets x reps / minutes / distance)."""
     if block.reps is not None:
diff --git a/src/performance_agent/programs/render_protocol.py b/src/performance_agent/programs/render_protocol.py
index 5538489..aa7f1a7 100644
--- a/src/performance_agent/programs/render_protocol.py
+++ b/src/performance_agent/programs/render_protocol.py
@@ -10,9 +10,7 @@
 
 from performance_agent.evidence.citations import ResolvedCitation
 from performance_agent.memory.schemas import CompetitionProtocol, FuelingPlan, ProtocolLine
-from performance_agent.programs.render import num_label, pace_label
-
-_SECONDS_PER_HOUR = 3600
+from performance_agent.programs.render import clock_label, num_label, pace_label
 
 
 def protocol_citation_ids(protocol: CompetitionProtocol) -> list[str]:
@@ -41,16 +39,6 @@ def _day_label(offset: int) -> str:
     return "J0" if offset == 0 else f"J{offset}"
 
 
-def _cumulative_label(seconds: float) -> str:
-    total = round(seconds)
-    if total >= _SECONDS_PER_HOUR:
-        hours, remainder = divmod(total, _SECONDS_PER_HOUR)
-        minutes, secs = divmod(remainder, 60)
-        return f"{hours}:{minutes:02d}:{secs:02d}"
-    minutes, secs = divmod(total, 60)
-    return f"{minutes}:{secs:02d}"
-
-
 def _line_text(line: ProtocolLine) -> str:
     parts = []
     if line.time_hint:
@@ -92,7 +80,7 @@ def _pacing_lines(protocol: CompetitionProtocol) -> list[str]:
         lines.append(
             f"| {seg.label} | {num_label(seg.distance_m)} m "
             f"| {pace_label(seg.target_pace_s_per_km)} "
-            f"| {_cumulative_label(seg.cumulative_time_s)} |"
+            f"| {clock_label(seg.cumulative_time_s)} |"
         )
     return lines
 
diff --git a/src/performance_agent/programs/render_protocol_html.py b/src/performance_agent/programs/render_protocol_html.py
index 1bfbace..fdfd562 100644
--- a/src/performance_agent/programs/render_protocol_html.py
+++ b/src/performance_agent/programs/render_protocol_html.py
@@ -11,11 +11,9 @@
 
 from performance_agent.evidence.citations import ResolvedCitation
 from performance_agent.memory.schemas import CompetitionProtocol, ProtocolDay
-from performance_agent.programs.render import pace_label
+from performance_agent.programs.render import clock_label, pace_label
 from performance_agent.programs.render_protocol import protocol_citation_ids
 
-_SECONDS_PER_HOUR = 3600
-
 _LABELS = {
     "en": {
         "protocol": "Competition protocol",
@@ -126,16 +124,6 @@ def _marker(numbers: dict[str, int], cite: str | None) -> str:
     return f'<sup class="cite">[{numbers[cite]}]</sup>'
 
 
-def _clock(value: float) -> str:
-    total = round(value)
-    if total >= _SECONDS_PER_HOUR:
-        hours, remainder = divmod(total, _SECONDS_PER_HOUR)
-        minutes, seconds = divmod(remainder, 60)
-        return f"{hours}:{minutes:02d}:{seconds:02d}"
-    minutes, seconds = divmod(total, 60)
-    return f"{minutes}:{seconds:02d}"
-
-
 def _day_html(day: ProtocolDay, numbers: dict[str, int], locale: str) -> str:
     title = (
         _t(locale, "event_day") if day.day_offset == 0 else f"{_t(locale, 'day')} J{day.day_offset}"
@@ -160,7 +148,8 @@ def _pacing_html(protocol: CompetitionProtocol, locale: str) -> str:
         return ""
     rows = "".join(
         f"<tr><td>{html.escape(seg.label)}</td><td>{seg.distance_m:g} m</td>"
-        f"<td>{pace_label(seg.target_pace_s_per_km)}</td><td>{_clock(seg.cumulative_time_s)}</td></tr>"
+        f"<td>{pace_label(seg.target_pace_s_per_km)}</td>"
+        f"<td>{clock_label(seg.cumulative_time_s)}</td></tr>"
         for seg in protocol.pacing
     )
     return (
@@ -242,11 +231,8 @@ def render_protocol_html(
     citations: Mapping[str, ResolvedCitation] | None = None,
 ) -> str:
     """Render the protocol to a standalone, offline-ready phone page."""
-    numbers = (
-        {cid: i for i, cid in enumerate(protocol_citation_ids(protocol), start=1)}
-        if citations
-        else {}
-    )
+    ids = [cid for cid in protocol_citation_ids(protocol) if cid in citations] if citations else []
+    numbers = {cid: i for i, cid in enumerate(ids, start=1)}
     advice = ""
     if protocol.advice:
         rows = "".join(
diff --git a/tests/memory/test_store_protocol.py b/tests/memory/test_store_protocol.py
index 3b87d5f..b7d9f35 100644
--- a/tests/memory/test_store_protocol.py
+++ b/tests/memory/test_store_protocol.py
@@ -89,3 +89,19 @@ def test_save_rejects_past_event(tmp_path):
 def test_latest_version_none_when_empty(tmp_path):
     assert store.latest_competition_protocol_version(tmp_path, "nationals") is None
     assert store.read_competition_protocol(tmp_path, "nationals") is None
+
+
+def test_read_rejects_unknown_version(tmp_path):
+    _seed_event(tmp_path)
+    store.save_competition_protocol(tmp_path, _protocol(), today=TODAY)
+    with pytest.raises(ValueError, match="does not exist"):
+        store.read_competition_protocol(tmp_path, "nationals", version=3)
+
+
+def test_read_rejects_frontmatter_version_mismatch(tmp_path):
+    _seed_event(tmp_path)
+    md_path, _ = store.save_competition_protocol(tmp_path, _protocol(), today=TODAY)
+    tampered = md_path.read_text(encoding="utf-8").replace("version: 1", "version: 2", 1)
+    md_path.write_text(tampered, encoding="utf-8")
+    with pytest.raises(ValueError, match="frontmatter declares version"):
+        store.read_competition_protocol(tmp_path, "nationals")
diff --git a/tests/programs/test_render_protocol_html.py b/tests/programs/test_render_protocol_html.py
index 136fc08..f689b04 100644
--- a/tests/programs/test_render_protocol_html.py
+++ b/tests/programs/test_render_protocol_html.py
@@ -71,7 +71,7 @@ def test_page_is_selfcontained_and_scriptless():
 
 def test_event_day_open_warnings_and_sources_rendered():
     page = render_protocol_html(_protocol(), citations=CITATIONS)
-    assert "<details" in page and "open" in page
+    assert '<details class="day" open>' in page
     assert "⚠" in page
     assert "Dehydration risk" in page
     assert "★★★★★" in page
@@ -79,6 +79,44 @@ def test_event_day_open_warnings_and_sources_rendered():
     assert "[1]" in page
 
 
+def test_unresolved_citation_id_is_skipped_from_numbering():
+    protocol = _protocol().model_copy(
+        update={
+            "days": [
+                ProtocolDay(
+                    day_offset=0,
+                    title="Race day",
+                    lines=[
+                        ProtocolLine(text="Missing source.", cite="missing-id"),
+                        ProtocolLine(text="Known source.", cite="carb-2017"),
+                    ],
+                )
+            ]
+        }
+    )
+    page = render_protocol_html(protocol, citations=CITATIONS)
+    assert "Missing source.</li>" in page  # no <sup class="cite"> marker attached
+    assert 'Known source.<sup class="cite">[1]</sup>' in page
+    assert page.count('<li><span class="stars">') == 1
+
+
+def test_line_text_is_escaped():
+    protocol = _protocol().model_copy(
+        update={
+            "days": [
+                ProtocolDay(
+                    day_offset=0,
+                    title="Race day",
+                    lines=[ProtocolLine(text="<b>&bold</b>")],
+                )
+            ]
+        }
+    )
+    page = render_protocol_html(protocol)
+    assert "<b>&bold</b>" not in page
+    assert "&lt;b&gt;&amp;bold&lt;/b&gt;" in page
+
+
 def test_french_labels():
     page = render_protocol_html(_protocol(), locale="fr", citations=CITATIONS)
     assert "Jour J" in page

From ddf365e6caba7cf9b8b1dd378987dd40c9ca3673 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 23:32:12 +0200
Subject: [PATCH 13/25] Add the five pre-competition MCP tools

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/performance_agent/server/app.py           |   2 +
 .../server/competition_tools.py               | 158 ++++++++++++++++++
 tests/server/test_competition_tools.py        |  81 +++++++++
 3 files changed, 241 insertions(+)
 create mode 100644 src/performance_agent/server/competition_tools.py
 create mode 100644 tests/server/test_competition_tools.py

diff --git a/src/performance_agent/server/app.py b/src/performance_agent/server/app.py
index d8a8f23..2f729fc 100644
--- a/src/performance_agent/server/app.py
+++ b/src/performance_agent/server/app.py
@@ -5,6 +5,7 @@
 from performance_agent.exercises.dataset import start_background_sync
 from performance_agent.server import (
     autoregulation_tools,
+    competition_tools,
     document_tools,
     engine_tools,
     evidence_tools,
@@ -33,6 +34,7 @@
 macro_tools.register(mcp)
 document_tools.register(mcp)
 followup_tools.register(mcp)
+competition_tools.register(mcp)
 
 
 def main() -> None:
diff --git a/src/performance_agent/server/competition_tools.py b/src/performance_agent/server/competition_tools.py
new file mode 100644
index 0000000..7f4596d
--- /dev/null
+++ b/src/performance_agent/server/competition_tools.py
@@ -0,0 +1,158 @@
+"""MCP tools for the pre-competition protocol.
+
+Engine numbers are quoted, never renegotiated upward; the athlete may always
+choose the more conservative option. The save gate resolves every citation id
+against the corpus — an unknown id aborts before anything is written.
+"""
+
+from dataclasses import asdict
+from typing import Any, TypedDict
+
+from mcp.server.fastmcp import FastMCP
+
+from performance_agent.engine import competition as competition_engine
+from performance_agent.evidence.citations import resolve_citations
+from performance_agent.memory import store
+from performance_agent.memory.paths import resolve_athlete_dir
+from performance_agent.memory.schemas import CompetitionProtocol
+from performance_agent.programs.render_protocol import protocol_citation_ids
+from performance_agent.programs.render_protocol_html import render_protocol_html
+
+
+class AttemptView(TypedDict):
+    """Meet-day attempts for one lift, engine-computed."""
+
+    lift: str
+    e1rm_kg: float
+    opener_kg: float
+    second_kg: float
+    third_kg: float
+    flags: list[str]
+
+
+class ProtocolSaved(TypedDict):
+    """Result of writing a protocol version (markdown + phone page)."""
+
+    path: str
+    version: int
+    html_path: str
+
+
+class ProtocolView(TypedDict):
+    """A stored protocol version: structured plan plus rendered markdown."""
+
+    version: int
+    event_id: str
+    goal_id: str
+    created_on: str
+    reason: str | None
+    markdown: str
+    protocol: dict[str, Any]
+
+
+def carb_loading_targets(body_mass_kg: float, event_duration_min: float) -> dict[str, Any]:
+    """Carb-loading and in-race fueling ranges for an event (evidence-based).
+
+    Events >= 90 min: 8-12 g/kg/day over the final 48 h; 60-90 min: 6-8 g/kg/day
+    over 24 h; shorter: loading_required=false (say so, don't invent a load).
+    In-race: none under 60 min, 30-60 g/h up to ~2.5 h, 60-90 g/h beyond. Quote
+    the ranges as ranges — food choices and timing are coaching conversation.
+    """
+    return asdict(competition_engine.carb_loading_targets(body_mass_kg, event_duration_min))
+
+
+def select_attempts(
+    lift: str, e1rm_kg: float, goal_kg: float, rounding_kg: float = 2.5
+) -> AttemptView:
+    """Three meet-day attempts from the e1RM (get it from estimate_1rm first).
+
+    Opener ~91% (a confident triple), second ~96%, third at the goal when it
+    lies within 93-105% of e1RM — else ~101% with flag goal_beyond_e1rm (or
+    goal_below_e1rm_range on the low side): name the gap honestly, never
+    pretend the goal is on the bar. The athlete may always call lighter
+    attempts; never push heavier than the engine's numbers.
+    """
+    selection = competition_engine.select_attempts(e1rm_kg, goal_kg, rounding_kg)
+    return AttemptView(
+        lift=lift,
+        e1rm_kg=e1rm_kg,
+        opener_kg=selection.opener_kg,
+        second_kg=selection.second_kg,
+        third_kg=selection.third_kg,
+        flags=list(selection.flags),
+    )
+
+
+def pacing_plan(
+    distance_m: float,
+    target_time_s: float,
+    segment_m: float = 1000.0,
+    strategy: str = "even",
+) -> list[dict[str, Any]]:
+    """Per-segment target paces and cumulative splits for a race plan.
+
+    target_time_s comes from the athlete's goal or predict_race_time — this
+    only distributes it. strategy 'even' or 'negative' (first half ~1% slower,
+    second half balanced so the total lands on target).
+    """
+    return [
+        asdict(split)
+        for split in competition_engine.pacing_plan(distance_m, target_time_s, segment_m, strategy)
+    ]
+
+
+def save_competition_protocol(
+    protocol: CompetitionProtocol, reason: str | None = None
+) -> ProtocolSaved:
+    """Write the NEXT protocol version for its event (immutable audit trail).
+
+    The event must exist in the calendar with a matching, non-past date.
+    Version 1 needs no reason; v2+ requires one naming the trigger. Every cite
+    (advice, day lines, fueling, practices) must be a real corpus id — an
+    unknown id aborts the save (anti-fabrication). Every documented practice
+    carries its warning by schema. Alongside the markdown, a standalone phone
+    page is written — hand that file to the athlete for the event.
+    MANDATORY: pass the draft through program-review's protocol gate BEFORE
+    saving; only an APPROVED verdict saves.
+    """
+    base = resolve_athlete_dir()
+    citations = resolve_citations(protocol_citation_ids(protocol))
+    path, version = store.save_competition_protocol(base, protocol, reason, citations=citations)
+    stored = store.read_competition_protocol(base, protocol.event_id, version)
+    if stored is None:  # pragma: no cover - just written above
+        msg = f"protocol v{version} vanished after save"
+        raise ValueError(msg)
+    locale = store.read_profile(base).locale
+    page = render_protocol_html(stored.protocol, locale=locale, citations=citations)
+    html_path = path.with_suffix(".html")
+    html_path.write_text(page, encoding="utf-8")
+    return ProtocolSaved(path=str(path), version=version, html_path=str(html_path))
+
+
+def read_competition_protocol(event_id: str, version: int | None = None) -> ProtocolView:
+    """Return the latest (or a specific) protocol version for an event."""
+    stored = store.read_competition_protocol(resolve_athlete_dir(), event_id, version)
+    if stored is None:
+        msg = f"no protocol saved for event {event_id!r}; save_competition_protocol first"
+        raise ValueError(msg)
+    return ProtocolView(
+        version=stored.version,
+        event_id=stored.event_id,
+        goal_id=stored.goal_id,
+        created_on=stored.created_on,
+        reason=stored.reason,
+        markdown=stored.markdown,
+        protocol=stored.protocol.model_dump(mode="json"),
+    )
+
+
+def register(mcp: FastMCP) -> None:
+    """Register the competition tools on the server."""
+    for tool in (
+        carb_loading_targets,
+        select_attempts,
+        pacing_plan,
+        save_competition_protocol,
+        read_competition_protocol,
+    ):
+        mcp.tool()(tool)
diff --git a/tests/server/test_competition_tools.py b/tests/server/test_competition_tools.py
new file mode 100644
index 0000000..daa31be
--- /dev/null
+++ b/tests/server/test_competition_tools.py
@@ -0,0 +1,81 @@
+"""MCP wrappers for the pre-competition protocol."""
+
+from datetime import date
+from pathlib import Path
+
+import pytest
+
+from performance_agent.memory import store
+from performance_agent.memory.schemas import (
+    CalendarEvent,
+    CompetitionProtocol,
+    Guidance,
+    Profile,
+    ProtocolDay,
+    ProtocolLine,
+)
+from performance_agent.server import competition_tools
+
+TODAY = date.today()
+
+
+@pytest.fixture
+def athlete_dir(monkeypatch, tmp_path):
+    monkeypatch.setenv("PERFORMANCE_AGENT_HOME", str(tmp_path))
+    store.write_profile(tmp_path, Profile())
+    store.upsert_calendar_event(
+        tmp_path,
+        CalendarEvent(
+            id="nationals",
+            date=TODAY.replace(year=TODAY.year + 1),
+            kind="competition",
+            priority="A",
+            label="Nationals",
+        ),
+    )
+    return tmp_path
+
+
+def _protocol(**overrides):
+    fields = {
+        "version": 1,
+        "event_id": "nationals",
+        "event_date": TODAY.replace(year=TODAY.year + 1),
+        "goal_id": "sub-40-10k",
+        "created_on": TODAY,
+        "window_days": 7,
+        "days": [ProtocolDay(day_offset=0, title="Race", lines=[ProtocolLine(text="Warm up.")])],
+    }
+    fields.update(overrides)
+    return CompetitionProtocol.model_validate(fields)
+
+
+def test_engine_wrappers_quote_engine_numbers(athlete_dir):  # noqa: ARG001 - fixture side effect
+    carbs = competition_tools.carb_loading_targets(70.0, 180.0)
+    assert carbs["carb_g_per_day_high"] == 840.0
+    attempts = competition_tools.select_attempts("Squat", 200.0, 205.0)
+    assert attempts["lift"] == "Squat"
+    assert attempts["third_kg"] == 205.0
+    splits = competition_tools.pacing_plan(10000.0, 2400.0)
+    assert len(splits) == 10
+
+
+def test_save_renders_html_and_read_roundtrips(athlete_dir):  # noqa: ARG001 - fixture side effect
+    result = competition_tools.save_competition_protocol(_protocol())
+    assert result["version"] == 1
+    page = Path(result["html_path"]).read_text(encoding="utf-8")
+    assert "<script" not in page
+    view = competition_tools.read_competition_protocol("nationals")
+    assert view["version"] == 1
+    assert view["protocol"]["event_id"] == "nationals"
+
+
+def test_save_rejects_unknown_citation(athlete_dir):  # noqa: ARG001 - fixture side effect
+    protocol = _protocol(advice=[Guidance(text="Fake.", cite="phantom-id")])
+    with pytest.raises(ValueError, match="phantom-id"):
+        competition_tools.save_competition_protocol(protocol)
+
+
+def test_read_without_protocol_raises(athlete_dir):  # noqa: ARG001 - fixture side effect
+    with pytest.raises(ValueError, match="no protocol"):
+        competition_tools.read_competition_protocol("nationals")

From 7d37e5eccab897b0b50a8fda64036e904c4f63aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 23:35:49 +0200
Subject: [PATCH 14/25] Surface the competition-protocol due action

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/performance_agent/engine/diligence.py    | 26 +++++++-
 src/performance_agent/memory/diligence.py    | 38 ++++++++----
 src/performance_agent/server/memory_tools.py |  5 +-
 tests/engine/test_diligence.py               | 62 ++++++++++++++++++++
 tests/memory/test_diligence.py               | 16 +++++
 5 files changed, 133 insertions(+), 14 deletions(-)

diff --git a/src/performance_agent/engine/diligence.py b/src/performance_agent/engine/diligence.py
index 950b671..708021f 100644
--- a/src/performance_agent/engine/diligence.py
+++ b/src/performance_agent/engine/diligence.py
@@ -36,17 +36,25 @@
 # a running program deserves a watch pass every two weeks (team-chosen priors).
 _LOADS_REVIEW_DUE_DAYS = 6
 _WATCH_DUE_DAYS = 14
+# Inside a week of the event, a missing protocol is urgent.
+_PROTOCOL_URGENT_DAYS = 7
 
 _SEVERITY_RANK: dict[Severity, int] = {"high": 0, "medium": 1, "low": 2}
 
 
 @dataclass(frozen=True)
 class UpcomingEvent:
-    """A dated A/B event within the follow-up horizon, in whole days from today."""
+    """A dated A/B event within the follow-up horizon, in whole days from today.
+
+    protocol_window_days is the taper-derived due window for a pre-competition
+    protocol; has_protocol says whether one exists for this event.
+    """
 
     event_id: str
     priority: str  # "A" or "B"
     days_until: int
+    protocol_window_days: int = 0
+    has_protocol: bool = True
 
 
 @dataclass(frozen=True)
@@ -193,6 +201,21 @@ def _watch_action(facts: DiligenceFacts) -> DueAction | None:
     )
 
 
+def _protocol_action(event: UpcomingEvent) -> DueAction | None:
+    if event.has_protocol or event.protocol_window_days <= 0:
+        return None
+    if event.days_until > event.protocol_window_days:
+        return None
+    severity: Severity = "high" if event.days_until <= _PROTOCOL_URGENT_DAYS else "medium"
+    return DueAction(
+        "competition_protocol",
+        severity,
+        "competition_protocol_due",
+        due_in_days=event.days_until,
+        ref=event.event_id,
+    )
+
+
 def _sort_key(action: DueAction) -> tuple[int, int, str, str]:
     # Severity first; then most urgent (soonest upcoming, longest overdue); then a
     # stable tiebreak on kind + ref so the order is fully deterministic.
@@ -223,6 +246,7 @@ def list_due_actions(facts: DiligenceFacts) -> list[DueAction]:
         _watch_action(facts),
     ]
     candidates.extend(_event_action(event) for event in facts.upcoming_events)
+    candidates.extend(_protocol_action(event) for event in facts.upcoming_events)
     actions = [action for action in candidates if action is not None]
     return sorted(actions, key=_sort_key)
 
diff --git a/src/performance_agent/memory/diligence.py b/src/performance_agent/memory/diligence.py
index a9d3d16..fbe9a7a 100644
--- a/src/performance_agent/memory/diligence.py
+++ b/src/performance_agent/memory/diligence.py
@@ -12,14 +12,16 @@
 
 from datetime import date
 from pathlib import Path
-from typing import TypedDict
+from typing import TypedDict, cast
 
+from performance_agent.engine.competition import protocol_window_days
 from performance_agent.engine.diligence import (
     DiligenceFacts,
     UpcomingEvent,
 )
 from performance_agent.engine.diligence import list_due_actions as list_due_actions_engine
 from performance_agent.engine.load import readiness_score
+from performance_agent.engine.season import EventPriority, recommend_taper_length
 from performance_agent.memory import store, weekly_review
 from performance_agent.memory.schemas import ProgramPlan, ReadinessEntry
 from performance_agent.memory.time_context import TimeContext, build_time_context
@@ -29,6 +31,10 @@
 _MISSED_WINDOW_DAYS = 7
 _READINESS_WINDOW_DAYS = 14
 _EVENT_HORIZON_DAYS = 21
+# The due-action window uses the population mixed-modality taper prior — no
+# per-athlete modality is persisted; the skill computes the individualized
+# window (recommend_taper) when it actually authors the protocol.
+_NEUTRAL_BUILDUP_WEEKS = 8
 
 
 class DueActionView(TypedDict):
@@ -151,16 +157,26 @@ def _days_since_watch_anchor(base_dir: Path, current: date) -> int | None:
     return (current - anchor).days
 
 
-def _upcoming_events(context: TimeContext) -> tuple[UpcomingEvent, ...]:
-    events = [
-        UpcomingEvent(
-            event_id=event["event_id"],
-            priority=event["priority"],
-            days_until=event["days_until"],
+def _upcoming_events(base_dir: Path, context: TimeContext) -> tuple[UpcomingEvent, ...]:
+    events = []
+    for event in context["next_events"]:
+        if (
+            event["priority"] not in ("A", "B")
+            or not 0 <= event["days_until"] <= _EVENT_HORIZON_DAYS
+        ):
+            continue
+        priority = cast(EventPriority, event["priority"])
+        taper_days = recommend_taper_length(_NEUTRAL_BUILDUP_WEEKS, "mixed", priority)
+        events.append(
+            UpcomingEvent(
+                event_id=event["event_id"],
+                priority=priority,
+                days_until=event["days_until"],
+                protocol_window_days=protocol_window_days(taper_days, priority),
+                has_protocol=store.latest_competition_protocol_version(base_dir, event["event_id"])
+                is not None,
+            )
         )
-        for event in context["next_events"]
-        if event["priority"] in ("A", "B") and 0 <= event["days_until"] <= _EVENT_HORIZON_DAYS
-    ]
     return tuple(events)
 
 
@@ -173,7 +189,7 @@ def _build_facts(base_dir: Path, current: date) -> DiligenceFacts:
         has_program=program is not None,
         checkin_cadence_days=cadence,
         days_since_checkin=context["days_since_last_checkin"],
-        upcoming_events=_upcoming_events(context),
+        upcoming_events=_upcoming_events(base_dir, context),
         missed_session_count=_missed_session_count(base_dir, plan, current),
         days_since_last_session=context["days_since_last_session"],
         training_days_without_readiness=_training_days_without_readiness(base_dir, current),
diff --git a/src/performance_agent/server/memory_tools.py b/src/performance_agent/server/memory_tools.py
index 9db8397..0dce79e 100644
--- a/src/performance_agent/server/memory_tools.py
+++ b/src/performance_agent/server/memory_tools.py
@@ -581,8 +581,9 @@ def list_due_actions() -> list[DueActionView]:
     (taper/peaking about to start), planned sessions missed this week, three-plus
     training days with no readiness read, an active goal whose deadline has no dated
     events, a response profile older than six weeks, a streak of red readiness
-    days, a finished training week that never got its loads review, and a program
-    unaudited for two weeks (program watch).
+    days, a finished training week that never got its loads review, a program
+    unaudited for two weeks (program watch), and an A/B event inside its protocol
+    window with no pre-competition protocol saved.
     Each action is {kind, severity, due_since_days|due_in_days, message_key,
     ref}; render the message_key yourself in the athlete's language and quote the
     numbers. An all-green athlete returns []. Severity is high, medium or low.
diff --git a/tests/engine/test_diligence.py b/tests/engine/test_diligence.py
index c7d0e81..f54c163 100644
--- a/tests/engine/test_diligence.py
+++ b/tests/engine/test_diligence.py
@@ -192,3 +192,65 @@ def test_program_watch_quiet_when_recent_or_no_program():
     for facts in (recent, no_program):
         kinds = {action.kind for action in list_due_actions(facts)}
         assert "program_watch" not in kinds
+
+
+def test_competition_protocol_due_inside_window_without_protocol():
+    facts = _facts(
+        upcoming_events=(
+            UpcomingEvent(
+                event_id="nationals",
+                priority="A",
+                days_until=8,
+                protocol_window_days=10,
+                has_protocol=False,
+            ),
+        )
+    )
+    action = next(a for a in list_due_actions(facts) if a.kind == "competition_protocol")
+    assert action.severity == "medium"
+    assert action.due_in_days == 8
+    assert action.ref == "nationals"
+
+
+def test_competition_protocol_high_when_event_is_close():
+    facts = _facts(
+        upcoming_events=(
+            UpcomingEvent(
+                event_id="nationals",
+                priority="A",
+                days_until=5,
+                protocol_window_days=10,
+                has_protocol=False,
+            ),
+        )
+    )
+    action = next(a for a in list_due_actions(facts) if a.kind == "competition_protocol")
+    assert action.severity == "high"
+
+
+def test_competition_protocol_quiet_outside_window_or_covered():
+    outside = _facts(
+        upcoming_events=(
+            UpcomingEvent(
+                event_id="nationals",
+                priority="A",
+                days_until=15,
+                protocol_window_days=10,
+                has_protocol=False,
+            ),
+        )
+    )
+    covered = _facts(
+        upcoming_events=(
+            UpcomingEvent(
+                event_id="nationals",
+                priority="A",
+                days_until=5,
+                protocol_window_days=10,
+                has_protocol=True,
+            ),
+        )
+    )
+    for facts in (outside, covered):
+        kinds = {a.kind for a in list_due_actions(facts)}
+        assert "competition_protocol" not in kinds
diff --git a/tests/memory/test_diligence.py b/tests/memory/test_diligence.py
index 344eeb0..b101f9e 100644
--- a/tests/memory/test_diligence.py
+++ b/tests/memory/test_diligence.py
@@ -176,3 +176,19 @@ def test_actions_sorted_by_severity(tmp_path):
     save_response_profile(tmp_path, ResponseProfile(as_of=TODAY), today=TODAY - timedelta(days=60))
     severities = [a["severity"] for a in list_due_actions(tmp_path, today=TODAY)]
     assert severities == sorted(severities, key=["high", "medium", "low"].index)
+
+
+def test_a_event_without_protocol_surfaces_competition_protocol(tmp_path):
+    upsert_calendar_event(
+        tmp_path,
+        CalendarEvent(
+            id="nationals",
+            date=TODAY + timedelta(days=6),
+            kind="competition",
+            priority="A",
+            label="Nationals",
+        ),
+    )
+    action = _action(tmp_path, "competition_protocol")
+    assert action["ref"] == "nationals"
+    assert action["due_in_days"] == 6

From dbc5b45295e99f8f4f306d67c69dd947ddbcff76 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 23:46:24 +0200
Subject: [PATCH 15/25] Type the competition tool outputs and harden the page
 write

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../server/competition_tools.py               | 66 ++++++++++++++++---
 1 file changed, 57 insertions(+), 9 deletions(-)

diff --git a/src/performance_agent/server/competition_tools.py b/src/performance_agent/server/competition_tools.py
index 7f4596d..3489d25 100644
--- a/src/performance_agent/server/competition_tools.py
+++ b/src/performance_agent/server/competition_tools.py
@@ -5,8 +5,8 @@
 against the corpus — an unknown id aborts before anything is written.
 """
 
-from dataclasses import asdict
-from typing import Any, TypedDict
+import os
+from typing import Any, Literal, TypedDict
 
 from mcp.server.fastmcp import FastMCP
 
@@ -19,6 +19,19 @@
 from performance_agent.programs.render_protocol_html import render_protocol_html
 
 
+class CarbTargetsView(TypedDict):
+    """Evidence-based carbohydrate targets for the final window and the race."""
+
+    loading_required: bool
+    carb_g_per_kg_low: float | None
+    carb_g_per_kg_high: float | None
+    carb_g_per_day_low: float | None
+    carb_g_per_day_high: float | None
+    window_hours: int | None
+    race_carb_g_per_h_low: float | None
+    race_carb_g_per_h_high: float | None
+
+
 class AttemptView(TypedDict):
     """Meet-day attempts for one lift, engine-computed."""
 
@@ -30,6 +43,15 @@ class AttemptView(TypedDict):
     flags: list[str]
 
 
+class PacingSplitView(TypedDict):
+    """One race segment: its target pace and the cumulative time at its end."""
+
+    label: str
+    distance_m: float
+    target_pace_s_per_km: float
+    cumulative_time_s: float
+
+
 class ProtocolSaved(TypedDict):
     """Result of writing a protocol version (markdown + phone page)."""
 
@@ -50,7 +72,7 @@ class ProtocolView(TypedDict):
     protocol: dict[str, Any]
 
 
-def carb_loading_targets(body_mass_kg: float, event_duration_min: float) -> dict[str, Any]:
+def carb_loading_targets(body_mass_kg: float, event_duration_min: float) -> CarbTargetsView:
     """Carb-loading and in-race fueling ranges for an event (evidence-based).
 
     Events >= 90 min: 8-12 g/kg/day over the final 48 h; 60-90 min: 6-8 g/kg/day
@@ -58,7 +80,17 @@ def carb_loading_targets(body_mass_kg: float, event_duration_min: float) -> dict
     In-race: none under 60 min, 30-60 g/h up to ~2.5 h, 60-90 g/h beyond. Quote
     the ranges as ranges — food choices and timing are coaching conversation.
     """
-    return asdict(competition_engine.carb_loading_targets(body_mass_kg, event_duration_min))
+    targets = competition_engine.carb_loading_targets(body_mass_kg, event_duration_min)
+    return CarbTargetsView(
+        loading_required=targets.loading_required,
+        carb_g_per_kg_low=targets.carb_g_per_kg_low,
+        carb_g_per_kg_high=targets.carb_g_per_kg_high,
+        carb_g_per_day_low=targets.carb_g_per_day_low,
+        carb_g_per_day_high=targets.carb_g_per_day_high,
+        window_hours=targets.window_hours,
+        race_carb_g_per_h_low=targets.race_carb_g_per_h_low,
+        race_carb_g_per_h_high=targets.race_carb_g_per_h_high,
+    )
 
 
 def select_attempts(
@@ -87,8 +119,8 @@ def pacing_plan(
     distance_m: float,
     target_time_s: float,
     segment_m: float = 1000.0,
-    strategy: str = "even",
-) -> list[dict[str, Any]]:
+    strategy: Literal["even", "negative"] = "even",
+) -> list[PacingSplitView]:
     """Per-segment target paces and cumulative splits for a race plan.
 
     target_time_s comes from the athlete's goal or predict_race_time — this
@@ -96,7 +128,12 @@ def pacing_plan(
     second half balanced so the total lands on target).
     """
     return [
-        asdict(split)
+        PacingSplitView(
+            label=split.label,
+            distance_m=split.distance_m,
+            target_pace_s_per_km=split.target_pace_s_per_km,
+            cumulative_time_s=split.cumulative_time_s,
+        )
         for split in competition_engine.pacing_plan(distance_m, target_time_s, segment_m, strategy)
     ]
 
@@ -123,9 +160,20 @@ def save_competition_protocol(
         msg = f"protocol v{version} vanished after save"
         raise ValueError(msg)
     locale = store.read_profile(base).locale
-    page = render_protocol_html(stored.protocol, locale=locale, citations=citations)
     html_path = path.with_suffix(".html")
-    html_path.write_text(page, encoding="utf-8")
+    tmp_path = html_path.with_suffix(".html.tmp")
+    try:
+        page = render_protocol_html(stored.protocol, locale=locale, citations=citations)
+        tmp_path.write_text(page, encoding="utf-8")
+        os.replace(tmp_path, html_path)
+    except OSError as exc:
+        tmp_path.unlink(missing_ok=True)
+        msg = (
+            f"protocol v{version} was saved, but writing the phone page failed at "
+            f"{html_path}: {exc}; fix the filesystem issue and re-save as v{version + 1} "
+            "with a reason"
+        )
+        raise ValueError(msg) from exc
     return ProtocolSaved(path=str(path), version=version, html_path=str(html_path))
 
 

From ef44cb8fed63ba19ee6a045eff544d8e2ad074cf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 23:48:49 +0200
Subject: [PATCH 16/25] Cover the phone-page write failure path

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 tests/server/test_competition_tools.py | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/tests/server/test_competition_tools.py b/tests/server/test_competition_tools.py
index daa31be..ee77653 100644
--- a/tests/server/test_competition_tools.py
+++ b/tests/server/test_competition_tools.py
@@ -2,6 +2,7 @@
 
 from datetime import date
 from pathlib import Path
+from types import SimpleNamespace
 
 import pytest
 
@@ -79,3 +80,21 @@ def test_save_rejects_unknown_citation(athlete_dir):  # noqa: ARG001 - fixture s
 def test_read_without_protocol_raises(athlete_dir):  # noqa: ARG001 - fixture side effect
     with pytest.raises(ValueError, match="no protocol"):
         competition_tools.read_competition_protocol("nationals")
+
+
+def test_save_survives_when_html_write_fails(athlete_dir, monkeypatch):
+    def raiser(*_args, **_kwargs):
+        raise OSError("disk full")
+
+    # store.save_competition_protocol also calls os.replace internally (its own
+    # atomic write of the md/yaml) via the SAME os module object, so patching
+    # os.replace globally would fail the store write instead of the html write
+    # this test targets. Rebinding the `os` name inside competition_tools'
+    # namespace scopes the failure to this module's own os.replace call.
+    monkeypatch.setattr(competition_tools, "os", SimpleNamespace(replace=raiser))
+    with pytest.raises(ValueError, match=r"protocol v1 was saved"):
+        competition_tools.save_competition_protocol(_protocol())
+    protocol_dir = athlete_dir / "competition"
+    assert (protocol_dir / "protocol-nationals-v1.md").exists()
+    assert (protocol_dir / "protocol-nationals-v1.yaml").exists()
+    assert not (protocol_dir / "protocol-nationals-v1.html").exists()

From 58de33b8f401735e10e64be376622d28c19b7684 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 23:51:17 +0200
Subject: [PATCH 17/25] Add pre-competition skill

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 skills/pre-competition/SKILL.md | 47 +++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 skills/pre-competition/SKILL.md

diff --git a/skills/pre-competition/SKILL.md b/skills/pre-competition/SKILL.md
new file mode 100644
index 0000000..aeaaa0a
--- /dev/null
+++ b/skills/pre-competition/SKILL.md
@@ -0,0 +1,47 @@
+---
+name: pre-competition
+description: Use when a competition_protocol due action fires or the athlete says
+  their competition is coming up. Authors the per-event, day-by-day protocol for
+  the final days (J-N to J0) and delivers the phone page for the event.
+tools: [read_athlete, get_time_context, read_calendar, read_program,
+  read_research_dossier, recommend_taper, predict_race_time, estimate_1rm,
+  carb_loading_targets, select_attempts, pacing_plan, get_citation,
+  save_competition_protocol, log_kpi_result,
+  fit_taper_response]
+---
+
+# Pre-competition
+
+The protocol author: the final days before a competition, planned day by day and
+handed over as a phone page the athlete reads on the morning of the event. Sport
+comes from the research, numbers come from the engine, and this skill NEVER
+edits the program — taper structure changes route to program-adaptation.
+
+## Ritual
+
+1. Open with `read_athlete` + `get_time_context` (quote its dates) and
+   `read_calendar`; name the event, its priority, and days until. `read_program`
+   for the planned taper; sanity-check it against `recommend_taper` (say the
+   basis — individual or population).
+2. First protocol for this event → run the dedicated mini-wave (deep-research
+   rules): ONE question — "the final days before [this event] for [this
+   athlete]" — verified studies join the corpus, the dossier gets a v+1.
+   `read_research_dossier` for what is already known.
+3. Build the day-by-day plan from J-window to J0, engine first:
+   - Endurance: target from the goal or `predict_race_time`; `pacing_plan` for
+     the splits; `carb_loading_targets` for fueling (quote ranges as ranges).
+   - Strength: e1RM via `estimate_1rm` (recent best sets); `select_attempts`
+     per lift. `goal_beyond_e1rm` flag → name the gap honestly; the athlete may
+     call lighter, never heavier than the engine's numbers.
+   - Everything else (meal timing, warm-up, logistics, checklist) is advice:
+     cited (`get_citation`) or plainly labeled coaching judgment.
+4. Documented practices (peak-week water/sodium, weight-cut tactics): describe
+   ONLY what the literature documents, each with its evidence grade and an
+   explicit warning — never a dose, never a schedule, never engine math. Red
+   flags and medical conditions keep precedence: refer out.
+5. Walk the draft through with the athlete, then submit it to program-review's
+   protocol gate. Only an APPROVED verdict saves: `save_competition_protocol`
+   (v2+ reason = the trigger). Hand the athlete the html_path — that page is
+   their event-day companion.
+6. Day J-0 to J+2: route the debrief to training-checkin and log the result
+   with `log_kpi_result` — the outcome feeds fit_taper_response for next time.

From 08eaf4338c3d9ef74507543624fc596e9b3fe590 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Fri, 17 Jul 2026 23:53:31 +0200
Subject: [PATCH 18/25] Wire the pre-competition protocol into the skills

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 skills/deep-research/SKILL.md     |  4 +++-
 skills/performance-coach/SKILL.md |  2 ++
 skills/pre-competition/SKILL.md   |  4 ++--
 skills/program-review/SKILL.md    |  6 ++++++
 skills/session-day/SKILL.md       |  7 ++++++-
 skills/training-checkin/SKILL.md  |  7 +++++++
 tests/skills/test_structure.py    | 24 ++++++++++++++++++++++++
 7 files changed, 50 insertions(+), 4 deletions(-)

diff --git a/skills/deep-research/SKILL.md b/skills/deep-research/SKILL.md
index baf3edc..7e749fc 100644
--- a/skills/deep-research/SKILL.md
+++ b/skills/deep-research/SKILL.md
@@ -131,7 +131,9 @@ live queries in English + the athlete's locale (+1 language if thin), same
 verification and save rules, folded into the dossier as v+1 whose reason names
 the trigger, with a "what changed vs v{N}" section. Program-adaptation runs
 mini-waves for substantive triggers; run one directly when the athlete drops a
-document or asks a question that touches one facet.
+document or asks a question that touches one facet. The pre-competition wave is
+a mini-wave whose single question is the final days before a named event (taper
+execution, fueling, pacing or attempts, weigh-in).
 
 The **incremental watch** (each mesocycle boundary, routed by training-checkin):
 replay the dossier facets' queries with `year_from` set to the current dossier's
diff --git a/skills/performance-coach/SKILL.md b/skills/performance-coach/SKILL.md
index 5f403c9..698f719 100644
--- a/skills/performance-coach/SKILL.md
+++ b/skills/performance-coach/SKILL.md
@@ -100,6 +100,8 @@ After a skill hands back:
   action fires → **next-week-loads**.
 - Two weeks since the last audit, a mesocycle boundary, or "is this program
   still right?" → **program-watch** (run it as a subagent; bring back verdicts).
+- competition_protocol action fires, or "my competition is in N days" →
+  **pre-competition** (authors the final-days protocol and the event-day page).
 
 Re-evaluate routing after each skill completes.
 
diff --git a/skills/pre-competition/SKILL.md b/skills/pre-competition/SKILL.md
index aeaaa0a..715d1c7 100644
--- a/skills/pre-competition/SKILL.md
+++ b/skills/pre-competition/SKILL.md
@@ -14,8 +14,8 @@ tools: [read_athlete, get_time_context, read_calendar, read_program,
 
 The protocol author: the final days before a competition, planned day by day and
 handed over as a phone page the athlete reads on the morning of the event. Sport
-comes from the research, numbers come from the engine, and this skill NEVER
-edits the program — taper structure changes route to program-adaptation.
+comes from the research, numbers come from the engine, and this skill
+NEVER edits the program — taper structure changes route to program-adaptation.
 
 ## Ritual
 
diff --git a/skills/program-review/SKILL.md b/skills/program-review/SKILL.md
index 7b0b863..10a3e6b 100644
--- a/skills/program-review/SKILL.md
+++ b/skills/program-review/SKILL.md
@@ -92,6 +92,12 @@ Work the list in order; every item is pass/fail with the evidence quoted.
 - Guidance honesty: every advice/rationale line either cites a corpus id
   (verify each with get_citation) or is phrased as coaching judgment; dosage
   claims without a cite are an objection.
+- Competition protocols (when the draft is a protocol, not a program): every
+  documented practice carries an evidence grade (verify cites with
+  get_citation) and an explicit warning; every engine-attributed number
+  (attempts, paces, carb targets) matches a tool recomputation; dehydration or
+  water-manipulation content stated as a computed or prescriptive line — rather
+  than a warned, graded practice — is an objection.
 
 ## 3. Pass two — ADVERSARIAL second opinion
 
diff --git a/skills/session-day/SKILL.md b/skills/session-day/SKILL.md
index 689cf45..077f6e9 100644
--- a/skills/session-day/SKILL.md
+++ b/skills/session-day/SKILL.md
@@ -5,7 +5,7 @@ description: Use when the athlete says they train tonight, now, or in an hour an
   hand. Adjusts the session in under a minute and never versions the program.
 tools: [read_athlete, get_time_context, read_program, read_readiness, compute_readiness,
   adjust_session, compress_session, substitute_exercise, log_session, log_session_adjustment,
-  read_session_adjustments]
+  read_session_adjustments, read_competition_protocol]
 ---
 
 # Session-day autoregulation
@@ -23,6 +23,11 @@ performance-coach ritual routes here.
 
 ## Protocol
 
+If today is an event day (J0) and a saved protocol exists
+(read_competition_protocol for the calendar event), open FROM the protocol page
+instead of improvising: quote its timeline, paces or attempts as written.
+Adjustments follow the protocol's fallbacks, never a rewrite an hour before.
+
 1. **Locate today's session.** From the session-start ritual you already ran
    `read_athlete` and `get_time_context`. Call `read_program` and pick today's
    `SessionPlan` by its weekday (or ask which of the day's sessions this is). If the
diff --git a/skills/training-checkin/SKILL.md b/skills/training-checkin/SKILL.md
index 0ecc569..cd386b1 100644
--- a/skills/training-checkin/SKILL.md
+++ b/skills/training-checkin/SKILL.md
@@ -199,6 +199,13 @@ first; (2) route to program-watch for the per-exercise audit. The
 loads_review and program_watch due actions surface both when overdue — treat
 them like any other due action: open with them.
 
+## Around a competition
+
+A competition_protocol due action routes to pre-competition. The first check-in
+AFTER an event owns the debrief: how it went vs the protocol, log the result
+with log_kpi_result (it feeds the individual taper response), and any pain or
+red flag follows the normal rules.
+
 ## Route
 
 - Any trigger above → its named destination (program-adaptation, or
diff --git a/tests/skills/test_structure.py b/tests/skills/test_structure.py
index 0a1abb2..f021d6f 100644
--- a/tests/skills/test_structure.py
+++ b/tests/skills/test_structure.py
@@ -15,6 +15,7 @@
     "session-day",
     "next-week-loads",
     "program-watch",
+    "pre-competition",
 }
 
 
@@ -53,6 +54,7 @@ def test_coach_skill_carries_the_global_rules(skills):
         "program-optimization",
         "nutrition-planning",
         "program-review",
+        "pre-competition",
     ):
         assert needle in body, f"coach skill lost the rule: {needle}"
 
@@ -171,6 +173,7 @@ def test_checkin_skill_protocol(skills):
         "stop prescribing",
         "list_athlete_documents",
         "mesocycle boundary",
+        "debrief",
     ):
         assert needle in body, f"checkin skill lost: {needle}"
 
@@ -251,6 +254,8 @@ def test_review_skill_protocol(skills):
         "verbatim",
         "program-planning",
         "program-optimization",
+        "protocol",
+        "warning",
     ):
         assert needle in body, f"program-review skill lost: {needle}"
 
@@ -325,3 +330,22 @@ def test_program_watch_skill_protocol(skills):
         "subagent",
     ):
         assert needle in body, f"program-watch skill lost: {needle}"
+
+
+def test_pre_competition_skill_protocol(skills):
+    precomp = next(s for s in skills if s.frontmatter["name"] == "pre-competition")
+    body = precomp.body.casefold()
+    for needle in (
+        "save_competition_protocol",
+        "carb_loading_targets",
+        "select_attempts",
+        "pacing_plan",
+        "recommend_taper",
+        "mini-wave",
+        "warning",
+        "program-review",
+        "never edits the program",
+        "log_kpi_result",
+        "coaching judgment",
+    ):
+        assert needle in body, f"pre-competition skill lost: {needle}"

From c7ae145445af6a08dc5a4337bfff22ee5306c635 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Sat, 18 Jul 2026 00:00:09 +0200
Subject: [PATCH 19/25] Read the existing protocol before authoring a v2

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 skills/pre-competition/SKILL.md | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/skills/pre-competition/SKILL.md b/skills/pre-competition/SKILL.md
index 715d1c7..31b4049 100644
--- a/skills/pre-competition/SKILL.md
+++ b/skills/pre-competition/SKILL.md
@@ -6,7 +6,7 @@ description: Use when a competition_protocol due action fires or the athlete say
 tools: [read_athlete, get_time_context, read_calendar, read_program,
   read_research_dossier, recommend_taper, predict_race_time, estimate_1rm,
   carb_loading_targets, select_attempts, pacing_plan, get_citation,
-  save_competition_protocol, log_kpi_result,
+  save_competition_protocol, read_competition_protocol, log_kpi_result,
   fit_taper_response]
 ---
 
@@ -23,11 +23,14 @@ NEVER edits the program — taper structure changes route to program-adaptation.
    `read_calendar`; name the event, its priority, and days until. `read_program`
    for the planned taper; sanity-check it against `recommend_taper` (say the
    basis — individual or population).
-2. First protocol for this event → run the dedicated mini-wave (deep-research
+2. If a protocol already exists for this event (`read_competition_protocol`),
+   read it first: the v2+ reason names what changed since v{N}, and unchanged
+   days carry forward rather than being reauthored.
+3. First protocol for this event → run the dedicated mini-wave (deep-research
    rules): ONE question — "the final days before [this event] for [this
    athlete]" — verified studies join the corpus, the dossier gets a v+1.
    `read_research_dossier` for what is already known.
-3. Build the day-by-day plan from J-window to J0, engine first:
+4. Build the day-by-day plan from J-window to J0, engine first:
    - Endurance: target from the goal or `predict_race_time`; `pacing_plan` for
      the splits; `carb_loading_targets` for fueling (quote ranges as ranges).
    - Strength: e1RM via `estimate_1rm` (recent best sets); `select_attempts`
@@ -35,13 +38,13 @@ NEVER edits the program — taper structure changes route to program-adaptation.
      call lighter, never heavier than the engine's numbers.
    - Everything else (meal timing, warm-up, logistics, checklist) is advice:
      cited (`get_citation`) or plainly labeled coaching judgment.
-4. Documented practices (peak-week water/sodium, weight-cut tactics): describe
+5. Documented practices (peak-week water/sodium, weight-cut tactics): describe
    ONLY what the literature documents, each with its evidence grade and an
    explicit warning — never a dose, never a schedule, never engine math. Red
    flags and medical conditions keep precedence: refer out.
-5. Walk the draft through with the athlete, then submit it to program-review's
+6. Walk the draft through with the athlete, then submit it to program-review's
    protocol gate. Only an APPROVED verdict saves: `save_competition_protocol`
    (v2+ reason = the trigger). Hand the athlete the html_path — that page is
    their event-day companion.
-6. Day J-0 to J+2: route the debrief to training-checkin and log the result
+7. Day J-0 to J+2: route the debrief to training-checkin and log the result
    with `log_kpi_result` — the outcome feeds fit_taper_response for next time.

From c504bf63e9a20f30467dba22da62e5719269b9d6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Sat, 18 Jul 2026 00:09:18 +0200
Subject: [PATCH 20/25] Make the review gate protocol-aware and complete the
 skill toolsets

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 skills/pre-competition/SKILL.md | 21 ++++++++------
 skills/program-review/SKILL.md  | 51 ++++++++++++++++++++-------------
 skills/session-day/SKILL.md     |  3 +-
 tests/skills/test_structure.py  |  4 ++-
 4 files changed, 49 insertions(+), 30 deletions(-)

diff --git a/skills/pre-competition/SKILL.md b/skills/pre-competition/SKILL.md
index 31b4049..3cc570e 100644
--- a/skills/pre-competition/SKILL.md
+++ b/skills/pre-competition/SKILL.md
@@ -7,7 +7,8 @@ tools: [read_athlete, get_time_context, read_calendar, read_program,
   read_research_dossier, recommend_taper, predict_race_time, estimate_1rm,
   carb_loading_targets, select_attempts, pacing_plan, get_citation,
   save_competition_protocol, read_competition_protocol, log_kpi_result,
-  fit_taper_response]
+  fit_taper_response, read_sessions, search_evidence, search_evidence_live,
+  save_evidence, verify_reference, save_research_dossier]
 ---
 
 # Pre-competition
@@ -28,14 +29,17 @@ NEVER edits the program — taper structure changes route to program-adaptation.
    days carry forward rather than being reauthored.
 3. First protocol for this event → run the dedicated mini-wave (deep-research
    rules): ONE question — "the final days before [this event] for [this
-   athlete]" — verified studies join the corpus, the dossier gets a v+1.
-   `read_research_dossier` for what is already known.
+   athlete]" — 2-3 `search_evidence_live` queries, each verified candidate
+   through `verify_reference` before `save_evidence`, folded into the dossier
+   via `save_research_dossier` as v+1. `read_research_dossier` for what is
+   already known.
 4. Build the day-by-day plan from J-window to J0, engine first:
    - Endurance: target from the goal or `predict_race_time`; `pacing_plan` for
      the splits; `carb_loading_targets` for fueling (quote ranges as ranges).
-   - Strength: e1RM via `estimate_1rm` (recent best sets); `select_attempts`
-     per lift. `goal_beyond_e1rm` flag → name the gap honestly; the athlete may
-     call lighter, never heavier than the engine's numbers.
+   - Strength: e1RM via `estimate_1rm` on the recent best sets from
+     `read_sessions`; `select_attempts` per lift. `goal_beyond_e1rm` flag →
+     name the gap honestly; the athlete may call lighter, never heavier than
+     the engine's numbers.
    - Everything else (meal timing, warm-up, logistics, checklist) is advice:
      cited (`get_citation`) or plainly labeled coaching judgment.
 5. Documented practices (peak-week water/sodium, weight-cut tactics): describe
@@ -46,5 +50,6 @@ NEVER edits the program — taper structure changes route to program-adaptation.
    protocol gate. Only an APPROVED verdict saves: `save_competition_protocol`
    (v2+ reason = the trigger). Hand the athlete the html_path — that page is
    their event-day companion.
-7. Day J-0 to J+2: route the debrief to training-checkin and log the result
-   with `log_kpi_result` — the outcome feeds fit_taper_response for next time.
+7. From the evening of J0 to J+2: route the debrief to training-checkin and
+   log the result with `log_kpi_result` — the outcome feeds fit_taper_response
+   for next time.
diff --git a/skills/program-review/SKILL.md b/skills/program-review/SKILL.md
index 10a3e6b..bfbee61 100644
--- a/skills/program-review/SKILL.md
+++ b/skills/program-review/SKILL.md
@@ -1,14 +1,17 @@
 ---
 name: program-review
 description: Use when program-optimization hands over an athlete-validated draft
-  program, or program-adaptation a confirmed v2+ proposal. The mandatory delivery
-  gate — a deterministic compliance pass, then an adversarial second opinion.
-  Verdict is APPROVED (program-optimization saves) or RETURNED with named,
-  quoted objections. Nothing is delivered without its sign-off.
+  program, program-adaptation a confirmed v2+ proposal, or pre-competition a
+  competition protocol draft. The mandatory delivery gate — a deterministic
+  compliance pass, then an adversarial second opinion. Verdict is APPROVED (the
+  originating skill — program-optimization, program-adaptation, or
+  pre-competition — saves) or RETURNED with named, quoted objections. Nothing
+  is delivered without its sign-off.
 tools: [read_athlete, get_time_context, read_analysis, read_research_dossier,
         read_nutrition_frame, check_citations, get_citation, prescribe_load,
         prescribe_reps_load, weekly_set_targets_for, compute_session_load,
-        read_program, read_calendar, check_week_sequencing]
+        read_program, read_calendar, check_week_sequencing, select_attempts,
+        pacing_plan, carb_loading_targets, estimate_1rm]
 ---
 
 # Program Review — le Contrôleur
@@ -29,12 +32,17 @@ lift_inventory, training_age), `get_time_context` (the window the draft
 claims), `read_analysis` (the feasibility verdict and its safe rates),
 `read_research_dossier` (the evidence the draft cites). The draft under review
 arrives in the conversation from program-optimization (or program-adaptation
-for a v2+ proposal). A missing brief is already a RETURN: a program that
-cannot be checked cannot be approved.
+for a v2+ proposal, or pre-competition for a competition protocol draft — read
+its event context: the competition, its priority, and days until). A missing
+brief is already a RETURN: a program that cannot be checked cannot be approved.
 
 ## 2. Pass one — COMPLIANCE (deterministic checklist)
 
 Work the list in order; every item is pass/fail with the evidence quoted.
+For a COMPETITION PROTOCOL draft (not a program), only item 2 (citations) and
+the guidance-honesty bullet apply, together with the competition-protocol
+bullet below — the program-structure items (plan present, sequencing,
+nutrition annex, calendar taper, load spot-checks) do not.
 
 1. **Every training number traces to an engine tool named in the draft's own
    justifications.** Spot-check by re-running the cited tools:
@@ -94,10 +102,11 @@ Work the list in order; every item is pass/fail with the evidence quoted.
   claims without a cite are an objection.
 - Competition protocols (when the draft is a protocol, not a program): every
   documented practice carries an evidence grade (verify cites with
-  get_citation) and an explicit warning; every engine-attributed number
-  (attempts, paces, carb targets) matches a tool recomputation; dehydration or
-  water-manipulation content stated as a computed or prescriptive line — rather
-  than a warned, graded practice — is an objection.
+  get_citation) and an explicit warning; every engine-attributed number is a
+  matched tool recomputation — attempts via select_attempts (from a fresh
+  estimate_1rm), paces via pacing_plan, carb targets via carb_loading_targets;
+  dehydration or water-manipulation content stated as a computed or
+  prescriptive line — rather than a warned, graded practice — is an objection.
 
 ## 3. Pass two — ADVERSARIAL second opinion
 
@@ -123,18 +132,20 @@ always quoting the objection verbatim so the fix targets the real problem.
 ## 4. Verdict — APPROVED or RETURNED, nothing else
 
 - **APPROVED:** state it, list what was checked (tools re-run, citations
-  clean, constraints verified, second opinion survived), and hand back to
-  program-optimization to run its save-and-deliver step (for a v2+
-  adaptation proposal, the saver is program-adaptation instead). The
-  Contrôleur never saves anything itself — approval authorizes the saver's
-  save, it does not perform it.
+  clean, constraints verified, second opinion survived), and hand back to the
+  ORIGINATING skill to run its save-and-deliver step: program-optimization
+  for a new program, program-adaptation for a v2+ adaptation proposal, or
+  pre-competition for a competition protocol. The Contrôleur never saves
+  anything itself — approval authorizes the saver's save, it does not
+  perform it.
 - **RETURNED:** batch every surviving objection from BOTH passes into one
   verdict — never return on compliance alone and hold adversarial objections
   for a second round. Name the recipient(s) (program-planning or
-  program-optimization, or both if objections split across them), list every
-  surviving objection verbatim, and state what an approvable revision looks
-  like. A revised draft comes back HERE and the gate re-runs in full — both
-  passes, every time.
+  program-optimization, or both if objections split across them; or
+  pre-competition for a competition protocol draft), list every surviving
+  objection verbatim, and state what an approvable revision looks like. A
+  revised draft comes back HERE and the gate re-runs in full — both passes,
+  every time.
 
 **Loop bound:** after THREE RETURNED verdicts on the same draft, stop
 returning it a fourth time. Instead hand back to performance-coach, naming
diff --git a/skills/session-day/SKILL.md b/skills/session-day/SKILL.md
index 077f6e9..fcb2c80 100644
--- a/skills/session-day/SKILL.md
+++ b/skills/session-day/SKILL.md
@@ -26,7 +26,8 @@ performance-coach ritual routes here.
 If today is an event day (J0) and a saved protocol exists
 (read_competition_protocol for the calendar event), open FROM the protocol page
 instead of improvising: quote its timeline, paces or attempts as written.
-Adjustments follow the protocol's fallbacks, never a rewrite an hour before.
+Adjustments follow any fallback the protocol's advice names — never a rewrite
+an hour before.
 
 1. **Locate today's session.** From the session-start ritual you already ran
    `read_athlete` and `get_time_context`. Call `read_program` and pick today's
diff --git a/tests/skills/test_structure.py b/tests/skills/test_structure.py
index f021d6f..02eee64 100644
--- a/tests/skills/test_structure.py
+++ b/tests/skills/test_structure.py
@@ -227,6 +227,7 @@ def test_research_skill_protocol(skills):
         "list_athlete_documents",
         "mini-wave",
         "year_from",
+        "pre-competition wave",
     ):
         assert needle in body, f"deep-research skill lost: {needle}"
 
@@ -254,7 +255,7 @@ def test_review_skill_protocol(skills):
         "verbatim",
         "program-planning",
         "program-optimization",
-        "protocol",
+        "competition protocol",
         "warning",
     ):
         assert needle in body, f"program-review skill lost: {needle}"
@@ -294,6 +295,7 @@ def test_session_day_skill_protocol(skills):
         "program-adaptation",
         "never",
         "hooper",
+        "read_competition_protocol",
     ):
         assert needle in body, f"session-day skill lost: {needle}"
 

From 311cd0c0ed49fee50e9ab5697a05b037d4c12c00 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Sat, 18 Jul 2026 00:12:01 +0200
Subject: [PATCH 21/25] Generalize the review gate wording to all originating
 skills

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 skills/program-review/SKILL.md | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/skills/program-review/SKILL.md b/skills/program-review/SKILL.md
index bfbee61..59e3b59 100644
--- a/skills/program-review/SKILL.md
+++ b/skills/program-review/SKILL.md
@@ -18,7 +18,8 @@ tools: [read_athlete, get_time_context, read_analysis, read_research_dossier,
 
 Follow performance-coach global rules. You are the last agent before delivery:
 independent and adversarial. The gate is enforced by the save discipline in
-program-optimization and this protocol — program-optimization will not save
+the originating skill and this protocol — the originating skill
+(program-optimization, program-adaptation or pre-competition) will not save
 the draft without your APPROVED verdict. You never write program content
 and you **never save** — you approve or you return, nothing else. **Nothing is
 delivered to the athlete without an APPROVED verdict from this skill.** The
@@ -119,9 +120,12 @@ Now argue against the draft as a genuinely independent reviewer:
   the research dossier, instructed to refute it — "is this volume sustainable
   at this availability? does the model choice contradict the dossier's
   evidence? are the progression rules coherent with this athlete's training
-  age?" It looks for reasons to reject, not reasons to agree.
+  age? For a competition protocol draft: is the taper actually executable as
+  written, are the attempts realistic at this e1RM, and does every documented
+  practice carry its grade and warning?" It looks for reasons to reject, not
+  reasons to agree.
 - **Elsewhere:** re-read the draft cold, top to bottom, arguing against it
-  with the same three questions before rendering any verdict.
+  with the same four questions before rendering any verdict.
 
 Discard objections that do not survive scrutiny (the dossier or an engine
 output already answers them — say which). Objections that survive go back

From d2c81725b8e41f97b08a77044477fd8dae8abdf5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Sat, 18 Jul 2026 00:12:34 +0200
Subject: [PATCH 22/25] Document the pre-competition protocol

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 README.md | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index 3be62b3..d6e60b6 100644
--- a/README.md
+++ b/README.md
@@ -66,6 +66,10 @@ tell you what you want to hear. PerformanceAgent is architected so neither is po
 - **Science on the gym page** — the offline program HTML opens with sourced
   advice and "why this program" lines, `[n]` markers on blocks, and a starred
   bibliography.
+- **Pre-competition protocol** — the final days before any competition planned
+  day by day (engine-computed attempts, pacing splits and carb loading; risky
+  peak-week practices described only with evidence grade + explicit warning),
+  delivered as a versioned document and an offline phone page for the event.
 
 ## Install (5 minutes, 3 steps)
 
@@ -124,7 +128,7 @@ session *starts*: close any open session completely and run `claude` again.
 > List the performance-agent tools.
 ```
 
-You should see 97 tools. If so, you're done — just talk to it.
+You should see 102 tools. If so, you're done — just talk to it.
 
 ## How to use it, step by step
 
@@ -331,8 +335,8 @@ typed backward from the major event with per-year quality-emphasis budgets deriv
 from the gap priorities, feeding the season) and a training-residuals guard (warns
 where a maintained quality would decay past its Issurin retention window without a
 refresh);
-1339 tests
-incl. property-based) · 97 MCP
+1396 tests
+incl. property-based) · 102 MCP
 tools · file-based athlete memory with a season calendar, pre-session readiness
 logs, versioned machine-readable programs (structured plan + rendered markdown),
 a day-of adjustment log with escalation signals, a versioned individual response
@@ -342,7 +346,7 @@ activity-file import (.fit/.tcx/.gpx/CSV, incl. power/cadence/splits and VBT
 exports) that proposes a session for the athlete to confirm before logging ·
 DOI/PMID/ISBN-verified evidence corpus with anti-fabrication
 citation checks · live evidence search (PubMed, OpenAlex, Crossref, Semantic Scholar)
-behind a double verification gate · fourteen coaching skills incl. a mandatory delivery
+behind a double verification gate · fifteen coaching skills incl. a mandatory delivery
 gate with an adversarial second opinion · Typst PDF reports (en/fr/es) behind a hard
 citation gate.
 

From 5d494b9540d105bf60a796e54c824ada1ff7183a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Sat, 18 Jul 2026 09:01:03 +0200
Subject: [PATCH 23/25] Teach attempt basis and guard protocol immutability

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 README.md                             | 2 +-
 skills/pre-competition/SKILL.md       | 4 +++-
 src/performance_agent/memory/store.py | 4 ++++
 tests/memory/test_store_protocol.py   | 8 ++++++++
 4 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index d6e60b6..ca19f1c 100644
--- a/README.md
+++ b/README.md
@@ -335,7 +335,7 @@ typed backward from the major event with per-year quality-emphasis budgets deriv
 from the gap priorities, feeding the season) and a training-residuals guard (warns
 where a maintained quality would decay past its Issurin retention window without a
 refresh);
-1396 tests
+1397 tests
 incl. property-based) · 102 MCP
 tools · file-based athlete memory with a season calendar, pre-session readiness
 logs, versioned machine-readable programs (structured plan + rendered markdown),
diff --git a/skills/pre-competition/SKILL.md b/skills/pre-competition/SKILL.md
index 3cc570e..43a627f 100644
--- a/skills/pre-competition/SKILL.md
+++ b/skills/pre-competition/SKILL.md
@@ -39,7 +39,9 @@ NEVER edits the program — taper structure changes route to program-adaptation.
    - Strength: e1RM via `estimate_1rm` on the recent best sets from
      `read_sessions`; `select_attempts` per lift. `goal_beyond_e1rm` flag →
      name the gap honestly; the athlete may call lighter, never heavier than
-     the engine's numbers.
+     the engine's numbers. Store each attempt plan with basis `engine` when
+     the numbers are the tool's, or `agreed` when the athlete chose lighter —
+     program-review recomputes `engine` numbers exactly.
    - Everything else (meal timing, warm-up, logistics, checklist) is advice:
      cited (`get_citation`) or plainly labeled coaching judgment.
 5. Documented practices (peak-week water/sodium, weight-cut tactics): describe
diff --git a/src/performance_agent/memory/store.py b/src/performance_agent/memory/store.py
index d6c5bc5..ae8935c 100644
--- a/src/performance_agent/memory/store.py
+++ b/src/performance_agent/memory/store.py
@@ -940,6 +940,10 @@ def save_competition_protocol(
     }
     md_path = base_dir / COMPETITION_DIR / f"{prefix}-v{version}.md"
     yaml_path = md_path.with_suffix(".yaml")
+    for existing in (md_path, yaml_path):
+        if existing.exists():
+            msg = f"{existing} already exists; protocol versions are immutable"
+            raise ValueError(msg)
     content = (
         "---\n"
         + _to_yaml(frontmatter)
diff --git a/tests/memory/test_store_protocol.py b/tests/memory/test_store_protocol.py
index b7d9f35..8164122 100644
--- a/tests/memory/test_store_protocol.py
+++ b/tests/memory/test_store_protocol.py
@@ -105,3 +105,11 @@ def test_read_rejects_frontmatter_version_mismatch(tmp_path):
     md_path.write_text(tampered, encoding="utf-8")
     with pytest.raises(ValueError, match="frontmatter declares version"):
         store.read_competition_protocol(tmp_path, "nationals")
+
+
+def test_orphaned_yaml_blocks_the_version_slot(tmp_path):
+    _seed_event(tmp_path)
+    store.save_competition_protocol(tmp_path, _protocol(), today=TODAY)
+    (tmp_path / "competition" / "protocol-nationals-v1.md").unlink()
+    with pytest.raises(ValueError, match="immutable"):
+        store.save_competition_protocol(tmp_path, _protocol(), today=TODAY)

From d30f726e04a1986518e7cf310bef41d00bccf914 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Sat, 18 Jul 2026 09:01:35 +0200
Subject: [PATCH 24/25] Check off completed plan tasks

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .../2026-07-17-pre-competition-protocol.md    | 124 +++++++++---------
 1 file changed, 62 insertions(+), 62 deletions(-)

diff --git a/docs/superpowers/plans/2026-07-17-pre-competition-protocol.md b/docs/superpowers/plans/2026-07-17-pre-competition-protocol.md
index 517f9bf..c339b7a 100644
--- a/docs/superpowers/plans/2026-07-17-pre-competition-protocol.md
+++ b/docs/superpowers/plans/2026-07-17-pre-competition-protocol.md
@@ -41,7 +41,7 @@
 - Create: `src/performance_agent/engine/competition.py`
 - Test: `tests/engine/test_competition.py`
 
-- [ ] **Step 1: Write the failing tests**
+- [x] **Step 1: Write the failing tests**
 
 Create `tests/engine/test_competition.py`:
 
@@ -89,9 +89,9 @@ def test_carb_guards_reject_out_of_range_inputs():
         carb_loading_targets(70.0, 2000.0)
 ```
 
-- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py -q` — Expected: FAIL (`ModuleNotFoundError`)
+- [x] **Step 2: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py -q` — Expected: FAIL (`ModuleNotFoundError`)
 
-- [ ] **Step 3: Implement**
+- [x] **Step 3: Implement**
 
 Create `src/performance_agent/engine/competition.py`:
 
@@ -171,9 +171,9 @@ def carb_loading_targets(body_mass_kg: float, event_duration_min: float) -> Carb
     )
 ```
 
-- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py tests/engine/test_engine_purity.py -q` — Expected: PASS (purity guard must stay green)
+- [x] **Step 4: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py tests/engine/test_engine_purity.py -q` — Expected: PASS (purity guard must stay green)
 
-- [ ] **Step 5: Lint + commit**
+- [x] **Step 5: Lint + commit**
 
 ```bash
 uv run ruff check src/performance_agent/engine/competition.py tests/engine/test_competition.py && uv run ty check
@@ -190,7 +190,7 @@ git log --oneline -1
 - Modify: `src/performance_agent/engine/competition.py` (append)
 - Test: `tests/engine/test_competition.py` (append)
 
-- [ ] **Step 1: Write the failing tests** (append)
+- [x] **Step 1: Write the failing tests** (append)
 
 ```python
 from performance_agent.engine.competition import select_attempts
@@ -224,9 +224,9 @@ def test_attempts_guards():
         select_attempts(200.0, 205.0, rounding_kg=0.0)
 ```
 
-- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py -q` — Expected: FAIL (`ImportError: select_attempts`)
+- [x] **Step 2: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py -q` — Expected: FAIL (`ImportError: select_attempts`)
 
-- [ ] **Step 3: Implement** (append to `engine/competition.py`)
+- [x] **Step 3: Implement** (append to `engine/competition.py`)
 
 ```python
 from performance_agent.engine.progression import round_to_increment
@@ -288,9 +288,9 @@ def select_attempts(
 
 (Move the `from performance_agent.engine.progression import round_to_increment` line up into the module's import block.)
 
-- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py tests/engine/test_engine_purity.py -q` — Expected: PASS
+- [x] **Step 4: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py tests/engine/test_engine_purity.py -q` — Expected: PASS
 
-- [ ] **Step 5: Commit**
+- [x] **Step 5: Commit**
 
 ```bash
 git add src/performance_agent/engine/competition.py tests/engine/test_competition.py
@@ -306,7 +306,7 @@ git log --oneline -1
 - Modify: `src/performance_agent/engine/competition.py` (append)
 - Test: `tests/engine/test_competition.py` (append)
 
-- [ ] **Step 1: Write the failing tests** (append)
+- [x] **Step 1: Write the failing tests** (append)
 
 ```python
 from performance_agent.engine.competition import pacing_plan, protocol_window_days
@@ -364,9 +364,9 @@ def test_window_guards():
         protocol_window_days(10, "X")
 ```
 
-- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py -q` — Expected: FAIL (`ImportError`)
+- [x] **Step 2: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py -q` — Expected: FAIL (`ImportError`)
 
-- [ ] **Step 3: Implement** (append to `engine/competition.py`)
+- [x] **Step 3: Implement** (append to `engine/competition.py`)
 
 ```python
 # Negative-split prior: first half ~1% slower than mean pace, second half
@@ -473,9 +473,9 @@ def protocol_window_days(taper_days: int, priority: str) -> int:
     return 0
 ```
 
-- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py tests/engine/test_engine_purity.py -q` — Expected: PASS. Note the rounded paces mean cumulative sums drift by < 1 s — the tests use `abs=1.0`; never widen past one second.
+- [x] **Step 4: Run** — `rtk proxy uv run pytest tests/engine/test_competition.py tests/engine/test_engine_purity.py -q` — Expected: PASS. Note the rounded paces mean cumulative sums drift by < 1 s — the tests use `abs=1.0`; never widen past one second.
 
-- [ ] **Step 5: Lint + commit**
+- [x] **Step 5: Lint + commit**
 
 ```bash
 uv run ruff check src/performance_agent/engine/competition.py tests/engine/test_competition.py && uv run ty check
@@ -496,7 +496,7 @@ git log --oneline -1
 - Modify: `src/performance_agent/memory/schemas.py` (insert the whole block right BEFORE `class CalendarEvent`)
 - Test: `tests/memory/test_schemas_protocol.py`
 
-- [ ] **Step 1: Write the failing tests**
+- [x] **Step 1: Write the failing tests**
 
 Create `tests/memory/test_schemas_protocol.py`:
 
@@ -607,9 +607,9 @@ def test_fueling_low_cannot_exceed_high():
         FuelingPlan(carb_g_per_kg_low=10, carb_g_per_kg_high=8, window_hours=48)
 ```
 
-- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/memory/test_schemas_protocol.py -q` — Expected: FAIL (`ImportError`)
+- [x] **Step 2: Run** — `rtk proxy uv run pytest tests/memory/test_schemas_protocol.py -q` — Expected: FAIL (`ImportError`)
 
-- [ ] **Step 3: Implement** — in `src/performance_agent/memory/schemas.py`, insert immediately before `class CalendarEvent`:
+- [x] **Step 3: Implement** — in `src/performance_agent/memory/schemas.py`, insert immediately before `class CalendarEvent`:
 
 ```python
 # --- Competition protocol (per-event final-days plan) ---------------------
@@ -748,9 +748,9 @@ class CompetitionProtocol(BaseModel):
         return self
 ```
 
-- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/memory/test_schemas_protocol.py tests/memory/ -q` — Expected: PASS
+- [x] **Step 4: Run** — `rtk proxy uv run pytest tests/memory/test_schemas_protocol.py tests/memory/ -q` — Expected: PASS
 
-- [ ] **Step 5: Commit**
+- [x] **Step 5: Commit**
 
 ```bash
 git add src/performance_agent/memory/schemas.py tests/memory/test_schemas_protocol.py
@@ -766,7 +766,7 @@ git log --oneline -1
 - Create: `src/performance_agent/programs/render_protocol.py`
 - Test: `tests/programs/test_render_protocol.py`
 
-- [ ] **Step 1: Write the failing tests**
+- [x] **Step 1: Write the failing tests**
 
 Create `tests/programs/test_render_protocol.py`:
 
@@ -887,9 +887,9 @@ def test_markdown_without_optional_sections_is_lean():
     assert "## Sources" not in text
 ```
 
-- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/programs/test_render_protocol.py -q` — Expected: FAIL (module missing)
+- [x] **Step 2: Run** — `rtk proxy uv run pytest tests/programs/test_render_protocol.py -q` — Expected: FAIL (module missing)
 
-- [ ] **Step 3: Implement**
+- [x] **Step 3: Implement**
 
 Create `src/performance_agent/programs/render_protocol.py`:
 
@@ -1029,9 +1029,9 @@ def render_protocol(
     return "\n".join(lines).strip() + "\n"
 ```
 
-- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/programs/test_render_protocol.py -q` — Expected: PASS
+- [x] **Step 4: Run** — `rtk proxy uv run pytest tests/programs/test_render_protocol.py -q` — Expected: PASS
 
-- [ ] **Step 5: Lint + commit**
+- [x] **Step 5: Lint + commit**
 
 ```bash
 uv run ruff check src/performance_agent/programs/render_protocol.py tests/programs/test_render_protocol.py && uv run ty check
@@ -1048,7 +1048,7 @@ git log --oneline -1
 - Modify: `src/performance_agent/memory/store.py` (constants + append at end)
 - Test: `tests/memory/test_store_protocol.py`
 
-- [ ] **Step 1: Write the failing tests**
+- [x] **Step 1: Write the failing tests**
 
 Create `tests/memory/test_store_protocol.py`:
 
@@ -1148,9 +1148,9 @@ def test_latest_version_none_when_empty(tmp_path):
     assert store.read_competition_protocol(tmp_path, "nationals") is None
 ```
 
-- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/memory/test_store_protocol.py -q` — Expected: FAIL (`AttributeError`)
+- [x] **Step 2: Run** — `rtk proxy uv run pytest tests/memory/test_store_protocol.py -q` — Expected: FAIL (`AttributeError`)
 
-- [ ] **Step 3: Implement**
+- [x] **Step 3: Implement**
 
 In `src/performance_agent/memory/store.py`:
 
@@ -1294,9 +1294,9 @@ def read_competition_protocol(
 
 (`Mapping` and `ResolvedCitation` are already imported since v0.8.0 — check the import block; if `ResolvedCitation` appears only in the quoted annotation, keep the existing import as is.)
 
-- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/memory/test_store_protocol.py tests/memory/ -q` — Expected: PASS
+- [x] **Step 4: Run** — `rtk proxy uv run pytest tests/memory/test_store_protocol.py tests/memory/ -q` — Expected: PASS
 
-- [ ] **Step 5: Commit**
+- [x] **Step 5: Commit**
 
 ```bash
 uv run ruff check src/performance_agent/memory/store.py tests/memory/test_store_protocol.py && uv run ty check
@@ -1313,7 +1313,7 @@ git log --oneline -1
 - Create: `src/performance_agent/programs/render_protocol_html.py`
 - Test: `tests/programs/test_render_protocol_html.py`
 
-- [ ] **Step 1: Write the failing tests**
+- [x] **Step 1: Write the failing tests**
 
 Create `tests/programs/test_render_protocol_html.py`:
 
@@ -1405,9 +1405,9 @@ def test_french_labels():
     assert "Allures" in page
 ```
 
-- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/programs/test_render_protocol_html.py -q` — Expected: FAIL (module missing)
+- [x] **Step 2: Run** — `rtk proxy uv run pytest tests/programs/test_render_protocol_html.py -q` — Expected: FAIL (module missing)
 
-- [ ] **Step 3: Implement**
+- [x] **Step 3: Implement**
 
 Create `src/performance_agent/programs/render_protocol_html.py`:
 
@@ -1691,9 +1691,9 @@ def render_protocol_html(
     )
 ```
 
-- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/programs/ -q` — Expected: PASS
+- [x] **Step 4: Run** — `rtk proxy uv run pytest tests/programs/ -q` — Expected: PASS
 
-- [ ] **Step 5: Lint + commit**
+- [x] **Step 5: Lint + commit**
 
 ```bash
 uv run ruff check src/performance_agent/programs/render_protocol_html.py tests/programs/test_render_protocol_html.py && uv run ty check
@@ -1715,7 +1715,7 @@ git log --oneline -1
 - Modify: `src/performance_agent/server/app.py`
 - Test: `tests/server/test_competition_tools.py`
 
-- [ ] **Step 1: Write the failing tests**
+- [x] **Step 1: Write the failing tests**
 
 Create `tests/server/test_competition_tools.py`:
 
@@ -1805,9 +1805,9 @@ def test_read_without_protocol_raises(athlete_dir):
         competition_tools.read_competition_protocol("nationals")
 ```
 
-- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/server/test_competition_tools.py -q` — Expected: FAIL (module missing)
+- [x] **Step 2: Run** — `rtk proxy uv run pytest tests/server/test_competition_tools.py -q` — Expected: FAIL (module missing)
 
-- [ ] **Step 3: Implement**
+- [x] **Step 3: Implement**
 
 Create `src/performance_agent/server/competition_tools.py`:
 
@@ -1975,9 +1975,9 @@ def register(mcp: FastMCP) -> None:
 
 In `src/performance_agent/server/app.py`: add `competition_tools,` to the import tuple (alphabetical, after `autoregulation_tools`) and `competition_tools.register(mcp)` after `followup_tools.register(mcp)`.
 
-- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/server/ -q` — Expected: PASS
+- [x] **Step 4: Run** — `rtk proxy uv run pytest tests/server/ -q` — Expected: PASS
 
-- [ ] **Step 5: Lint + commit**
+- [x] **Step 5: Lint + commit**
 
 ```bash
 uv run ruff check src/performance_agent/server/competition_tools.py src/performance_agent/server/app.py tests/server/test_competition_tools.py && uv run ty check
@@ -1996,7 +1996,7 @@ git log --oneline -1
 - Modify: `src/performance_agent/server/memory_tools.py` (docstring)
 - Test: `tests/engine/test_diligence.py` (append), `tests/memory/test_diligence.py` (append)
 
-- [ ] **Step 1: Write the failing tests**
+- [x] **Step 1: Write the failing tests**
 
 Append to `tests/engine/test_diligence.py`:
 
@@ -2070,9 +2070,9 @@ def test_a_event_without_protocol_surfaces_competition_protocol(tmp_path):
     assert action["due_in_days"] == 6
 ```
 
-- [ ] **Step 2: Run** — `rtk proxy uv run pytest tests/engine/test_diligence.py tests/memory/test_diligence.py -q` — Expected: FAIL (`unexpected keyword argument 'protocol_window_days'`)
+- [x] **Step 2: Run** — `rtk proxy uv run pytest tests/engine/test_diligence.py tests/memory/test_diligence.py -q` — Expected: FAIL (`unexpected keyword argument 'protocol_window_days'`)
 
-- [ ] **Step 3: Implement**
+- [x] **Step 3: Implement**
 
 In `src/performance_agent/engine/diligence.py`:
 
@@ -2157,9 +2157,9 @@ and update its call site in `_build_facts` to `upcoming_events=_upcoming_events(
 
 In `src/performance_agent/server/memory_tools.py`, extend the `list_due_actions` docstring list with: `an A/B event inside its protocol window with no pre-competition protocol saved`.
 
-- [ ] **Step 4: Run** — `rtk proxy uv run pytest tests/engine/test_diligence.py tests/memory/ tests/server/ -q` — Expected: PASS. If `test_imminent_a_event_is_high`-style existing tests now ALSO see a `competition_protocol` action, that is correct behavior — fix only tests that assert exact action lists (add the new kind or a protocol), never the engine.
+- [x] **Step 4: Run** — `rtk proxy uv run pytest tests/engine/test_diligence.py tests/memory/ tests/server/ -q` — Expected: PASS. If `test_imminent_a_event_is_high`-style existing tests now ALSO see a `competition_protocol` action, that is correct behavior — fix only tests that assert exact action lists (add the new kind or a protocol), never the engine.
 
-- [ ] **Step 5: Commit**
+- [x] **Step 5: Commit**
 
 ```bash
 uv run ruff check src tests && uv run ty check
@@ -2172,8 +2172,8 @@ git log --oneline -1
 
 ### Task 10: Phase gate
 
-- [ ] **Step 1:** Run: `rtk proxy uv run pytest -q >/dev/null 2>&1; echo "exit=$?"` — Expected: `exit=0`
-- [ ] **Step 2:** Run: `uv run ruff check src tests && uv run ty check` — Expected: clean. Fix anything before Phase 4.
+- [x] **Step 1:** Run: `rtk proxy uv run pytest -q >/dev/null 2>&1; echo "exit=$?"` — Expected: `exit=0`
+- [x] **Step 2:** Run: `uv run ruff check src tests && uv run ty check` — Expected: clean. Fix anything before Phase 4.
 
 ---
 
@@ -2184,7 +2184,7 @@ git log --oneline -1
 **Files:**
 - Create: `skills/pre-competition/SKILL.md`
 
-- [ ] **Step 1: Write the skill**
+- [x] **Step 1: Write the skill**
 
 ````markdown
 ---
@@ -2235,9 +2235,9 @@ edits the program — taper structure changes route to program-adaptation.
    with `log_kpi_result` — the outcome feeds fit_taper_response for next time.
 ````
 
-- [ ] **Step 2: Verify** — Run: `rtk proxy uv run pytest tests/skills/ -q` — Expected: only `test_all_expected_skills_exist` fails (fixed in Task 12). If `test_tool_references` fails, fix the frontmatter now.
+- [x] **Step 2: Verify** — Run: `rtk proxy uv run pytest tests/skills/ -q` — Expected: only `test_all_expected_skills_exist` fails (fixed in Task 12). If `test_tool_references` fails, fix the frontmatter now.
 
-- [ ] **Step 3: Commit**
+- [x] **Step 3: Commit**
 
 ```bash
 git add skills/pre-competition/SKILL.md
@@ -2253,7 +2253,7 @@ git log --oneline -1
 - Modify: `skills/performance-coach/SKILL.md`, `skills/training-checkin/SKILL.md`, `skills/session-day/SKILL.md`, `skills/deep-research/SKILL.md`, `skills/program-review/SKILL.md`
 - Modify: `tests/skills/test_structure.py`
 
-- [ ] **Step 1: Update the invariants first (they drive the edits)**
+- [x] **Step 1: Update the invariants first (they drive the edits)**
 
 In `tests/skills/test_structure.py`:
 
@@ -2290,7 +2290,7 @@ Run: `rtk proxy uv run pytest tests/skills/ -q` — Expected: FAIL on exactly th
 
 **Beware line wrap:** every needle must appear UNBROKEN on one line in the skill body (casefolded). Reflow sentences if needed.
 
-- [ ] **Step 2: `skills/performance-coach/SKILL.md`**
+- [x] **Step 2: `skills/performance-coach/SKILL.md`**
 
 In the routing section, after the next-week-loads / program-watch lines added in v0.8.0, add:
 
@@ -2299,7 +2299,7 @@ In the routing section, after the next-week-loads / program-watch lines added in
   **pre-competition** (authors the final-days protocol and the event-day page).
 ```
 
-- [ ] **Step 3: `skills/training-checkin/SKILL.md`**
+- [x] **Step 3: `skills/training-checkin/SKILL.md`**
 
 In the "Mesocycle boundary duties" section (or right after it), add:
 
@@ -2314,7 +2314,7 @@ red flag follows the normal rules.
 
 Frontmatter: add `log_kpi_result` to `tools` if not already declared.
 
-- [ ] **Step 4: `skills/session-day/SKILL.md`**
+- [x] **Step 4: `skills/session-day/SKILL.md`**
 
 Add near the top of the protocol/ritual section:
 
@@ -2327,7 +2327,7 @@ Adjustments follow the protocol's fallbacks, never a rewrite an hour before.
 
 Frontmatter: add `read_competition_protocol` to `tools`.
 
-- [ ] **Step 5: `skills/deep-research/SKILL.md`**
+- [x] **Step 5: `skills/deep-research/SKILL.md`**
 
 In the "Mini-waves and the incremental watch" section, append one line to the mini-wave paragraph:
 
@@ -2336,7 +2336,7 @@ The pre-competition wave is a mini-wave whose single question is the final days
 before a named event (taper execution, fueling, pacing or attempts, weigh-in).
 ```
 
-- [ ] **Step 6: `skills/program-review/SKILL.md`**
+- [x] **Step 6: `skills/program-review/SKILL.md`**
 
 Append to the deterministic compliance checklist (after the v0.8.0 structured-progression/guidance items):
 
@@ -2349,9 +2349,9 @@ Append to the deterministic compliance checklist (after the v0.8.0 structured-pr
   than a warned, graded practice — is an objection.
 ```
 
-- [ ] **Step 7: Run the full skills suite** — `rtk proxy uv run pytest tests/skills/ -q` — Expected: PASS. If `test_bodies_do_not_reference_undeclared_tools` fails, add the mentioned tool to that skill's frontmatter `tools`.
+- [x] **Step 7: Run the full skills suite** — `rtk proxy uv run pytest tests/skills/ -q` — Expected: PASS. If `test_bodies_do_not_reference_undeclared_tools` fails, add the mentioned tool to that skill's frontmatter `tools`.
 
-- [ ] **Step 8: Commit**
+- [x] **Step 8: Commit**
 
 ```bash
 git add skills/ tests/skills/test_structure.py
@@ -2366,7 +2366,7 @@ git log --oneline -1
 **Files:**
 - Modify: `README.md`
 
-- [ ] **Step 1: Update README** — replace `You should see 97 tools.` with `You should see 102 tools.`; replace `97 MCP` with `102 MCP`; replace `fourteen coaching skills` with `fifteen coaching skills`; add one feature bullet after the "Science on the gym page" bullet:
+- [x] **Step 1: Update README** — replace `You should see 97 tools.` with `You should see 102 tools.`; replace `97 MCP` with `102 MCP`; replace `fourteen coaching skills` with `fifteen coaching skills`; add one feature bullet after the "Science on the gym page" bullet:
 
 ```markdown
 - **Pre-competition protocol** — the final days before any competition planned
@@ -2377,9 +2377,9 @@ git log --oneline -1
 
 Then recount the suite and update the test count: run `rtk proxy uv run python -m pytest --collect-only -q 2>/dev/null | awk -F': ' '{s+=$2} END {print s}'` and replace the `1339 tests` figure with the new number.
 
-- [ ] **Step 2: Full suite + linters** — Run: `rtk proxy uv run pytest -q >/dev/null 2>&1; echo "exit=$?"` then `uv run ruff check src tests && uv run ty check` — Expected: exit=0, everything clean.
+- [x] **Step 2: Full suite + linters** — Run: `rtk proxy uv run pytest -q >/dev/null 2>&1; echo "exit=$?"` then `uv run ruff check src tests && uv run ty check` — Expected: exit=0, everything clean.
 
-- [ ] **Step 3: Commit**
+- [x] **Step 3: Commit**
 
 ```bash
 git add README.md
@@ -2389,7 +2389,7 @@ Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>"
 git log --oneline -1
 ```
 
-- [ ] **Step 4: NOT in this plan** — version bump, CHANGELOG, PyPI release.
+- [x] **Step 4: NOT in this plan** — version bump, CHANGELOG, PyPI release.
 
 ---
 

From 294f47d522e114b8516ff67e75b8bd4d413522a7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Rieux?= <clement.rieux@yahoo.com>
Date: Sat, 18 Jul 2026 09:06:14 +0200
Subject: [PATCH 25/25] Bump version to 0.9.0

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 CHANGELOG.md   | 30 ++++++++++++++++++++++++++++++
 pyproject.toml |  2 +-
 uv.lock        |  2 +-
 3 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3a9ff75..6bff743 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,36 @@
 
 All notable changes to PerformanceAgent. Versions follow the git tags.
 
+## 0.9.0 — Pre-Competition Protocol
+
+### Added
+
+- **Pre-competition protocol** — the final days before any competition planned
+  day by day, per calendar event, delivered as a versioned document
+  (`competition/protocol-<event>-vN`) plus a standalone offline phone page for
+  the event (no JS, en/fr/es, J0 open by default, starred bibliography).
+- **Engine math for the final days** — `carb_loading_targets` (evidence-based
+  g/kg windows by event duration + in-race fueling ranges), `select_attempts`
+  (meet-day attempts from the estimated 1RM, with honesty flags when the goal
+  is outside what the data supports), `pacing_plan` (even or negative splits
+  landing on the target time), `protocol_window_days` (priority-adaptive
+  trigger window derived from the taper).
+- **Safety by construction** — risky peak-week practices (water/sodium
+  manipulation, weight cuts) can only be stored as documented practices with a
+  schema-required warning and an evidence grade; they are described, never
+  dosed, never engine-quantified. `save_competition_protocol` refuses any
+  citation id not in the evidence corpus.
+- **Proactive trigger** — `list_due_actions` surfaces `competition_protocol`
+  when an A/B event enters its window with no protocol saved (urgent within a
+  week of the event).
+- **New skill `pre-competition`** (15 skills) — the protocol-author ritual:
+  re-reads the existing protocol before a v2, runs a dedicated research
+  mini-wave, builds engine-first, passes program-review's protocol gate before
+  saving, and routes the post-event debrief into the athlete's taper history.
+  Five skills updated (coach routing, check-in debrief, session-day opens J0
+  from the protocol page, deep-research pre-competition wave, program-review
+  made protocol-aware).
+
 ## 0.8.0 — Living Evidence & Weekly Follow-up
 
 ### Added
diff --git a/pyproject.toml b/pyproject.toml
index b05a983..8839325 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "performance-agent"
-version = "0.8.0"
+version = "0.9.0"
 description = "Evidence-based AI physical preparation platform — backend"
 readme = "README.md"
 requires-python = ">=3.13"
diff --git a/uv.lock b/uv.lock
index 8f88342..5e8edff 100644
--- a/uv.lock
+++ b/uv.lock
@@ -367,7 +367,7 @@ wheels = [
 
 [[package]]
 name = "performance-agent"
-version = "0.8.0"
+version = "0.9.0"
 source = { editable = "." }
 dependencies = [
     { name = "fitdecode" },