Module health 

Health and well-being, for the window: the page (a day, or its week, at a glance: meals, naps, the night and the doses, each day’s own changes; the medicines and the prescriptions), its settings (the usual meals and nights, the pauses), and the minute tick that reminds a dose once, quietly, and turns refills and renewals into tasks in a list your phone has. The rest goes to no server, except sealed to your other computers when you share with them (docs/database.md).

Structs

Around 🔒

What lies around the days: the week’s events, their times with margins, today’s planned steps.

ContextItem 🔒

An event or a planned step, for context only.

DayItem 🔒

A row of a day’s list: a meal, a nap, the night, or a dose.

DayView 🔒

One day: its list and what its column of the timeline draws.

DeviceRow 🔒

A device as Settings ▸ Your folder and sharing lists it (share::status).

DoseNotes 🔒

A dose’s reminder as this computer records it, for the notice’s thread (sioul_sync::notify::DoseRecord): this device’s entry in the dose’s reminders, written before each notice goes, and the marks’ record for an older Sioul (reminded, unshown).

DoseRow 🔒

ForProfessional 🔒

What a doctor or a pharmacist is shown, read-only, at arm’s length (qml/ShowMedicines.qml): a prescription’s medicines, or all those taken now.

Knowledge 🔒

What is known here of the doses marked elsewhere: this computer’s record, and each other device sharing with it (sioul_core::health::doubts).

Mark 🔒

What a device had said when you said it was off, or forgot it.

MedicineEdit 🔒

A medicine as its form gives it.

MedicineRow 🔒

A medicine as the page lists it, and as its form reads it.

OffButton 🔒

“This device is off”, under a doubt naming it: the device’s id, the button’s words.

PageView 🔒

The page: a week of days, the day shown one of them (week), and what only today says.

PeerSeen 🔒

Peers 🔒

What this computer saw of your other devices, for the doses: kept here only ($XDG_STATE_HOME/sioul/share/peers.json), never shared.

PorchDoses 🔒

The Porch’s doses (docs/health.md, “On the Porch”). due: today’s, from their time on, not marked yet, reminded or not (a notification can go unseen), each with “Taken” (past its half hour, when it was taken is asked) and the doubt when another device may know; until marked, the day’s end, or twelve hours after its time. closed: those due while Sioul ran nowhere, the question on the past, once your other devices were heard from (heard), so that a dose marked there is not asked about here. Whatever the hours: doses are not mail. None while you sleep with doses staying silent (silent): they come at waking.

PrescribedEdit 🔒

A medicine as a row of its prescription’s form gives it.

PrescriptionEdit 🔒

A prescription as its form gives it.

PrescriptionRow 🔒

A prescription as the page lists it, and as its form reads it.

RecordDoubt 🔒

The doses’ record found broken or gone here, kept on this computer only ($XDG_STATE_HOME/sioul/health-doubt.toml): the doses due before stay not known, for a day.

Segment 🔒

A part of the timeline’s column: from, to, in minutes from the column’s midnight (a night split at midnight, its morning part the day before’s).

SettingsView 🔒

The page’s settings (⚙), what is set once: the pauses, where the errands go (the usual meals and night: needs_page).

Shown 🔒

One medicine, for a professional.

WeekView 🔒

Monday to Sunday, the hours the timeline shows (minutes from midnight, whole hours, the same for every day: the lines stay put from day to day).

Enums

Coming 🔒

What comes for a prescription, on a day.

Plan 🔒

What this computer does for a dose at its tick (docs/health.md, “What became of a reminder”; review of battery part C, the fifth review).

Constants

ALARMS_AHEAD_HOURS 🔒

How far ahead the coming doses are given to Android’s alarm clock.

FIRST_WORD 🔒

How long a phone’s alarm keeping the doses itself (the phone in use at the dose’s time) waits for the computers’ words that they leave the dose to it (dose_reminders::Tried::quiet), before it reminds with the doubt.

FORGET_NOW_AFTER 🔒

How long a phone says nothing before a computer offers to forget it now (DeviceRow::forget_now): a day, where a living phone restates its entry every hour (devices::RESTATED).

FUTURE 🔒

How far ahead of this device’s clock another device’s times may run and still be taken (ten minutes: a clock left to drift; one set wrong by hours or a year is not): beyond it, its copy is no news and is set aside (Peer::set_aside): nothing it says counts, nor a word it gives, and its doubt says its clock runs ahead (the ninth review’s F1; the final review’s F1H).

GRACE_MINUTES 🔒

LATE_UNTIL 🔒

Until when after a dose’s time this computer may show its reminder late while a phone shares the doses (a try after the first that did not go out, a dose an earlier Sioul here tried, a reminder waiting for news): three minutes before the phone’s alarm, so that what it shows reaches the phone first (its exchange each minute, the server, the phone’s own pull at its alarm); later, the phone’s alarm and the question on the past take it up (review of battery part C, the fourth review’s H2).

MISSED_HOURS 🔒

How far back a dose due while Sioul was closed is asked about, and the minutes a dose is reminded live before that.

SHOWN_EVERY 🔒

SHOWN_WATCH 🔒

How long a reminder shown on a phone is checked again (every quarter of an hour, the others’ news read first), so that a dose marked on another device takes it away: three hours after the dose’s time.

UNSURE_WAKE 🔒

The longest an opening’s news counts as late when this device cannot tell whether its own news came in time (a sync app carries the folder: paused, or stopped, unseen from here): a longer wait is as likely this device’s own outage, and would hold the doses of a closed device in doubt that long, for its next WAKES openings (review of 10 October 2026, R8).

WAIT_FOR_NEWS 🔒

How long a dose not known here waits for news from your other devices before it is reminded all the same, the doubt said; a phone’s alarm, when a computer keeps the doses, waits as long for the computer’s reminder (sioul_core::health::ALARM_AFTER, one moment for both).

WAKES 🔒

How many of a device’s openings are kept to time the next: an opening whose news came late once (a phone offline when picked up) holds the wait for this many more, then goes.

WAKE_GAP 🔒

Each minute: a dose due is reminded once, quietly, with “Taken”; a refill or a renewal coming becomes a task in a list kept on this computer. How long a gap between two of this computer’s ticks (each minute) makes its coming back a new opening (devices::resumed): three minutes, two ticks and their exchanges missed (asleep, the machine frozen), so that a laptop woken has no phone’s word on it until a phone read it awake (the seventh review’s C1).

WORD_FRESH 🔒

How long a phone’s word counts on this computer after this computer last saw that phone’s entry change (Peer::seen): twice the hour within which a living phone restates its entry (devices::RESTATED), one restatement missed allowed. Past it the phone may have taken its word back (said this computer off, or stopped counting it after a week’s silence) without this computer hearing it: no word, this computer is not the first (the eighth review’s N1, N2).

Statics

ACKED 🔒

Since when every device that must (must_acknowledge) said in its sealed entry that it read this computer’s opening, start, as this process saw it first: kept across ticks for the same opening; none while one has not.

ASKED 🔒

The question on doses due while Sioul was closed: asked once a session.

KNOWING 🔒

One look at a time at the others’ claims.

LAST_TICK 🔒

This computer’s last tick (Unix seconds; 0 none yet).

MOVED 🔒

When the pause to move was last offered, or Sioul started (Unix seconds).

PULLED 🔒

Whether this device’s own pull from the server went through lately, as know last saw it (share::Others::news): a phone’s alarm takes a computer’s “closed” as its word that it did not remind a dose only then (dose_reminders::others; the sixth review’s C1).

REMINDED_THERE 🔒

“Reminders come on <computer>”, when another computer keeps them.

SENT 🔒

Doses reminded in this session: never twice, even when the record cannot be written.

SHOWN 🔒

The day the page shows (show_week): its week is made. None: today.

STATE 🔒

The doses’ state is read, changed and written by the minute’s tick, the page and the notifications’ buttons: one at a time, so that none writes back an older state over another’s mark (a dose shown untaken could be taken twice).

TICKING 🔒

One tick at a time: a slow one (a shared folder) is not overtaken by the next.

Functions

acked_after 🔒

ACKED’s next value: kept for the same opening while all still say it, from now for a new one, none while one does not.

acknowledged_openings 🔒

A phone’s word on each computer it counts now (Entry::acked): the opening of that computer’s entry it read. Written by phones only, of computers only: none elsewhere (the seventh review’s L4). A computer said off, forgotten or silent a week here goes from it (C1).

acknowledged_since 🔒

ACKED brought up to date at now; since when all acknowledged, if they do.

acknowledgements 🔒

What each phone’s sealed entry says of computer’s opening (devices::Entry::acked), by phone.

alarm_again 🔒

When a dose’s alarm in doubt within the wait for news asks again: as soon as it may be known (known: a device closed before the dose, once the news of an opening had the time to come), a minute apart at least; known already by what was read (known now), in doubt only because no news came since the alarm began, nothing tells when news comes: at the end of the wait, as for a doubt that has no end in view, then reminded with the doubt said if none came (until 10 October 2026 it asked each minute, a pull each time: R9 of that day’s review).

alarm_decide 🔒

At a dose’s time, Android’s alarm asks what to say (alarms), maybe with nothing on the screen. What your other devices marked is read first (share::exchange_here: Sioul’s own pull from the server while it works, else the sync app asked to bring it; an exchange without notes and papers, which never holds a dose back); then, as the window would: taken, not taken said, or reminded already: nothing; kept by another device you use: its turn, asked again after the wait for news; not known: after that wait, reminded with the doubt said first; else the dose. Recorded reminded only when shown, so that another device still reminds what was not. JSON {show, title, body, again_at (Unix ms, 0: never)}.

alarm_taken 🔒

“Taken”, pressed on the phone’s reminder. More than half an hour late, when it was taken is asked in the window instead (open). JSON {done, open, line}.

alarms_coming 🔒

The coming doses, as Android’s alarm clock is given them (alarms::schedule): [{key, at (Unix milliseconds), title}], from half an hour ago to two days ahead, those marked or reminded left out. A record that does not read leaves none out: the decision at their time reads it again.

all_acknowledged 🔒

Whether every device that must (must_acknowledge) said it read this computer’s opening start, that very one (acks: acknowledgements): a word naming another opening, later or impossible, says nothing (M1); a word of a phone not heard here within WORD_FRESH says nothing either (N1, N2).

answer 🔒

apply_medicine 🔒

A medicine made (id empty) or changed in health, as its form gives it: its id, or what is wrong, nothing changed then.

apply_prescription 🔒

A prescription made (id empty) or changed in health, with its medicines as its rows give them: made, changed, taken out. Every row is read before anything changes: what does not save changes nothing. Its id, or what is wrong.

apply_replaced 🔒

The devices another device says it replaces (devices::Entry::replaces; this device’s own entry’s too), counted as forgotten here (Peer::off, Peer::forgotten: no word owed on this computer’s openings, no doses waited for from them) while they said nothing newer than the replacement says: a new start, a later time of their entry, a claim renewed since. A phone said replaced wrongly counts again by itself the moment it speaks. Read anew at each look, never kept as a mark.

block_name 🔒

A block’s name: its own, else its usual one by its key (“meal:1”: lunch); one added for a day without a name of its own: “Meal”, “Rest”.

blocks_now 🔒

A day’s own blocks as they are: its changes, its meals pushed past its events.

capitalized 🔒

“Wednesday”: a word’s first letter in capitals, as a title starts.

card_doses 🔒

Today’s doses for the card on a phone’s home screen (homecard): those due and not marked, from their time on, as the Porch has them (due_today: until marked, the day’s end, or twelve hours after their time), and those still to come today; each with until when it is known not marked on another device, the Porch’s rule given ahead (doubts_now: every other device heard within five minutes), 0 when it is not known from its time on. A record that does not read is never read as empty: every dose is then not known. Whether doses show while you sleep or pause is the card’s frames’ to say.

card_known_until 🔒

Until when a dose due at due stays known not marked elsewhere, seen from from (doubts_now: each other device fresh five minutes after it was last heard in full): until when nothing ends it before; 0 when it is not known at from.

change 🔒

The record changed by change, under its lock; one that cannot be trusted is repaired first, then changed. Returns what went wrong, else “”.

change_day 🔒

change_health 🔒

The health file read, changed by change and written back, all under its lock, which the sharing takes too: a change is set over the medicines as the file holds them then (Health::change), never over a copy read earlier.

change_need 🔒

A day’s block changed, that day only, as the page asks (JSON: its date, “2026-10-07”, today when none, and sioul_core::needs::DayEdit: key, action, from, to…; Needs::change_day). The plan and the page follow; a block moved is not said again: moving it never brings a nag. Returns what went wrong, else “”.

change_records 🔒

The records changed by change, under their lock; ones that cannot be trusted repaired first, then changed. Returns what went wrong, else “”.

chat_minute 🔒

One more minute in a chat; returns whether chats are covered now.

chats_covered 🔒

Whether chats are covered now.

choose 🔒

You chose, seeing answers that differ (DoseRow::choose): taken (at the time the earliest “taken” said, else now), or not taken. Your answer here, every answer saying otherwise taken out, on purpose; the marks beside, for an older Sioul, as you chose; not taken after all, the doses its take moved go back. Returns what went wrong, else “”.

clock 🔒

at (Unix seconds) on the clock in zone: “12:30”.

coming 🔒

What comes for a prescription, the soonest first: the next visit to the pharmacy (a month back at most), and the day to renew it by.

coming_night 🔒

When the night’s own notice may come in the next nights, for a phone’s alarms (eventalarms::coming): as each night’s wind-down begins, while sleep is kept with its notices, and in the quarter of an hour after, as Today::due gives it, unless given here already; each (day:night:<date>, Unix seconds). A start just past stays as it was, so that the list stays the same from one minute to the next: Android rings it at once.

covered 🔒

The medicines tied to a prescription, unless its title already names them all (“Levothyroxine 75 µg” for Levothyroxine).

day_view 🔒

One day: its list (blocks, those taken out that day, its doses) and what its column draws.

days 🔒

Each day’s own meals, naps and nights (sioul_core::needs::Days). The moves and skips of today an older Sioul kept on this device (needs-today.toml) are moved into them once, as times.

decide_night 🔒

A phone’s alarm as the night’s wind-down begins (eventalarms, “day:night:…”): the night’s own notice as a computer’s minute says it (needs_now), from the device you are at as who keeps the reminders reads, never claimed from there (share::looked). Shown in Android’s notifications with “Close the whole day” while that night’s review is to give, and “Options…”, each opening Sioul on its sheet or its question. {“shown”: true}; {“again_at”: ms} rung early, or kept here only lately; {} when it does not come.

device_forget 🔒

A device silent for a week, forgotten: not listed until it says anything newer.

device_forget_doses 🔒

A device whose files you removed from the folder while it no longer counted for the sharing (it left, was forgotten or replaced): forgotten by the doses too, exactly as “Forget it now” does, before its claims go (its entry too, once nothing needs it): a device whose entry no longer reads is known by its claims, as an older Sioul, and with none left the doses would doubt for it until it had been silent SILENT_DAYS. It counts again if it says anything newer. Returns what went wrong, else “”.

device_off 🔒

A device you say is off (off), or not any more: not counted for the doses until it says anything newer (a new start, a new export, a claim), said plainly meanwhile (shared_note, Settings). It never answers a dose for you. Returns what went wrong, else “”.

device_rows 🔒

Your other devices, as this one knows them, for Settings: nothing red, no counts. holders: the devices that hold the newer form of what travels back, or run an older Sioul once it travels (share::formats), with when each was last heard (seconds, 0 when nothing says it) and whether it holds it back; each is listed (holder_rows).

device_rows_of 🔒

device_start 🔒

A device named at a sentence’s start: “The phone”, “Another device of yours”, else its name as it is.

device_word 🔒

A device as a doubt names it: “the phone”, else its name; one whose name is not known (an older Sioul on a phone says “localhost”), “another device of yours”.

differ_sentence 🔒

Answers that differ, each said, the earliest first: “Marked taken on the phone at 08:02, skipped here at 08:10. Check which is right before taking it.” me: this device’s id, said “here”.

dose_info 🔒

What the late dose’s question shows, as JSON: {name, dose, due, now, hours}.

dose_open 🔒

dose_open_now, from what was read (records: the dose record and the records come from the other devices; none when one does not read): a dose of today’s, its time come (twelve hours back at most), answered nowhere this device knows; the records unread, any such dose.

dose_open_now 🔒

Whether a dose’s time has come and it is not marked yet, as the Porch still asks about it (until the day’s end, twelve hours at most): while one is and another device runs Sioul, a phone in the background keeps its two-minute steps, while you sleep too, so that a mark made there comes within them, not at its next slow look (docs/health.md, “Knowing”; steps::keeps_close). Read only, nothing repaired here; a record that does not read counts every dose whose time has come as open, never as none, and only within the same hours: never before a dose’s time nor past its day’s end (review of battery part C, G4).

doses_for_card 🔒

card_doses, from what was read. A dose answered differently on two devices (doses::answered: taken on one, said not taken on another) is on the card too, never known: “check before taking it”, as the Porch asks you to choose.

doubt_now_with 🔒

A dose’s doubt as what stays in view says it (the Porch, the Health page, where a dose shows due hours after its time: as of now, health::doubts_now), and a “This device is off” for each device it names (one: “This device is off”; several: each by its name). None for a line that could not be read, nor a device that does not share its doses: its being off would lift neither.

doubt_of 🔒

A dose’s doubt as its reminder says it, at its time (waking: the waking it waited for, else its time); “” when it is known.

doubt_unread 🔒

The same, at an alarm whose pull did not go through since it began (share::news_missed: when, and the devices whose entry or health claim says more since): any other known closed by what was read before is said in doubt, as last heard (sioul_core::health::doubts_unread).

doubt_unread_with 🔒

The doubt, first said before what the devices leave unknown (a reminder that comes late, one another device may have shown): “Sioul can’t tell whether it was taken: …. Check before taking it.”; “” when nothing is. What looks back counts from the dose’s time, the opening for it from waking (sioul_core::health::doubts_at; the sixth review’s M1).

drag_need 🔒

A day’s block moved by a drag on the page’s timeline (change_need’s JSON: “move”, or “times” for one of its ends), changed as “Move to…” and “Change its times…” change it, then “Undo” offered for ten seconds, which puts that day’s block back as it was. Dropped where it was: nothing changes, nothing to undo. Returns what went wrong, else “”.

due_of 🔒

When a dose is due, from its key (<medicine>@<Unix seconds>).

elsewhere_said 🔒

Why a phone’s alarm cannot know it is a dose’s first reminder, in words, each device said (dose_reminders::others): “the desk may have shown its reminder at 08:00”, “Pixel may have reminded you too, by its own alarm”.

errands_list 🔒

The list the errands go to: the one chosen, else your usual list, else the first list on a server (so the phone has them), else one on this computer.

first_here 🔒

Whether this computer may remind a dose to remind from since plainly, as its first (docs/health.md, “What became of a reminder”; the sixth and seventh reviews’ C1): alone (sharing off, or no other device in the folder); or its opening, its claim and its records written (told), the doses kept here since before since (kept_since), and every phone’s word that it read this opening seen here lead before since (acked). Else it is as a computer opened after the dose: quiet around a phone’s alarm, then the doubt first.

first_wait 🔒

How long this computer’s first reminder of a dose may wait for news, its window as its first: until three minutes before a phone’s alarm while a phone shares the doses (LATE_UNTIL), else ten minutes (WAIT_FOR_NEWS).

for_professional 🔒

“Show to a doctor or pharmacist”: a prescription’s medicines (its id), or all those taken now (“”), as JSON (ForProfessional).

for_professional_of 🔒

A prescription’s medicines (prescription, its id), or those taken now (“”: not paused, not past their last day), for a professional, in your language; the generic names as typed (international).

forgotten_here 🔒

Whether id is forgotten here (Forget this device), or replaced by another device (apply_replaced), as this device last knew it.

from_the_future 🔒

Whether a copy of an entry is dated more than FUTURE ahead of now.

held_on 🔒

date‘s events’ held times: today’s from the minute’s cache, another day’s read now.

held_today 🔒

Today’s events’ held times (their margins counted), read again five minutes after at most: the needs’ tick runs every minute.

hhmm 🔒

“8:00” → “08:00”, as the day’s list writes its times; what does not read stays as written.

holder_rows 🔒

Every device holding the newer form back has its line, so that the window says which (docs/database.md, “The format of what travels”): one the rows do not list (known to the sharing alone, by what it shared before, or forgotten here while the sharing heard it since) is added, with “Forget this device”: it is not counted for your doses, so forgetting it makes no dose look known. One listed keeps its own line: forgotten only once silent for a week, as any device, since a device counted for your doses and forgotten could make a dose it took look not taken.

how_long 🔒

How long since since, in words: days, then weeks, months, years.

is_late 🔒

Whether a dose marked now is late: more than half an hour past its time.

is_zero 🔒

joined 🔒

Reasons said one after the other, as words’ language joins them (“…; …”, in French “… ; …” with its thin space: the fifth review’s L6).

kept_here 🔒

Whether this computer keeps the doses now, as the claims read.

know 🔒

What this computer knows now: the others’ claims on the doses read (each says how far it wrote its records, and whether it closed), set against what was read of their records here.

late_reminded 🔒

shown_late’s record: a reminder at now, unless reminded or marked meanwhile (the earlier word kept); the unshown of its first try stays, a reminder outweighing it (HealthState::reminder_unshown).

late_reminder_wanted 🔒

Whether a dose’s reminder may still be shown: neither marked here (taken, or said not taken) nor answered on another device, nor reminded since (another device took it up: a phone’s alarm rang): what the phone did is never contradicted, and nothing is ever said of it but a reminder.

late_said 🔒

A late reminder’s words: “Check first: …”, then its time and why Sioul cannot tell, why it is late first: its first try could not be shown in time (Late::Retry), it was shown and not confirmed in time (Late::Unconfirmed), or another device may have reminded it (None); then what the devices leave unknown, from since.

late_words 🔒

The words of a dose’s reminder shown late on this computer, the doubt first, always (late_said); none when it is no longer to remind (still_to_remind), or its grace is over (GRACE_MINUTES from since: its question on the past takes it up).

later_minutes 🔒

The minutes “Later” moves a block by.

latest_time 🔒

The latest of an entry’s times (its device’s clock).

learn_with 🔒

The same, news saying whether this device’s own news was flowing now (share::Others::news), for timing the others’ openings.

let_go 🔒

The doses kept elsewhere a moment: this dose’s tries end here for now, nothing promised (never “none again”: the sixth review’s M3), and it is taken out of this session’s sent ones, so that the tick works its plan out again should the doses come back here within its grace.

listed 🔒

“Levothyroxine and Magnesium”, “A, B and C”.

load 🔒

load_peers 🔒

mark_device 🔒

marked_lately 🔒

The doses of the last day marked taken or not taken: their reminders, if shown on a phone, are taken away (alarms::schedule).

medicine_row 🔒

A medicine as the page and its forms read it.

medicine_rows 🔒

The medicines, in the order they were added (a row keeps its place).

midnight 🔒

Midnight of date in zone, Unix seconds.

missed 🔒

The Porch’s doses, as JSON (PorchDoses), made off the window’s thread.

missed_rows 🔒

Doses neither marked nor reminded: a question on the past, each saying when whether it was taken is not known here. Three questions, each its own heading: those due while Sioul ran nowhere, then those due while it ran but whose reminder could not be shown (no notification server: never said “while Sioul was closed”), then those whose reminder went and was not known shown (told: what each device did); by their time within each.

missed_title 🔒

The notification’s title for the question on doses neither marked nor reminded (missed): “While Sioul was closed” only when it was; “A reminder could not be shown” when Sioul ran; both kinds, a title true of both.

moment_said 🔒

A moment (Unix seconds) as a doubt says it (when_said).

move_today 🔒

A block moved today only (the question, a notice’s “Later”): by minutes more (“Later”: by the minutes set, again and again), or to start at time (“13:30”). Returns what went wrong, else “”.

movement_minutes 🔒

Minutes of focus before the pause to move; 0 when off.

movement_tick 🔒

The pause to move and stretch, every so many minutes since Sioul started or since the last one, without waiting for a focus session; a session running offers its own (FocusWindow.qml). A desktop notification: it reaches you with the window hidden, from the computer you are at. A phone makes none (docs/android.md, “Notifications”): nothing is tried there, so that its status line never says notifications are not made on Android (the owner’s new phone, 16 October 2026).

must_acknowledge 🔒

The devices that must say they read this computer’s opening before it may be a dose’s first (first_here): every phone in the folder that has not stopped sharing and that you have not forgotten here, counted or not, said off or not, silent or not (the seventh review’s C1: what counts is each device’s own view, maybe stale); and every device whose entry does not say what it is (an older Sioul, one not read), which never says it: this computer is then never the first.

name_of 🔒

named 🔒

A dose as a reminder names it: “Levothyroxine · 75 µg”.

named_by 🔒

A device named by its id, from what is known here of the others: “the phone” when it is the one phone, else its name; one not known, “another device of yours”.

named_of 🔒

A device as a doubt names it, from what is known of it.

needs_now 🔒

The needs’ notices that may come at now, each its block and whether it is the heads-up, marked given on this device (Today::due): two at most a block, each once, only near its time; none while an event goes on, none for a block quiet or taken out that day; as the matrix of what reaches you lets them come (as usual, nothing while you sleep, in a pause or in Free time). The window’s minute on a computer and a phone’s alarm at the night’s start both ask here (needs_tick, decide_night).

needs_page 🔒

The usual meals, naps and night as the page’s settings set them, as JSON: the settings, the usual names, the long gaps between meals.

needs_tick 🔒

Each minute, from the computer you are at (needs_now): a block’s heads-up about the work, heads_up minutes before it (“No new big task”), with “Later”; then one at its time. Its name and time only: safe to be read by someone else (docs/health.md). A phone shows only the night’s own, at its alarm (decide_night).

needs_today 🔒

Today’s meals, naps and night as they are now, as JSON: [{key, kind, name, from, to, skipped, past}], for the question (Interruption.qml).

newest_entries 🔒

Each other device’s newest entry read here (learn_with: an older copy put back never replaces it), as know last kept them, of the devices whose entry reads now only (Peer::said), and not set aside: one no longer read, or dated far ahead, says nothing. Its words (Entry::acked) only those the copy read now says too: a copy that is no news (an older one, one written in the same second, one of a phone whose clock was set back) may take a word away, never give one (the final review’s F1H).

newest_of 🔒

news_from 🔒

From when a phone’s alarm waits for news of a dose due at due: its time; the dose due while sleep or a pause held it (hours::woken: when it began and ended), the waking, when a computer keeping the doses reminds it too, so that the two never remind it together, both plainly (review of battery part C, the fourth round).

night_of 🔒

Which day a night is: the evening it starts, or, its bedtime after midnight, the evening before (Needs::kept_with’s rule).

night_offered 🔒

The night’s own notice’s buttons (docs/reviews.md): “Close the whole day” while that night’s review is to give at now, its press carrying the night’s day (“night:2026-10-14”), then “Options…”, the block’s question.

not_taken 🔒

A dose not taken, said afterwards: asked no more. Returns what went wrong, else “”.

note_minute 🔒

What a minute of tick did, written in the doses’ record: the reminders shown, those that surely could not be, and those sent whose fate is not known, both unshown (the question on the past says Sioul ran; an older Sioul reminds them; which of the two, and what each device did, is in dose_reminders), and the errands’ tasks made.

note_wake 🔒

How late the news of a device’s opening came here, kept (PeerSeen::wakes), when this device’s own news was flowing then (news: its own pull went through lately; none when a sync app alone carries the folder, the delay then counted up to UNSURE_WAKE). Its own pull stale or failing: the delay is its own outage, not timed.

open_canaries 🔒

Each of keys opened here, not taken yet, unless a device opened or answered it already.

open_due 🔒

The doses due in the last hours (as far back as a dose is asked about), answered nowhere this device knows: their records opened, not taken yet (the canary), where no device opened them yet.

page 🔒

The health page, as JSON: the week of the day it shows, and what only today says.

peers_path 🔒

phone_alarms 🔒

Whether a phone may remind the doses by its own alarm: one in the folder, counted or not (silent a while, its alarms may still be set), or a device whose entry does not say (an older Sioul, one not read): this computer then keeps quiet around that alarm, promised (the sixth review’s R3).

plan 🔒

The plan for a dose to remind from since (its time, or the waking it waited for), at stamp: own, this computer’s entry for it (read: the file read here); first_ok, whether this computer may be its first (first_here: the phones’ word on its opening, before since); alarms, a phone may remind it by its own alarm ten minutes on: none from here around it, promised. The rule: a first reminder is plain only where it is the dose’s first; every other says the doubt first; none twice in the same words.

porch_doses 🔒

records and me (this device’s id): today’s doses whose answers differ on your devices come too, both answers said, until you choose.

prescription_rows 🔒

The prescriptions, in the order they were added, as the page lists them.

promise 🔒

This computer promises no notice of the dose key until until (dose_reminders::NEVER: none again); a longer promise kept.

quiet_since 🔒

Since when another device has said nothing, as this device sees it: the later of when this device saw its entry change and its own last word (Peer::seen, Peer::heard), as “Forget it now” judges it (FORGET_NOW_AFTER); none while this device knows nothing of it.

record 🔒

The doses’ record. One that cannot be trusted is never read as empty: it is repaired (repair), and the doses due before are said not known.

record_answer 🔒

Your answer for a dose, captured here (its time at), in the doses’ records, beside the marks: settle takes every other answer saying otherwise out (you chose, seeing them). Returns what went wrong, else “”.

record_doubt 🔒

record_doubt_path 🔒

records 🔒

The doses’ records (sioul_core::doses: each dose that fell due, and the answers your devices captured), as record reads the marks: records that cannot be trusted are never read as empty; they are repaired, and the doses due before are said not known for a day.

refilled 🔒

Fetched at the pharmacy today: the next refill is counted from now.

remove 🔒

A medicine or a prescription taken out; returns what went wrong, else “”.

removed_at 🔒

Where a list lost one block: the place taken out, when the rest is the same.

repair 🔒

A record that cannot be trusted: nothing it held may be taken out on your other devices, so the sharing forgets it first and reads it again from every device’s records at the next exchange; it is kept aside in the same step, before any exchange can run, and a new one starts. Sharing failing that, it is left as it is: never started again empty where the sharing could take marks out elsewhere.

repair_records 🔒

Records that cannot be trusted, as repair does the marks: the sharing first forgets holding them and reads them again from every device’s records; they are kept aside in the same step, and new ones start.

repair_told 🔒

A reminders’ file that cannot be trusted, as repair_records does the records: read again from every device’s at the next exchange, kept aside in the same step; the doses due before said not known for a day (write_record_doubt).

replaced_now 🔒

What a replacement says of id now (devices::Replaced): its last start as kept here, and the latest it was heard of, from its entry, its claims and its records (share::heard_of), in milliseconds.

replacements 🔒

Every replacement said (devices::Entry::replaces): by the entries read now, by the newest copy of each kept here (an older copy put back never takes one away), and by this device’s own entry (a phone that joined in another’s place).

said 🔒

A message with its words given, in words’ language (say, for any translator).

save_medicine 🔒

A medicine made (id empty) or changed; returns {“id”} or {“error”}.

save_needs 🔒

The usual meals, naps and night saved as the settings give them; a meal or a nap taken out, the days’ changes of those after it follow them to their new place. Returns what went wrong, else “”.

save_peers 🔒

Written whole beside its place, then renamed over it (share::write_atomically): a crash in mid-write never leaves half of it, which read as nothing would lose the newest copies kept, the openings read and the off and forgotten marks (final review of 15 October 2026).

save_prescription 🔒

A prescription made (id empty) or changed, with its medicines; returns {“id”} or {“error”}.

set_setting 🔒

The pause to move and the chats’ limit: “movement.enabled”, “movement.minutes”, “chats.enabled”, “chats.minutes”, “chats.locked_minutes”.

set_taken 🔒

A dose marked taken, or not, as it happens: taken every few hours, the next doses come that many hours after now; a mark taken back puts them back. Returns what went wrong, else “”.

settings_view 🔒

The page’s settings (⚙), as JSON.

shared_note 🔒

Why the doses here may not be all: this computer alone, or what is not known of your other devices now; “” when all is known.

show_health 🔒

The Health page, the doses due while closed and today’s meals and naps, made on a thread (they read the doses’ record and the other devices’ claims, a shared folder that may be slow) and shown.

show_week 🔒

The page shows the week of day (“2026-10-07”); one that does not read: today’s.

skip_today 🔒

A block without notices today, or with them again: kept free all the same.

state_held 🔒

still_to_remind 🔒

Whether a dose is still to remind, as read here now: neither marked nor answered anywhere, nor reminded anywhere (the marks’ record, or a device’s notice shown).

take_problem 🔒

Why takes could not be set, in words; with the medicine’s name in a prescription’s form, where several are.

taken_late 🔒

A dose taken late, at time (“09:30”, the last such time before now), as you say: marked then; for a medicine taken every few hours, the next doses that many hours after it. Returns what went wrong, else “”.

tell_mine 🔒

This computer’s entry for the dose key changed by change; false when it could not be written.

this_device 🔒

This device’s id in the sharing (“” before it has one).

tick 🔒

tied 🔒

The medicines tied to a prescription (Medicine::prescription), in the order they were added.

told 🔒

What each device did to remind each dose (sioul_core::dose_reminders), as read here; none when the file cannot be trusted (repaired first, the doses due before then said not known for a day: repair_told). None is never read as “nothing done”: a phone’s alarm then says the doubt.

usual_name 🔒

A block’s usual name, in your language: breakfast, lunch, dinner, then “Meal 4”; a nap; winding down for the night.

week_events 🔒

The events of the week from monday, read again five minutes after at most: the page is made again each minute while it is open.

week_view 🔒

The week of day, Monday to Sunday: each day’s list and timeline, and the hours the timeline shows (the same each day).

when_of 🔒

What a medicine says of its takes: each with its amount when they differ (“08:00 · 1 tablet, 20:00 · 2 tablets”), else its times, or its schedule in words.

when_said 🔒

A moment as a doubt says it: “at 07:45” today, “on Monday 5 October at 07:45” before.

why 🔒

Why a dose is not known, in words: “your laptop: last heard at 07:52”.

why_in 🔒

The same, in words’ language (the tests give theirs).

why_parts 🔒

Each reason in words, one per doubt.

woke_from_gap 🔒

Whether a tick at now, after one at last, comes back from a gap (WAKE_GAP); never the first tick, nor a clock set back.

word_lead 🔒

How long before the dose’s time the phones’ word must be seen here: two minutes (SKEW) and the most any of them was measured ahead of this computer’s clock (Peer::ahead): a phone ahead decides its alarm that much earlier (the seventh review’s L1).

words 🔒

When a medicine is taken: its times each day, “08:00 · 20:00”; every few days or hours, in words (“every other day at 08:00, from Sunday 4 October”).

words_of 🔒

When a medicine taken every few days or hours is taken, in words; at set times, its times.

write_record_doubt 🔒