feat: restore last workspace on cold start

Persist the user's last active workspace and navigate directly to it
on cold start instead of always landing on the open-project screen.

- Unified bootstrap into one cross-platform wait step after
  platform-specific connection setup
- Store-level wait with workspace preference: preferred host online
  resolves immediately, grace period if a different host connects
  first, bounded 5s timeout for unreachable hosts
- index.tsx is fully declarative — reads resolved target from context,
  no useEffect/promises/refs/timers

packages/app/src/stores/navigation-active-workspace-store.test.ts

@@ -1,9 +1,28 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
+const asyncStorageMock = vi.hoisted(() => ({
+  getItem: vi.fn<(_: string) => Promise<string | null>>(),
+  setItem: vi.fn<(_: string, __: string) => Promise<void>>(),
+}));
+
+vi.mock("@react-native-async-storage/async-storage", () => ({
+  default: asyncStorageMock,
+}));
+
 vi.mock("@/constants/platform", () => ({
   isWeb: true,
 }));
 
+const LAST_WORKSPACE_ROUTE_SELECTION_STORAGE_KEY = "paseo:last-workspace-route-selection";
+
+function createDeferred<T>() {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((nextResolve) => {
+    resolve = nextResolve;
+  });
+  return { promise, resolve };
+}
+
 function installWindowStub(pathname: string) {
   const windowStub = {
     location: {
@@ -75,6 +94,10 @@ function createNavigationPathWithParamsRef(path: string, serverId: string, works
 describe("navigation active workspace store", () => {
   beforeEach(() => {
     vi.resetModules();
+    asyncStorageMock.getItem.mockReset();
+    asyncStorageMock.setItem.mockReset();
+    asyncStorageMock.getItem.mockResolvedValue(null);
+    asyncStorageMock.setItem.mockResolvedValue();
   });
 
   afterEach(() => {
@@ -173,4 +196,58 @@ describe("navigation active workspace store", () => {
       workspaceId: "workspace-a",
     });
   });
+
+  it("hydrates the last workspace route selection from storage on startup", async () => {
+    const storedSelection = createDeferred<string | null>();
+    asyncStorageMock.getItem.mockReturnValue(storedSelection.promise);
+    installWindowStub("/open-project");
+
+    const store = await import("@/stores/navigation-active-workspace-store");
+
+    expect(store.getIsLastNavigationWorkspaceRouteSelectionLoaded()).toBe(false);
+    const hydration = store.hydrateLastNavigationWorkspaceRouteSelection();
+    storedSelection.resolve(JSON.stringify({ serverId: "server-1", workspaceId: "workspace-a" }));
+    await hydration;
+
+    expect(asyncStorageMock.getItem).toHaveBeenCalledWith(
+      LAST_WORKSPACE_ROUTE_SELECTION_STORAGE_KEY,
+    );
+    expect(store.getLastNavigationWorkspaceRouteSelection()).toEqual({
+      serverId: "server-1",
+      workspaceId: "workspace-a",
+    });
+    expect(store.getIsLastNavigationWorkspaceRouteSelectionLoaded()).toBe(true);
+  });
+
+  it("hydrates empty and corrupt workspace route storage as null", async () => {
+    installWindowStub("/open-project");
+
+    asyncStorageMock.getItem.mockResolvedValueOnce(null);
+    let store = await import("@/stores/navigation-active-workspace-store");
+    await store.hydrateLastNavigationWorkspaceRouteSelection();
+
+    expect(store.getLastNavigationWorkspaceRouteSelection()).toBeNull();
+    expect(store.getIsLastNavigationWorkspaceRouteSelectionLoaded()).toBe(true);
+
+    vi.resetModules();
+    asyncStorageMock.getItem.mockResolvedValueOnce("{not json");
+    store = await import("@/stores/navigation-active-workspace-store");
+    await store.hydrateLastNavigationWorkspaceRouteSelection();
+
+    expect(store.getLastNavigationWorkspaceRouteSelection()).toBeNull();
+    expect(store.getIsLastNavigationWorkspaceRouteSelectionLoaded()).toBe(true);
+  });
+
+  it("persists valid last workspace route selections", async () => {
+    installWindowStub("/h/server-1/workspace/workspace-a");
+    const store = await import("@/stores/navigation-active-workspace-store");
+    await store.hydrateLastNavigationWorkspaceRouteSelection();
+
+    store.syncNavigationActiveWorkspace(createNavigationRef("server-1", "workspace-a"));
+
+    expect(asyncStorageMock.setItem).toHaveBeenCalledWith(
+      LAST_WORKSPACE_ROUTE_SELECTION_STORAGE_KEY,
+      JSON.stringify({ serverId: "server-1", workspaceId: "workspace-a" }),
+    );
+  });
 });

packages/app/src/stores/navigation-active-workspace-store.ts

@@ -1,3 +1,4 @@
+import AsyncStorage from "@react-native-async-storage/async-storage";
 import { useMemo, useSyncExternalStore } from "react";
 import { useSyncExternalStoreWithSelector } from "use-sync-external-store/shim/with-selector";
 import {
@@ -38,8 +39,13 @@ interface NavigationObserverRef {
   } | null;
 }
 
+const LAST_WORKSPACE_ROUTE_SELECTION_STORAGE_KEY = "paseo:last-workspace-route-selection";
+
 let snapshot: ActiveWorkspaceSelection | null = null;
 let lastWorkspaceRouteSelection: ActiveWorkspaceSelection | null = null;
+let isLastWorkspaceRouteSelectionLoaded = false;
+let lastWorkspaceRouteSelectionRevision = 0;
+let lastWorkspaceRouteSelectionHydrationPromise: Promise<void> | null = null;
 let nextWorkspaceRouteSelectionOverride: ActiveWorkspaceSelection | null = null;
 const listeners = new Set<() => void>();
 
@@ -54,13 +60,87 @@ function getSnapshot(): ActiveWorkspaceSelection | null {
   return snapshot;
 }
 
+function notifyListeners() {
+  for (const listener of listeners) {
+    listener();
+  }
+}
+
 function emitIfChanged(next: ActiveWorkspaceSelection | null) {
   if (snapshot?.serverId === next?.serverId && snapshot?.workspaceId === next?.workspaceId) {
     return;
   }
   snapshot = next;
-  for (const listener of listeners) {
-    listener();
+  notifyListeners();
+}
+
+function parseStoredLastWorkspaceRouteSelection(
+  stored: string | null,
+): ActiveWorkspaceSelection | null {
+  if (!stored) {
+    return null;
+  }
+
+  try {
+    return normalizeActiveWorkspaceSelection(JSON.parse(stored));
+  } catch {
+    return null;
+  }
+}
+
+function normalizeActiveWorkspaceSelection(input: unknown): ActiveWorkspaceSelection | null {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return null;
+  }
+
+  const selection = input as Record<string, unknown>;
+  const serverId = typeof selection.serverId === "string" ? selection.serverId.trim() : "";
+  const workspaceId = typeof selection.workspaceId === "string" ? selection.workspaceId.trim() : "";
+
+  if (!serverId || !workspaceId) {
+    return null;
+  }
+
+  return { serverId, workspaceId };
+}
+
+function persistLastWorkspaceRouteSelection(next: ActiveWorkspaceSelection) {
+  void AsyncStorage.setItem(LAST_WORKSPACE_ROUTE_SELECTION_STORAGE_KEY, JSON.stringify(next)).catch(
+    () => {},
+  );
+}
+
+function setLastWorkspaceRouteSelection(next: ActiveWorkspaceSelection) {
+  const normalized = normalizeActiveWorkspaceSelection(next);
+  if (!normalized) {
+    return;
+  }
+
+  if (
+    lastWorkspaceRouteSelection?.serverId === normalized.serverId &&
+    lastWorkspaceRouteSelection.workspaceId === normalized.workspaceId
+  ) {
+    return;
+  }
+
+  lastWorkspaceRouteSelectionRevision += 1;
+  lastWorkspaceRouteSelection = normalized;
+  persistLastWorkspaceRouteSelection(normalized);
+}
+
+async function readLastWorkspaceRouteSelectionFromStorage(hydrationRevision: number) {
+  try {
+    const stored = await AsyncStorage.getItem(LAST_WORKSPACE_ROUTE_SELECTION_STORAGE_KEY);
+    if (lastWorkspaceRouteSelectionRevision === hydrationRevision) {
+      lastWorkspaceRouteSelection = parseStoredLastWorkspaceRouteSelection(stored);
+    }
+  } catch {
+    if (lastWorkspaceRouteSelectionRevision === hydrationRevision) {
+      lastWorkspaceRouteSelection = null;
+    }
+  } finally {
+    isLastWorkspaceRouteSelectionLoaded = true;
+    notifyListeners();
   }
 }
 
@@ -170,7 +250,7 @@ export function syncNavigationActiveWorkspace(navigationRef: NavigationObserverR
   const route = navigationRef.current?.getCurrentRoute();
   const routeState = classifyNavigationWorkspaceRoute(route);
   if (routeState.kind === "workspace") {
-    lastWorkspaceRouteSelection = routeState.selection;
+    setLastWorkspaceRouteSelection(routeState.selection);
     if (nextWorkspaceRouteSelectionOverride) {
       const overrideSelection = nextWorkspaceRouteSelectionOverride;
       nextWorkspaceRouteSelectionOverride = null;
@@ -197,6 +277,22 @@ export function getLastNavigationWorkspaceRouteSelection(): ActiveWorkspaceSelec
   return lastWorkspaceRouteSelection;
 }
 
+export function getIsLastNavigationWorkspaceRouteSelectionLoaded(): boolean {
+  return isLastWorkspaceRouteSelectionLoaded;
+}
+
+export function hydrateLastNavigationWorkspaceRouteSelection(): Promise<void> {
+  if (lastWorkspaceRouteSelectionHydrationPromise) {
+    return lastWorkspaceRouteSelectionHydrationPromise;
+  }
+
+  const hydrationRevision = lastWorkspaceRouteSelectionRevision;
+  lastWorkspaceRouteSelectionHydrationPromise =
+    readLastWorkspaceRouteSelectionFromStorage(hydrationRevision);
+
+  return lastWorkspaceRouteSelectionHydrationPromise;
+}
+
 export function overrideNextNavigationWorkspaceRouteSelection(next: ActiveWorkspaceSelection) {
   nextWorkspaceRouteSelectionOverride = next;
 }
@@ -223,6 +319,14 @@ export function useNavigationActiveWorkspaceSelection(): ActiveWorkspaceSelectio
   return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
 }
 
+export function useIsLastNavigationWorkspaceRouteSelectionLoaded(): boolean {
+  return useSyncExternalStore(
+    subscribe,
+    getIsLastNavigationWorkspaceRouteSelectionLoaded,
+    getIsLastNavigationWorkspaceRouteSelectionLoaded,
+  );
+}
+
 export function useIsNavigationWorkspaceSelected(input: {
   serverId: string | null;
   workspaceId: string | null;
@@ -243,6 +347,8 @@ export function useIsNavigationWorkspaceSelected(input: {
   );
 }
 
+void hydrateLastNavigationWorkspaceRouteSelection();
+
 export function useIsNavigationProjectActive(input: {
   serverId: string | null;
   workspaceIds: readonly string[];