Merge commit '9999e0912e9c38bd24a8754d64e7a14c589b1646' into pipelines/run-20261112-0206-composer-border-shows-the-agent-working-fd87

This commit is contained in:
2026-11-12 03:26:25 +00:00
31 changed files with 2257 additions and 79 deletions
+63
View File
@@ -0,0 +1,63 @@
# 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.
+71
View File
@@ -0,0 +1,71 @@
# Android notifications grouped per chat and run
## What changed (native service only; Flutter unchanged)
- `android/.../notify/NotificationThreads.kt` (new): `ThreadEntry`, `ThreadHistory`
(bounded per-thread entries, bounded thread count, persisted through the
ledger's `LedgerStore` under `threads.history`), and naming helpers. Threads are
keyed by the server `group` (`chat:<id>` or `run:<id>`, per `docs/ntfy.md`).
- `NotificationPresenter.kt`: a grouped notification posts one conversation
notification per thread with a stable id (`thread:<group>`), the latest 5 lines
(sender = chat title, run title for runs), the unread count (`setNumber`), and a
shared group per namespace (`pipelines.chats`, `pipelines.runs`). The group
summary reads "N chats" / "N runs" and is removed when fewer than two are shown.
Empty-group notifications keep the old standalone path. Channels and importance
are unchanged (`channelFor` takes kind and priority, same rules).
- `cancel(ids)` removes the cleared entries from history, drops a thread whose
entries are all gone, and reposts a partially cleared thread with its new count.
`cancelAll()` also clears the history.
- `NotificationDismissReceiver.kt`: `EXTRA_NOTIFICATION_ID` may carry several
newline-separated ids, so a tap or swipe on a thread clears every entry it shows.
- `NotificationService.kt`, the ledger and the protocol are untouched, so run 405's
reconnect/wakelock work is not affected.
## Review fix (visit 2)
- The thread notification now uses `androidx.core.app.NotificationCompat.MessagingStyle`
with `androidx.core.app.Person`, built by `NotificationCompat.Builder` (the presenter's
builder is compat throughout). Platform `Notification.MessagingStyle` and its API 28
BigTextStyle fallback are gone; the compat style renders on every supported API level.
- `app/android/app/build.gradle.kts` adds `implementation("androidx.core:core:1.15.0")`
(already in the offline Gradle cache).
## Focused results
- Gradle 9.1.0 (cached), `--offline`, JDK 17 (`/opt/homebrew/opt/openjdk@17`):
`:app:testDebugUnitTest --tests 'net.awan.pipelines_app.notify.*'` → BUILD SUCCESSFUL.
JUnit XML: ThreadHistoryTest 9 tests / 0 failures, DeliveryLedgerTest 8 / 0,
NotificationProtocolTest 12 / 0.
- `tool/analyze.sh` (run from `app/`, after the Kotlin tests): clean, exit 0.
- No Flutter test was run: no Dart source changed.
- JDK 27 fails the Android JDK image transform (`jlink`) in a plugin, so builds here
need JDK 17 (environment issue, unrelated to this change).
## Affected states
- No Flutter UI changed. Native states not exercised on a device: a second chat
appearing as a thread, a summary at 2 and 1 chats, tap/swipe on a multi-line
thread, and the restart rebuild from persisted history.
## Merge with main (land re-entry)
- main moved `NotificationPresenter.kt` (sign-in notice, `openApp()` helper,
`SIGN_IN_ID`, `ACCOUNT_CHANNEL`). Resolved by keeping both sides: the
connection notification uses `openApp()`, and the sign-in block, constants and
thread code all remain. The merge is staged with `--no-commit`; land concludes it.
- Gradle, JDK 17, offline: `:app:compileDebugUnitTestKotlin` succeeds.
- Gradle, JDK 17, offline: `:app:testDebugUnitTest --tests 'net.awan.pipelines_app.notify.*'`
passes 37 of 37 (ConnectionLog 5, DeliveryLedger 8, NotificationProtocol 12,
ReconnectPolicy 3, ThreadHistory 9).
- No Dart changed in this stage, so no Flutter tests or analyze were run.
## Limitations
- Android posting (MessagingStyle, summary, PendingIntent extras) is not covered by
JVM tests and has not been run on a device. Mobile behaviour is unverified.
- The new androidx.core dependency is compiled offline but not run through a full
APK build or on a device in this stage.
- History is capped: 100 unread entries per thread (count is capped there) and 50
threads; the oldest thread is forgotten first when the cap is hit.
- Swipe-dismissal of a thread clears its ids on the server, but the local history
is trimmed only when the server confirms (`notifications_cleared`).