iPhone: the second open is instant: sealed tiles and ring, asks by the data's age (WP5)

[frahlg]

Why

Fredrik, 13 Oct: "Surely it should already have the data when you go back into the app a second time?"

On main the phone kept its history and live trace in memory only, and asked the box again for most things on every return. A redial reset every ask, so a return from the background read the chargers, the prefs, the plan and the prices again, whatever their age. After a kill, a node's live trace started empty and its history waited for the box.

This is WP5 of the polish release, the second step of the cache lane after WP4 (#35).

What changes

• Asks keyed on the data's age (State/BoxAPI.swift). LiveAsk names what it wants by how old the data is: the five minutes for history, the quarter for the plan, the day and publish state for prices. An answer stands while that name holds. When someone starts looking again (a view appears, or the stream comes back), an answer older than its time to live no longer stands: a minute for the chargers, a quarter of an hour for the planner's prefs. Neither a view appearing nor a redial asks by itself, and no timer does. A view that stays open asks only when the name changes. Prices are asked again each quarter after 14:00 only while tomorrow's rates are late.
• Reads in order (Protocol/Session.swift). Reads wait for the box's one API slot in ReadOrder: chargers, prefs, plan, status, then the rest. An idle slot waits one display frame for reads, so the order holds when they are asked in the same moment. Anything a person asked for never waits.
• Redial at .inactive (FTWApp.swift, AppModel.glance()). Coming back, iOS passes through inactive before active; the new carrier dials there, so the handshake runs beside the app switch. A glance at Control Center or the app switcher keeps the session at 1 Hz; only the background closes it. Inactive still writes the cache, in case the app is closed from the switcher.
• The live trace records from any live source (State/LiveTrace.swift, SiteModel). It recorded only the box's own stream, so through FTW Cloud a node's curve stayed empty. It now records whatever the screen reads, from the relay or FTW Cloud, and only fields whose own reading is live. Each point is stamped with when the box took it: the box's uptime placed by the smallest clock gap seen this connection, or FTW Cloud's send time by rule U. Each source has its own gap rule (SiteModel.readingGapMs): three and a half beats of the box's stream, or twice FTW Cloud's heartbeat and a margin, since the cloud sends on change. The node view's trace now takes it in place of NodeLive.sourceGapMs.
• SiteModel.recent is gone. LiveTrace is the one copy of the last minutes.
• Sealed ring-<site> (about 16 KB). The last five minutes of each ring, written with the home's other files: every 15 s while streaming, at inactive and at background. After a kill a node's curve opens with them before anything connects. Each restored point reaches the trace as LiveSample.seen false, so WP6's surface draws it in ink with no glow. LiveTrace.missed(nowMs:) gives the time the app missed, from the newest restored point to the first live one.
• Sealed tiles-<site> (about 11.5 KB of closed tiles for 48 hours, and the tile still filling). After a kill a node's history draws in frame one. Past the newest value in the tile that was still filling, the steps read as on their way, never as a hole the box confirms.
• History primed once. The first live frame asks for the window once, with no node open: the tile still filling first when older tiles are missing too, then the rest. After that the window is asked for again only when the five minutes turn while a node's view is open. Only closed tiles are offered to the box as held. The open tile stays on screen until its replacement lands, so the right edge never pulls back. Tiles that land within one display frame draw as one change. The grid widget's read waits for a load already on the wire instead of sending its own.
• Prices after 14:00. The name the window was asked under stays once tomorrow's rates are here, so the answer that brings them is no reason to ask again.
• Model files. A model adds its own sealed file with SiteModel.keepFile and reads it back with keptFile. Same key and seal as the snapshot and the home file; removing the phone erases them with the rest.
• A count of request frames. Session logs each request frame under category asks, and SiteModel logs how many each stay in front cost when the app hides. The demo box lists every request frame for tests.
• CLAUDE.md: the chargers are read when someone starts looking and the last read is over a minute old; a short rule for asks by the data's age.
• SecondOpenTour (UI test, skipped unless asked for) opens the battery twice, kills the demo and opens it again straight into the battery.

Evidence

Tests. swift test on main f73c890 merged in: FTWShared 181 and FTWKit 319, all green. The app with its widgets and the watch app builds for the simulator. New in SecondOpenTests.swift:

• a return within a minute sends no request; after two minutes only the chargers are read again (requestsThisVisit agrees);
• a view opened again asks nothing while its answer stands, asks once when it is older than its time to live, and a view that stays open on a minute's clock asks nothing more;
• reads wanted in the same moment reach the box as chargers, prefs, plan, status; a person's request goes first;
• a return dials at inactive, and a glance from the front keeps the session and its rate (AppModelTests);
• the trace records from FTW Cloud with the cloud's gap rule; box frames are stamped by uptime, so a frame 700 ms late lands one second after the one before; a device that stopped answering records nothing;
• after a kill the trace opens with the last five minutes the app saw, every point restored and seen false, and the first live reading starts its own run;
• runs survive the file;
• history is primed once, newest tile first, and a burst of tiles draws as at most two changes, where without the gather it drew five;
• reopening a node within the same five minutes sends no hist.query, across a return from the background;
• after a kill history and the trace draw before anything connects, the twenty minutes since read as on their way, and the right edge never pulls back while the open tile comes;
• the grid widget shares the priming: two hist.query, not three;
• after 14:00 the price window is asked for once, and tomorrow's rates arriving are no reason to ask again.

I broke each rule on purpose: forgetting answers on a redial, an unordered queue, no person-first slot, no open-tile tail, no coalescing, no shared load, a price name that changes with its own answer. Each made its test fail.

Request frames per return from the background. Counted from the asks log and the demo box's list. Each column is a return after that long in the background.

Over the relay path, as a paired home does it (suspend closes the session, the return dials a new carrier), in a unit test against the demo box:

Build	First stay	30 s	30 s	2 min	30 s
main	4	4	4	4	4
this branch	6	0	1	1	0

On main every return asked for the prefs, the plan, the prices and the chargers. Here only the chargers come back, once the last read is over a minute old. The first stay asks for history too (two hist.query, newest tile first), which main did only when a node opened.

In the demo app in the simulator (log show … category == "asks"), where the session stays open in the background:

Build	First stay	30 s	30 s	2 min	30 s
main	4	2	2	2	2
this branch	6	0	0	1	0

LaunchClock. Debug build, simulator (iPhone 17 Pro, iOS 26.5), demo with -FTWDemoCache YES, 8 cold launches of each, run in turns, machine load average 13 to 25. Milliseconds after process start, medians (range):

Build	First frame	First content	Live
main	561 (520–642)	562 (520–642)	1035 (955–1247)
this branch	547 (515–574)	548 (516–574)	1037 (995–1063)

No change beyond the noise. Reading both new files and building every model of the home takes about 2 ms in a Mac test, which is why.

Recording. The demo in the simulator (iPhone 17 Pro, iOS 26.5), SecondOpenTour.

The second open of the battery's Today, on this branch: the curve is in its final shape during the zoom and holds still.

Main has done this too since WP7 (#44): its new history surface starts settled. Before WP7 the curve grew back from a flat line on every open. One frame every 0.1 s from the second tap; main on top, this branch below:

The difference this PR makes shows after a kill. The Now screen stayed up 90 s, the app went to the background and was killed, then opened straight into the battery. Left, main: the live trace is empty. Right, this branch: the minutes the app saw before, in ink with no glow, under ○ PER 14:33 and SPARAD PÅ TELEFONEN, then the live head after the gap.

In the demo the box answers in a few milliseconds, so the history it fetches lands almost at once on main too. The unit tests prove the frame-one case without a box.

Full recordings: main short, 90 s on Now; this branch short, 90 s on Now.

Not in here

• The RESUMED band and its tag. The data is there (LiveTrace.missed(nowMs:)); drawing it is a few lines in FTWCharts/LiveTrace.swift, which belongs to the chart lane. Until then the time the app missed shows as WP6's dotted baseline between the ink and the live line.
• A device run against the home box: requests per return over the real relay, the time to live after a return, and Animation Hitches. The simulator cannot measure hitches.
• At the switch from cached to live, the status line cross-fades two texts over each other (third picture above). That is WP8's.

Overlap

PR #27 (plan dial, draft) touches NowModels.swift; this changes only PriceModel there. The watch (#43) reads through the phone and uses none of what this changes.

🤖 Generated with Claude Code

[chatgpt-codex-connector]

Codex Review Summary

This comment shows the latest Codex review activity on this pull request.

Review	Status	Commit	Review trigger
📝 Code Review	✅ Completed 2026-10-14T13:14:39.497716Z	6f11ad5	PR opened

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review" or "@codex security review".

Codex reacts with 👀 while any review is running, comments if it has suggestions, and reacts with 👍 once all reviews finish with no findings.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 6f11ad5b45

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Cancel the inactive reconnect when backgrounding

When a suspended app enters the switcher, FTWApp.swift routes .inactive through glance(), which clears suspended and launches the asynchronous connect() task. If the user returns to .background before that task reaches site.connect, suspend() closes the currently absent carrier but does not invalidate the pending connection; connect() checks only its generation and site identity, so it can subsequently attach a new carrier while the app is backgrounded, consuming a relay stream despite the background-close policy. Cancel or invalidate this reconnect in suspend(), or recheck background/visibility immediately before attaching the carrier.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Carry recorded run boundaries into chart samples

This conversion discards Point.run, even though recording and restoration now preserve source-specific gap boundaries in that field. NodeView consequently rebuilds all five minutes with one current site.readingGapMs; after switching from Cloud to relay, for example, older Cloud heartbeat intervals can be split using the relay's 3.5-second rule, while switching the other way can reconnect previously recorded gaps. Restored/live boundaries can likewise be joined when the elapsed time is short. Pass the stored run boundaries through to LiveSeries rather than recomputing them from a single current-source gap.

Useful? React with 👍 / 👎.

[chatgpt-codex-connector]

Serialize changed-name asks behind the in-flight ask

When want() changes while another name is still being fetched, this starts a second task immediately instead of waiting for the current ask to settle. Models such as LoadpointsModel and HistoryModel coalesce concurrent loads onto their existing reading/running task, so the second task merely awaits the old request and then records the new name as answered. A pull-to-refresh during a charger read, or a five-minute history boundary crossed during priming, can therefore send no request for the new state and suppress the real refresh until the name changes again.

Useful? React with 👍 / 👎.