feat(mobile): mobile app navigation rework and beta-feedback closeout (#2561)

Navigation model rebuilt around two full-width drawers and a minimal
header (sessions / title-switcher / usage ring / workspace):

- Left sessions drawer: cross-project tree with live status indicators,
  swipe actions on sessions (rename/archive/delete) and on group headers
  (project edit / two-step close, worktree delete), reorder-only edit
  mode with collapsible project cards and draggable worktrees, app-level
  footer (connected instance, settings, pending web update).
- Right workspace drawer: Changes / Files / Terminal / Notes / MCP as
  pill tabs (inactive tabs icon-only); panes stay mounted once visited.
  The full desktop file editor serves the Files tab; read/skill tool taps
  in chat open the file there at the requested line.
- Header session switcher on title tap: 10 cross-project recents with
  live busy/attention indicators and project · branch metadata; the
  usage ring opens a metadata overlay with an explicit loading state.
- The overflow menu is gone on phones (its destinations moved into the
  drawers); iPad keeps it until its dedicated layout pass.

Correctness and continuity:

- /auth/session answers bearer-first, so a stale WebView cookie can no
  longer mask a revoked device token; cold launches classify failures
  fast and land on an explicit connect screen.
- Authoritative session snapshots raise frozen ordering baselines and
  stale live ranks — recents stay truthful after the app slept.
- Cold launches reopen the last active session per instance (persisted
  pointer, confirmed against a sessions snapshot; a user-opened draft
  clears it), with a logo hold instead of a draft flash.

Also: collapsed pill composer gains the stop control; chat tool rows
share one 36px rhythm; Task subtool rows truncate; larger bottom safe
area so the composer clears big-screen corner radii; Capacitor build
hides About/Update (store updates apply there); widgets link to the
sessions drawer with a list icon; MobileApp split into focused modules;
five mobile-surface detectors unified; translucent borders normalized to
70%; all new strings translated across the 10 locales.

iPad and foldable layouts are intentionally untouched - separate next version PR.

packages/ui/src/sync/session-ordering.ts

@@ -120,6 +120,48 @@ const baselineRank = (session: Session, pinned: boolean): number => {
   return rank;
 };
 
+/**
+ * Raise cached baselines to the sessions' current authoritative timestamps.
+ *
+ * The frozen baseline keeps live metadata churn from reordering an open list,
+ * but a client that slept through a session's whole active→settled cycle never
+ * saw the transition that would have promoted its live rank — so its stale
+ * baseline pins it in place forever. Call this when an authoritative session
+ * SNAPSHOT arrives (global refresh); monotonic, so it can never demote.
+ */
+export const raiseSessionOrderingBaselines = (sessions: Iterable<Session>): void => {
+  const currentRanks = useSessionOrderingStore.getState().rankById;
+  let nextRanks: Map<string, number> | null = null;
+  let baselinesChanged = false;
+
+  for (const session of sessions) {
+    const fresh = updatedAt(session);
+    const liveRank = currentRanks.get(session.id);
+    if (liveRank !== undefined) {
+      // A live rank frozen BEFORE this newer authoritative stamp is stale —
+      // the session was active again while this client wasn't watching (its
+      // transition events never arrived, e.g. другий пристрій + сон). Ranks
+      // share the epoch-ms scale with `updated`, so raising is well-ordered.
+      if (fresh > liveRank) {
+        nextRanks = nextRanks ?? new Map(currentRanks);
+        nextRanks.set(session.id, fresh);
+      }
+      continue;
+    }
+    const existing = baselineRankById.get(session.id);
+    if (existing?.updated !== undefined && existing.updated >= fresh) continue;
+    baselineRankById.set(session.id, { ...existing, updated: fresh });
+    baselinesChanged = true;
+  }
+
+  if (nextRanks) {
+    useSessionOrderingStore.setState({ rankById: nextRanks });
+  } else if (baselinesChanged) {
+    // Baselines live outside the store; nudge subscribers so open lists re-sort.
+    useSessionOrderingStore.setState((state) => ({ rankById: new Map(state.rankById) }));
+  }
+};
+
 export const getSessionLifecycleOrderValue = (
   session: Session,
   rankById: ReadonlyMap<string, number>,