Logbook Cloud Continuity Update

Another important continuity layer is now in place.

Companion can now treat logbook history as part of the signed-in Apex account instead of leaving that history trapped on one install.

That means the platform has crossed a meaningful threshold:

• local logbook data can sync upward into the account-backed cloud path
• missing logbook data can restore back down onto another Companion device
• and the user can start thinking of history as something the platform remembers, not just something one machine happened to import first

That is a bigger shift than it may look like from a single icon in the app.

The logbook is starting to behave like account-backed history

Earlier continuity work had already pushed Apex Infinity in this direction.

Owned UX, library state, favorite locations, and Companion preferences were all moving toward a model where the signed-in account could carry more of the real user experience across devices.

The logbook was always going to be a harder version of that same problem.

History is more sensitive than preferences.

It has stronger expectations around accuracy, privacy, duplication, and restoration.

That is exactly why this step matters.

Companion can now upload eligible local logbook history into the account-backed cloud path and restore that history onto another signed-in Companion install when it is missing locally.

That turns the logbook into something much closer to real continuity instead of a local-only archive.

The model is still local-first, which is the right product behavior

This does not mean cloud behavior is allowed to get in the way of the primary logging path.

The order of operations matters.

The product still treats local durability as the first responsibility:

• Core offload should complete into Companion without waiting on cloud behavior
• local import should remain the safe boundary for keeping a session
• and cloud sync should follow in the background instead of blocking the user from getting their history into the app

That is the healthier product model.

Cloud continuity is important, but it should not weaken the reliability of the local logbook path that the user depends on first.

The user can now see cloud state instead of guessing

Another important part of this work is that Companion is starting to represent cloud history more honestly.

There is now a clearer cloud status path in the logbook experience, including visible session-level state and a broader cloud-sync view for the overall logbook.

That matters because sync features feel fragile when they are invisible until something fails.

A connected platform needs to show the user whether history is still local-only, in flight, or safely synced.

That visibility is especially important now that the system has both upload and restore behavior instead of only one direction.

Privacy has to be part of continuity, not an afterthought

The logbook is not the same as syncing a preference or a saved view.

History carries more responsibility, so the privacy model has to be explicit.

The current direction is straightforward:

• cloud sync is tied to the signed-in account
• anonymous analytics remains an explicit user choice
• and Apex does not inspect synced logbook data unless the user requests troubleshooting through support

That boundary matters.

Continuity is only valuable if the user can also trust how that continuity is handled.

Why this matters

This is one of the clearest signs yet that Apex Infinity is turning into a connected product instead of a set of isolated installs.

Preferences following the account was important.

Favorite locations following the account was important.

But history following the account is a different class of milestone.

Once the logbook can survive device changes and restore onto another install, the platform starts behaving more like something that actually remembers the user over time.

That is a big step toward product maturity.

What is next

This does not finish the cloud logbook story.

The next questions are now easier to see:

• how delete behavior should work across local and cloud history
• how broader logbook lifecycle rules should behave once continuity exists in both directions
• and how the privacy, support, and consent language should continue to become clearer inside the product

Those are the right next questions.

They mean the platform is no longer trying to prove that cloud logbook behavior is possible.

It is starting to define what responsible cloud logbook behavior should be.