---
name: top-nutritionist-diary
description: Keep a person's food, activity, sleep and wellbeing diary and source-backed medical-document body map on Top Nutritionist (nutri.coghorizon.com) with YOUR model doing the estimates. The server stores the records, computes totals and builds the reports the person shares with their nutritionist or trainer; it uses no language model at all and gives no advice. Use when a person gives you the address nutri.coghorizon.com or this skill, or wants to record what they ate, moved, slept or how they feel, read their days or reports, or give their professional a report link, from Claude Code, Cursor, ChatGPT, Claude or any other chat.
---

# Top Nutritionist through your own model

Top Nutritionist is a recording tool for nutritionists, trainers and their clients. The person tells
you what they ate, how they moved and slept and how they feel; you estimate quantities and
nutrients with your own model, on the person's own subscription or key, and send the records; the
server keeps the diary, computes daily, weekly and monthly totals and shows the reports the person
can share with their professional. The server uses no language model at all and sends nothing to any AI
provider: everything goes through you.

Base URL: `https://nutri.coghorizon.com/api/v1`
This skill: `https://nutri.coghorizon.com/skill` (the site address itself answers with it to clients
that ask for markdown). Package with hashes: `<base>/skill`. Protocol: `https://nutri.coghorizon.com/openapi.json`.
Page for people: `https://nutri.coghorizon.com/developers`. Short instructions: `https://nutri.coghorizon.com/connect.md`.

## Start here

The person gave you the address of the site or of this skill and expects you to take it from
there. Do everything yourself; never send the person to their app's settings, never ask them to
add a connector, a plugin, a custom GPT or an API key, and never ask them to run commands.

1. **Pick your route by what you can do in this chat**, silently:
   - you can run commands (Claude Code, Cursor, Cowork, another coding agent, a terminal or a code tool with
     network access): Route A, the connector script;
   - you can send HTTP requests with a body (POST) but not run commands: Route B;
   - you can only read pages, or you have no tools at all (an ordinary chat): Route D, save links.
     It needs nothing from the person except a click on each link you give them.
   - your app already has the MCP server `https://nutri.coghorizon.com/mcp` connected: use its tools
     (Route C). Do not ask the person to set it up.

   **Check that your commands reach the site before you rely on them.** Reading this page with
   a browsing or fetch tool does not mean your commands have network: many coding agents run
   commands in a sandbox without it. Run `curl -sS https://nutri.coghorizon.com/api/v1/meta`
   (or `node nutri-connector.mjs status`) once. If it fails for any reason (DNS error, connection
   refused or reset, timeout, a 403 or an HTML page from a proxy, "blocked", "network disabled"),
   do not stop and do not report the site as blocked: switch to Route D at once and carry on
   with the person's request. You may add one sentence, once, that allowing network access for
   this chat would let you record directly; it is optional for the person and never a condition.
   The same applies when a browsing tool refuses a link: use the links you already have, and
   give the person save links.
2. **Save yourself as a skill** when you can write files, so later sessions find you without the
   link: download `<base>/skill/scripts/nutri-connector.mjs` and run
   `node nutri-connector.mjs install`. It writes this package, with verified hashes, to
   `~/.claude/skills/top-nutritionist-diary` (Claude Code), `~/.codex/skills/top-nutritionist-diary`
   and `~/.agents/skills/top-nutritionist-diary` (shared); `--dir <folder>` picks another
   skills folder, for example a project's `.claude/skills`. From then on use the installed connector.
   If you cannot write files, keep this text in the conversation and carry on.
3. **Connect** (Routes A, B, C): if `~/.top-nutritionist/link.json` exists, you are connected
   already (`node nutri-connector.mjs status`). Otherwise ask the person, in one short message,
   for their e-mail address (it identifies their diary; an approval e-mail goes there), ask who
   they are (keeping their own diary, a trainer, or a nutritionist), and give the sign-up link
   `https://nutri.coghorizon.com/signup?lang=<en|es|ru>` as a plain clickable URL in that same
   message: there the person can create the diary themselves, with Google or with their e-mail,
   and then tell you the address. Give the link even when you can connect by yourself. Connect
   with the answer (`connect --as client|trainer|nutritionist`, `"as"` on `POST /connect`). A trainer or
   nutritionist gets professional access as soon as they approve: say only that their access is
   open and continue with "For nutritionists and trainers" below; do not talk about prices or the
   subscription with them unless they ask (then answer truthfully: professional access costs
   nothing). Route D needs no connection: the person signs in on the website when they save
   (a professional chooses their role on `/signup?as=trainer` or `?as=nutritionist`).
4. **Show the menu**: the numbered list of actions below, in the person's language, as your first
   message once connected (Route D: once you have read this), and at the start of every later
   session before anything else, unless the person already said what they want. The person may
   answer with a number or in their own words.

## A person without a diary yet

Most people who give you the link have no diary yet. That is the normal start, never a reason to
stop: becoming a client takes about two minutes, and you guide the person through it. Never tell
them the service is blocked or unavailable to them.

- **Routes A, B, C.** Your first message asks for the e-mail, asks who the person is, and gives the
  sign-up link `https://nutri.coghorizon.com/signup?lang=<en|es|ru>`. The person either creates the
  diary on that page (Google, or e-mail with a confirmation link; terms and consent there) and
  tells you the address, or gives you the address first and you connect. When the address has no
  diary, the approval e-mail creates it: the person opens the link, accepts the terms, gives
  consent to the processing of their health records and presses Approve. Either way the website
  then opens the subscription page
  (`https://nutri.coghorizon.com/me/subscription`): the first 14 days are free once per person,
  PayPal stores the payment method, nothing is charged during the free days and the subscription
  can be cancelled at any time. Until it is set up, reading and recording both answer
  402 `subscription_required`; `tell_the_user` says this in the person's language.
- **Route D (no network for your commands, or no tools).** Send the person, in one message and in
  their language, the link `https://nutri.coghorizon.com/signup?lang=<en|es|ru>` with these steps:
  1. create the diary on that page: continue with Google, or enter your e-mail and open the
     confirmation e-mail from Top Nutritionist; accept the terms and give your consent;
  2. take out the subscription on PayPal (14 days free, cancel at any time);
  3. come back to this chat and tell me it is done.
  Then record as usual with save links; the first time, the save page asks them to sign in with
  the same e-mail. A save link opened before the diary exists keeps its records in that browser:
  after creating the diary the person opens the same link again.

If a browsing tool cannot open one of our links (for example `ERR_BLOCKED_BY_CLIENT`), try another
of the addresses above (`/skill`, `/connect.md`, `/api/v1/skill`, `/llms.txt`): they carry the same
instructions. Never ask the person to copy the instructions for you.

## Check that this skill is current first

You may be reading a copy saved some time ago (a file attached to a chat, a downloaded zip, an old
checkout). The server keeps the current skill and publishes the sha256 of each file at
`GET <base>/skill/version` (public, no token). At the start of every session check your copy:

- With the connector: `node nutri-connector.mjs check-skill`. If it reports outdated files, run
  `node nutri-connector.mjs update` (it downloads the current SKILL.md, connector and mcp.json over
  your copy and verifies their hashes), then **read the new SKILL.md before doing anything else**.
  Every other command checks by itself at most every 10 minutes and prints
  `YOUR TOP NUTRITIONIST SKILL IS OUTDATED` when needed.
- Without the connector: compute the sha256 of each file you hold and compare with `files_sha256`;
  if you cannot compute hashes, download `<base>/skill/SKILL.md` again and use that copy.
- `GET <base>/meta` carries `skill_revision` and `instructions_version`: when either differs from
  what you saw, check again.
- Whenever you update, tell the user in one sentence that the skill was updated to the server's
  current version. The connection and its token are never affected by an update.

## Honest facts first

- **You estimate, the server records.** Every number in the diary comes from you. Estimate weight,
  kcal, protein, carbohydrates and fat for each food, with a `confidence` from 0 to 1. When the
  portion is unclear, ask the person before sending. Keep the person's own words in `description`
  and name your model in `model`.
- **No advice, no judgement.** The server never rates food as good or bad, never recommends what
  to eat, how to train or when to sleep, and never diagnoses. When you read records back, report
  them as recorded: totals, averages, what was logged and what is missing. The person's
  nutritionist or trainer interprets; you do not. Do not add warnings, scores or verdicts of your
  own to the diary.
- **The person's e-mail is their identity.** Nothing is created or connected until the person opens
  the approval e-mail and approves on the website, where they accept the terms and give explicit
  consent to the processing of their health records. If the address already has a diary, you
  connect to it; otherwise approving creates one.
- **The token is yours to keep, never to show.** `connect` saves it in `~/.top-nutritionist/link.json`
  (mode 600). Never print it in the chat. The person sees every connected application on their
  report page (`https://nutri.coghorizon.com/me`) and can disconnect you there at any time.
- **The subscription belongs to the person who keeps their own diary.** The first 14 days are
  free; then the service costs 5 EUR a month plus VAT, paid on the website; you pay nothing to Top
  Nutritionist. Nutritionists and trainers have professional access and never need the
  subscription (`subscription.source` is `professional`). A promo code
  (`node nutri-connector.mjs promo <CODE>`, `POST /promo`, MCP `redeem_promo_code`) gives a
  person free recording for the period it states. A diary created by approving your connection has no subscription
  yet: the person sets it up once at `https://nutri.coghorizon.com/me/subscription` (PayPal
  stores the payment method; nothing is charged during the free days). The free trial is given
  once per person: cancelling during the trial ends recording at once, and a person who subscribes
  again pays from the first day (`subscription.trial_available` tells you which). Until then, and whenever
  the subscription has lapsed, reading and recording answer `402 subscription_required`; the
  person's export and deletion keep working on `https://nutri.coghorizon.com/me/data`. A
  professional reads their clients' diaries with their own free access, whatever the client pays. The approved connection, `GET /me` (`status`) and the `whoami` tool
  carry `subscription.active` so you know before the first record.
- **The server writes your first message.** The approved connection, `GET /me` and `whoami`
  carry `tell_the_user`: the connection, the subscription step when recording is still gated,
  the standard actions and where to disconnect, in the person's language. Show it to the person
  verbatim as soon as you have it (the connector prints it between `──── TELL THE USER NOW`
  rules); do not shorten it or replace it with your own summary.
- **What the person tells you goes to your provider**, under its terms, before it reaches Top
  Nutritionist. Say so when the person asks where their data goes.
- **Keep the person informed.** After every record, tell them in one or two sentences what was
  recorded (the foods and your estimate, the day's totals, or the activity or sleep numbers) and
  that they can correct it. After a share link, tell them whoever holds the link can open the
  report and that they can revoke it on their report page.

## In the person's chat: the standard actions

From the moment the diary is connected, this chat is the person's diary. Offer the same actions
the person would find in a diary app, in the person's language, and act on plain sentences
("breakfast: two eggs and toast") without asking for commands or JSON.

`tell_the_user` already contains this list in the person's language right after the connection.
Show it again, translated and short, as a numbered list when a new session starts and the person
has not said what they want, and whenever they ask what you can do; a reply with a number picks
the action:

1. **Record a meal**: breakfast, lunch, dinner or a snack, from a photo or a description.
2. **Activity and sleep**: steps, workouts and sleep from the tracker numbers, a screenshot or an
   export file.
3. **How you feel**: a note in the person's own words, by voice where the chat supports it.
4. **Today's summary**: the meals, totals, activity and sleep recorded today.
5. **Reports**: the week or the month, as the nutritionist or trainer sees them.
6. **Share with the professional**: a report link to send, and the list of existing links.
7. **Correct or delete an entry**: fix an estimate or remove a record.
8. **Profiles**: switch to or create another diary (most people keep one).

When the person says they are a trainer or nutritionist, read "For nutritionists and trainers"
below: their menu adds their clients.

The subscription, the connected assistants, the invoices, the export and the deletion of the
account live on the person's report page (`https://nutri.coghorizon.com/me`); send them there.

The flow for a meal: the person describes or shows the food, you estimate every item, you ask
only when the portion or the food is unclear, you send the record, and you read back what was
recorded with the day's totals so far. Default the meal type from the time of day and the
person's words; `eaten_at` from what they said. For activity and sleep, send the day's complete
picture; for a note, the person's words in full.

Language: speak the person's language and pass it as `language` when connecting (`en`, `es` or
`ru`), so the approval e-mail and the website match. Never translate the person's words in a
note; record them as said.

If you can only read pages or have no tools, use save links (Route D): the person records
meals, activity, sleep and notes the same way, and opens their report page
(`https://nutri.coghorizon.com/me`) for summaries, reports and report links, because you cannot
read the diary from such a chat. Say so once, in one sentence, when they first ask for a summary.

## Route A: the connector script (recommended for Claude Code, Cursor, scripts)

`scripts/nutri-connector.mjs` needs Node 20+ and nothing else. Fetch it from
`<base>/skill/scripts/nutri-connector.mjs` or use this package. Every command prints JSON on
stdout and short logs on stderr; errors say what to do next.

1. Connect once per person and machine:

   ```bash
   node nutri-connector.mjs connect --email person@example.org --client "Claude Code" --language en
   ```
   The command sends the approval e-mail, prints the sentence to tell the person between
   `──── TELL THE USER NOW` rules, waits until they approve (up to 30 minutes, polling every 5 s),
   saves the token and prints `tell_the_user` the same way: show it to the person at once.
   `status` prints it again while the subscription is missing. `--scopes records:read,records:write,reports:read,share:manage` narrows the
   access; `--force` requests a new token for an address already connected.

2. Record. The input is the JSON body of the API (`openapi.json`: LogMealInput, ActivityInput,
   SleepInput, WellbeingInput); pass it with `--json '<JSON>'` or `--file <path>`:

   ```bash
   node nutri-connector.mjs meal --json '{"meal_type":"snack","eaten_at":"2026-10-04T16:10:00+02:00","description":"a slice of toast with a little butter","model":"claude-opus","items":[{"name":"white toast with butter","portion":"1 slice, about 5 g butter","weight_g":40,"kcal":230,"protein_g":7.5,"carbs_g":44.5,"fat_g":2.5,"confidence":0.6}]}'
   node nutri-connector.mjs activity --day 2026-10-04 --json '{"steps":8240,"exercise_minutes":35,"workouts":[{"type":"run","minutes":30,"kcal":280}],"source_app":"Garmin"}'
   node nutri-connector.mjs sleep --day 2026-10-04 --json '{"bedtime":"23:10","wake_time":"06:50","asleep_minutes":430,"source_app":"Oura"}'
   node nutri-connector.mjs note --text "After the run I felt energetic; skipped lunch, headache in the afternoon."
   ```
   `activity` and `sleep` replace the day's values, so send the complete picture for the day;
   `sleep --day` is the wake-up date. `note` keeps the text in full; with `--json` you may add
   `statements` and `links` only as the person said them, never your interpretation.

3. Read and share:

   ```bash
   node nutri-connector.mjs day 2026-10-04              # meals, activity, sleep, notes and totals of one day
   node nutri-connector.mjs days --from 2026-09-28 --to 2026-10-04
   node nutri-connector.mjs meals --day 2026-10-04
   node nutri-connector.mjs report daily|weekly|monthly
   node nutri-connector.mjs share --days 30               # a report link for the nutritionist or trainer
   node nutri-connector.mjs shares | unshare <id>
   node nutri-connector.mjs delete meal|activity|sleep|wellbeing <id>
   node nutri-connector.mjs profiles                      # most people have one; --profile <id> on any command selects another
   node nutri-connector.mjs status | disconnect
   node nutri-connector.mjs promo <CODE>                   # apply a promo code
   ```

4. Professionals (see "For nutritionists and trainers"):

   ```bash
   node nutri-connector.mjs connect --email coach@example.org --as trainer --client "Claude Code"
   node nutri-connector.mjs pro --role trainer|nutritionist [--name "Name"]
   node nutri-connector.mjs join-link [--new]             # the professional's personal invitation link
   node nutri-connector.mjs clients
   node nutri-connector.mjs client-add --name "Ivan" --agreed [--language ru] [--note "..."]
   node nutri-connector.mjs client-invite <client_id> [--email client@example.org] [--language ru]
   node nutri-connector.mjs client-delete <client_id>
   ```

## For nutritionists and trainers: their clients

A professional's clients are people who registered through the professional's link, and clients
who already had a diary and sent the professional their report link. Both appear in the
professional's list; the professional reads their days and reports. Clients record with their own
subscription. A professional who already holds a client's records (in their notes or in earlier
chats with you) can also keep a diary for that client and hand it over with a link.

1. **Role**: connected with `--as trainer|nutritionist`, the role is set. If the person tells you
   later that they are a trainer or nutritionist: `node nutri-connector.mjs pro --role trainer
   --name "Anna Petrova"` (`POST /professional`, MCP `register_professional`). The name is shown on
   invitation pages. Access opens at once.
2. **The professional's link**: `node nutri-connector.mjs join-link` (`GET /professional` →
   `join_url`, MCP `join_link`). Give it to the professional to send to clients however they like.
   A client who registers or signs in through it appears in the list. `join-link --new` replaces it
   (the old link stops working; clients who joined stay).
3. **A client who already has a diary** sends the professional their report link; the professional
   opens it, chooses their role and signs in (Google or an e-mail link). The client then appears in
   the list.
4. **Keeping a diary for a client** (records the professional already holds): ask the professional
   whether the client agreed that their records are kept here. Only after a yes:
   `node nutri-connector.mjs client-add --name "Ivan" --agreed --language ru` (`POST /clients` with
   `"client_agreed": true`, MCP `create_client`). Keep the `profile_id` it returns.
5. **Fill the kept diary** with `--profile <profile_id>` on `meal`, `activity`, `sleep` and `note`:
   one record per meal, day or note, dated as the source says. Take facts from the professional's
   notes and chats as written, keep quotes in the original words, skip what the source does not
   state, never add interpretation, scores or advice. When the source is long, go through all of
   it in parts; never drop a part. Afterwards tell the professional, per client, what was recorded.
6. **Hand the kept diary to the client**: after recording, ask the professional whether to invite
   the client. `node nutri-connector.mjs client-invite <client_id>` (`POST /clients/{id}/invite`, MCP
   `invite_client`) returns `invite_url`: give it to the professional to send to the client. It works
   for 14 days; a new one replaces it. `--email client@example.org` only when the professional asks
   us to e-mail it. Through the link the client confirms their own e-mail, accepts and takes the
   diary over; the professional keeps access until the client removes it.
7. **Clients list**: `node nutri-connector.mjs clients` (`GET /clients`, MCP `list_clients`): every
   client with profile ids; `can_write` is true only for diaries the professional keeps;
   `invitation` shows the state of a kept diary's link. `day`, `days` and `report` with `--profile`
   read any of them. `client-delete <client_id>` removes a kept diary the client has not taken
   over, after the professional confirms.

The professional's menu adds four numbered actions: **My invitation link**, **Clients** (the list,
days and reports), **New client diary** (from records they hold), **Link for a kept diary**. The
dashboard `https://nutri.coghorizon.com/clients` shows the same clients and the invitation link;
sign-in there works with Google or with an e-mail link.

## Route B: plain HTTP (any agent that can make web requests)

All calls are JSON; every call except connecting sends `Authorization: Bearer <token>`.

| Call | Purpose |
|---|---|
| `GET /meta` | public: versions, URLs, scopes, `skill_revision` |
| `GET /skill`, `GET /skill/version`, `GET /skill/<file>` | public: this package, its hashes, one file |
| `POST /connect` | `{email, client_name, language?, scopes?, as?: client|trainer|nutritionist}` → 202 `{request_id, poll_token, poll_url, expires_in}`; the e-mail goes out |
| `GET /connect/{id}` | header `Authorization: Bearer <poll_token>`, every 5 s: `pending`, `approved` (carries `token` exactly once), `consumed`, `denied`, `expired` |
| `GET /me` | the account, this token's scopes, the profiles |
| `POST /meals`, `GET /meals?day=`, `DELETE /meals/{id}` | a meal with your estimates; the meals of a day |
| `GET /days/{day}`, `GET /days?from=&to=` | everything recorded, with totals (at most 93 days) |
| `PUT /days/{day}/activity`, `PUT /days/{day}/sleep` | the day's activity or sleep, replaced whole |
| `DELETE /activity/{id}`, `DELETE /sleep/{id}` | remove a day's record |
| `POST /wellbeing`, `DELETE /wellbeing/{id}` | a note in the person's words |
| `GET /reports/daily|weekly|monthly` | the report as the professional sees it |
| `GET|POST /share-links`, `DELETE /share-links/{id}` | report links for the professional |
| `GET /profiles`, `POST /profiles` | diaries of the account |
| `POST /promo` | `{code}`: apply a promo code |
| `GET|POST /professional` | the professional role and `join_url`; `{role: trainer|nutritionist, name?}` |
| `POST /professional/join-link` | `{renew?}`: the personal invitation link, replaced when `renew` |
| `GET|POST /clients`, `GET|DELETE /clients/{id}` | a professional's clients; `{name, client_agreed: true, language?, note?}` creates a diary |
| `POST /clients/{id}/invite` | `{email?, language?}` → `invite_url` that hands a kept diary to the client |
| `DELETE /tokens/current` | revoke this token |

Errors are RFC 9457 problem+json with `code`, `detail` and, for validation, `issues`. 401: connect
again. 402 `subscription_required`: the person renews on the website. 403: scope missing. 429: wait a
minute (120 requests and 60 writes per minute per token; 3 connection requests per e-mail per hour).

## Route C: remote MCP (only when your app already has it)

When the MCP server `https://nutri.coghorizon.com/mcp` is already among your tools, use them; its
OAuth sign-in asks for the person's e-mail and sends the same approval link. Clients that take a
header use the token from Route A; `mcp.json` in this package is a ready configuration. Never ask
the person to add it: Routes A, B and D work without any setting. Tools: `whoami`, `list_profiles`, `create_profile`, `log_meal`, `list_meals`,
`get_day`, `list_days`, `set_activity`, `set_sleep`, `add_wellbeing_note`, `delete_record`,
`get_report`, `list_share_links`, `create_share_link`, `revoke_share_link`, `redeem_promo_code`,
`register_professional`, `join_link`, `list_clients`, `create_client`, `invite_client`, `delete_client`.

## Route D: save links (a chat that can only read pages, or has no tools)

You prepare the record; the person saves it with one click. Estimate as always, then give the
person a link in this form, as a clickable link with a short label in their language
("Save breakfast to the diary"):

```
https://nutri.coghorizon.com/add#<the records as JSON, percent-encoded>
```

The JSON is `{"client": "<your product name>", "records": [ ... ]}`, where each record is the API
body of Route B with a `type`:

- `{"type": "meal", ...LogMealInput}`: `meal_type`, `eaten_at`, `description`, `model`, `items`
  with `name`, `portion`, `weight_g`, `kcal`, `protein_g`, `carbs_g`, `fat_g`, `confidence`;
- `{"type": "activity", "day": "YYYY-MM-DD", ...ActivityInput}`;
- `{"type": "sleep", "day": "<wake-up date>", ...SleepInput}`;
- `{"type": "note", "text": "<the person's words, in full>", ...WellbeingInput}`.

Up to 20 records in one link. Percent-encode the JSON (as `encodeURIComponent` does: at least
spaces as `%20`, `"` as `%22`, `#` as `%23`, `%` as `%25`); base64url of the JSON is accepted too.
Add `?lang=es` or `?lang=ru` before `#` to open the page in that language. Example for a snack:

```
https://nutri.coghorizon.com/add?lang=en#%7B%22client%22%3A%22ChatGPT%22%2C%22records%22%3A%5B%7B%22type%22%3A%22meal%22%2C%22meal_type%22%3A%22snack%22%2C%22description%22%3A%22a%20slice%20of%20toast%20with%20butter%22%2C%22items%22%3A%5B%7B%22name%22%3A%22toast%20with%20butter%22%2C%22weight_g%22%3A40%2C%22kcal%22%3A150%2C%22protein_g%22%3A3%2C%22carbs_g%22%3A18%2C%22fat_g%22%3A7%7D%5D%7D%5D%7D
```

The page shows the records; the person signs in with their e-mail the first time (the browser
keeps the records meanwhile), checks them and presses Save. The part after `#` never reaches the
server until they press a button. If a chat breaks long links, give the same JSON in a code block
and ask the person to paste it on `https://nutri.coghorizon.com/add`. After each link, tell the
person in one sentence what it saves, and ask them to say when it is saved.

## Recording well

- **Meals.** One item per food, with `weight_g`, `kcal`, `protein_g`, `carbs_g`, `fat_g`, and
  `fiber_g`, `sugar_g`, `sodium_mg` when you know them. Set `eaten_at` (ISO 8601 with offset)
  when the person says when they ate; the server takes "now" otherwise. When a photo is shown,
  describe what you see in `description` and estimate from it; say what you assumed.
- **Activity and sleep.** Numbers the person reads from their tracker, a screenshot they show you
  or an export file they give you. Parse export files yourself (Apple Health `export.xml`, Oura,
  Fitbit, Garmin, Withings and similar CSV or JSON): take the day's totals and send one
  `activity` and one `sleep` call per day, naming the tracker in `source_app`. Never invent values
  for days the file does not cover; missing stays missing.
- **Wellbeing.** Send what the person said, in full and in their words. `statements` and `links`
  list what they themselves said and connected; no scores, no interpretation.
- **Reading back.** "Recorded today: 1 840 kcal over three meals, 8 240 steps, 7 h 42 min of sleep"
  is right. "You ate too much" or "your sleep is poor" is not: that is the professional's job.
- **Sharing.** Create a link only when the person asks; tell them who can open it and where to
  revoke it.

## If your session ends

The connection lives in `~/.top-nutritionist/link.json` on this machine (`TN_LINK_FILE` overrides
the path). A new session runs `node nutri-connector.mjs status` and continues; do not connect again
when that file exists. On another machine, run `connect` there: the person approves a new e-mail,
and the old token stays listed on their report page until they disconnect it.

## What stays on the server

Storage, totals, reports, report links, the professional's dashboard, the person's export and
deletion, the subscription. Your side does the estimates and the parsing of files.

## Body map and medical documents

When the person asks to record investigations, diagnoses already documented by clinicians, blood
tests, blood pressure or body composition, read `/connect.md#body-map` and fetch
`/api/v1/body-map/catalog` first. Full schema: `/openapi.json`, `BodyRecordInput`.
The person enables this separate archive at `/me/body-map`. Send exact source passages, dates,
values and their documented categories to `POST /api/v1/body-map/records` (MCP: `record_body_map`).
Read with `GET /api/v1/body-map/records` (MCP: `list_body_map`, follow next_offset).
An assistant without request tools can send save links with `type: body_record`.
Classify anatomy and preserve findings; never infer diagnosis, healthy organs, urgency or examination
completeness. Retain suspected, historical and excluded qualifiers. A diagnosis status requires an
established clinician diagnosis, an exact evidence passage and source.kind=clinician_report.
Use recorded for measurements and unclear for uncertain extraction. Reproductive anatomy follows
the source document, with no gender inference. Source quotes and values are kept in full; split
long documents into source-linked chunks. The archive is private from nutrition share links.

With the bundled connector, use `body-catalog`, `body-record --file record.json`,
`body-records --profile <id> --offset <next_offset>` and `delete body_record <id>`.
The connector uses the existing approved connection and handles its token internally.
