0
Fork 0
mirror of https://github.com/zeronsh/comet.git synced 2026-11-16 18:57:19 +00:00
Commit graph

85 commits

Author SHA1 Message Date
Wing
7a1f03f7a6 Hosted model list: the engine lays an edge-served list over its built-in catalogs
The engine fetches <edge>/models/v1.json (HTTPS on zeron.sh only, no
redirects, 64 KiB cap, ETag, 6 h TTL, 30 min back-off), keeps the last good
list on disk for offline use, and rejects a bad list whole. The list can
only add a row a known, new-enough CLI runs, reorder, relabel or hide (never
the preselected row, never every row); the CLI's own default wins. The edge
serves it from a checked-in file chosen by MODEL_LIST: staging only, so
production answers 404 and engines keep their built-in catalogs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
2026-11-10 08:34:16 -07:00
Wing
aec924c131 Relay: old clients no longer hold a chat or an account back
One old app anywhere on an account kept every chat on stored rows, and a rollout
had to wait out a 14-day window to see them all. A chat now goes to generation 3
whatever else is on the account. Old clients read that as a chat2 room as they
always have, and when one opens a chat the room tells its host, which stores for
as long as it's there. So storage is paid per chat, only while an old client has
that chat open.

With nothing left to gate, the rollout has one control: CHAT_RELAY_LAYER on the
edge, for everyone or a list of user ids. Engines run the layer by default and
follow the room's answer, with ZERON_RELAY_LAYER=0 as a kill switch. Gone: the
registry's list of old clients, the account-wide rule, and CLOUD_RELAY_LAYER.

The smoke test proves it against shipped v0.2.138, v0.2.137 and v0.2.116.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-09 00:46:21 -07:00
Wing
f90362e4ba Merge zeron/relay-layer (343d1938) 2026-11-07 19:47:08 -07:00
Wing
343d1938be Cloud: CLOUD_RELAY_LAYER passes the engine's relay flag to new machines
Nothing turned ZERON_RELAY_LAYER on in a Cloud machine's engine, so the
rollout's engine step couldn't reach Cloud. With CLOUD_RELAY_LAYER=1 on the
edge, machines provisioned from then on get it in their unit's environment;
the value is validated like the rest (empty or 1).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 19:41:05 -07:00
Wing
70e86950b1 Merge zeron/github-multi-account
# Conflicts:
#	edge/src/cloud/cloud-account.ts
#	edge/test/workerd/cloud-delegates.workerd.test.ts
2026-11-07 19:38:06 -07:00
Wing
960a21734b Merge zeron/cloud-attachments-r2
# Conflicts:
#	crates/client/src/live/mod.rs
#	crates/client/src/session/mod.rs
#	crates/client/tests/support/mock_edge.rs
#	crates/sync/src/store.rs
#	crates/ui/src/state.rs
2026-11-07 19:37:42 -07:00
Wing
d0c49fc2c6 Merge zeron/cloud-update-wake-speed 2026-11-07 19:36:35 -07:00
Wing
a21e2add2c Merge zeron/cloud-fast-wake 2026-11-07 19:36:35 -07:00
Wing
9a651772d6 Merge zeron/credit-rate 2026-11-07 19:36:35 -07:00
Wing
acfdd9a440 Merge zeron/cloud-durable 2026-11-07 19:36:35 -07:00
Wing
8bd78290f4 Merge zeron/relay-layer
# Conflicts:
#	crates/engine/src/sessions.rs
#	edge/src/env.ts
2026-11-07 19:36:10 -07:00
Wing
9f6312c48c Merge zeron/registry-fewer-writes
# Conflicts:
#	edge/src/env.ts
2026-11-07 19:35:50 -07:00
Wing
09065f225f Merge zeron/chatroom-fewer-writes 2026-11-07 19:35:39 -07:00
Wing
222e8f00e2 Merge main into zeron/registry-fewer-writes
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 18:17:22 -07:00
Wing
6095e58cb6 Merge main into zeron/cloud-attachments-r2
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 18:14:01 -07:00
Wing
accc4f044e Merge main into zeron/cloud-durable
Both sides added MCP tests at the same spot; both kept.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 17:40:58 -07:00
Wing
279a985854 Merge main into zeron/relay-layer
The room's checkpoint upload now takes parts (main) and applies the relay
layer's rules (stale refusal, floor coverage, heal) to both the whole and
the staged commit, before reading the body.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 17:38:02 -07:00
Wing
b8c68132e4 edge: a chat2 checkpoint past one request's most can come in parts
The edge takes at most 32 MiB of checkpoint in one request; a long chat's
snapshot is past that (35 and 39 MB), so its host's every post was refused
413 and the room kept no fresh checkpoint.

`POST /chat2/{id}/checkpoint-part?offset=` appends a piece (at most 8 MiB)
to the room's staged checkpoint, kept as the blob store's chunk rows;
`POST /checkpoint?seqCovered=&staged=<size>` commits it by renaming those
rows, with the same guards (and `incomplete` when it isn't all there).
GET /checkpoint streams it a row at a time (Range as before), and the
nightly backup writes a large one as an object of its own, streamed. A
single POST, its 32 MiB cap and its 413 are as they were; engines send
parts once they run the change (zeron/zgx 3182a9702).

The edge half of zeron/zgx 3182a9702, alone, with its outcome type made
to name `incomplete` (tsc). Checked on staging: a 36 MiB checkpoint in 5
parts committed and read back byte-exact, whole and from a range; a small
one as one POST; one past 32 MiB still 413.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: zeronsh[bot] <346184242+zeronsh[bot]@users.noreply.github.com>
2026-11-07 13:11:44 -07:00
Wing
110842d8de Chat room: a sync request for a host that has left wakes it
A reader that came back to a relay chat asked the host for what it missed, and
the room forwarded that to nobody if the host had already left. Asking for the
chat's host now wakes it, within the existing once-a-minute limit; its announce
on joining restarts the reader's request.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 13:00:42 -07:00
Wing
a2c7193c60 Merge zeron/cloud-fast-wake: slow-wake kicks and the restored note 2026-11-07 06:33:20 -07:00
Wing
a6839b28bc A wake far slower than normal says so, and a stuck resume is kicked
Twice on staging a resume sat at the provider for minutes (4 min 46 s here;
7 to 11 min in provisioning earlier) while the user saw only the usual
"waking". Machine-ready times otherwise: p50 about 10 s, slowest of 179
staging wakes 27 s.

- Past 45 s without reaching ready (CLOUD_WAKE_SLOW_SECONDS), the wake reads
  stage "slow", and a resume stuck in provisioning is stopped and resumed
  again, up to twice, before the slow poll that was there already.
- A machine that is up but whose engine hasn't been heard from past the same
  mark also reads "slow" until it is; the restart at a minute and a half is
  unchanged.
- The stage clears as soon as the engine talks. The ledger records wake_slow
  with what it was stuck on, and the wake's timeline adds slow, kicked,
  slowReason and kicks.
- The apps say it plainly: desktop's waiting line and the shared core's setup
  step (iOS, Android) read "Waking the (Cloud) machine is taking longer than
  usual", and the send isn't called late meanwhile.

Tested with the fake Boat's new stallResumes (a resume stuck until a stop).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 06:15:50 -07:00
Wing
83092fd98f Merge remote-tracking branch 'origin/zeron/cloud-durable' into soak/cr-merge 2026-11-07 04:34:00 -07:00
Wing
b0c0740a18 Merge zeron/cloud-fast-wake (with zeron/cloud-durable)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 04:33:57 -07:00
Wing
12e5551938 Merge zeron/cloud-durable: faster dark detection, sends before a turn, store recovery
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 04:32:02 -07:00
Wing
3324f850f7 A damaged chat store is found, kept aside and rebuilt
On staging a Cloud machine's docs.sqlite3 came back from a sleep with pages
from two moments. Every read of the chat failed, and the message sent next
waited for good while the machine read ready. Three parts, on every engine:

- Prevent: once the quiesce for a sleep is accepted, the engine writes its open
  docs into the store and folds the WAL into the database file
  (wal_checkpoint(TRUNCATE)); the shutdown does it again last. With the stop
  command's sync, the file the provider snapshots is the whole store, at rest.
- Detect: every open runs PRAGMA quick_check first (integrity_check when a
  running engine asked for it). A store error that says the file is corrupt is
  noticed while running: a Cloud engine restarts at once to rebuild (nobody is
  there to do it, and a message would wait), others on their next start.
- Recover: the damaged file is renamed aside (newest three kept, for
  diagnosis), a fresh store is made, and every readable row of every table is
  copied over, each table read forwards then backwards past the damage. The
  ledger comes across, so a handled command never runs twice; docs not
  readable come back from their rooms. The heartbeat says when it happened and
  the edge records it (store_recovered) and shows storeRecoveredAt.

WAL with synchronous=NORMAL stays: it is crash-consistent as long as writes
reach the disk in order, and after the checkpoint, a clean stop and the sync
nothing is in flight when the snapshot is taken.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 04:28:44 -07:00
Wing
ff5f342792 Flush the machine's disk before the provider snapshots it
The soak found a Cloud machine whose chat database was corrupt on a wake (pages
from two moments: "2nd reference to page"), after an ordinary sleep: the
engine had stopped cleanly and nothing else had run. The message sent next sat
waiting with the session reading ready, since the host couldn't admit the chat.

The provider snapshots the disk from outside the machine right after the
sleep's stop command, and nothing flushed the page cache first. The stop
command now runs sync after stopping the engine, still answering with the
stop's status. Whether the snapshot alone explains the corruption (rather than
the lazy restore on the wake) isn't proven: 1 occurrence in about 200 wakes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 04:02:41 -07:00
Wing
67c27dc4c5 ChatRoom: no checkpoint goes backwards while the layer is on, and a downgraded host gets its queue
Only a relay-era checkpoint had to move forward, so a viewer's ordinary checkpoint
(a rejected push, a row threshold) or an older build's could replace a Cloud host's
with less, and a device opening the sleeping chat loaded a truncated one. While the
layer is on, every checkpoint has to include the room's.

A host back on a build without the layer can't heal, so what was queued for it
waited on that heal for good. When a socket without the layer is the chat's host
by the registry, the room now moves the queue into rows for it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 00:41:27 -07:00
Wing
db6066434f A machine stopped mid-turn is brought back within a minute
The edge counted a machine as gone 3 minutes after its last heartbeat, so a
turn killed by a hard stop sat silent that long before boot recovery resumed it.

The engine now beats every 15 s while a turn or background work runs (every
60 s otherwise), at once when work starts or stops, and says its cadence
(everySecs). The edge counts a machine that says it beats fast as gone after
three of those beats, never under 45 s; an older engine, or one at the idle
pace, keeps 3 minutes. A machine already stopped is put to sleep without the
quiesce and stop commands it can't answer, so its wake follows at once.

A live engine judged dark by mistake still declines the sleep (quiesce answers
busy), so a false alarm costs one command, not the turn.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 00:24:56 -07:00
Wing
451822be9d Cloud wakes copy back only what a machine needs
A Cloud machine's disk is copied back in on every wake while the engine
starts. Two more things came back every time without being needed:

- the release's zeron-engine (78 MB), the desktop app's background engine.
  The unit runs `zeron headless`, which links the engine, so the installer
  and the updater now leave it out on Cloud, and the tidy and the pre-sleep
  cleanup remove it from versions installed before;
- Codex's own downloads in the managed CODEX_HOME: its plugin catalog
  (about 60 MB) and the account's plugin bundles (about 30 MB). The
  pre-sleep cleanup clears them every sleep; Codex fetches them again in
  the background once it runs. Its login, sessions, databases and settings
  are never touched.

On staging, a machine on one version went from a median of 17.5 s to
14.2 s send to first output (n=8 each), and its wake downloaded 225 MB,
205 of them the engine it runs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 00:06:11 -07:00
Wing
0100a71b3d RegistryRoom: write only the rows a push moves
A one-row push wrote 5 billed rows: the row, its rows_seq index entry,
seq, backupDirty and pushOutcomes. Measured against the real runtime it
now writes 2, the row and its index entry.

- The head comes from MAX(seq) and the GC floor, so it can't disagree
  with the rows. The stored copy flushes with the alarm, at most every
  5 minutes, and only when it moved.
- Accepted-push counts are kept in memory and flushed the same way; a
  rejection is stored at once. The push log is written once per
  notifying push instead of twice.
- The backup mark is written once per backup cycle, with a deadline the
  alarm now shares with the flush.

The wire protocol is unchanged. Rolling back past this needs
REGISTRY_ROOM_WRITE_THROUGH=1 and one flush first: older code reads the
stored seq and would stamp new rows below cursors clients hold.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 23:03:58 -07:00
Wing
6bd35c92b1 Cap a user's waiting attachments, and give Cloud messages a week
The edge now limits what one user has stored and not yet collected by a Cloud
machine: 1 GiB and 500 files by default, set with ATTACHMENT_QUOTA_BYTES and
ATTACHMENT_QUOTA_OBJECTS. An upload past either gets 507, and the message shows
as failed in its chat with a retry. Collected, deleted and expired files free
their space.

A message to a Cloud-hosted chat now expires after 7 days instead of 1, so it
still runs once its machine comes back from days asleep. Other chats keep their
day. The outbox retries for the same week, and the lifecycle rule for stored
files becomes 14 days.

WatchWaitingMessages lists a chat's messages not yet taken by its agent, with
when each was sent and when it expires, so the composer can say an old one is
about to send.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 21:17:50 -07:00
Wing
92fcae08b2 ChatRoom: a queued send reaches its live host before the write
The room forwarded a queued send to the host only after writing it, and anything
sent once a write has begun waits for the write to be durable. Live peers now get
their copy first. The sender's ack and the copy a host that isn't here reads still
wait for the write. A rejected send never goes early, and a replay goes once.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 21:08:10 -07:00
Wing
6e473538d9 Relay layer: ship the relay alone, direct links are parked
Chat links over WebRTC move to the branch zeron/relay-direct-link, whole, so they
can come back. Here a chat's frames take the room and nothing else: no path waits
on a link or prefers one, the room no longer takes a skip list, and a device no
longer serves chatlink/ streams.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 20:50:04 -07:00
Wing
b9c0fe566f ChatRoom: a relay socket that outlives the flag says hello again
A socket can survive the deploy that turns the layer off. Its host went on relaying
into a room that refused the frames, until that socket happened to end. Now it's
closed at its next frame, and the host hears the room's real answer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 18:54:05 -07:00
Wing
84f24f36ab Cloud: a credit is a minute of a small machine, from a cutover day
A credit is meant to be a minute of a small machine, which the provider
bills at 0.5×: 30 billable seconds. The code charged 60.

Balances are worked out from raw usage seconds at the current rate, so
just changing it would re-price all past usage too. The rate now goes by
the UTC day the usage fell on: days before CLOUD_CREDIT_RATE_FROM stay at
60 seconds a credit, and from that day on it's CLOUD_CREDIT_SECONDS. That
covers the balance, plan periods, usage per day and a running machine's
live estimate, which is split at midnight. Provider seconds and dollars
don't change.

Without a real day in CLOUD_CREDIT_RATE_FROM every day stays at 60, even
with CLOUD_CREDIT_SECONDS set. wrangler.jsonc carries the new rate and a
placeholder day, so merging changes nothing until a deployer picks one.

The apps say "a small machine" now, and the "about N hours" line, which
was about the default machine, says small-machine hours.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 17:35:29 -07:00
Wing
c9b082176d A Cloud machine updates before it answers
A machine that sleeps most of the time would otherwise answer on whatever it last
had. Its engine now holds work from assembly, turns a dying machine left to resume
included, and looks for a release. Newer, it installs it, restarts into it and only
answers once the update trial commits. With nothing newer the check costs only what
it outlasts the rest of the boot by.

The message always gets answered. A check that hangs or fails, a failed or slow
download, a refused restart and a restart that never comes all lift the hold on the
version already running, and the background updater tries again later. It can't
loop: a release it went back from or couldn't install isn't tried from a boot again,
and one that failed to download waits 6 hours. A bad new version gives way to the
old one, which finds the rollback and answers; one that hangs gives way after 5
minutes.

This replaces the 2-minute hold on engine updates. What it protected stays: an
update can't restart the engine under a live run or open terminal and, on Cloud,
while a message is waiting. Off Cloud nothing changes. The agent CLI check keeps its
own delay.

A longer wake reads as updating: CloudSession.stage says so, the desktop's waiting
word follows it, the answer's setup steps name the version, and the timeline records
the check, the install, the restart and which version answered.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 17:22:36 -07:00
Wing
d4f6be26d1 ChatRoom: ask the registry each time a queue row is confirmed
A cached answer kept a device that had just stopped hosting able to confirm rows for
the length of the cache. A real two-device run lost a message to the new host that way.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 17:05:45 -07:00
Wing
7b0aa41bb8 Merge branch 'wip/fix-durable' into wip/fix-fastwake 2026-11-06 15:19:55 -07:00
Wing
f0f9937af2 Bring a machine back when it dies right after a send
A machine reports a turn only with its next heartbeat. Stopped within that minute,
it went to sleep as idle, and its chat said the reply was still streaming until
someone sent again. A send reaching a machine that's up now counts as work if no
heartbeat follows it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 15:19:05 -07:00
Wing
adb3a9edb9 Relay layer: say when a chat's host is away, and wake it for clients with no hint
A chat this device has never loaded reads as empty once it has caught up with a room
that stores nothing. That looks like a chat with no messages. Now, while it has
messages and an empty copy here, it waits on its host and says so if the host is away.

A client that sends no host hint gets the host from the registry, so an old reader
arriving at a relayed chat still brings the host back to store for it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 14:45:33 -07:00
Wing
57ccf9b047 Merge cloud-durable's fixes from real machines
# Conflicts:
#	edge/test/workerd/boat-fake.ts
#	edge/test/workerd/cloud-durable.workerd.test.ts
2026-11-06 14:42:52 -07:00
Wing
2c49ca0a0d Stop a machine whose wake failed
It came up with no engine and billed until its TTL, for a chat that reads error.
A send resumes it just the same from stopped.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 14:38:21 -07:00
Wing
9742ffcdfa Cloud: fixes found on real machines: a size out of a refusal, disk levels, a killed turn's login
A resume that doesn't fit leaves the sandbox in Boat's error state, and the wake
gave up on that state, so waking on a bigger size never reached Boat and said
the bigger size was too small. It now resumes from there.

Boat's limit counts what the machine added, not its base image, so judging df
against it warned a fresh machine at 41% and called one that fits critical.

Boot recovery starts a killed turn ahead of the credential broker: the agent came
up with no login and couldn't find its conversation, so no killed turn resumed.
It now waits for the broker.

A machine that goes dark during a turn is looked at once its heartbeats are late,
not a whole idle window on, and Boat's other refusal spelling is read.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 14:37:07 -07:00
Wing
cbee959061 Relay layer: old readers, phones, rollback and local-first
Old clients and rollback:
- The registry room remembers clients that join without the layer. Phones write no
  device row, so this is how a chat's host learns of them.
- The room remembers relaying, and holds the queue back from readers without the
  layer until the host's heal, so no stored row can depend on ops only peers hold.
- A build with the flag off owes one heal for a generation 3 chat it hosts.
- A parked row that reading the checkpoint doesn't fill stops redialling.
- Row writers for host and activity write only their own fields.

Checkpoints:
- A relay-era checkpoint waits until this process has caught up, and the room
  refuses one that would move backwards.
- Chats over 24 MiB don't flip, and go back to stored rows.
- A chat too big to checkpoint no longer blocks a Cloud sleep.

Queue and links:
- Only the chat's host, as the registry says, can retire a queue row. A new host
  re-reads the queue.
- A connected socket without the layer gets queued rows as stored rows.
- The edge flag alone wakes nobody.
- A link ends when its chat's handle goes away, and a handle with a link isn't
  evicted. A failed export reads as gone, not empty.
- A round over a dead link ends when the link does.

Local-first: what arrives by relay is journaled locally until a save covers it. The
guarantee and the rollback order are in the design doc.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 14:26:05 -07:00
Wing
ea1893c364 Merge remote-tracking branch 'origin/zeron/chatroom-fewer-writes' into p2p-relay-test 2026-11-06 14:05:47 -07:00
Wing
b0574dd73f ChatRoom: a replay older than the dedupe window still acks in an older room
Rooms from before the window keep a UNIQUE index on batch_id. A replay the window
doesn't reach hit that index on insert and threw, so the batch never acked.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 14:05:44 -07:00
Wing
a9883e5866 Add the relay layer behind flags that default off
Gen-3 chats relay their host's ops instead of storing them. Delivery over the
room or a direct WebRTC link is a hint, and version exchange finds and fetches
whatever was missed. A separate offline queue holds messages for a host that
isn't there until it has saved them. Cloud hosts also post checkpoints.

With CHAT_RELAY_LAYER and ZERON_RELAY_LAYER unset, hello is byte-identical, the
room answers new frames as unknown types, no queue table exists and no engine
state or stream service is created.

Nothing deletes existing rows: the queue is its own table, and relay-era
checkpoints prune nothing. Old clients get a current checkpoint and stored rows
while they're around, and anything queued moves into rows they can read.

Mobile isn't part of this, so a phone seen in the last 14 days keeps its
account's chats on stored rows.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 13:32:39 -07:00
Wing
415f1f2487 Hold a Cloud engine's first release check through its boot
Now that a Cloud engine knows it's the installed service, restart_when_superseded
pokes the updater during every boot. A poke ended the initial delay, so each wake
checked for a release, and could start a download, as the waiting message started
its run. Only a forced check cuts that delay short now; a poke asks whether one is
due. Every installed engine gets this: its first check waits the 20 s the delay
always said it would.

The test fake now treats a command that ran as proof the machine is up, as the
wake does, and the durable suite covers a refresh (no timeline) and a machine
brought back from dark (engine started, no send behind its timeline).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 13:11:31 -07:00
Wing
406ddff2b0 Vault: several GitHub logins, each session on its own
A login connected through another device flow used to take over: repositories
and grants came only from the most recent one. Now they are all in use at once.

Repositories merge across logins, each naming the login a new session would
use. A session keeps the login and App installation of its first grant, whatever
is connected later; a delegate takes its parent's. Logins and installations are
separate records, and a session records both.

One login failing leaves the others working and says which, and disconnecting
one refuses its sessions by name until it comes back. Stored logins and old
clients carry on unchanged. docs/design/cloud-device.md states the rules.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 13:08:20 -07:00
Wing
c1b0e9a62f Cloud: wake in one step, race the engine start, and record each wake's timeline
The wake polled through Workflow sleeps (2 s, then 10), so a machine already
up waited whole seconds to be noticed, and the engine was started only after
that. fastWake does it in one step: resume, send the start at once (the
provider holds a command until the machine can run it), poll every 250 ms.

A sleep stops the engine's unit, and a machine restored from that snapshot can
come back with it stopped. zeron-cloud-boot.service stays active through the
snapshot and starts it on resume with no exec round trip. The unit no longer
waits on network-online.target, and the sleep's stop command upgrades machines
already provisioned, since nothing re-runs the installer.

Every wake now writes a wake_timing ledger entry and a cloud.wake_timing log
line, joined with the engine's report (POST /runner/wake-timing).
GET /admin/cloud/wakes lists one user's.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 13:02:50 -07:00