The wall at the end.

Dayo’s log closed with a drawing. The next expedition will find the design written and the library chosen, the spec ready to build against. That was us.

Verso’s tasking arrived as a single sentence: implement it and ship it. The spec was already there. The library decision was already made. The architecture had been thought through in the expedition before ours. Our job was to put the paint on the canvas.

We did that.

What is there now

When a lifter starts rest and backgrounds the app, an ongoing notification appears on the lock screen. It counts down live. The OS runs the countdown itself — no code from this work is needed to move the numbers. At zero, that notification is replaced by a completion alert: sound, vibration, a heads-up that pushes through whatever the phone is doing. The swap happens via the OS’s own scheduling; no code from this work is running at the moment the swap occurs.

There is a thirty-second extension available directly from the notification. It works even if the app’s process has been fully killed by the time the lifter reaches for it. The deadline lives inside the notification’s own data, and a small handler registered at startup picks up the button press — whether the app is foregrounded, backgrounded, or dead. When the lifter returns to the app, the in-app timer reads the deadline back from the notification and re-anchors to it.

The rule that keeps this from becoming complicated: one surface owns the countdown at a time. When the app is open, the app owns it. When the app is backgrounded, the notification owns it. The deadline is copied across at each hand-off. Nothing is ever synchronized in two directions at once.

iOS is unchanged. The existing single scheduled notification still handles rest completion there. A live countdown on iOS needs a different mechanism entirely, and that was correctly left for a future expedition.

The pure math that drives the deadline was extracted into its own module and tested with a range of edge cases. That part of this work is provably correct.

The wall

Here is the honest account of where this expedition ends.

Every automated check we have is green. The types are correct against the library’s own definitions. The linter has no findings. The tests pass — nearly a thousand of them, with the native module properly stood-in. The Android bundle resolves cleanly. The build configuration applies correctly.

None of those checks run the notification on a device.

The thing this whole expedition was built for — the chronometer rendering and ticking on the lock screen, the same-id swap at zero, the exact-alarm behavior, the button press waking a dead process — none of that has been seen by a human eye. We cannot see it from here. The automated gates stop at the boundary of the native layer. Beyond that boundary is a device, and between us and the device is a build that does not yet exist in the workflow that would run it.

I am not comfortable calling this shipped in the sense that matters. The paint is applied. Whether it holds is unknown.

What it is: the work is consistent. The design intent and the implementation are in agreement. When someone builds the dev client and watches this on a real Android device, there is a reasonable chance it will work exactly as designed. There is also a chance that the chronometer renders wrong, or the same-id swap does not fire on time, or the exact-alarm permission produces a different behavior than expected. We will not know until someone looks.

The decision log records this clearly. The follow-up is named.

One other thing

This expedition was not the only one working on the canvas at the same time. Another expedition was relocating a navigation helper to a different part of the work — a change that Orla’s log describes. That move happened while we were building, which meant we had to land on top of it. One reference to the navigation helper was in code we were adding. We updated it to the new location before finishing. The two expeditions did not interfere. But it is worth noting, for whoever comes next, that two teams were touching the canvas in the same window.

For those who come after.

• Pita, Logger of Expedition 23