Seed desktop today is polling-based with manual TanStack Query invalidation over Connect-RPC to a local Go daemon. The daemon already owns the source-of-truth SQLite database on the same machine; IPC is the boundary, not the network. P2P sync results in the daemon, but the renderer only learns about new data on the next poll tick or manual invalidateQueries().

Observed pain points motivating this work:

1. Flicker / loading states on navigation. Switching documents shows skeletons even when data is already cached locally, because each panel waits on its own query lifecycle.

2. P2P sync feels frozen. Discovery and inbound blobs land in the daemon but the UI takes seconds (or a focus event) to reflect them.

3. State sprawl. Server cache (TanStack), UI state (React + electron-store), document editor state (XState) live in separate reactive systems with ad-hoc bridges. Bugs leak across them.

Riffle solves analogous problems via (a) reactive relational queries, (b) synchronous transactional updates, (c) unifying UI + domain state in one reactive substrate. We adopt the reactive layer ideas only — daemon SQLite stays the source of truth; we do not ship a client-side DB. Web app (@shm/web) out of scope.

Replace polling + manual invalidation with push-driven, dependency-tracked reactive queries that batch into transactional UI ticks, plus a single reactive store for UI state that participates in the same tick.

Build the smallest end-to-end loop (event source → bus → reactive graph → one UI surface) for one feature first. Each subsequent slice adds one more fetcher + topic + UI surface. The transport, engine, and UI-state store evolve inside the same vertical pipeline, swapped behind a stable renderer-facing API.

Benefits over horizontal phasing:

• Ship visible win after slice 1 (~days, not weeks).

• API gets stress-tested on real component before broad migration.

• Can be killed cheaply if approach fails — small blast radius.

• Each slice is independently mergeable; no big-bang flag.

┌────────────────────────────── Go daemon ──────────────────────────────┐
│  SQLite (truth) → commit hooks → internal pubsub                      │
│  Events.Watch streaming RPC                                           │
│  • emits typed events: blob.inserted, doc.changed, sub.updated…       │
│  • topic-tagged (ENTITY:<id>, DIRECTORY:<acct>:<path>, ACCOUNT:<id>)  │
└──────────────────────────────┬────────────────────────────────────────┘
                               │ Connect-RPC server-streaming
                               ▼
┌──────────────────────── Electron main process ────────────────────────┐
│  EventBridge — owns the single daemon stream, fans out to renderers   │
│  TopicPoller (slice-1 fallback) — polls daemon, diffs, emits events   │
│  Both push to renderers over electron-trpc subscription               │
└──────────────────────────────┬────────────────────────────────────────┘
                               │ tRPC observable
                               ▼
┌──────────────────────────── Renderer ─────────────────────────────────┐
│  @shm/reactive                                                        │
│   • graph.ts: Node={key,topics,fetcher,equals?}, dirty, tick scheduler│
│   • event-bus.ts: pipes events → markDirty(topic)                     │
│   • react.tsx: useReactiveQuery(node), useReactiveState(schema)       │
│  UIStateStore (later slice) — extends StateStream, same tick          │
└───────────────────────────────────────────────────────────────────────┘

Stable API contract from day 1: useReactiveQuery(node) and useReactiveState(schema, scope). Everything below can change without touching components.

Key design choices:

• Engine deferred. No client SQLite. Slice 1 = "refetch whole result on dirty". Later: swap for IVM (cr-sqlite, materialize-wasm) behind same node API.

• Transport swap, not rewrite. Slice 1 uses electron-trpc subscription backed by main-process polling. Later slice swaps event source for Events.Watch Connect streaming RPC; renderer untouched.

• Topic-level reactivity, not row-level. Mirrors Riffle's "on-demand layer" (paper §A). Manually declare topics per node; later derive from query shape.

• Transactional tick. All dirty nodes triggered by one event resolve before React notification. Mirrors Riffle §3.2 (synchronous transactional updates).

• UI state migration is its own slice. Don't conflate with server-state reactivity.

Each slice = one fetcher + one topic + one UI surface. Stop or pivot after any slice if no win.

• Delete refetchIntervals once parity holds.

• (Optional) Swap "refetch on dirty" for cr-sqlite / materialize-wasm with incremental views. Requires schema mirror — separate design doc.

NEW:

• frontend/packages/reactive/package.json

• frontend/packages/reactive/src/{graph,react,event-bus,index}.ts

• frontend/apps/desktop/src/main/topic-poller.ts

EDIT:

• frontend/apps/desktop/src/app-api.ts — add events.watch subscription.

• frontend/apps/desktop/src/app-context.tsx — wire bus on boot.

• One sidebar component file (TBD when scanning components) — swap hook.

Common gates after every slice:

• pnpm typecheck

• pnpm --filter @shm/reactive test (once tests exist, slice 1 prototype skips)

• pnpm --filter @shm/desktop test:unit

• Manual: golden path + monitor devtools (no console spam, single tRPC subscription open).

Slice-specific:

• Slice 1: P2P-added sidebar doc appears <1.5s, no manual focus. Baseline = current 10s polling.

• Slice 3: remote change of open doc reflects in body <1s.

• Slice 5: swap to streaming verified by grpcurl plus desktop e2e equivalence with slice-1 polling baseline.

• Slice 6: Playwright frame trace confirms sidebar selection + main pane swap in same paint.