# Server-authoritative open chat workspace ## Behaviour The authenticated `/connect` protocol stores one bounded ordered open-chat set per server scope (`default`). Entries hold only an operator session id and a floating bit; split ratios, pane ids and window rectangles stay on the device. * `chat_open_workspace` without `chat_open_workspace_request` reads the set. With a request it replaces the set as a compare-and-swap on `base_revision`: a write from a stale base is not applied and the reply carries the current set with `rejected: true`. Each stored change increments `revision`; an identical write stores nothing. * `seed: true` applies only when the server never stored a set (even an emptied set wins over an old device-local snapshot), so the migration from the old local layout happens once. * Stored changes are pushed to every other connection as `chat_open_workspace_changed`. Pushes run on separate goroutines and can arrive out of order; clients keep the highest revision. * Only recorded, not-closed operator chats are kept (registry check; the broker is not asked, so validation never starts a harness). `chat_close` drops the chat and pushes the new revision to every connection. A new connection prunes stale entries and pushes the result to all connections, else sends the current set to the new connection only (reconnect catch-up). App (`ChatOpenWorkspaceController`): one write in flight at a time; later changes coalesce into the newest full set, sent from the revision of the last reply. Pushes and replies with a lower (or, for pushes, equal) revision are ignored. A push or a rejected reply wins over unsent local changes. After the local layout is restored, the device seeds (or, with no chats, reads) and applies the answer; the first answer keeps a deep-linked chat. Server drops in a successful reply are not applied locally, so a closed chat can still be read on the device that opened it, but no other device receives it. Remote membership is applied with `reconcileChatWorkspaceTree`: removed chats' panes go, survivors keep pane ids and split sizes and move to follow the order, new chats split off the last pane. The controller is disposed on a server or gateway rebind. A federated (all-servers) list keeps its local layout. Ctrl+Tab: main's behaviour (floating chats when shown, else visible panes) is kept; the single-pane recent-chat swap is removed there. ## Verification * Go: `internal/pipeline` `TestChatOpenWorkspace*` (seed once, stale revision, remove, bounds); `internal/server` `TestChatOpenWorkspaceSyncsEveryConnection` (two connections get the same snapshot, stale write rejected, reorder, close pruned and pushed to both, closed chat not restorable) and `TestChatOpenWorkspacePrunesOnConnectForEveryone`. * App: `test/features/chat/workspace/chat_open_workspace_controller_test.dart` (serialized writes, late reply vs newer push, rejected write, dispose), `chat_workspace_reconcile_test.dart`, and `test/features/chat/chat_open_workspace_sync_test.dart` (seed migration, remote removal drops the pane, server set wins over an old local snapshot, rebind disposes the old sync). * Live two-client check (2026-11-12): server built from this worktree, run on an OS-assigned loopback port with a scratch HOME/XDG and database, three scratch operator rows; a Node script drove two websocket clients through read, open, reorder, stale write, float, pane close, `chat_close`, write-back of the closed chat, and an out-of-band close pruned on a third connection. All 16 checks passed (`RESULT: PASS`); every connection received the same revisions. The scratch server and its own OpenCode child were stopped. Not verified: rendered UI captures and on-device behaviour.