Health and well-being¶

Kept on this device: $XDG_DATA_HOME/sioul/health.toml (what you enter), $XDG_DATA_HOME/sioul/health-days.toml (the days that differ from the usual one: below, "Each day its own") $XDG_STATE_HOME/sioul/health-state.toml (doses marked taken, reminders sent, reminders that could not be shown, errands made, chat minutes) and $XDG_STATE_HOME/sioul/health-doses.toml (each dose that fell due, and the answers your devices captured: below, "Doses as records"). These files go nowhere, unless you share between your devices: then they travel sealed, through a folder your sync carries (database.md). The errands it makes are tasks in a list your phone has (below), and their titles name the medicine.

Medicines¶

What it is: its name, the brand on the box or your own word for it, which reminders, the day's list and a phone's card say; and, optional, for whoever prescribes or hands it out, the generic name of its molecule as you type it (the INN, "levothyroxine"; « DCI » in French) and its strength ("75 µg", "500 mg per tablet"), apart from a take's amount ("1 tablet"). With a generic name and no name, the generic name is its name. When it was first taken, if you know (Taken since, its own form only). In both forms; in a prescription's rows, beside the name on a computer, folded under it on a phone (a tap unfolds them; filled, the fold says them).
When: at set times each day, each a take (below), every few days from a day ("every other day at 08:00, from Sunday 4 October"), or every few hours ("every 8 hours; next: today at 17:30"); until a day, or for as long as it goes; paused for now.
Takes, at set times each day: rows in the medicine's form and in its prescription's (qml/TakesEditor.qml), each a time picked, not typed (an hour, then a minute every five, the minute set kept when it falls between: qml/TimeField.qml; Tab and the arrows reach both), and its own amount, only where it differs from the medicine's dose (1 tablet at 08:00, 2 at 20:00: the dose "1 tablet", the 20:00 row "2 tablets"). Add a take adds a row at a usual time not taken yet; each row can be taken out. No take, a time that does not read, or two takes at one time (one dose, whose amount would be lost) are said, and nothing is saved (Medicine::set_takes, health::apply_medicine).
On the page, its content rather than its settings (qml/MedicinesSection.qml): under the day's list, or in a column of their own on a wide window (below, "The page"). Each medicine with its dose and its times ("07:30", "12:30 · 20:00"), or, when its takes' amounts differ, each take with its own ("08:00 · 1 tablet, 20:00 · 2 tablets"); every few days or hours in the words above; and until when; its name said precisely, with its generic name and strength ("Thyrolan — levothyroxine 75 µg"; the generic name once when it is the name: Medicine::precise); paused, or past its last day, quieter. Add a medicine and Edit open its form (qml/MedicineDialog.qml, made the first time, scrolling when its takes are many), and Take it out there asks once. Nothing of today's doses: they are in the day's list.
Each dose says its take's amount: in the day's list, its reminder (desktop and phone), the Porch, the question on doses due while Sioul was closed, a phone's home screen card ("Iron · 2 tablets", Health::doses, by the time of day the take is set for, so that a dose a change of hour moves, 02:30 to 03:30, keeps its amount). The doses fall due as before: a take's amount never enters a dose's key (<medicine>@<time>), its marks, its record or its reminder's timing.
On the day: each dose in the day's list and its timeline (below, "The page"); today's with "Taken". A dose taken says when; one click takes it back. A dose not marked is simply not marked: nothing counts what was missed, nothing turns red. Another day shows its doses plainly, without marks: the page keeps no record of the past.
Two kinds of medicines: at set times of the day, they keep their times (being ready for something); every few hours, they keep the hours between two doses, which the body (the liver, the kidneys) needs to clear one before the next: each dose taken, on time, early or late, sets the next one that many hours after it (Health::taken_at, the schedule's start moved to the time taken plus the interval). A mark taken back puts the doses back where they were, unless they moved again since (HealthState::moved). The move lives in the medicine, which travels whole between devices; changed meanwhile on another device (its note, its dose's text), the medicine there, its start as it was, could win everywhere and bring the next dose early. The moves travel with the marks, apart: each minute, a medicine whose start is one a mark moved it from goes again where that mark moved it, its other changes kept, and that goes to the other devices (Health::mend_shifts; review of 5 October 2026, F23; share::correctness_tests::a_late_dose_s_move_survives_an_edit_of_the_medicine_elsewhere).
Taken late: "Taken" pressed more than half an hour past the dose's time (on the page, in its notification, or for a dose due while Sioul was closed) asks when it was taken, now unless you say (qml/DoseTaken.qml), or that it was not; a medicine taken every few hours says its next dose comes that many hours after the time given.
Reminders: one desktop notification per dose, within half an hour of its time, without sound, with "Taken" where the desktop's notifications take buttons (Linux; on Windows and macOS the notification has none, and the dose is marked on the page). Not repeated. Reminders come in quiet time too: they are yours; and while you sleep, unless you asked doses to stay silent then (below, "Do not disturb"). On a phone they come otherwise, with the phone's sound (below, "On a phone").
While Sioul was closed: a dose of the last twelve hours, past its half hour, neither marked nor reminded anywhere, is asked about on the Porch at the next start, and above the day on this page ("Due while Sioul was closed, and marked nowhere Sioul can see: did you take them?", with Taken… and Not taken); a notification asks once a session, its "Answer" opening the Porch. A question on the past, never a reminder to take one now. Answered, it is not asked again.
What became of a reminder (review of battery part C, the third to sixth reviews, 14 October 2026). The rule: a dose's reminder is plain only on the device that knows it is the dose's first reminder; every other reminder, on any device, says the doubt first ("Check first: …"). A device knows it is the first in two ways only, each resting on a word written after the device it answers opened, never on a wait: the computer that kept the doses at the dose's time (or at waking, or at a pause's end), at its first try then, once every phone has said in the folder, before that time, that it read this computer's current opening; or a phone's alarm that has read, from every other device that could have reminded the dose, that device's own word that it did not. Two phones, a phone off or flat, a stall of any length, a restart: each can at most add a "Check first", never a plain second reminder, but for one case no design can close (below, "What it cannot know").
- Each device's word (sioul_core::dose_reminders, health-reminders.toml, a file of its own in the health part, each device's entry for a dose written by it alone and travelling whole): before each notice of a dose goes, the device writes that it is going (maybe; taken back only when the bus says no server took it, ServiceUnknown; any other refusal or a server gone with it may come after it showed, and keeps it); when one is shown (its server answered, or a phone's alarm showed it), shown; when its first try surely did not go out (nothing sent), unshown; and a promise, quiet: no notice of the dose from it until then (NEVER: none again). Each device takes only its own entries out, two days after their dose by its clock, never another's (a clock days ahead would else empty the others'); a device that stopped sharing has its entries taken out by every device that reads it so; any device's entries go a month after their dose (STALE_DAYS: a device forgotten, or reinstalled under a new id), forgetting being one device's view, counted not by the clock of the device that prunes alone but by the earlier of it and the newest dose the other devices' entries name, so that a clock a month ahead, there or on one other device, takes nothing of today's out (the ninth review's P1; a device's entries then stay while no device but the one that prunes names a dose a month newer). A file of its own because an older Sioul (0.0.3 to 0.0.5) does not know it and writes nothing in it, where a table of health-state.toml or a field of health-doses.toml would be dropped by its next save and taken out everywhere by the sharing; it keeps the file's changes waiting instead, forever, its quiet exchanges off (0.0.5) and its waiting list growing: update every device at once (docs/database.md). health-state.toml still says reminded and unshown for an older Sioul: a reminder not known shown is written there unshown, read by it as a dose not reminded, its alarm ringing plainly as it always did. A file that does not read is never read as "nothing done": a phone's alarm then says "what your other devices did to remind it could not be read here"; it is read again from every device's at the next exchange, and the doses due before are said not known for a day.
- The handshake (health::first_here, devices::Entry::acked; review of battery part C, the sixth and seventh reviews): each phone says, in its own entry (sealed with the sharing's key and bound to its id, as the rest of the entry), the opening of each computer's entry it read, the latest it ever read (an older copy put back never lowers it: the eighth review's N3; an entry dated more than ten minutes ahead of the phone's clock is set aside while it reads so, FUTURE, so that a clock once far ahead holds nothing there once set right: the ninth review's F1), of each computer it counts now; a computer it stops counting (said off, forgotten, silent a week) goes from it. Only phones write it, only of computers. A computer is a dose's first only if it is alone (sharing off, or no other device in the folder), or if its opening is written into the folder (its entry), its claim and records written, it kept the doses since before the dose's time (lease::Keeper::since; kept alone, since its process began), and every phone in the folder that has not stopped sharing, that you have not forgotten on this computer, and that no other device says it replaces (database.md, replaces: a new phone in place of a dead one) (counted or not, said off or not, silent or not) says, in its entry, this very opening (a word naming another opening, later or impossible, says nothing), and was heard on this computer within two hours (a copy of its entry newer by its own times than any read here, devices::written: a living phone restates it each hour, devices::RESTATED; an older copy put back by whoever serves the files is no news of it, and the word is read from the newest copy, of a phone whose entry reads now, never from an older one: the ninth review's W1; and it stands only where the copy read now says it too: a copy that is no news (an older one put back, one written in the same second as the one before, one of a phone whose clock was set back) may take the word away, never give it, and a phone whose copy read now is set aside, its clock more than ten minutes ahead of this computer's (FUTURE), gives none (newest_of; the final review before 0.0.6, F1H); and of the two copies of its entry read here (the folder's, the one fetched beside it), a computer that either copy no longer names is withdrawn, whichever is dated later, while a copy naming an older opening of it is only behind and takes nothing away (devices::chosen; the re-check before 0.0.6, LOW-2); a time seen here ahead of this computer's clock now, set back since, is not within the two hours; past them, the phone may have taken its word back unheard, said this computer off or stopped counting it: WORD_FRESH, the eighth review's N1, N2), seen here before the dose's time less two minutes and the most a phone's clock was measured ahead (word_lead); a device whose entry does not say what it is (an older Sioul, one not read) never says it, and the computer is never the first while it is in the folder. A computer back after three minutes or more without a tick of its own (asleep, the machine frozen: WAKE_GAP) opens anew: its entry says a new start, and a phone's word on the old one says nothing of it. Without all that it is as a computer opened after the dose: while a phone is in the folder (counted or not; or the sharing's key not read, the others unknown), no notice until five minutes past that phone's alarm, promised (QUIET_AFTER), then the doubt first, never plain, each other device named ("the phone may have reminded you too, by its own alarm"; "another of your devices may have reminded you at 08:00" when none can be named); its key not read, or its claim or opening not written, it says so: "this computer could not tell your other devices it was open, and one of them may remind you of it too".
- The computer (health::plan): its first reminder (the handshake holding, nothing of its own recorded for the dose) is plain within its window as the first (the wait for news: seven minutes while a phone may remind, LATE_UNTIL, ten without); the devices' doubts said first when there are any ("Knowing": what looks back, a record lost, a device apart, a line lost, counted from the dose's time, the moment a device may be opened for it from waking). Another device's notice sent and not known shown is said first, named: "desk may have shown its reminder at 08:00". Its first try fits in the tick's ten seconds (notify::FIRST_TRY: the connection, its two matches a second each, the server's two answers), and is recorded as it goes. Not gone out, it is tried again, five seconds apart for two minutes, then half a minute (each waiting as a slow bus needs, notify::TRY_AGAIN), always the doubt first: "Check first: Levothyroxine · 75 µg", "08:00. Sioul can't tell whether it was taken: its reminder, due at 08:00, could not be shown in time, and it may have been taken since without being marked. Check before taking it."; a late notice whose own record cannot be written goes all the same, the doubt first. While a phone may remind, none goes from seven minutes after the dose to five minutes after the phone's alarm, promised before that quiet begins; after it, the tries go on, the doubt first, whether the phone rang or not (off, flat, its alarms not set), until the dose is marked, answered or reminded anywhere this computer has read, or its half hour is over (then promised NEVER). The doses seen kept elsewhere a moment end the tries for now, nothing promised: back here within the half hour, the tick takes the dose up again, the doubt first. A notice sent and not answered in time is never sent again: its answer is listened for on its connection however late (a day at most), then it is recorded shown and said again in place, the doubt first, "its reminder, due at 08:00, was not confirmed in time, and it may have been taken since without being marked" (its "Taken" still counts, once; pressed before that answer, it is never said again over the press; a new number the server gives it, as GNOME does, is followed); or taken away, never recorded shown, when it is no longer to remind; refused late, or its server gone with it unanswered, it may have shown, and it is tried again, the doubt first ("its reminder, due at 08:00, was not confirmed in time"), while the half hour lasts. A notice still shown is taken away by its number once its dose is marked or answered anywhere this computer has read.
- The phone's alarm (dose_reminders::others): a computer keeping the doses, it waits for news ten minutes (WAIT_FOR_NEWS, from waking for a dose that waited for it), then reads what each other device that counts and shares the doses did. Shown somewhere: silent. Plain only when each of them is known, by its own word, not to have reminded it: its promise of quiet covering this moment (its clock's lead and two minutes allowed) with nothing sent; or a computer closed cleanly, everything it wrote read here, until a few minutes after the alarm (QUIET_AFTER, clocks allowed), and only when its entry is the one this phone said it read, or a later one (an older copy put back reads as no word), this alarm's own pull from the server went through since the dose, and nothing that computer wrote after its close was read (a claim renewed while open, an entry of the reminders): opened since, it is never the first before this phone said it read that opening, and it keeps quiet past the alarm. A computer never takes another computer's "closed" as its word. Else it reminds, titled "Check first: …", each device said first: "desk may have shown its reminder at 08:00" (sent, not known shown), "desk could not show its reminder at 08:00, and may have shown it since" (not gone out, no promise read), "desk was in use and may have reminded you at 08:00" (in use, no word of its own read), "FP5 may have reminded you too, by its own alarm" (a device whose entry does not say what it is), "desk has its clock more than ten minutes ahead of this one's, so what it says is set aside here" (its entry set aside: its times and promises say nothing here, and the doubt says the same, once; never "an older Sioul there?", which its claims, dated ahead too, would else suggest: the final review's words), "desk closed at 23:00, and its news can be slow to come" (closed as last heard, not its word: no pull through, or something later read), "tablet may have reminded you too, by its own alarm" (another phone, always), "what your other devices did to remind it could not be read here" (the file not read); then the devices' doubts ("Knowing"). Kept by the phone itself (in use at the dose's time), it waits two minutes for the computers' promises (FIRST_WORD). Before it shows, it records its own word (shown) and reminded.
- Questions on the past: "Due while Sioul ran, but their reminder could not be shown (notifications did not work then)…" when nothing went; "…their reminder may not have been shown (the notifications did not answer in time)…" when a device's notice went and was not known shown.
- Tested: sioul_core::dose_reminders::tests (the phone's proof, case by case, a later claim or entry, no pull; each device pruning only its own entries, and a clock a month ahead taking out no entry of today's), sioul_core::health::tests::at_waking_what_looks_back_counts_from_the_doses_time, sioul_sync::devices::tests::what_each_device_did_to_remind_travels_and_an_older_sioul_leaves_it, health::tests::every_phone_not_gone_must_say_it_read_this_opening, a_phones_word_counts_while_it_is_heard_and_never_goes_back, only_a_newer_copy_of_an_entry_is_news (older copies replayed hourly, a word taken back then an older copy served, a clock a year ahead and set right, Settings saying so), a_copy_that_is_no_news_takes_a_word_away_and_never_gives_one (the final review's F1H timeline: the desk quiet, then the doubt; a copy in the same second; a phone's clock set back), a_device_said_off_stays_so_until_it_says_anything_newer (F1L), a_computer_whose_clock_runs_ahead_is_said_so (the words, English and French, said once), a_word_the_lagging_copy_still_names_is_withdrawn (the re-check's residual: no plain reminder at 08:00), a_new_word_stands_while_one_channel_lags (and its cost), sioul_sync::devices::tests::of_two_copies_the_later_and_a_word_both_name, sioul_sync::devices::tests::a_phones_word_on_an_opening_travels_sealed_in_its_entry, notify::tests::reminders_keep_their_word (a try refused and taken back, the tries' end, the quiet promised and kept, a notice taken away once its dose is marked, a press before a late answer, a new number followed, the lasting notification closed once its late answer comes), reminders_go_on_after_a_late_refusal_or_a_lost_server, reminders_say_their_outcome_and_show_late_after_a_stall, reminders_whose_fate_was_not_known_say_the_doubt_once_known_shown, a_slow_bus_shows_the_reminder_late_the_doubt_first (stand-in buses and servers), health::tests::a_desk_opened_just_before_a_dose_is_never_a_second_first (the sixth review's R1 to R9), a_phone_reminds_plainly_only_on_the_others_word, a_computer_reminds_first_only_when_it_is_and_keeps_its_word, a_replaced_or_forgotten_phone_never_makes_two_plain_reminders_nor_none (a dead phone replaced by a new one, or forgotten at once: the desk the first again once the new phone read its opening, quiet then the doubt until then, the new phone's alarm owing the old one nothing, an older copy of the old one no news, the old one speaking again counted at once), a_phone_silent_a_day_is_offered_to_be_forgotten_now, at_waking_the_first_reminder_counts_from_waking, a_phone_held_by_sleep_waits_for_news_from_waking, a_reminder_that_may_have_shown_is_asked_about_under_its_own_question. The question's notification is titled for what happened: "While Sioul was closed", "A reminder could not be shown", "A reminder may not have shown", or "Doses due earlier" for several kinds (health::missed_title). The record travels with the others (a table of health-state.toml, kept a week): another device says the same.
On the Porch: every dose due today and not marked yet, from its time on, reminded or not (a notification can go unseen, and on a computer it is all there was): its time, its name and dose, Taken (more than half an hour past its time, Taken…, which asks when), and under it, when another device may know, the doubt ("Sioul can't tell whether it was taken: …. Check before taking it."). Whatever the hours: doses are not mail. It stays until it is marked (taken, or said not taken), the day ends, or twelve hours after its time, as far back as a dose is asked about; asleep with doses staying silent (below, "Do not disturb"), it waits for waking. Those due while Sioul was closed keep their question, under it (above). The notification is as before. Made off the window's thread with the Health page (health::porch_doses, HealthState::due_today; qml/PorchPage.qml), read again at each minute's turn.
Knowing, before saying: a dose taken twice can harm, so Sioul never says a dose was not taken when it cannot know (below, "Knowing").
One device reminds: the one you are using (sioul_sync::lease: the device used most recently keeps the medicines' reminders, and acts once it has kept them a minute and a half, time for your other devices to know). A dose marked taken goes to your other devices at once (a sharing exchange right away), and the question on doses while Sioul was closed waits until the others were heard from, so a dose marked elsewhere comes first.
Sharing is not optional for this: with medicines and Sioul on more than one device, share between them (Settings ▸ Sharing). Without it, the page says the doses are known to this device only; with it, it says what it cannot know for long (a device in use whose news stopped, an older Sioul, this device's record not reading) and the devices you said are off. The doses' marks and records are always among what sharing carries (state/health-state.toml, state/health-doses.toml).

Doses as records¶

Each dose that falls due becomes a record your devices share (sioul_core::doses, $XDG_STATE_HOME/sioul/health-doses.toml, in the sharing's health part), so that whether it was taken is an explicit state, not the absence of a mark:

Opened, not taken yet (the canary): the device that sees it fall due (the window's minute, a phone's alarm) opens it, with the medicine, the time it was due, and itself (opened.<device> = <when>), for doses of the last twelve hours that no device answered. Two devices opening it before they see each other make one record, both openings kept, the earliest named.
Answered: the first device to capture your answer turns it into taken (when you took it: earlier when you say so, "Taken…") or skipped ("Not taken"), noting itself and when (answer.<device> = { state, at, noted, name, kind }). Each device writes only its own opening and its own answer: the sharing, where the later word wins entry by entry, never has two devices fighting over one entry, and an answer travels whole.
Merged when read (doses::answered): the same answer on several devices is that answer, the earliest captured; answers that differ are all kept and all said, the earliest first ("Marked taken on the phone at 08:02, skipped here at 08:10. Check which is right before taking it."), on the Porch and on this page, with Taken and Not taken: you choose (health::choose), and the answers saying otherwise go, on purpose. A merge never takes anything out. A mark taken back ("one click takes it back") takes every "taken" out, on purpose.
Kept nine days after the dose (the page's week back, read only, and two days), then dropped by each device from its copy.
What it names: the medicine and when the dose was due, never its amount: a take's amount changed afterwards changes no record.
The marks beside: taken and not_taken in health-state.toml are still written with each answer, for an older Sioul, which reads them; and read as answers of a device not named. An older Sioul does not know the new file: its changes wait there, never written, never taken out.
Hardened as the record of marks (below): never read as empty when it does not read, or is gone though it was written before (a witness file beside it); the sharing reads it again from every device's records, the broken one is kept aside, and the doses due before stay not known for a day.

Knowing¶

Sioul may run on several devices that share through a folder another program syncs, late or not at all. Whether a dose was taken is said only when it is known; otherwise the doubt is said, with why and which device, and the person checks (sioul_core::health::doubts_now).

What each device says of itself (database.md, "Devices"): when it last started, when it last closed cleanly, whether it is working now (up from its start to the last step of a clean close, once an export read all it recorded: a crash, or a final export that failed, leaves it up), when it last read the others and when it last wrote its own, and how far its records went then.
Known not taken: a dose due at T, answered nowhere this device has read, is known not taken when this device's record reads, and every other device that counts is either
- closed cleanly, everything it wrote up to its last export read here: closed after T, or before T and not started since. Its last export holds every answer it captured, and it captures none until it starts again. Its close and its start are both on its own clock. Closed before T, it may be picked up right then to mark the dose, its sync slow to wake (a phone in a pocket); a phone is also opened by its own alarm, ten minutes after T when a computer keeps the doses (ALARM_AFTER), which may remind the dose or have it marked: from then on it is known only once the news of that opening had the time to come, counted from its alarm, never from T (review of battery part C, H2; sioul_core::health::tests::a_phone_put_away_is_known_from_its_alarm_once_that_rang). For the opening at T: how late the news of its openings came here lately is measured (Peer::wake: each start of its, seen while this device looked a moment before and its own news flowed, its clock's lead taken off; the longest of the last ten), and it is known closed only once that long went by after T, and two minutes more (SKEW: a clock's lead is measured less the quickest news seen, so each opening is timed short by as much). None measured yet, at once, as before (review of 5 October 2026, F21). This device's own news flowed when its own pull from the server went through within the last two minutes; its pull failing or late, an opening seen then is not timed: the wait would be this device's own outage. Where a sync app alone carries the folder, nothing here tells whether it paused, and an opening counts as an hour late at most (UNSURE_WAKE; review of 10 October 2026, R8: health::tests::an_opening_is_not_timed_by_this_devices_own_outage). A reminder waits for that, then comes plainly; a phone's alarm asks again then, not ten minutes later; a phone's home screen card says "check before taking it" for that while;
- in use, having exported after T (its clock, allowing SKEW, two minutes, a guess, and how far ahead its clock was seen) and lately (its entry seen changing here within five minutes, FRESH, this device's clock, and dated within it), everything it wrote read: an answer it captures goes out at once, and comes within the sync's own time. A phone in the background reads the others at its own pace, every fifteen minutes while you sleep and nobody is at a computer (every five while you are awake and no other device runs Sioul): so while a dose is due and not marked (from its time until it is marked, here or in the records another device sent, or its day ends) and another device runs Sioul, the phone keeps its two-minute looks, at night too, and a mark made at a computer reaches it within them; a record that does not read counts the doses whose time has come as open, in those hours alone, never before a dose's time nor past its day's end. Its home screen card says the dose plainly at most two minutes past such a mark, where FRESH alone would allow five (steps::keeps_close, health::dose_open_now; steps::tests::a_dose_due_keeps_the_phone_close_while_a_computer_runs, health::tests::a_dose_is_open_from_its_time_until_marked_or_its_day_ends; review of battery part C, 13 October 2026, F2 and G4).
Uncertain, the device named with when it last shared, under the dose: one in use that has not exported since T, or not lately ("Sioul can't tell whether it was taken: the phone was in use and last shared at 07:45. Check before taking it."); one in use and silent for over an hour (QUIET), which may have stopped without closing; one whose last export has not all come here yet (its entry came before its records, or a round of its records came before the end of the one before); a line of its records lost, written from twelve hours before T on (BROKEN_SPAN: a dose marked ahead of its time; dated by the line after it, at the latest, never by the line before it, which may be days older, nor by when it was found), and everything it wrote, all not known here until its next full round (a lost line is never counted as read; this device asks for that full round); one that does not share its doses (Health switched off there), unless it was closed before T (and, as above, its opening's news had the time to come); one closed before T whose openings' news has not had the time to come; an older Sioul, below; this device's own record broken or gone, for a day.
Lifting the doubt: by itself, as soon as that device exports after T or closes cleanly; or by you: This device is off, under the doubt, marks it not counted until it says anything newer (a new start, a new export, a claim renewed), said plainly on this page ("The phone counts as off, as you said: a dose marked there would not show here until it shares again.") and in Settings ▸ Your folder and sharing, where Count it again takes it back. It never answers the dose for you.
Clocks are not compared across devices beyond what they can tell: a device's start against its own close; its export against the dose's time with a margin (SKEW) and how far ahead its clock was seen: each time a newer copy of its entry is read, its export's date less this device's clock then is a lower bound of how far ahead it is, the largest of the last sixty kept (peers.json). A clock behind only makes Sioul wait longer. Settings says when a device's clock is a minute or more ahead. An entry that reads more than ten minutes ahead of this device's clock when it is read (FUTURE) is set aside while it reads so (Peer::set_aside): no news, no word of a phone, nothing it says counted, its doubt saying why ("desk has its clock more than ten minutes ahead of this one's, so what it says is set aside here", Doubt::Ahead), as Settings does ("Its clock runs more than ten minutes ahead of this one's: what it says is set aside here until its clock is set right."); taken, a clock a year ahead would hold its times there, an opening a phone said it read among them, for a year (the ninth review's F1). The same copy read again later, or one arriving late, within ten minutes by then, is taken, its lead measured at ten minutes at most: a phone's clock ahead is set aside only while its copies read more than ten minutes ahead here: far ahead with its news quick, it keeps that computer from being the first; its copies late enough, they are taken (the re-check before 0.0.6, LOW-1). The copy kept before stays the newest when it only looks ahead because this clock went back since, and so do the marks "off" and "forgotten" set against it, lifted only by a copy taken as news or a claim renewed since (the final review's F1L); one kept by a Sioul before this rule from a clock already far ahead when it came is dropped.
A device silent for seven days (SILENT_DAYS, a guess: a computer away for a long weekend comes back within it), by this device's clock and by its own, stops counting; Settings ▸ Your folder and sharing lists it with Forget this device. One first seen here lately counts for a week from then: never dropped for a date on another clock.
An older Sioul writes no entry: known by its claims, as before: heard in full after the dose and within five minutes, or its last word, read in full, that it closed and its news comes within three minutes (NEWS_IN), and, closed before the dose, once the news of its openings had the time to come, as above. A claim dated ahead of this device's clock is known only until now, and not at all when more than a minute ahead (its clock fast: what it marks meanwhile is not here yet). Never taken as closed for want of a word; an entry that does not read is none, and so is one saying it closed while its claim, renewed open after that close on its own clock, says it runs (an older Sioul put back there).
One rule for reminders, near the dose's time, and for what stays in view hours later (the Porch, this page, a phone's home screen card: known_until, until when a dose stays known while nothing new comes). A reminder of a dose not known waits up to ten minutes for news (seven, LATE_UNTIL, while a phone shares the doses: none goes from the computer after it until the phone's alarm, promised; above, "What became of a reminder"), then comes all the same, titled "Check first: …", with why; one known reminds plainly; the question on doses due while closed shows the doubt under each. A reminder is recorded as given only when it was shown (a desktop without a notification server, a phone before its alarms: another device still reminds it, and the question on the past still asks about it); one that could not be shown, or was not known shown, is recorded apart (unshown; what each device did, in each dose's reminders: above, "What became of a reminder"), so that its question says so rather than "while Sioul was closed".
The record, hardened: never read as empty when it does not read, is of no bytes at all, or is gone though it was written before (a hidden witness beside it says so, and a second one kept with the medicines in the data folder, which a state folder wiped whole leaves: review of 5 October 2026, F10 and F22): it is repaired instead. Written, its bytes reach the disk before it takes its name: a phone's file system can keep the name of a file whose bytes a crash lost (health::write_witnessed; cargo test -p sioul-core a_record_of_no_bytes_or_gone_with_its_folder_is_lost_never_empty). The sharing writes a mark received from another device the same way, witnesses included (until 10 October 2026 it wrote without either, so a device that had only ever received the record could find it of no bytes after a power cut and read it as sound and empty: share::correctness_tests::the_doses_records_the_sharing_writes_are_witnessed); a record not here that would hold no entry (only removals came) is not written at all (removals_alone_write_no_doses_record). Sharing on, the sharing first forgets holding it and reads it again from every device's records, this one's too, and the broken one is kept aside (health-state.toml.unreadable-<time>) in the same step, before any exchange can run (share::rebuild_then), so an empty new record takes no mark out elsewhere and gets back what was written; a new one starts. At the next exchange what the new record holds goes out as any change made here does, and the rest comes back from the records: a dose marked after the repair stays marked everywhere, even when an older record of that dose says it was taken back (final review of 15 October 2026, RF-J), and a mark taken back on another device and not read here yet stays taken back, since the old marks went aside with the broken record. The record writes no chat minutes while it has none, so a new record never resets the day's count on your other devices (review of 15 October 2026, P1); a minute of chat counted before that exchange still starts the count again from that minute. The doses due before stay "not known" for a day (health-doubt.toml, this device only). The record is changed under a lock shared with the sharing (sioul_core::filelock): before, the minute's tick could write back an older copy over a dose another device had marked meanwhile, and the sharing then took it out everywhere. The same for the doses' records (health-doses.toml).
What it cannot know: a device that starts again while its sync cannot carry the news (offline), and where a dose is marked: until its start reaches the folder, the others take it as closed, once the while its openings' news usually takes went by. The same time as any mark's own trip; a phone's Sioul asks its sync app to carry its start at once, when the app offers a way. What is left, said plainly (the seventh and eighth reviews):
- Ways to two plain reminders:
  - a computer opened with no network, which can tell nobody that it is open, and that sees no phone in its folder as last carried (a phone joined since, or never seen there): it takes itself as alone and reminds plainly, while the phone, which cannot hear it, reminds plainly too; the same between two computers when no phone shares the doses, one of them opened offline (the eighth review's N4). A computer that sees a phone in the folder (one not stopped sharing, not forgotten on that computer) is never the first without that phone's word on its current opening, heard within two hours;
  - within two hours after a computer that keeps running is cut off both ways (its network, the server, its sync app), saying it off on the phone: the phone's word taken back is not heard there until the two hours are over (the eighth review's N1), counted from the newest copy of the phone's entry read there: older copies put back by whoever serves the files do not stretch them (the ninth review's W1);
  - a phone you forgot on a computer while it still rings: outside the handshake there; forget only a device you no longer use;
  - a phone that takes back its word on a computer that runs but is silent there (its sends failing; "This device is off" said for it on the phone, or a week of its silence), less time before a dose than the phone's next entry takes to reach that computer: the computer reads the word until that entry comes, and may remind plainly meanwhile, while the phone does too. Whatever the clocks: in the re-check's runs, the phone 0, 8, 14 or 20 minutes ahead, its copies twelve minutes late, the desk reminded plainly each time; with copies two minutes late, it kept quiet (the phone 0 or 20 minutes ahead). A phone's clock ahead adds nothing to it and takes nothing away: its copies are set aside only while they read more than ten minutes ahead, and a late one is taken (its lead then measured short, by as much as its news is late: the eighth review's L5). Where that phone's openings were timed on the computer (Peer::wake), the computer waits that long and two minutes more before it is the first, and the withdrawal must come after that (the re-check before 0.0.6, LOW-1);
  - quitting at the dose's minute: a notice under way may go after the computer said it closed, and the phone may then take that close as its word and remind plainly too (a few seconds).
- "Check first" more often than needed: an older Sioul, or a device not read, in the folder: no computer is the first, each dose comes from the computer fifteen minutes late, "Check first"; the same while a phone in the folder never gives its word (dead, flat, a tablet rarely opened, the old id of a phone reinstalled), until you forget it on that computer (Settings ▸ Your folder and sharing: "Forget" is offered once it is silent a week, or said off); a computer started or woken within about two minutes of a dose is not its first either; a phone whose news comes through a sync app alone (no pull of Sioul's own) takes no computer's "closed" as its word: "Check first" while a computer exists. A computer that has read no newer copy of a phone's entry for two hours (WORD_FRESH) is not the first: it promises quiet until five minutes past the phone's alarm (QUIET_AFTER), so that the phone, reading that promise, reminds plainly ten minutes after the dose, and the computer stays silent once it reads that reminder, else says "Check first" fifteen minutes after the dose; offline, its promise does not reach the phone, and both say "Check first": no plain reminder at all (the ninth review's D2). That happens after an outage of about 45 to 60 minutes or more on either side before a dose (a living phone restates its entry each hour, and the two hours count from the restatement read last), at most doses while the phone's background steps are off (its entry then changes only when Sioul opens or an alarm rings), and most nights for a phone whose files a sync app alone carries, unless Android's battery optimisation is off for that app (deep Doze holds the app's scans for Android's maintenance windows). An older copy of a phone's entry served again (a sync app's put-back, a server's replay) from before its word on the computer's current opening takes that word away until the phone's next write (minutes while it is in use, the hour when put away), the computer having opened anew within that copy's age (the final review's F1H class fix; rare, on the safe side). While one of the two copies of a phone's entry a computer reads lags (its sync app, Sioul's own pull), a phone that starts counting that computer again, or is paired anew, gives its word there only once the lagging copy names it too; a channel stopped for good on such a copy keeps that computer from ever being the first (the re-check's LOW-2 cost).
- A server that shows a notice and never answers it: its "Taken" goes nowhere (its number never known); the phone says the computer may have shown it.
A newer Sioul's doses: should a later Sioul one day share the doses in a form this one does not read (database.md, "A newer format met"), its dose records wait here unwritten and do not count as read: what that device wrote is not known here, so a dose it may have answered stays in doubt. This device's own answers wait too; its exchanges then claim no export, its entry says it does not share its doses, and it never says it closed with all its answers out, after a restart too (the hold is read from the sharing's memory on the disk, share::holds): the others doubt a dose it may have answered, unless it closed before the dose was due, and never take one as not taken (a_held_doses_part_claims_no_knowledge_after_a_restart).
No news at the alarm: a phone's alarm whose own pull did not go through since it went off (failed, or too slow) asks the sync app instead; of each other device, only its entry or its claim on the doses saying more since then, by its own times (in the folder, or in what was fetched beside it), is news of it: a claim on another part (notices), a file touched with the same bytes or an older copy put back is none. A device of which none came, known closed only by what was read before, may have opened since and answered: the doubt is said with when it closed ("Sioul can't tell whether it was taken: your laptop closed at 07:02, and its news can be slow to come. Check before taking it."), whatever else the sync app brought (its notes, another device's files); one in use stays as FRESH has it (sioul_core::health::doubts_unread, remote::AlarmNews::SyncApp { heard }, share::news_missed; remote::tests::an_alarm_doubts_each_device_whose_own_entry_did_not_come, only_a_newer_entry_or_health_claim_is_news_of_a_device). The reminder then waits its ten minutes for news, as any doubt does, and comes with "Check first". The cost: every dose's alarm while the phone is offline says that doubt. Only where Sioul can pull from the server: without the backup, an alarm still takes the folder as the sync app left it after its twenty seconds, as before.
A sync app late: where the sharing folder lives on a Nextcloud one of your accounts reaches, the others' entries, claims and records are read on the server too, the newer copy of each (database.md): a phone whose sync app brings nothing down still knows the others as they are, and the doubts are the ones a fresh folder would give.
Tested: cargo test -p sioul-core generic_name_and_strength_written_only_when_given (written only when given, read back, said precisely, 0.0.3 reading the file, its doses the same; a generic name standing in for a name written by hand), cargo test -p sioul-app a_doctor_or_pharmacist_reads_the_generic_name_first (saved from both forms, the view of a prescription and of all taken now, in English and French), tools/qml-test.sh tst_takes.qml (a time picked with the keyboard, a minute between the steps kept, rows added at usual times and taken out, a take's own amount with the dose as its hint), cargo test -p sioul-sync share (a medicine's takes travelling whole into an older copy), cargo test -p sioul-core health (each take its time and its own amount; a prescription with three medicines and several takes each; an older file read as before; an older Sioul reading the new file; a take moved by the change of hour keeping its amount; and one test per case of knowing: the phone closed before the dose, closed after it without a mark, in use and exported after it, in use and not since, crashed then started again or said off, clocks a few minutes apart either way, silent seven days, not sharing its doses, each device said apart, an older Sioul by its claims; doubts as of now; a record that cannot be trusted; a reminder that could not be shown still asked about, told apart, kept a week, an older file as it was; one that may have shown told apart, an older Sioul reading it as one to give; a phone put away known from its alarm), cargo test -p sioul-core doses (answers merged by the earliest, answers that differ both kept, older marks, a canary opened twice, nine days), cargo test -p sioul-sync devices (two devices and one folder: the phone marking "Taken" from its notification in the background and the desktop showing it taken; raised but not exported, and records behind the entry; answers that differ kept on both; a canary opened on both; an older Sioul taking nothing out; two processes never undoing each other's session), share (what was read is known, a broken line said, a lost record rebuilt with nothing taken out elsewhere; and the review of 5 October 2026 rechecked, correctness_tests: a round brought before the end of the one before, a lost line dated by its own time, a late dose's move kept against an edit elsewhere), lease, cargo test -p sioul-app health (a prescription's medicines and their takes saved from its form, a row taken out, what cannot be saved changing nothing; a take's own amount on the Porch, the home screen card, the reminder and the late dose's question; what the claims and the registry teach; the Porch's doses: due now, due earlier and reminded, due while closed, due while Sioul ran but its reminder not shown, or maybe not (its own question, the notification's title in both languages); each device saying the doubt once another may have reminded; answers that differ, a device in use named with "This device is off", closed, said off, asleep, marked, the day over; your devices listed in words; how late a device's opening comes, timed while looking, and not by this device's own outage; an alarm in doubt asking again when the doubt may end; a claim from a clock ahead; the card saying "check" while a closed device may have opened; on health files written for the test), cargo test -p sioul-core a_device_closed_before_the_dose_is_known_once_its_opening_could_have_come.

On a phone¶

Android stops an app it does not see: Sioul in the background on a phone cannot remind at the minute as the desktop does. So each coming dose (the next two days, those not marked) is given to Android's alarm clock (crates/sioul-app/src/alarms.rs, android/), again whenever a dose is marked or a medicine changes. At its time Android wakes a small part of Sioul, even when Sioul was stopped, which first asks the sync app to bring what your other devices marked and reads it, then decides as the window would:

taken, said not taken, or reminded already somewhere: nothing;
not known the first: another device's word missing or saying it may have reminded it (a notice sent, a first try not gone out without a promise of quiet read, a computer in use not heard on it, another phone's own alarm): after the wait for news, the reminder titled "Check first: …", each device said first (above, "What became of a reminder");
kept by a device you use now: its turn first; asked again after the wait for news (from the dose's time; held by sleep or a pause, from waking);
not known (a device in use not heard since the dose, one that stopped without closing, an older Sioul: "Knowing" above): after the wait for news, the reminder titled "Check first: …", with why;
otherwise: the reminder, the medicine and its time, with Taken (more than half an hour late, Taken opens Sioul on when it was taken). The reminders come on Android's "Doses" channel, at its default importance: the phone's notification sound, no banner, yours to change in Android's settings (DoseAlarms.java). A reminder tapped opens Sioul on its dose. Android must let Sioul set exact alarms (Settings ▸ Apps ▸ Sioul ▸ Alarms & reminders); without it, alarms may come late, up to an hour (setAndAllowWhileIdle), and the page says so.

Shown to a doctor or a pharmacist¶

Show to a doctor or pharmacist, under the medicines (all those taken now: not paused, not past their last day) and on each prescription (its medicines): the whole window, read-only, to hold out across a counter (qml/ShowMedicines.qml, health::for_professional). Large type, one medicine a block: its generic name and strength first, then its name when it differs; each take, its time and amount ("07:30 — 1 tablet"; every few days or hours in words, with the amount); how long it has been taken, from Taken since ("Taken since Monday 2 March, 7 months"); who prescribed it (above, for a prescription's own view, with until when it is valid); until when, paused. In your language; the generic names as typed, international. One button, Close; Escape and Back close it too. Nothing else to tap.

Kept as¶

health.toml, readable and editable by hand. A medicine at set times each day:

[[medicine]]
id = "iron"
name = "Iron"
dose = "1 tablet"
prescription = "thyroid-and-iron"
[medicine.schedule]
every = "day"
times = ["08:00", "20:00"]

When its takes' amounts differ, a field Sioul 0.0.3 does not know, amounts, holds every take's amount by its time, and dose holds them all in one line:

dose = "08:00 · 1 tablet, 20:00 · 2 tablets"
[medicine.schedule]
every = "day"
times = ["08:00", "20:00"]
[medicine.schedule.amounts]
"08:00" = "1 tablet"
"20:00" = "2 tablets"

The same amount at every take: no amounts, dose that amount: the file is as before, field for field.
Generic name, strength, first day: generic = "levothyroxine", strength = "75 µg", since = 2025-08-04 on the medicine, each written only when given. name is always written, the generic name standing in when no name is given, as 0.0.3 needs one. None of them changes when a dose falls due, its key or its reminder's time.
What Sioul 0.0.3 drops: it reads generic, strength and since as nothing, and leaves them out at its next save of health.toml (any change on its Health page), as it does amounts; the name, the dose, the times and every dose stay. Shared, the medicine's entry then travels without them, and your other devices lose them too: update every device together.
An older Sioul (0.0.3) reads the times as before, so every dose falls due, reminds and is marked as before, with the same keys; it says the whole line with each dose ("Iron · 08:00 · 1 tablet, 20:00 · 2 tablets"), never one amount that is wrong for some takes. At its next save of health.toml (any change on its Health page) it drops amounts; the times stay, and so does the whole line, which this Sioul then says with each dose until the form sets the takes again. Tested on a copy of 0.0.3's own types (an_older_sioul_reads_the_times_and_says_every_amount).
Sharing: a medicine travels whole, one entry by its id (database.md): the new field travels with it, and an older device keeps it in its file until it saves the file itself (above). Your devices are updated together.

Meals, rest and sleep¶

Set first, the work planned around them (sioul_core::needs). The usual ones are set once, in the page's settings (qml/NeedsSection.qml in qml/HealthSettings.qml); a day that differs is changed on the page itself, that day only (below, "Each day its own"). The research behind it: research/meal-prompts.md, whose criteria are numbered below.

Blocks: meals (three when first turned on, one in the evening: Murphy et al. 2010; more in one step, "a meal or a snack"), naps (with minutes to come back after, as waking up takes a while: Hilditch et al. 2017), and the night (bedtime, waking, an hour to wind down: Harvey et al. 2021). Each is named as you like (none needed: "Breakfast", "Nap"…), at the time you set, on the weekdays you choose, its notices on or off (criteria 1, 4, 14, 23, 26, 27). Meals planned more than four hours apart are said where they are set, never in a notice (2).
Kept free: a meal from getting it ready to its end, a nap with its minutes after, the night from winding down to waking. The plan lays no task in them (plan::Settings::with_needs), every day, as each day has them (with_days); the Tasks page's day shows meals and naps, a step going around them (3).
Two notices at most, each once (5): a heads-up about the work, "No new big task", with the block's name and time, a quarter of an hour before, how long as you choose (criteria 4, 6, 9), then one at the time, its name and time. Each has one button, Options…, where the desktop's notifications take buttons (Linux; on Windows and macOS a notice is its name and time alone, and the same moves are on the Health page's day; but the night's own notice, which has Close the whole day too, as each system allows: reviews.md), which opens the question in the window (qml/Interruption.qml): a quarter of an hour later (you choose; as often as you like), Move to a time, or Not today, today only and without a word asked, and one line on where you stopped (7). A notice is never given twice for a block, moved or not: no nagging. Nothing else is said: none while an event goes on (the time stays kept: 22), none for a block not today (21), none when one passes (20). The same moves, and more, are on the page, for any day of its week (below). Only the block's name and time: safe on a screen someone else reads (24). Notices are said by the day a block starts on: a bedtime after midnight still has its own (before, it had none). From the computer you are at, as the doses. Not on a phone yet, but the night's own notice as it begins (android.md): there Android shows Sioul's notifications for the doses, the time running, events, new mail and the end of the day only; the blocks are kept free in the plan all the same.
Each day its own (3, 21–23): on the page's day or week, a block is a tap away from what changes it, that day only, nothing asked: 15 min later (as often as you like; the minutes are yours), Move to… a time, Change its times… (from, to; a meal's minutes to get it ready, a nap's to come back; the night's bedtime and waking), Not today (no notice that day, the time kept free all the same; Today after all takes it back), Back to usual, Remove from today (neither kept free nor said: its time goes back to the plan; the row stays, muted, with Put back); and Add a meal or a rest… for that day alone (removed with Remove); the night's No alarm at 07:00 (below, "The alarm at waking"). On another day the words say "that day". All of it in needs::Needs::change_day.
Moved by hand: on the page's timeline (qml/HealthTimeline.qml, qml/TimeDrag.qml), a meal with its getting ready, a nap with its coming back, or the night is dragged to another time on its day: whole, it keeps its length; by its bottom edge, a meal or a nap changes its length; the night's top edge is bedtime (its winding down before it, as long as it was), its bottom edge waking, in the next morning's column (tonight's waking is in tomorrow's: the next day, or the week). Where it would go is drawn while the hand moves, with a tag above it out of the finger's way: its times by whole five minutes ("12:45–13:35"), and "eating from 13:05" or "winding down, bed at 23:30". Let go, it is that day's change as Move to… and Change its times… make it (health::drag_need, then Needs::change_day), the plan goes around it at once, and "Undo" waits ten seconds in the status line, putting that day's block back as it was; let go where it was, nothing changes and nothing waits. A day past and a block over stay as they are; in the week a block moves within its own day; the night keeps its bedtime on its evening (noon to noon). With a mouse: press and drag (the wheel scrolls the hours). With a finger: a long press picks it up and the finger moves it; a plain swipe scrolls as before; a long press let go in place opens its menu. On a phone the whole day sits in a third of the screen, where a meal is a few pixels tall: a long press there opens the timeline readable (an hour 56 pixels tall, the page's height, the list behind it), the minute under the finger kept under it, and the block under the finger comes with it when there is no doubt which: the finger on it, or the only one within 20 pixels; two as close (a meal right after the night's end), none, and the next long press chooses. Readable, the ends that can be taken show a grip; Done, in a bar under the hours with how it works, or Back, folds it to the whole day. The keyboard has the menus (Move to…, Change its times…). One set of handlers for the whole timeline finds what lies under the pointer: the blocks carry none, and the page opens no slower.
Kept as times: in $XDG_DATA_HOME/sioul/health-days.toml (needs::Days), a table per day and block, readable and editable by hand: [2026-10-07."meal:1"] with at = "13:30"; wake for the night, minutes, before, after only where they differ from the usual ones; quiet = true, off = true; the night's no_alarm = true; one added has kind and name. So a usual time changed afterwards moves the usual days, never a day already changed; a meal or a nap taken out of the settings takes its changes with it, and those after it follow to their new place (Days::removed_usual). A past day stays as it was (DayProblem::Past): the page goes a week back at most, read-only; changes are dropped two weeks after their day. Today's moves an older Sioul kept in needs-today.toml are moved in once.
Pushed past events: a meal that would fall in an event moves after it, the time to come back from it counted (its margins, tasks.md), by whole five minutes, on every day laid out, so that the page and the plan agree; not a meal whose time you set for that day, nor one added that day: you chose it with the day in view (Needs::past_events_on). Its notices, the plan and the day follow.
Travels: a day's changes go to your own devices with the sharing's health part (data/health-days.toml, one entry per field), so that each plans the same day; a file rather than a table in health.toml, which an older Sioul would drop at its next save, and the sharing everywhere with it. The notices given stay on the device that gave them (needs-today.toml). None of it goes to anyone else (25).
Never (16–19, 29–31): food, portions, numbers, colours, streaks, counts, praise, generated text; no record of what was eaten or slept, no "missed", no countdown during a meal.
Not built yet: the heads-up at a breakpoint inside its window (8), a block tied to an event of yours rather than the clock (10), an if-then plan for the transition (28).

The alarm at waking¶

On a phone, an alarm can ring when the night ends (crates/sioul-app/src/wake.rs, needs::Needs::alarm_of; Android's side in android.md, "Waking").

Which mornings: seven switches under the usual night in the page's settings, Monday to Sunday in the language's order, none at first. A switch is the morning it rings on, not the evening the night starts. Kept with the night in health.toml ([needs.sleep] alarm = [true, true, true, true, true, false, false], Monday first), so set from any device; only a phone rings it. The setting says so ("Rings on your phone…"), and when it rings next.
When: at the night's end as the page has it that day: the usual waking, or the night's own waking that day (Change its times…, 15 min later); on the clock where the phone is, through the changes of hour (a waking the change skips, 02:30 on the last Sunday of March in Paris, rings at 03:30). A night removed that day: no alarm that morning. A night "Not today" still rings: that choice silences the night's notices, never the waking, which is asked for on its own.
No alarm that morning: the night's row says "alarm at 07:00"; its menu has No alarm at 07:00, and back, Alarm at 07:00 after all, for that night only, even after midnight while it goes on (no_alarm = true on the night's own day in health-days.toml). Back to usual brings it back too.
The ring: the phone's alarm sound, rising from very low to full over half a minute, until Stop or 10 min later, over the lock screen, the time and those two buttons, nothing else. After 10 min later, a quiet line says when it rings again, with Stop.
Never stopped silently: the phone is given the wakings of the next eight days, again whenever the night, a day's change or the mornings change, here or from another device (the sharing). It asks Sioul again at each ring, as each night starts and ten minutes before each ring (another device may have changed the night while Android kept Sioul frozen), after a restart and a change of time or zone. When Sioul cannot answer (its file not readable, Sioul not opened for weeks), the phone goes on with what it has, then with the usual mornings, repeated.
Try the alarm, on the phone, under the mornings (shown with the night off too, so that trying it changes nothing of the night): it rings ten seconds later, as a waking would, over the lock screen; nothing is written, and the next waking stays as it is. Its 10 min later rings once more, then Stop alone. When Android refuses what it needs (exact alarms, notifications, the full screen), it does not ring and says why.
Not tried on a phone yet: built and checked on a computer (Rust's tests; the Java compiled against android-36).

Do not disturb¶

The night, from winding down to waking, and each nap with its minutes to come back, are sleep, one of the five times (areas.md): what you set above makes them. While you sleep, almost no notification comes, as usual (the matrix's sleep column, sioul_core::attention, crates/sioul-app/src/hours.rs; attention.md): no site, no reminder before a date, no pause to move, no meal or nap notice; the codes you just asked for come, unless their sleep cell says On the Porch only. The night's own notice at its time, the start of the wind-down, still comes: it says the night begins and, while that day's review is not given, has Close the whole day beside Options… (Linux): how the whole day felt, what it asked and gave in words, tomorrow's first step (reviews.md). What waits comes at waking when it still makes sense (a reminder before its date passes, a site's notification at the next gathered time); codes stay on the Porch. What the window shows is shown when you open it.

Doses come all the same: you set their times, and a dose at 05:00 is meant to wake you. Settings ▸ What reaches you ▸ Sioul's own, the doses' sleep cell: At once (the default) or Later ([attention] doses; seeded once from [reminders] doses_in_sleep, attention.md §7). Later, a dose due while you sleep is reminded at waking, once, its time said (taken more than half an hour late, "Taken" asks when), and the question on doses due while Sioul was closed, and the doses on the Porch, wait for waking too; on a phone, Android's alarm asks again at waking, and when a computer keeps the doses it waits for that computer's news from waking, as it does from a dose's time (the computer reminds the dose at waking too: the two never remind it together, both plainly; health::news_from, review of battery part C, the fourth round). Sioul never silences a dose without that choice.
During a pause (pauses.md): as during sleep, nothing notifies but doses, unless you hold them there too (What reaches you ▸ Sioul's own, the doses' pause cell, [attention] doses; seeded once from [pause] doses; on a phone, Android's alarm asks again five minutes on, and once the pause is over waits for a computer's news from then, as at waking); held, they are reminded once on coming back. Alarms always ring. In Free time, doses come as always. Sioul never silences a dose without that choice.
The alarm at waking ends the sleep: it rings at the night's end, which is no longer sleep (quiet::Blocks::at: the end left out), and the phone rings it without asking Sioul whether it may. Android's own do-not-disturb lets alarms through, unless set to total silence.
No night set: no sleep at night, and nothing keeps notifications away. The Porch asks for it in a card, "Set my night", which opens this page at its meals and night, or "Leave as is".

Prescriptions¶

What it is for, who wrote it, until when it is valid, how many days the pharmacy gives at a time, when it was last fetched, a note: its form (qml/PrescriptionDialog.qml), from Add a prescription or Edit on the page.
On the page, under it, its medicines a line each when one has a generic name or a strength ("Thyrolan — levothyroxine 75 µg · 07:30 · 1 tablet"); else, as before, the names its title does not say.
Its medicines, as rows in its form: each its name, its dose and its takes (above, "Takes"); the medicines tied to it already (Medicine::prescription) come as rows. Add a medicine adds a row, at set times each day, one take at 08:00 to change; a row added and left empty is not kept. A row taken out goes at once when it was added there; a medicine saved before stays in the form, said in its row ("Iron is taken out when you save: no more reminders for it.", Keep it puts it back), and goes when the form is saved: no more reminders, its marks kept, as Take it out in its own form. A medicine taken every few days or hours shows when in words; its own form changes its schedule. The form is saved whole or not at all: a row without a name, or takes that cannot be set, are said with the medicine's name, and nothing changes (health::apply_prescription). A medicine made there is a medicine like any other: on the page, in reminders, in the doses.
On the page, after the medicines: each with who wrote it, then in words the next visit to the pharmacy and the day to renew it by, the soonest first ("pharmacy from Tuesday 27 October · renew by Thursday 4 February 2027"; once that day has passed, "valid until …", never a word of lateness), the medicines tied to it when its title does not already name them ("for Levothyroxine and Magnesium"), and Fetched today, with a check once pressed that day (health::prescription_rows).
Errands: two days before the medicines run out, a task "Pharmacy: …"; two weeks before the prescription ends, a task "Doctor: renew the prescription for …". Each is made once, tagged health (shown in quiet time), in the list chosen in the page's settings ("Errands go to"): else your usual task list, else the first list on a server, so your phone has them; a list on this device only when there is no other. Errands made on this device before move to that list once. "Fetched today" counts the next pickup from today.

Moving¶

While a focus session runs, every 45 minutes (the Health page's settings), a pause to move and stretch is offered, never imposed: "Pause now" pauses the session and offers a line on where you stopped ("Where you stopped" in tasks.md); "Not now" goes on and asks again after as many minutes; unanswered, the session keeps counting, since a pause missed must not stop the time counted (something urgent may come first). "Back to it" goes on. The pause is counted again for each new session. Outside a focus session, while you are at this computer, a quiet notification says the same after as many minutes (ten at least).

Chats¶

A limit a day, off by default: after the minutes chosen (counted while a chat is in front of you), chats are covered, blurred, muted and silent (their notifications wait), for the minutes chosen; then they come back by themselves.

The page¶

The day at a glance, and what changes it (qml/HealthPage.qml, qml/HealthTimeline.qml; its view health::page, made off the window's thread, the week of the day shown at once). A header: ‹ Today, Tuesday 6 October ›, a day at a time (a week in the week); Day or Week; Today when elsewhere; ⚙.

The day: a timeline, the same hours every day of the week (half an hour before the earliest waking or first thing, to half an hour after the latest bedtime or last thing), in three lanes: the day's events, and today's planned steps, faded, for context only; meals, naps and the night as blocks, getting ready, winding down and coming back lighter than the time itself, a quiet one lighter still; the doses as dots, hollow when due, filled when marked taken, warm when another device may know ("Check first": never "not taken"). A line at now, moved at each minute's turn by the window's one clock (qml/Clock.qml) and at once when the window comes back, alone: nothing is laid again for it. Beside it on a wide window, under it on a phone: the same as a list, in time order: each row its times (getting ready and winding down included, as the notices say), its name, how that day has it ("eating from 12:30", "changed for this day", "moved after an event", "this day only", "no notice that day"), and 15 min later and ⋯ (the menu above), a dose Taken; whole-day events and a refill or a renewal falling that day on a line above; Add a meal or a rest… below; under it, how the day went in the words said then and their notes, and today Close the whole day in the evening and during the night (reviews.md). A row and its block light up together, under the pointer or chosen; a block tapped brings its row into view; the morning part of a night begun the day before, which is not in the day's list, opens that night's menu instead (after midnight, its alarm alone: the rest of a past day stays as it was). Today, under the list: what is not known of doses marked elsewhere, and where reminders come.
The medicines and the prescriptions, after the day (above, "Medicines", "Prescriptions"): under its list, after the notes on doses, or, on a window that leaves the page 1400 pixels, in a column of their own on the right, as wide from the start (340 to 440 pixels), kept in the week: switching Day and Week moves nothing there, and a week being planned has the next pharmacy visit and renewal in view. On a narrower window or a phone, the week's seven columns take the page: the medicines are the same every day and their doses are its dots. On a phone they come below the day's first screen.
The week: seven narrow columns, Monday to Sunday, today on a lighter ground with its line at now (both move at midnight, before the page is read again); the same blocks and dots, a tap on a block gives the same changes, for that day (someone who plans the coming week on Mondays fixes a day that will differ there); a day's title opens it.
Doses due while Sioul was closed: the question (above, "Medicines"), above the day, only then.
⚙ (qml/HealthSettings.qml, made the first time it opens; on the right, all of a phone's): what is set once: where the pharmacy and renewal errands go, the usual meals, naps and night, the pause to move, the limit on chats. The Porch's "Set my night" and Settings ▸ Hours open it at the meals and night (showNeeds).
Calm: no red, no strikeout, no count, nothing about food; the rows keep their places as the day goes (one over keeps its row, without its buttons); on a phone the day's rows fit the screen with its timeline. Made at first use: the week, the settings, the menu, the forms; the list a moment after the first frame, the medicines after it.

Your watch¶

Sioul read a Garmin watch's own files (FIT) until 8 October 2026: the day's heart rate, stress, Body Battery, steps and sleep on this page, gentle offers of a pause or a walk between tasks, and a line on the Tasks page after a short night. That feature was taken out, because the watch's health figures are not shown to be accurate and Garmin has no official interface, only unofficial connectors that risk being blocked; the research on how a watch's data maps, and why its figures are doubtful, stays in research/wearables.md.

Your files stay where they are: Sioul no longer reads, writes or shares anything of a watch, and deletes nothing. The folder you chose for its files, the days it kept ($XDG_DATA_HOME/sioul/watch/) and the memory of its offers ($XDG_STATE_HOME/sioul/watch-offers.json) are yours to keep or delete.
An older configuration still loads: watch_folder and watch_offers in health.toml, and a watch row under [attention] or [notify], are read and left aside, as any key Sioul does not know; health.toml drops the two keys the next time Sioul writes it (health::tests::the_watch_s_old_keys_are_read_and_left_aside).
An older device: the watch's days and offers that a device on an older Sioul still shares are left aside here, never written and never kept waiting, and the rest of the exchange goes on (database.md, "Stores that leave, arrive or move").