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

164 commits

Author SHA1 Message Date
Wing
715a1b4db4 Edge: production's relay setting lives in the config again
CHAT_RELAY_LAYER="1" (every room offers the relay layer) has been set
on the live production Worker since 2026-11-12 19:57 UTC, but this
branch's wrangler.jsonc, which production is deployed from, had no
CHAT_RELAY_LAYER at all. The next deploy from here would have dropped
it, and unset means nobody gets the relay layer. The config now says
what production runs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 23:42:22 -07:00
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
f4c55861e6 edge: an oversize checkpoint is refused before it's read
An engine from before checkpoint parts posts a long chat's whole snapshot
(35 MB and more) as one checkpoint, gets 413, and posts it again a few
seconds later: the edge read every byte of each before refusing it. Now
/checkpoint and /checkpoint-part read their bodies through `readCapped`:
a declared length past the cap is answered 413 before a byte is read,
and a body of no declared length is read only until it passes the cap.
What's within the cap is read as before.

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 16:48:04 -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
5b3f50b3ce Offer Remove on the desktop, and fail a queued row whose file is gone
The desktop transcript now shows Remove beside Retry on a failed send, and
beside "Sending..." while a send's files upload. It calls RemoveHeldSend and
takes the message out of view at once.

The lifecycle rule for stored files goes to 30 days, so a queued message on a
machine asleep for weeks still finds its files. If one has aged out anyway, a
Cloud machine past the 15-minute cap now takes the row out of its queue and
leaves it as its sender's failed message, with a retry that uploads the files
again. Before, the row waited for them forever.

A phone keeps each file it sent through the store until that message is in the
transcript, for queued rows as well as runs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-07 00:15:43 -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
ea2c29cccc RegistryRoom: count the rows it writes, and a live test that measures them
/stats gains writesSinceStart: the billed rows (index entries and alarms
included) the object wrote since it started, counted from each statement's
rowsWritten. The live test runs a streaming turn and a parked session
between two engines on wrangler dev and reports pushes, rows and fields
per phase.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 22:50:36 -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
051be288fb Vault: disconnecting a GitHub login revokes its tokens
A token already on a machine no longer lives out its hour. Disconnecting a login
revokes its user token and every installation token minted for its sessions with
GitHub, at once. Installation tokens are now kept with the login they were minted
for and never shared between logins, so one login's revocation never reaches
another's sessions.

The disconnect succeeds whether or not GitHub answers: what it didn't revoke is
retried on the object's alarm until GitHub answers or the token would have expired
anyway. A token minted while its login was being disconnected is revoked and never
handed out.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 21:04:29 -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
3f1164d32f Fast wake: resume a sandbox in the provider's error state
A resume that didn't fit leaves it there, and only a resume on a bigger size gets
it out.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-06 14:42:52 -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