# HeksLog

A training log: a plan of routines laid over a calendar, and the sets actually performed
against it. This file is for an agent that has been given this site's address and an
access key, and is expected to work out the rest on its own.

## What you need

The address of this site and an **access key** — a secret that looks like `wlt_…`, made by
the user under *Profil → Klucze*. The key is the whole credential: it says which space
to open and what may be done in it.

The server checks the key on every request, by its hash, and nothing else is accepted here:
not a passphrase and not the user's login. A key carries one permission and is revoked on its
own. The dziennik it opens is readable on the server — the user has been told so in the app.

Your permission arrives with the first answer, in the `x-hekslog-perm` header: `read` or
`write`. A `read` key is refused a write by the server, not by politeness. If a key stops
working it was revoked, or it went 90 days unused and expired (403 `key-expired`) — ask for a new
one rather than working around it.

A key makes a counted number of requests: on a Darmowy account 10 a day, on Premium 600 reads
and 120 writes an hour. Past that the server answers 429 `key-limit` with `max` and `per`
(`hour` or `day`); wait, and work in fewer, larger acts.

## How to drive it

Download one file from this site and ask it what it can do. Nothing is installed.

    curl -O https://THIS-SITE/agent.mjs
    node agent.mjs help

`help` prints every operation with its full JSON argument schema. That listing is
generated from the code that runs, so it is never out of date — prefer it to anything
written here. Node 20 or newer; no dependencies.

    node agent.mjs overview --url https://THIS-SITE --token wlt_…

Or put them in `HEKSLOG_URL` and `HEKSLOG_TOKEN` and drop the flags. Results are JSON on
stdout. A failure is a message on stderr and a non-zero exit.

No Node? `/wire.txt` says how to write a client in any language: the endpoints, the shape of
the document, and the merge rules a write has to obey.
It is longer and easier to get wrong — this file is the shorter road.

## The operations

Reading: `overview`, `get_plan`, `get_day`, `get_sessions`, `get_exercise_history`,
`get_volume`, `get_measurements`, `search_exercises`.

What a screen of the app shows: `get_view`. It answers with the same view the screen draws from,
run over this dziennik on the person's calendar - `screen` is `date-bar`, `day`, `rest`,
`journal`, `plans`, `plan` (with `plan`, a plan id, and `version`, one of its versions from
`get_plan`, to read the page in that version - the plan as written where none is named),
`measures`, `account`, `exercise` (with
`exercise`, an exercise id) or `shell`, and `date` is the day the screen reads, today where it is
not given; an argument a screen does not take is refused. The labels and states in it are the
Polish words on the screen, with the figures, ids and the reason or source of each beside them;
**What the screens say** at the end of this file says what each word means. Use it when a
question is about what the person sees - a day's card, why a training is lighter, where a plan
stands, how the goal reads - and the readings above for the records themselves. What only the
person's device knows comes back `null`: the sync mark and unsent changes, the save alarm, the
update bands, the running rest clock, the account card, the room and the kinds of account. It
writes nothing.

What the account held before: `get_history`, `get_version`.

**A record that is gone without a tombstone was written over** - unless it is dated before
`overview`'s `cloudFrom`. Deleting anything here leaves the record in place carrying `del`, so
what a person deleted is still visible and dated. A training, its sets, a measurement or a sealed
plan stretch dated before the cloud's start left the cloud when the start moved forward: it is on
the person's devices, not written over. Any other record that is simply absent was never written
to this account — or the document holding it was replaced whole, which leaves no trace in the
document at all. `get_history` lists the documents
this account replaced, newest first; `get_version` says what one of them holds without putting
it back. Putting a version back is the owner's, in the app, and cannot be done from here. A
version written before the space moved to the readable format opens only with a key made before
it was written.

**A position says everything it asks for, everywhere.** `{ exId, exercise, sets, target, rir,
rest, superset }` — the same list from `get_plan`, `get_day` and `overview`, with `null` where nothing is
asked rather than the field left out: a reader cannot tell a term nobody set from one a reading
forgot. Anything a writer can put on a position is in it.

**A reading names what its writers take.** Where `get_plan` says which routine is dealt — a
week's `days`, the trainings a week marks `light`, the routine a substitution belongs to — the
answer is `{ routine: "<id>", name: "<what it is called>" }`. Where the routine is itself the
answer — `overview`'s `routineToday` and `routines`, a `get_day` training's `routine` — it is `{ id, name, … }`.
The name is what a person reads; the id is what `set_layout_day` and the rest take. Two routines of one name are two routines, and a plan
whose stages carry copies of one is the ordinary case rather than the awkward one.

Writing what was done: `log_sets`, `delete_sets`, `set_session`. One set at a time, for
correcting a row rather than writing it down: `add_set`, `edit_set`, `drop_set`. A row is the
ENTRY it answers, and every record names one. Name the row with `entry` (from `get_day`) wherever
the training asks for the exercise — `edit_set` and `drop_set` always take it. Left out on
`log_sets` or `add_set` for an exercise the training does not ask for, the exercise is added to
that training as a position of its own, and the record answers it. `delete_sets` names the
`entry` with the exercise. A correction is the app's own: `edit_set` keeps the stamp of a set done
before the training ended, and `drop_set` on a training that is over empties the slot and keeps
it; while the training is on it removes the slot, and the slots after it move down one. A row's
`sets`, as `get_day`, `get_sessions` and `get_exercise_history` give it, lists every slot after
the index `edit_set` and `drop_set` take, from 0 (`0: empty (20 kg) warm-up, 1: 100×8`): a
warm-up holding only a load and a slot emptied on a training that is over are listed as `empty`.
`set_session`'s `mark` is one of 1–5 and nothing else. A day operation given no `routine` or
`session` opens the training the day deals where it deals exactly one, and a free one otherwise.

Writing what ONE DAY did, as against what the plan asked: `set_training` (skip it, or take
the skip back), `add_day_exercise`, `drop_day_exercise`, `set_day_exercise` (something else
was done instead), `set_day_terms`. None of these touches the plan — see **A day is not an
execution of its routine** below. Each takes the training by `routine`, or by `session` — the
id `get_day` gives on every row, which is how a FREE training is reached (`routine: "wolne"`
reaches the day's free training and starts one where there is none) and the only way to tell
two free trainings on one day apart.

The body: `set_measurement`, `set_profile`.

Where you train: `add_place`, `set_place`, `drop_place`.

Writing the plan — its pool of routines: `add_routine`, `rename_routine`, `drop_routine`.
The positions inside one: `add_entry`, `drop_entry`, `set_entry_exercise`,
`set_entry_volume`, `set_entry_terms`, `move_entry`, and `set_superset`, which makes positions a
superset - done in turn, opened together on the day with no rest counted between them - or takes
one out; a position's `superset` is the name its group shares. The stages that arrange them:
`add_stage`, `drop_stage`, `rename_stage`, `move_stage`, `set_stage_weeks`, `set_layout_day`,
`set_stage_rules`, `set_stage_goal` (the weekly working sets it aims at per muscle), `enter_stage`.
And the plan itself: `add_plan`, `drop_plan`, `rename_plan`,
`set_plan_settings`, and where it stands on the calendar: `place_plan`, `end_placement`.

A plan that stands nowhere is a plan nothing reads: a **placement** is a stretch of days, from
a date and optionally to one, and several plans may stand at once — the stretch is what says
which plan a given morning was trained under. Closing one is giving it a `to`, never removing
it, because the days before it still read under that plan.

Exercises come from the shipped database only; there is no writer for one of your own. A
dziennik may still hold an older one, marked `local: true`: `search_exercises` finds it and
the volume chart reports it as unattributable.

The rest you give an exercise, wherever it comes round: `set_rest`. It stands over the
database's own figure and two minutes, and under a rest a position states for itself; `null`
clears it and the database answers again.

Writing what ONE DAY decided back into the routine: `adopt_day`. It carries the terms the day
answered, what it added, dropped or swapped, the ORDER the positions were done in — the
started ones by their first set, the rest after them as they stood — and the SUPERSETS: positions
whose sets interleave were done in turn, and where that differs from the routine's supersets over
the positions started, `together` says so (`now` the groups done, `was` the routine's, as entry
ids) and writing it groups the positions as they were done. Until it is performed, the
difference belongs to the day and tomorrow is dealt as the routine was written. `only` takes
some of it: the marks `get_day` lists under `differs` (`terms:<entry>:sets`, `instead:<entry>`,
`without:<entry>`, `added:<entry>`, `order`, `together`), and what is not named stays the day's own. A
training done in a version takes what it did instead into that version's substitution for the
entry, and the plan as written is left as it was. A day that goes on reading the plan's earlier
version keeps all of its own changes; what of them the routine already carries `get_day` lists
under `inRoutine` (`from`, the first day of the plan's current content, and its `differs`)
instead of under `differs`, and `adopt_day` does not write it again.

The versions of a plan — the same work done with different exercises: `add_variant`,
`rename_variant`, `drop_variant`, and `set_variant_exercise` for one substitution at a time.
A version substitutes at an ENTRY of a routine and changes nothing else, so the plan goes on
asking for what it asked for and the version answers `with what`.

Everything you can change here that the app can change too is changed the way the app changes
it: both call the same act, so an operation cannot hold a version of a rule the screens do not.
A few acts are this surface's own and say so (`AGENT ONLY`): ordering stages, closing a stretch
by naming a day.

Every argument is checked before anything is written: a date that is not a calendar day, an
exercise the database does not know, an entry that is not in the routine named, a weekday
outside 0–6, a reserve (`rir`) or a position's rest that is not a whole number from 0 up, an
argument of a kind its schema does not name (text where a list is asked, a number where text
is), an argument a writer does not take (`notes` where it takes `note`), a set carrying a key the model never reads (a set is `w`, `r`, `s`, `d`, `warmup` and `rir`; a working
set needs one of `r`, `s` or `d`, and a warm-up one of `w`, `r`, `s` or `d`). A refusal is a sentence saying what was wrong; it is never a write that half
happened.

Start with `overview`. It says which plan is placed on today, which stage it is in and since
when, its week of how many, the plan's round, whether it has ended, the stage's terms as they
stand and the day the stage is expected to end, what the plan's routines and the places are
called (`routines` and `places`, each `{ id, name }`), and how much has been logged — enough to know what any other question is about. `today`
is the day on the person's calendar: read in `zone.name`, the zone their dziennik records
(`profile.me.tz`, the zone the profile was last edited from in the app, or first saved from where
it never was), or in this machine's zone where it
records none - `zone.from` says which, `dziennik` or `machine`. Every operation that defaults to
today, and the day a write is filed under, reads it in that zone. `get_plan` adds what
the plan does past its last stage, every visit to a stage it has made, and every stretch of a
stage on the calendar.

### Managed only through the agent

Some of what the model carries is managed through this surface alone. It is real data and this
surface reads and writes it, but the person cannot see or manage it in the app — so do not send
them to look for it, and do not read its absence as something they did wrong.

**Places.** A training records the room it was done in and history is kept per place, and
places are managed through the agent: the app has no screen that creates, renames or removes
one, and nothing binds a version to one. Expect most logs to name one place or none.
`add_place`, `set_place` and `drop_place` are the only way one exists at all, so a place made
here is a place the person cannot rename or remove themselves — make one when they ask for it,
not on your own initiative.

Operation descriptions say this too, on each one it touches: look for `AGENT ONLY`.

## What the model means

- A **routine** (A, B, C, D) is an ordered list of **entries**. An entry HOLDS an exercise,
  a set count (a whole number, 0-20) and a rep target. `sets: 0` excludes it from the stage
  without removing it.
- A **stage** holds the week layouts the plan cycles through, and its layouts point at the
  plan's routines. `add_stage` COPIES the routines the stage before it dealt, so the new stage's
  work is edited on its own, and `drop_stage` takes those copies back with it. The person
  ENTERS a stage, and the entry is a dated record — the only thing that ever moves a plan to
  another stage, the step from its last stage back to its first included. The stage in force on
  a day is the latest visit begun on or before it, and consecutive entries naming one stage are
  one visit, counted from its first - except an entry on a day the plan did not stand the day
  before, which is the plan begun again and a visit of its own. A period that opens after a gap
  left by an earlier period ending begins the plan again at its first stage even with no entry on
  its first day, and moving a period's start past a stage entered later leaves it in that stage.
- A row may stand for several weeks — `rep: 6` is how a mesocycle is written down, and the
  model expands the rows on every reading. `rep` is a whole number from 1 to 52; a stored one
  above 52 reads as 52. The row advances only over weeks holding a TRAINING
  of the plan (a session with a working set, under one of the plan's routines) since the stage
  was entered; a free training or another plan's moves nothing. A row that deals no training (a
  week of rest) passes with its calendar week. Forward the calendar projects one
  row per week from the later of today and the stage's start, and says it is a forecast. Past its
  rows a stage goes round them again while it waits to be moved on and counts its weeks on; a
  plan of one stage, and a last stage the plan keeps going (`after: stage`), repeat their rows
  and wrap the week; a plan that ends (`after: end`) has ended once its last stage's rows are
  through, and deals nothing more.
- A **plan** is PLACED on the calendar over STRETCHES — `{planId, from?, to?}`, both ends
  optional — so one plan may run over several periods, several plans may stand at once, and
  none of them is "in force" as a flag. A stretch with neither end fills any date. A stretch
  opened where the plan did not stand the day before enters its first stage on its first day,
  unless that day already holds an entry; that entry names the stretch (`placementId`) and
  moves with the stretch's start; an entry made by hand on a stretch that continues the plan
  stays on its day; one with no `placementId` on the first day of a stretch that began the plan
  again moves with its start and still has no `placementId`.
- A **day may hold several trainings**: one per plan standing on it that puts a routine there,
  plus free trainings. A session is identified by its date AND the routine it was — or by its
  own id, which is what a free training (`wolne`) has to be reached by when a day holds two — and each
  training carries its own place, version, duration, note and mark.
- A **place** is a room you train in — a name, and optionally what it has. It never selects
  anything.
- A **variant** substitutes exercises at named entries of one routine, and nothing else.
  Which one you are doing is chosen DURING a training and remembered on that session; a new
  training opens on whichever the last one used. A substitution carries the exercise it was
  chosen against, so it retires itself when the plan changes what it asks for at that entry.
- A **deload** is a fraction of the sets, rounded up — or down, where the plan's `round` says
  so, which the app's plan settings set — with a floor of one set, and it is a
  property of a TRAINING — there is no light week. `deloads: { "<routineId>": true }` on a week
  layout says that training of that week is light, and a `deloadWeeks` record
  `{ week, date, routineId }` says by hand that the training on that date is light. A record
  with no `date` says it of that routine on every day of the week. There is no deload stage, and an exercise added
  on the day is not trimmed.
- A **plan is versioned as it is edited**: what it said over a stretch of days is sealed when
  it changes, one record per `(planId, from)`, so a past day is read against the plan that
  stood then — `get_day` reads that stretch, and only a WRITE ever touches the plan as it
  stands now. Write a plan through the tools rather than into the document: that is where the
  sealing happens.
  A plan written before versioning existed has no first day to seal from, so its first edit
  claims today and seals nothing — days before that have no stretch to read and are drawn
  against the plan as it stands. Nothing can be reconstructed there, which is why the reading
  never lets the plan decide what was LOGGED: work whose position has since been dropped comes
  back under `alsoLogged`, and a record logged against a different exercise than its position
  now asks for says so on the spot.
- A **training may differ from the routine it was done under**, and the difference belongs to
  the DAY: the session carries `asked` (the terms for this day), `added` (a position the
  routine has not got), `dropped` (one the day did without) and `sub` (what was done instead at
  a position). Saving those into the routine is a separate act, and an edit of the plan like
  any other: it seals the stretch the plan stood in where that stretch began before today.

### A day is not an execution of its routine

The routine says what to do; the training says what happened. They are separate records, and
which one you write is the difference between a change for today and a change for every week
from now on.

- An exercise added with `add_day_exercise` belongs to that TRAINING. Tomorrow's asks for
  exactly what it asked for before. `add_entry` is the other one — that changes the plan.
- `drop_day_exercise` on a position the ROUTINE deals sets it aside rather than deleting it:
  the plan is not the day's to edit, so it comes back tomorrow, and `get_day` reports it under
  `doneWithout`. On one the day itself added, it is simply gone. `keep: true` puts one back.
  A row that carries sets is not dropped — what was written down happened; drop the sets first.
- `set_day_exercise` is "the rack was taken, I did this instead". The position keeps its place
  in the order and the plan is untouched; `get_day` says what the row stands in for, and the
  sets already logged against the position are re-filed under what it now runs. A position the
  day itself added is swapped on the position and cannot be taken back — there is nothing to take
  it back to. A substitution that should hold at one PLACE every time is a version, not this.
- `set_day_terms` is this day's own sets, reps, rest or reserve. Pass `null` to let the plan's answer
  stand again — the override is removed, not set to nothing.
- A skipped training is a record, not the absence of one: it is a training decided against,
  and it stays on the day saying so.

Every one of these opens the training if the day has none, because a day is edited more often
before it is trained than after.

`get_day` is where the entry ids come from. Nothing else on this surface hands them out. Its
`sets` is what the position asks for TODAY: a light training trims it to the plan's fraction, and a
position the day added, or one the day answered for itself, is never trimmed.

## Things that will otherwise go wrong

- **Never invent an exercise id.** Run `search_exercises` and use an id it returns. The
  database has 1089 entries with Polish and English names; an entry holds an id.
- **The log is keyed by id, never by a name.** A session is a header plus one record per
  ENTRY performed, and that record names the exercise itself — the plan is not consulted to
  find out what was done. The entry is what tells two rows of the same exercise apart.
- **Volume is counted from the exercise actually performed** and weighted by its muscle
  profile. An exercise whose profile says nothing is reported as UNATTRIBUTABLE rather than
  counted as zero.
- **Every reading states its window and refuses when there is not enough**: a load increment
  the person gave the exercise in the app answers at once, and otherwise needs two loads ever
  used; a capacity trend needs two sessions at one load with a reserve.
  "Not enough to tell" is an answer; a guess is not.
- **A space holds a v5 document**, and a v4 one is read as a v5 holding no `marks`. One of
  another shape is refused with a sentence rather than half-read — say so to the user instead
  of writing over it.
- **Weights are kilograms.** Omit the weight for a bodyweight set rather than sending 0.
- **Some exercises put two of the load in your hands.** `search_exercises` reports
  `loadUnits: 2` on those — a dumbbell in each hand. Write down the weight of ONE, which is
  what is stamped on it and what the person reads off the rack; the app counts both when it
  sums kilograms. Doubling it yourself would double it twice.
- **Say which training of the day you mean.** A date may hold several — one per plan standing
  on it, plus a free one — and every writer takes `routine`, the routine's id. Omitted on a day
  that holds one, it means that one; omitted on a day that holds two, it is an error rather
  than a guess. Omitted on a day that holds none, a writer that may open a training opens the
  one the day deals where it deals exactly one, and a free training otherwise.
- **Dates are `YYYY-MM-DD`, zero-padded.** Every reader compares them as text, so `2026-8-3`
  sorts after `2026-08-19` and a record written with it is one nothing will ever find.
- **A workout logged afterwards has no duration of its own.** The sets are stamped when
  you write them, and the app infers the span from those stamps — so a session typed up
  in five minutes reads as five minutes. No operation here writes the real times: the person
  states them from the training's card menu in the app. Do not invent them.
- **Writes merge, they do not overwrite.** The user's phone syncs into the same dziennik
  while you work, and both survive: `agent.mjs` sends only the records an operation changed,
  and the server keeps each record by its stamp, so what the phone wrote meanwhile stands beside
  it. Do not attempt to read the whole document, change it, and put it back yourself.
- **The cloud holds the newest part of the dziennik, not always all of it.** An account's room
  is limited, and where the dziennik passes it the cloud keeps the newest whole days that fit:
  `overview`'s `cloudFrom` is the day the cloud starts on. Trainings, their sets, measurements and
  sealed plan stretches dated before it are on the person's devices only - you cannot read them,
  and a write dated before it is refused. A training before it done under a routine left its day
  and routine behind, and `overview`'s `week`, its terms and `stageEnds` count those, as the app
  does. Say so when a question reaches further back, rather
  than reading the absence as nothing having happened. `null` means the cloud holds everything.

## What is on the wire

    GET  /api/sync?since=<seq>        Authorization: Bearer <access key>
    POST /api/sync                    Authorization: Bearer <access key>
    GET  /api/space                   Authorization: Bearer <access key>

`agent.mjs` exchanges records at `/api/sync`. A record travels as `[collection, id, record]`,
and every write to the dziennik is a commit with the next `seq`. A `GET` with `since` answers
`{ seq, at, v, cloudFrom, changes }`: the records written after that commit, and nothing where
none were, and the day the cloud starts on ('' where it holds everything). A `POST` of
`{ since, changes, day, v }` takes each record where it wins by its stamp - none dated before the
cloud's start, which it counts as `outside` - and answers the same for what others wrote after
`since`. A record that leaves the cloud when its start moves forward leaves without a tombstone:
it is no deletion. `/api/space` is the document door: the whole
dziennik as one document, `{ v, at, <collection>: { <id>: record } }`, the same thing the app's
"pobierz kopię" saves; the versions are read there too.

The key travels in the `Authorization` header rather than the address, which every log on the way writes down; `?k=<access key>` is the old way, still taken for agents made before the header, and read only where no header came. A read or a write of the dziennik
that lands carries `x-hekslog-perm` (`read` or `write`); a refusal of the key does not. A write with
a `read` key is refused with 403, and so is an unknown key — from outside, a revoked key and a wrong key are the same thing. A dziennik a newer
app wrote refuses a write of an older shape with 409 `space-is-newer`, and a server refuses a write of
a shape newer than its own with 409 `server-is-older`. The server knows your key
only by its SHA-256, which is what lets it enforce the permission and record when the key was
last used.

A space written before that may still be sealed, `{ v: 2, kdf, iv, ct, keys }`, until its owner
opens the app while logged in. A key made while the app still wrote that envelope has its own
wrapped copy of the master under `keys.<sha256 of the key>` and reads it; a key made since has none,
and reads the space only once it moves. You must not write to it: `agent.mjs` refuses, and the
server answers a readable write over a sealed space with 422 `space-is-sealed`. `/wire.txt` has
the envelope for a client of your own.

`agent.mjs` also refuses two writes before they go: one that would remove most of what the space
holds alive, and one made after somebody replaced the dziennik (a newer `marks.replaced`) since
your read — read again and make the change on what stands. The server refuses the first from any
key too, with 409 `would-bury`: replacing the dziennik is its owner's act, in the app.

## Interface language

Operation names, arguments and errors are English. Values are the user's own data and
stay Polish: exercise names, place names, weekday labels. Weekdays are keyed by
number (0 Sunday … 6 Saturday) wherever a tool accepts one.

## What the screens say

The app draws its screens in Polish, and `get_view` answers in the words they are drawn in.
What each word means, by where it is said - with the `get_view` screen it comes back in - and
a word followed by a figure or a name is said with it (`etap 2`, `przebieg 3`). Written from
`log/core/view/glossary.js`, the table the screens read their words from.

### Signs

- `′` - after a routine's letter (date bar, day card, dziennik): the training differs from its routine - an exercise swapped, added or done without, a term answered on the day, or the order - beyond what the routine as it stands now already carries

### A training on the calendar (`date-bar`)

- `lżejszy` - a light training: it asks the plan's share of each position's sets, rounded the plan's way, at least one
- `zrobiony` - finished: every row of the training has its asked sets
- `zaczęty` - begun: a working set is logged and something is left
- `pominięty` - the person skipped the training, and no working set is logged in it
- `trening poza planem` - a training outside every plan (routine `wolne`)
- `dzień wolny` - in a stage's week grid: no training is dealt on that weekday

### Stage edges on the date bar (`date-bar`)

- `początek etapu` - the stage named after it begins on this day
- `przewidywany początek etapu` - a stage the plan page is looking at, drawn as if it were entered on the read day
- `koniec etapu` - the last day of the stage named after it
- `przewidywany koniec etapu` - the day the stage is expected to end - walked forward from its weeks and counted terms, not entered

### The mark a training is given (1-5) (`day`)

- `Słabo` - mark 1 of 5
- `Tak sobie` - mark 2 of 5
- `W porządku` - mark 3 of 5
- `Dobrze` - mark 4 of 5
- `Świetnie` - mark 5 of 5

### The day's cards and rows (`day`)

- `Jak poszedł trening?` - the question standing where a training has no mark yet
- `etap` - followed by a number: a stage nobody named, by its place in the plan
- `tydzień` - `tydzień X z N`: week X of the N weeks of the stage's list
- `przebieg` - on a day card, followed by a number: which time round - the stage's own list where it repeats (a plan of one stage, or a last stage the plan keeps going), the plan's round otherwise; said from 2
- `plan zakończony` - the plan has gone through its last stage and ends there, so it deals nothing more
- `dzień wolny` - this plan deals no training on the day, while another plan standing on it does (where none deals one, no card is drawn)
- `Postęp w etapie` - the fold under the plan's line holding the stage's conditions - headed by the stage's badge, with a bar and its count (`1/4`, `-/4` while there is too little to read) for each read condition to move on, this name said to a screen reader; shut while they are not met, open by itself once they are
- `przejdź dalej, gdy` - heads the stage's conditions to move on, each as asked (`4 tygodnie w etapie`, `Przysiad: zakres powtórzeń przebity 2 treningi z rzędu`); a read one shows its count against the number asked (`1/4`), and beside it the exercise that decided a condition about every exercise or whichever comes first
- `wstrzymaj, gdy` - heads the stage's terms that argue against moving on
- `nieliczone` - a condition's state where the plan declares one this build does not know: drawn, never met
- `za mało danych` - a condition's state where the stage has too little behind it to read it yet - an exercise not yet trained in it, a load with one training, no finished week: never met
- `niedokończone` - a condition's state where it names no exercise or muscle to read: drawn, never met, until the rules sheet names what it is about
- `ale` - over the offer to move on, followed by the conditions that argue against it and are met; the offer stands
- `reszta tygodnia` - beside a count of trainings that is reached: the stage still deals the rest of the week that count was reached in, and ends with it
- `po ostatnim etapie` - with the stage's terms met and no next stage: heads what the plan does after its last stage
- `Zmiany w rutynie` - the training differs from the routine, and the routine as it stands now already carries those changes (from the day named)
- `zrobione` - the row has every set it asks for
- `zamiast` - followed by the exercise the plan asks for at this position; the row did another one instead
- `przerwa` - followed by the exercise's own rest, shown where the position asks no terms
- `cel ustawiony w treningu` - the reserve (RIR) chip that is the reserve asked for this training
- `w toku` - said of the row marked as the one being done today: begun and not finished, and written into last
- `następne` - said of the row marked as the one to do next today: none is going, and it is the first not begun

### A row's slots (`day`)

- `ciężar` - the load field, kilograms
- `powtórzenia` - the reps field
- `sekundy` - the seconds field
- `dystans` - the distance field
- `RIR` - the set's own reserve field, 0-4 where 4 is four or more - drawn where the device asks the reserve for every set; the last working set's answers for the exercise
- `nieudana próba` - a slot written and not worked: an attempt that did not come up, which keeps its slot and no set number
- `jeszcze niedostępne` - a slot that opens once the one before it holds a set
- `sugestia` - a figure offered for an empty field: the change the last training of this routine calls for
- `jak seria wyżej` - a figure offered for an empty field: what the set above it in this row holds
- `poprzedni trening` - a figure offered for an empty field: what this position did the previous time this routine was trained
- `w innym treningu` - a figure offered for an empty field: what the exercise did last, in another training

### The rest strip (`rest`)

- `przerwa` - the rest after the last set is still running
- `po przerwie` - the rest asked is over and the clock counts past it
- `przerwa ustawiona w treningu` - the rest's length is the one the training asks at that position
- `domyślna przerwa ćwiczenia` - the rest's length is the exercise's default rest, as `set_rest` and the database set it

### The dziennik (`journal`)

- `pominięty` - a training declined, or dealt on a past day and never logged
- `trening bez rutyny` - a training logged under no routine
- `tonaż` - kilograms moved in working sets: load times reps, a load held in each hand counted twice, and a bodyweight exercise counting the database's share of the person's weight
- `ocena` - followed by the mark the training was given, of 5

### A line of the dziennik where the plan moved (`journal`)

- `plan aktywny od tego dnia` - a stretch of the plan on the calendar begins on this day
- `początek etapu` - a visit to a stage begins on this day

### Where a light training came from (`day`)

- `Lżejszy trening z planu` - the stage's week layout marks this training light
- `Lżejszy trening oznaczony ręcznie` - the person marked this training light by hand

### The plan list and where a plan stands (`plans`)

- `etap` - followed by `X z N`: the stage the plan is in, of how many
- `tydzień etapu` - the week of the stage's list, said where the plan has more than one stage
- `tydzień` - the week of the plan's only stage
- `przebieg planu` - the plan's round through all its stages
- `zrobione treningi` - how many trainings were done under the plan's routines
- `aktywny` - the stretches of calendar the plan stands on
- `nie dziś` - the plan has stretches, and today is in none of them
- `nigdy` - the plan stands on no stretch of calendar
- `zawsze` - a stretch open at both ends
- `po ostatnim etapie` - what the plan does after its last stage
- `gdy plan się skończy` - what a plan of one stage does when its list is through
- `lżej w tym tygodniu` - the read day's week makes this routine's training light
- `poza etapem` - routines the plan holds that the stage being read does not deal
- `aktywne tego dnia` - plans standing on the read day
- `pozostałe plany` - every other plan
- `warianty` - the plan as written, then its versions

### After the last stage (`plans`)

- `powtarza ostatni etap` - the plan keeps repeating its last stage
- `zaczyna od początku` - the plan goes back to its first stage
- `kończy się` - the plan ends

### A plan's page and its sheets (`plan`)

- `etapy` - the plan's stages, listed where there is more than one
- `serie na mięsień` - the working sets a stage's week asks of each muscle, weighted by each exercise's muscle profile
- `przejdź dalej, gdy` - the terms that move the plan on from this stage
- `wstrzymaj, gdy` - the terms that argue against moving on
- `nieznany warunek` - a condition this build does not know: drawn, never met
- `za mało danych` - where the stage being trained stands against a term with too little behind it to read: never met
- `wybierz ćwiczenie` - a term about an exercise that names none yet, and the choice that names it: every exercise the stage deals, whichever comes first, or one of them
- `wybierz mięsień` - the muscle term that names none yet, and the choice that names one of the muscles the stage loads
- `warunek` - the choice that adds a condition to a side: each tally once, a state as often as wanted
- `większość ćwiczeń` - followed by what most of the routine's positions ask
- `0 serii - wyłączone` - a position asking 0 sets: kept in the routine and excluded from the stage
- `wszystkie` - the tab over a plan's routines that reads every one of them, those no stage deals included; each other tab is a stage and reads the routines it deals
- `superseria` - on a routine's position: it is done in turn with the positions of the routine that share its superset

### A stage's terms (`plan`)

- `tygodni w tym etapie` - finished weeks trained in the stage
- `treningów w tym etapie` - trainings done in the stage
- `zakres powtórzeń przebity` - an exercise topped the rep range its position asks, on the last n trainings in a row
- `ciężar nie rośnie` - the last n trainings in a row of an exercise moved no working load past the heaviest the stage had before them
- `wydolność przy tym samym ciężarze` - reps plus reserve at one load moved by at least n across the stage, the way asked (`spada`, `rośnie`)
- `serie na mięsień w tygodniu` - working sets for a muscle, weighted by each exercise's profile, in the last finished week of the stage, at least n

### What a stage's exercise term is about (`plan`)

- `każde ćwiczenie` - every exercise the stage deals: met when the one furthest behind is
- `którekolwiek ćwiczenie` - whichever exercise of the stage comes first: met when the one furthest ahead is

### The way a capacity term moves (`plan`)

- `spada` - reps plus reserve at one load fell by the number asked
- `rośnie` - reps plus reserve at one load rose by the number asked

### What a light training keeps (`plan`)

- `wszystkie serie` - every set
- `połowę serii` - half the sets
- `dwie trzecie` - two thirds of the sets
- `trzy czwarte` - three quarters of the sets

### How a light training rounds (`plan`)

- `w dół` - the share of sets is rounded down, at least one
- `w górę` - the share of sets is rounded up

### Pomiary i cel (`measures`)

- `od startu` - the reading since the standing goal began
- `zmiana wagi` - the weight's change since the goal began
- `do celu` - kilograms left to the goal's target weight
- `osiągnięta` - the target weight is reached
- `tempo` - the weight's change per week over the window read
- `spożycie` - the average daily kcal written over the window read
- `zero kaloryczne` - the daily kcal that hold the weight: measured from the weighings and kcal written over the window read, with its 95 % error, or typed in
- `cel` - followed by what the goal sets for the figure above it
- `brakuje` - followed by what a figure still needs
- `skład ciała` - body composition: the body-fat figure and the waist
- `tkanka tłuszczowa` - body fat, per cent
- `wpisane ręcznie` - a figure the person typed in rather than one the app worked out
- `szacunek z obwodów` - body fat estimated from the tape (waist, neck, height, and the hip on a female body)
- `duży błąd` - the measured maintenance may be off by more than 200 kcal a day
- `szacunek` - a body-fat figure worked out from the tape
- `wpisane` - a body-fat figure typed in
- `domyślne` - the goal's pace is the middle of its band, since none is typed
- `zgodnie z celem` - the weight moves at the goal's pace: within 0.1 kg or a fifth of it
- `szybciej niż cel` - the weight moves the goal's way, faster than its pace
- `wolniej niż cel` - the weight moves the goal's way, slower than its pace
- `waga stabilna` - the weight stood, to the hundredth - or, under a goal to hold it, stayed within its band
- `waga spada` - the weight goes down, against the goal's direction or out of a hold's band
- `waga rośnie` - the weight goes up, against the goal's direction or out of a hold's band

### The named goals (`measures`)

- `masa` - a goal to gain weight
- `utrzymanie` - a goal to hold the weight
- `redukcja` - a goal to lose weight

### Records nothing points at (Konto i dane) (`account`)

- `zapisane serie` - logged sets whose training is gone
- `własne ćwiczenia` - exercises written by hand that nothing uses
- `zamiany ćwiczeń` - substitutions under a routine that is gone
- `warianty planu` - versions with no substitution, of no plan that stands
- `okresy w kalendarzu` - stretches of a plan that is gone
- `wejścia w etap` - stage entries of a plan that is gone
- `rutyny` - routines of a plan that is gone that no training was done under
- `ćwiczenia rutyn` - positions of a routine that is gone
- `dawne stany planu` - sealed past states of a plan that is gone, and second copies of one sealed stretch

### The account card (on a device) (`account`)

- `Konto lokalne` - no account: the dziennik is on this device only
- `dane czekają na logowanie` - the dziennik goes to an account once this device logs in
- `Wszystko w chmurze` - the cloud holds the whole dziennik
- `W chmurze od` - followed by the day the cloud starts on; what is older is on the devices only
- `tylko na tym urządzeniu` - followed by what this device alone holds

### Kinds of account (`account`)

- `Lokalny` - no account: the whole dziennik on one device
- `Darmowy` - an account that syncs, within its room, with a read-only agent key
- `Premium` - an account with more room and more days of versions than Darmowy, and agent keys that read and write
- `Premium AI` - Premium with an agent built into the app; not available yet

### The sync mark on the Profil tab (on a device) (`shell`)

- `zmiany nie trafiają do chmury` - the exchange has stopped and changes are not reaching the account

### The panel on one exercise (`exercise`)

- `Pozycja startowa` - the starting position
- `Wykonanie` - how the movement is done
- `Oddech` - breathing
- `Na co uważać` - what to watch out for
- `ciężar ×2` - the load is one implement in each hand: the weight of one is written, and tonnage counts both

### Movement tags (`exercise`)

- `pchanie` - push
- `ciągnięcie` - pull
- `przysiad` - squat
- `zawias biodrowy` - hip hinge
- `tułów` - core
- `jednostronne` - one side at a time

### How a movement is built (`exercise`)

- `wielostawowe` - compound: several joints
- `izolowane` - isolation: one joint