diff --git a/apps/cli/src/__tests__/command-output/notifications.test.ts b/apps/cli/src/__tests__/command-output/notifications.test.ts
new file mode 100644
index 0000000000..1a6f1248ec
--- /dev/null
+++ b/apps/cli/src/__tests__/command-output/notifications.test.ts
@@ -0,0 +1,181 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  collectLogLines,
+  collectLogPayloads,
+  runCommand,
+  setupCommandOutputTestEnvironment,
+  stubServerApi,
+  type CommandRegistrar,
+} from "../helpers/command-output-harness.js";
+import { registerNotificationCommands } from "../../commands/notifications.js";
+
+const subscription = {
+  id: "push_abc123",
+  expoPushToken: "ExponentPushToken[abc]",
+  platform: "ios",
+  deviceLabel: "Sawyer's iPhone",
+  createdAt: 1_000,
+  lastSeenAt: Date.now(),
+};
+
+describe("bb notifications push-subscriptions commands", () => {
+  setupCommandOutputTestEnvironment();
+
+  const register: CommandRegistrar = (program) =>
+    registerNotificationCommands(program, () => "http://server");
+
+  it("lists registered devices as a table and as JSON", async () => {
+    stubServerApi({
+      "v1.notifications.push-subscriptions.$get": vi.fn(async () => ({
+        subscriptions: [subscription],
+      })),
+    });
+
+    await runCommand(["notifications", "push-subscriptions", "list"], register);
+    const lines = collectLogLines(vi.mocked(console.log)).join("\n");
+    expect(lines).toContain("ID");
+    expect(lines).toContain("push_abc123");
+    expect(lines).toContain("Sawyer's iPhone");
+    expect(lines).toContain("ios");
+    expect(lines).toContain("just now");
+
+    vi.mocked(console.log).mockClear();
+    await runCommand(
+      ["notifications", "push-subscriptions", "list", "--json"],
+      register,
+    );
+    expect(collectLogPayloads(vi.mocked(console.log))).toEqual([
+      JSON.stringify([subscription], null, 2),
+    ]);
+  });
+
+  it("prints a hint when no devices are registered", async () => {
+    stubServerApi({
+      "v1.notifications.push-subscriptions.$get": vi.fn(async () => ({
+        subscriptions: [],
+      })),
+    });
+
+    await runCommand(["notifications", "push-subscriptions", "list"], register);
+    expect(collectLogLines(vi.mocked(console.log))).toEqual([
+      "No push devices registered",
+    ]);
+  });
+
+  it("registers a device and reports created versus refreshed", async () => {
+    let calls = 0;
+    const post = vi.fn(async ({ json }) => {
+      calls += 1;
+      return new Response(
+        JSON.stringify({ ...subscription, ...json, lastSeenAt: 5 }),
+        {
+          status: calls === 1 ? 201 : 200,
+          headers: { "Content-Type": "application/json" },
+        },
+      );
+    });
+    stubServerApi({ "v1.notifications.push-subscriptions.$post": post });
+
+    await runCommand(
+      [
+        "notifications",
+        "push-subscriptions",
+        "add",
+        "--token",
+        "ExponentPushToken[abc]",
+        "--platform",
+        "ios",
+        "--label",
+        "Sawyer's iPhone",
+      ],
+      register,
+    );
+    await runCommand(
+      [
+        "notifications",
+        "push-subscriptions",
+        "add",
+        "--token",
+        "ExponentPushToken[abc]",
+        "--platform",
+        "ios",
+        "--label",
+        "Sawyer's iPhone",
+        "--json",
+      ],
+      register,
+    );
+
+    expect(post).toHaveBeenCalledTimes(2);
+    expect(post).toHaveBeenNthCalledWith(1, {
+      json: {
+        expoPushToken: "ExponentPushToken[abc]",
+        platform: "ios",
+        deviceLabel: "Sawyer's iPhone",
+      },
+    });
+    expect(collectLogPayloads(vi.mocked(console.log))).toEqual([
+      "Registered push device Sawyer's iPhone (push_abc123)",
+      JSON.stringify(
+        {
+          created: false,
+          subscription: { ...subscription, lastSeenAt: 5 },
+        },
+        null,
+        2,
+      ),
+    ]);
+  });
+
+  it("rejects unknown platforms before calling the server", async () => {
+    const post = vi.fn();
+    stubServerApi({ "v1.notifications.push-subscriptions.$post": post });
+
+    await expect(
+      runCommand(
+        [
+          "notifications",
+          "push-subscriptions",
+          "add",
+          "--token",
+          "ExponentPushToken[abc]",
+          "--platform",
+          "web",
+          "--label",
+          "Browser",
+        ],
+        register,
+      ),
+    ).rejects.toThrow("process.exit:1");
+    expect(post).not.toHaveBeenCalled();
+    expect(vi.mocked(console.error).mock.calls.flat().join("\n")).toContain(
+      "Invalid platform 'web'",
+    );
+  });
+
+  it("removes a device by id", async () => {
+    const del = vi.fn(async () => ({ ok: true }));
+    stubServerApi({ "v1.notifications.push-subscriptions.:id.$delete": del });
+
+    await runCommand(
+      ["notifications", "push-subscriptions", "remove", "push_abc123"],
+      register,
+    );
+    await runCommand(
+      [
+        "notifications",
+        "push-subscriptions",
+        "remove",
+        "push_abc123",
+        "--json",
+      ],
+      register,
+    );
+
+    expect(del).toHaveBeenCalledWith({ param: { id: "push_abc123" } });
+    expect(collectLogPayloads(vi.mocked(console.log))).toEqual([
+      "Removed push device push_abc123",
+      JSON.stringify({ id: "push_abc123", ok: true }, null, 2),
+    ]);
+  });
+});
diff --git a/apps/cli/src/__tests__/json-flag-enforcement.test.ts b/apps/cli/src/__tests__/json-flag-enforcement.test.ts
index 9996250ba2..12962e7954 100644
--- a/apps/cli/src/__tests__/json-flag-enforcement.test.ts
+++ b/apps/cli/src/__tests__/json-flag-enforcement.test.ts
@@ -6,6 +6,7 @@ import { registerProjectCommands } from "../commands/project.js";
 import { registerProviderCommands } from "../commands/provider.js";
 import { registerManagerCommands } from "../commands/manager.js";
 import { registerMachineCommands } from "../commands/machine.js";
+import { registerNotificationCommands } from "../commands/notifications.js";
 import { registerThreadCommands } from "../commands/thread/index.js";
 // Commands intentionally excluded from --json requirement
 const EXCLUDED_COMMANDS = new Set<string>();
@@ -37,6 +38,7 @@ describe("CLI --json flag enforcement", () => {
     registerProviderCommands(program, getUrl);
     registerManagerCommands(program, getUrl);
     registerMachineCommands(program, getUrl);
+    registerNotificationCommands(program, getUrl);
     registerThreadCommands(program, getUrl);
 
     const commands = collectLeafCommands(program);
diff --git a/apps/cli/src/commands/notifications.ts b/apps/cli/src/commands/notifications.ts
new file mode 100644
index 0000000000..255d973a74
--- /dev/null
+++ b/apps/cli/src/commands/notifications.ts
@@ -0,0 +1,136 @@
+import { Command } from "commander";
+import {
+  pushSubscriptionPlatformSchema,
+  pushSubscriptionPlatformValues,
+  type PushSubscription,
+  type PushSubscriptionPlatform,
+} from "@bb/server-contract";
+import { action } from "../action.js";
+import { createCliBbSdk } from "../client.js";
+import { renderBorderlessTable } from "../table.js";
+import { formatMachineLastSeen } from "./machine.js";
+import { outputJson, type JsonOutputOptions } from "./helpers.js";
+
+// Commander enforces the three required options before the action runs.
+interface PushSubscriptionAddCommandOptions extends JsonOutputOptions {
+  token: string;
+  platform: string;
+  label: string;
+}
+
+function parsePlatform(value: string): PushSubscriptionPlatform {
+  const parsed = pushSubscriptionPlatformSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new Error(
+      `Invalid platform '${value}'. Expected one of: ${pushSubscriptionPlatformValues.join(", ")}.`,
+    );
+  }
+  return parsed.data;
+}
+
+function printPushSubscriptionTable(
+  subscriptions: readonly PushSubscription[],
+): void {
+  const now = Date.now();
+  const rows = subscriptions.map((subscription) => [
+    subscription.id,
+    subscription.deviceLabel,
+    subscription.platform,
+    formatMachineLastSeen(subscription.lastSeenAt, now),
+    subscription.expoPushToken,
+  ]);
+  const widths = [
+    Math.max(2, ...rows.map((row) => row[0].length)),
+    Math.max(6, ...rows.map((row) => row[1].length)),
+    Math.max(8, ...rows.map((row) => row[2].length)),
+    Math.max(9, ...rows.map((row) => row[3].length)),
+    Math.max(5, ...rows.map((row) => row[4].length)),
+  ];
+  console.log("");
+  console.log(
+    renderBorderlessTable(
+      {
+        head: ["ID", "Device", "Platform", "Last seen", "Token"],
+        colWidths: widths,
+        trimTrailingWhitespace: true,
+      },
+      rows,
+    ),
+  );
+  console.log("");
+}
+
+export function registerNotificationCommands(
+  program: Command,
+  getUrl: () => string,
+): void {
+  const notifications = program
+    .command("notifications")
+    .description("Manage push notifications for bb mobile devices");
+
+  const pushSubscriptions = notifications
+    .command("push-subscriptions")
+    .description(
+      "Devices registered for Expo push notifications (pending interactions, finished turns, errors)",
+    );
+
+  pushSubscriptions
+    .command("list")
+    .description("List registered push devices")
+    .option("--json", "Print machine-readable JSON output")
+    .action(
+      action(async (opts: JsonOutputOptions) => {
+        const subscriptions =
+          await createCliBbSdk(getUrl()).notifications.pushSubscriptions.list();
+        if (outputJson(opts, subscriptions)) return;
+        if (subscriptions.length === 0) {
+          console.log("No push devices registered");
+          return;
+        }
+        printPushSubscriptionTable(subscriptions);
+      }),
+    );
+
+  pushSubscriptions
+    .command("add")
+    .description(
+      "Register an Expo push token, or refresh an existing registration",
+    )
+    .requiredOption("--token <expo-push-token>", "Expo push token")
+    .requiredOption(
+      "--platform <platform>",
+      `Device platform (${pushSubscriptionPlatformValues.join(" or ")})`,
+    )
+    .requiredOption("--label <label>", "Human-readable device name")
+    .option("--json", "Print machine-readable JSON output")
+    .action(
+      action(async (opts: PushSubscriptionAddCommandOptions) => {
+        const result = await createCliBbSdk(
+          getUrl(),
+        ).notifications.pushSubscriptions.add({
+          expoPushToken: opts.token,
+          platform: parsePlatform(opts.platform),
+          deviceLabel: opts.label,
+        });
+        if (outputJson(opts, result)) return;
+        const verb = result.created ? "Registered" : "Refreshed";
+        console.log(
+          `${verb} push device ${result.subscription.deviceLabel} (${result.subscription.id})`,
+        );
+      }),
+    );
+
+  pushSubscriptions
+    .command("remove <id>")
+    .description("Remove a registered push device")
+    .option("--json", "Print machine-readable JSON output")
+    .action(
+      action(async (id: string, opts: JsonOutputOptions) => {
+        const result = await createCliBbSdk(
+          getUrl(),
+        ).notifications.pushSubscriptions.remove({ id });
+        if (outputJson(opts, { id, ...result })) return;
+        console.log(`Removed push device ${id}`);
+      }),
+    );
+}
diff --git a/apps/cli/src/index.ts b/apps/cli/src/index.ts
index 42816b0cc7..8b7a034649 100644
--- a/apps/cli/src/index.ts
+++ b/apps/cli/src/index.ts
@@ -7,6 +7,7 @@ import { registerGuideCommand } from "./commands/guide.js";
 import { registerManagerCommands } from "./commands/manager.js";
 import { registerMarketplaceCommands } from "./commands/marketplace.js";
 import { registerMachineCommands } from "./commands/machine.js";
+import { registerNotificationCommands } from "./commands/notifications.js";
 import { registerProjectCommands } from "./commands/project.js";
 import { registerPluginCommands } from "./commands/plugin.js";
 import { registerProviderCommands } from "./commands/provider.js";
@@ -90,6 +91,7 @@ registerProjectCommands(program, getUrl);
 registerProviderCommands(program, getUrl);
 registerManagerCommands(program, getUrl);
 registerMachineCommands(program, getUrl);
+registerNotificationCommands(program, getUrl);
 registerUpdatesCommands(program, getUrl);
 registerTerminalCommands(program, getUrl);
 registerThreadCommands(program, getUrl);
diff --git a/apps/mobile/README.md b/apps/mobile/README.md
index c58b2dc2c7..2631095c5a 100644
--- a/apps/mobile/README.md
+++ b/apps/mobile/README.md
@@ -16,7 +16,7 @@ timeline with every row kind, markdown, inline diffs, terminal output, images +
 lightbox, sticky-bottom, older pages, unread divider, table of contents; the
 prompt area with pending-interaction banners, prompt-stack cards, the context
 banner, the queued-message list and the follow-up composer; header / message /
-git action sheets), deep links, and the workspace panel
+git action sheets), push notifications + deep links, and the workspace panel
 (a bottom sheet with Info · Diff · Files · Terminal + the thread's synced file
 tabs: thread metadata, the batched Diff tab with "Add to chat", file search /
 thread-storage browser / previews for text, markdown, CSV, HTML, images, the
@@ -26,7 +26,7 @@ and a host terminal), the settings buckets (General / Appearance /
 Experiments / Haptics, provider settings, usage limits, Machines with pairing /
 rename / permission ceiling / provider CLI installs, Updates, Plugins with
 detail / settings form / logs / catalog / marketplaces, Skills library +
-skills.sh registry, Discord / GitHub), "Share link" from the
+skills.sh registry, Notifications, Discord / GitHub), "Share link" from the
 thread menu, and the `Mobile E2E` GitHub workflow are in place. The Phase 0
 spikes and the renderer / composer / interactions showcases live under
 Settings → Developer.
@@ -86,9 +86,12 @@ src/
                          (switch profile → wait → push thread),
                          ThreadOpenSignalHandler (realtime `thread-open` →
                          navigate, like the web's wsManager.onThreadOpen)
-  notifications/         push notifications arrive in a later PR (RN glue:
-                         expo-notifications behind the data-layer contract,
-                         registration sync, taps → thread, badge, Settings rows)
+  notifications/         push (RN glue): expo-notifications behind the data
+                         layer's PushNotificationsModule, MMKV push store,
+                         app-wide registration controller, PushNotificationsHost
+                         (registration sync, taps → thread, foreground toast
+                         with Open, app-icon badge, first-run prompt),
+                         PushSettingsRows + usePushRegistration (Settings)
   screens/               screen components (home/, settings/, shell/, compose/,
                          connect/ — bb connect enrollment: ConnectEnrollScreen,
                          ConnectScanner (expo-camera QR), AccountServersList;
@@ -217,9 +220,12 @@ src/
                          pending interactions, question form state, plugin
                          payload parsing, child-thread attention —, thread-runtime
                          — send/edit/stop/cancel-plan/clear-goal + the queued
-                         message CRUD with optimistic transactions;
-                         notifications — push registration policy — arrives in
-                         a later PR); see src/data/README.md
+                         message CRUD with optimistic transactions,
+                         notifications — push registration policy
+                         (decidePushSync / syncPushRegistration / controller),
+                         push store, SDK push-subscriptions wrapper,
+                         notification payload → profile resolution, badge count);
+                         see src/data/README.md
   lib/                   pure TypeScript, vitest-tested (no react-native imports)
     profiles/            ServerProfile model, SecureStore-backed store, URL
                          validation, /health + /system/config probe
@@ -374,8 +380,7 @@ typeahead, pills, "+" menu and attachment chip. `phase5-links.yaml` takes
 backend's startup JSON and drives the deep links while the app is warm:
 `bb://threads/<id>` and the web alias `bb://projects/<p>/threads/<t>` open the
 seeded "Completed thread", `bb://settings/servers` shows the added server, and
-`bb://settings` opens Settings (the per-server push row is asserted once the
-push-notifications PR lands).
+`bb://settings` shows the per-server push row.
 `phase6-panel.yaml` opens a thread named "P6 panel thread" (create it first:
 a managed-worktree thread through the API with a file written into its
 worktree), presents the workspace panel from the header button, checks the
@@ -672,9 +677,33 @@ add-root-cert`). Env: `BB_MOBILE_E2E_GATE_PORT` (42998),
 
 ## Push notifications and deep links (Phase 5)
 
-- Push notifications (Expo push registration, tap routing, foreground toast,
-  app-icon badge, Settings → Notifications rows, and the server side) arrive
-  in a later PR; `expo-notifications` is already part of the native build.
+- Registration: `PushNotificationsHost` (mounted once in `app/_layout.tsx`)
+  registers the phone's Expo push token with every server whose Settings →
+  Notifications toggle is on, through the SDK area
+  `sdk.notifications.pushSubscriptions` (`POST/GET/DELETE
+/api/v1/notifications/push-subscriptions`). It syncs on connect, on
+  AppState active, when the OS rolls the token (re-register), and when the
+  toggle flips; profiles removed from the app get their server row deleted
+  by the stored server URL. The token needs an EAS project id
+  (`expo.extra.eas.projectId`, written by `eas init`); a dev client built
+  with plain `expo run:ios` has none, so Settings shows "Push unavailable
+  until the app is built with EAS" and nothing is registered. The OS
+  permission is requested from the toggle or from the one-time prompt after
+  the first successful connection — never on launch. Pure policy + tests:
+  `src/data/notifications`.
+- Handling: a foreground arrival becomes a toast with "Open" (no system
+  banner); a tap on a background / cold-start notification opens
+  `/threads/<threadId>` on the profile that owns it (the payload `data`
+  carries `{kind, threadId, projectId}` only — the phone probes its saved
+  servers for the thread when it has more than one). The app-icon badge is
+  the count of unread finished root threads + threads blocked on an
+  interaction on the active server (client-derived from the sidebar
+  bootstrap), written on background and cleared while the thread list is on
+  screen.
+- Simulator check without APNs: `xcrun simctl push <udid> app.getbb.mobile
+payload.apns` with `{"aps":{"alert":{…}},"body":{"kind":"turn-finished",
+"threadId":"…","projectId":"…"}}` (expo-notifications reads remote `data`
+  from the `body` key) after granting the permission from the toggle.
 - Deep links: `bb://<mobile path>` (`bb://threads/<id>`, `bb://settings/servers`,
   `bb://projects/<p>/threads/<t>`, …) and universal / app links
   `https://<handle>.getbb.app/{threads,projects,settings}/*` (iOS
@@ -757,7 +786,7 @@ devserver.yaml` drives the same screens against the checkout's dev server
 ## Release (EAS)
 
 Nothing is published yet: no Expo/EAS account exists, so `app.json` has no
-`extra.eas.projectId` (push registration, in a later PR, needs it). The
+`extra.eas.projectId` and push registration is disabled in every build. The
 steps, once the account is created (Apple team `9QCU24SXK5`, bundle id
 `app.getbb.mobile`):
 
@@ -792,8 +821,11 @@ steps, once the account is created (Apple team `9QCU24SXK5`, bundle id
 - Preferences (theme mode `bb.theme`, sidebar `bb.sidebar.*`, thread-creation
   picks `bb.promptbox.*` / `bb.root-compose.*`, composer drafts
   `bb.promptbox.contents-*` in the web's `PromptDraftState` JSON, all with the
-  web app's key names): MMKV store `bb.preferences` (the push state of the
-  later push-notifications PR shares it).
+  web app's key names): MMKV store `bb.preferences`. Push state shares it:
+  `bb.push.enabled.<profileId>` (+ `bb.push.enabledProfiles` index),
+  `bb.push.registration.<profileId>` (+ `bb.push.registrations` index: the
+  token / server row the phone registered, so a removed profile can still be
+  unregistered), `bb.push.prompted`.
 - Each profile owns one SDK client, one realtime socket, and one TanStack
   QueryClient (`src/lib/sdk/client-registry.ts`, instantiated once by
   `src/app-shell/client-registry.ts`); the active profile's socket/session
diff --git a/apps/mobile/app/_layout.tsx b/apps/mobile/app/_layout.tsx
index 7ffd795c48..4bd6e6f573 100644
--- a/apps/mobile/app/_layout.tsx
+++ b/apps/mobile/app/_layout.tsx
@@ -15,6 +15,7 @@ import {
   ThreadOpenSignalHandler,
   useAppBoot,
 } from "@/app-shell";
+import { PushNotificationsHost } from "@/notifications";
 import { RootNavigator, RouteErrorBoundary } from "@/screens";
 import { ThemeProvider } from "@/theme";
 import { useAppFonts } from "@/theme/useAppFonts";
@@ -49,6 +50,7 @@ export default function RootLayout() {
                     <RootNavigator />
                     <ThreadOpenSignalHandler />
                     <ShareIntentHandler />
+                    <PushNotificationsHost />
                     <Toaster />
                   </SheetProvider>
                 </ProfilesProvider>
diff --git a/apps/mobile/e2e/flows/phase5-links.yaml b/apps/mobile/e2e/flows/phase5-links.yaml
index 372c9fe16e..537c69b8c6 100644
--- a/apps/mobile/e2e/flows/phase5-links.yaml
+++ b/apps/mobile/e2e/flows/phase5-links.yaml
@@ -4,8 +4,8 @@
 # `GET /api/v1/threads`) → the web alias `bb://projects/<p>/threads/<t>`
 # (pass `-e PROJECT_ID=<id>`) lands on the same thread → `bb://settings/servers`
 # opens the Servers screen with the added server → `bb://settings` opens
-# Settings. (The Notifications section and its per-server push row arrive
-# with the push-notifications PR; this flow asserts them once they exist.)
+# Settings, whose Notifications section shows the per-server push row
+# (disabled with the "built with EAS" note in a dev-client build).
 #
 # Run: pnpm --filter @bb/mobile e2e:ios   (Metro on 8082, backend on 41999)
 #      maestro test -e THREAD_ID=thr_xxx -e PROJECT_ID=proj_xxx e2e/flows/phase5-links.yaml
@@ -54,10 +54,16 @@ env:
     visible: ".*E2E backend.*"
     timeout: 10000
 - takeScreenshot: phase5-link-servers
-# Settings root by link.
+# Settings root by link: the Notifications section has one row per server.
 - openLink: "bb://settings"
 - extendedWaitUntil:
     visible:
       id: "settings-screen"
     timeout: 30000
-- takeScreenshot: phase5-link-settings
+- scrollUntilVisible:
+    element:
+      text: "Notifications"
+    direction: DOWN
+    timeout: 20000
+- assertVisible: "(?s).*Push unavailable until the app is built with EAS.*"
+- takeScreenshot: phase5-link-settings-push
diff --git a/apps/mobile/src/app-shell/e2e.ts b/apps/mobile/src/app-shell/e2e.ts
index b9542a2c4f..f0b217ff8b 100644
--- a/apps/mobile/src/app-shell/e2e.ts
+++ b/apps/mobile/src/app-shell/e2e.ts
@@ -5,6 +5,7 @@ import {
   type E2eEnv,
 } from "@/lib/e2e";
 import { getProfileStore } from "@/lib/native";
+import { getPushStore } from "@/notifications/push-storage";
 import { getAppProfileClientRegistry } from "./client-registry";
 import { getPreferencesStorage } from "./preferences-storage";
 
@@ -24,4 +25,6 @@ export async function resetLocalState(): Promise<void> {
     preferences: getPreferencesStorage(),
     disposeClients: () => getAppProfileClientRegistry().disposeAll(),
   });
+  // The push store caches its MMKV slice in memory; drop the stale copy.
+  getPushStore().reload();
 }
diff --git a/apps/mobile/src/data/README.md b/apps/mobile/src/data/README.md
index 0b1803a43e..2351d435a0 100644
--- a/apps/mobile/src/data/README.md
+++ b/apps/mobile/src/data/README.md
@@ -145,8 +145,24 @@ Conventions:
   builders and mutations over the XHR multipart poster, and the typeahead
   queries (plugin contributions + mention search via raw fetch, environment /
   thread-storage paths, project commands).
-- `notifications/` (push registration policy) arrives with the push-notifications
-  PR.
+- `notifications/` is the push layer's policy, pure and vitest-tested; the RN
+  glue (expo-notifications, MMKV, navigation) lives in `src/notifications`.
+  `push-registration.ts`: `decidePushSync` (toggle × EAS project id × OS
+  permission × existing record → skip / unregister / fetch-token),
+  `shouldReregister` (token / platform / server change, daily refresh),
+  `syncPushRegistration` (never throws; removes the stale row before a
+  re-register), `unregisterPushRegistration` (by profile id: the record keeps
+  the server URL, so a removed profile can still be cleaned up),
+  `enablePushForProfile` (asks the OS once), `describePushStatus`.
+  `push-registration-controller.ts` coalesces concurrent syncs per profile
+  and reconciles removed profiles / token rolls. `push-store.ts` is the
+  injected-storage store (MMKV `bb.preferences` in the app, a Map in tests).
+  `push-subscriptions-api.ts` wraps `sdk.notifications.pushSubscriptions`
+  keyed by server URL (not by profile client, which may be disposed).
+  `push-notification-target.ts` parses a payload's `data` and picks the
+  profile (server hint → single profile → probe active first).
+  `app-badge.ts` counts unread finished root threads + pending interactions
+  from the sidebar bootstrap.
 - `hosts/` (Phase 7 additions) backs Settings → Machines and → Updates on
   top of the list/directory queries: `useHostProviderCliStatus` /
   `useHostsProviderCliStatus` (`GET /hosts/:id/provider-clis/status`,
diff --git a/apps/mobile/src/data/notifications/app-badge.test.ts b/apps/mobile/src/data/notifications/app-badge.test.ts
new file mode 100644
index 0000000000..6333eb9609
--- /dev/null
+++ b/apps/mobile/src/data/notifications/app-badge.test.ts
@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import { badgeCountFromSidebar } from "./app-badge";
+
+function thread(over: Record<string, unknown>) {
+  return {
+    id: "t",
+    status: "idle",
+    parentThreadId: null,
+    archivedAt: null,
+    deletedAt: null,
+    lastReadAt: 10,
+    latestAttentionAt: 5,
+    hasPendingInteraction: false,
+    ...over,
+  } as never;
+}
+
+describe("badgeCountFromSidebar", () => {
+  it("counts unread finished root threads and pending interactions once each", () => {
+    const count = badgeCountFromSidebar({
+      projects: [
+        {
+          threads: [
+            thread({ id: "read" }),
+            thread({ id: "unread-idle", lastReadAt: 1 }),
+            thread({ id: "unread-error", status: "error", lastReadAt: null }),
+            thread({ id: "running-unread", status: "active", lastReadAt: 1 }),
+            thread({ id: "pending", hasPendingInteraction: true }),
+            thread({
+              id: "pending-and-unread",
+              hasPendingInteraction: true,
+              lastReadAt: 1,
+            }),
+            thread({ id: "child", parentThreadId: "x", lastReadAt: 1 }),
+            thread({ id: "archived", archivedAt: 1, lastReadAt: 1 }),
+            thread({ id: "deleted", deletedAt: 1, lastReadAt: 1 }),
+          ],
+        } as never,
+      ],
+      personalProject: {
+        threads: [thread({ id: "personal-unread", lastReadAt: 1 })],
+      } as never,
+    });
+    expect(count).toBe(5);
+  });
+});
diff --git a/apps/mobile/src/data/notifications/app-badge.ts b/apps/mobile/src/data/notifications/app-badge.ts
new file mode 100644
index 0000000000..66d4c5844e
--- /dev/null
+++ b/apps/mobile/src/data/notifications/app-badge.ts
@@ -0,0 +1,25 @@
+import type { SidebarBootstrapResponse } from "@bb/server-contract";
+import { isUnreadDoneThread } from "@bb/client-core";
+
+/**
+ * App-icon badge = threads that want the user's attention on the active
+ * server: root threads that finished (idle / error) since they were last
+ * read, plus threads blocked on a pending interaction. Derived client-side
+ * from the sidebar bootstrap (`GET /system/attention` is only a boolean).
+ */
+export function badgeCountFromSidebar(
+  bootstrap: Pick<SidebarBootstrapResponse, "projects" | "personalProject">,
+): number {
+  let count = 0;
+  const projects = [...bootstrap.projects, bootstrap.personalProject];
+  for (const project of projects) {
+    for (const thread of project.threads) {
+      if (thread.archivedAt !== null || thread.deletedAt !== null) continue;
+      if (thread.parentThreadId !== null) continue;
+      if (thread.hasPendingInteraction || isUnreadDoneThread(thread)) {
+        count += 1;
+      }
+    }
+  }
+  return count;
+}
diff --git a/apps/mobile/src/data/notifications/index.ts b/apps/mobile/src/data/notifications/index.ts
new file mode 100644
index 0000000000..4d9b6464ea
--- /dev/null
+++ b/apps/mobile/src/data/notifications/index.ts
@@ -0,0 +1,56 @@
+// Push notifications: the server contract wrapper, the local push store, the
+// registration policy, notification → thread resolution, and the badge count.
+// RN glue (expo-notifications, MMKV, navigation) lives in src/notifications.
+export { badgeCountFromSidebar } from "./app-badge";
+export type {
+  PushPlatform,
+  PushSubscriptionInput,
+  PushSubscriptionRecord,
+  PushSubscriptionRef,
+} from "./push-contract";
+export {
+  parsePushNotificationData,
+  resolvePushTargetProfile,
+  type PushNotificationTarget,
+  type ResolvePushTargetProfileDeps,
+} from "./push-notification-target";
+export {
+  PUSH_REGISTRATION_REFRESH_MS,
+  decidePushSync,
+  describePushStatus,
+  enablePushForProfile,
+  shouldReregister,
+  syncPushRegistration,
+  unregisterPushRegistration,
+  type PushNotificationsModule,
+  type PushPermissionState,
+  type PushSkipReason,
+  type PushSyncDecision,
+  type PushSyncDeps,
+  type PushSyncOutcome,
+  type PushSyncProfile,
+} from "./push-registration";
+export {
+  PUSH_ENABLED_INDEX_KEY,
+  PUSH_ENABLED_KEY_PREFIX,
+  PUSH_PROMPTED_KEY,
+  PUSH_REGISTRATION_INDEX_KEY,
+  PUSH_REGISTRATION_KEY_PREFIX,
+  createMemoryPushStorage,
+  createPushStore,
+  pushRegistrationRecordSchema,
+  type PushRegistrationRecord,
+  type PushStorage,
+  type PushStore,
+  type PushStoreSnapshot,
+} from "./push-store";
+export {
+  createPushSubscriptionsApi,
+  type PushSubscriptionsApi,
+} from "./push-subscriptions-api";
+export {
+  createPushRegistrationController,
+  type PushProfileSyncState,
+  type PushRegistrationController,
+  type PushRegistrationControllerSnapshot,
+} from "./push-registration-controller";
diff --git a/apps/mobile/src/data/notifications/push-contract.ts b/apps/mobile/src/data/notifications/push-contract.ts
new file mode 100644
index 0000000000..ae449d8120
--- /dev/null
+++ b/apps/mobile/src/data/notifications/push-contract.ts
@@ -0,0 +1,22 @@
+import type {
+  PushSubscription,
+  PushSubscriptionPlatform,
+  RegisterPushSubscriptionRequest,
+} from "@bb/server-contract";
+
+/**
+ * The server's push-subscription contract as the phone uses it
+ * (`/api/v1/notifications/push-subscriptions`, SDK area
+ * `sdk.notifications.pushSubscriptions`). The server owns the table and the
+ * Expo Push sender; the phone registers / removes its Expo token per server
+ * profile and tags a tap with the payload's `threadId`.
+ */
+export type PushPlatform = PushSubscriptionPlatform;
+export type PushSubscriptionInput = RegisterPushSubscriptionRequest;
+export type PushSubscriptionRecord = PushSubscription;
+
+/** Which server row the phone holds for a profile (enough to remove it later). */
+export interface PushSubscriptionRef {
+  subscriptionId: string | null;
+  expoPushToken: string;
+}
diff --git a/apps/mobile/src/data/notifications/push-notification-target.test.ts b/apps/mobile/src/data/notifications/push-notification-target.test.ts
new file mode 100644
index 0000000000..a7ca8f8ac9
--- /dev/null
+++ b/apps/mobile/src/data/notifications/push-notification-target.test.ts
@@ -0,0 +1,88 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  parsePushNotificationData,
+  resolvePushTargetProfile,
+} from "./push-notification-target";
+
+const sawyer = { id: "p1", serverUrl: "https://sawyer.getbb.app" };
+const lan = { id: "p2", serverUrl: "http://192.168.1.20:3000" };
+
+describe("parsePushNotificationData", () => {
+  it("reads the thread id and optional project / server hints", () => {
+    expect(
+      parsePushNotificationData({ threadId: "thr_1", projectId: "prj_1" }),
+    ).toEqual({ threadId: "thr_1", projectId: "prj_1", serverUrl: null });
+    expect(
+      parsePushNotificationData({
+        threadId: "thr_1",
+        url: "https://sawyer.getbb.app/threads/thr_1",
+        extra: 1,
+      }),
+    ).toEqual({
+      threadId: "thr_1",
+      projectId: null,
+      serverUrl: "https://sawyer.getbb.app",
+    });
+  });
+
+  it("rejects payloads without a thread id", () => {
+    expect(parsePushNotificationData({ projectId: "p" })).toBeNull();
+    expect(parsePushNotificationData("nope")).toBeNull();
+    expect(parsePushNotificationData(undefined)).toBeNull();
+  });
+});
+
+describe("resolvePushTargetProfile", () => {
+  const target = { threadId: "thr_1", projectId: null, serverUrl: null };
+
+  it("uses the server hint when it names a saved profile", async () => {
+    const hasThread = vi.fn(async () => false);
+    expect(
+      await resolvePushTargetProfile(
+        { ...target, serverUrl: "http://192.168.1.20:3000" },
+        { profiles: [sawyer, lan], activeProfileId: "p1", hasThread },
+      ),
+    ).toBe(lan);
+    expect(hasThread).not.toHaveBeenCalled();
+  });
+
+  it("returns the only profile without probing", async () => {
+    const hasThread = vi.fn(async () => false);
+    expect(
+      await resolvePushTargetProfile(target, {
+        profiles: [sawyer],
+        activeProfileId: null,
+        hasThread,
+      }),
+    ).toBe(sawyer);
+    expect(hasThread).not.toHaveBeenCalled();
+  });
+
+  it("probes the active profile first, then the others, tolerating failures", async () => {
+    const hasThread = vi.fn(async (serverUrl: string) => {
+      if (serverUrl === lan.serverUrl) throw new Error("offline");
+      return serverUrl === sawyer.serverUrl;
+    });
+    expect(
+      await resolvePushTargetProfile(target, {
+        profiles: [sawyer, lan],
+        activeProfileId: "p2",
+        hasThread,
+      }),
+    ).toBe(sawyer);
+    expect(hasThread.mock.calls.map(([url]) => url)).toEqual([
+      lan.serverUrl,
+      sawyer.serverUrl,
+    ]);
+  });
+
+  it("gives up when no server has the thread", async () => {
+    expect(
+      await resolvePushTargetProfile(target, {
+        profiles: [sawyer, lan],
+        activeProfileId: "p1",
+        hasThread: async () => false,
+      }),
+    ).toBeNull();
+  });
+});
diff --git a/apps/mobile/src/data/notifications/push-notification-target.ts b/apps/mobile/src/data/notifications/push-notification-target.ts
new file mode 100644
index 0000000000..2f811c276b
--- /dev/null
+++ b/apps/mobile/src/data/notifications/push-notification-target.ts
@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { matchProfileForWebLink, type LinkProfileLike } from "@/lib/links";
+
+/**
+ * What a bb push notification points at. The server's Expo Push payload
+ * carries `data: { threadId, projectId? }` (and may add `serverUrl`); the
+ * phone resolves which saved profile the thread lives on — one Expo token
+ * serves every profile on the device, so the payload alone cannot name it.
+ */
+export interface PushNotificationTarget {
+  threadId: string;
+  projectId: string | null;
+  /** Optional server hint (`serverUrl` / `url` in the payload). */
+  serverUrl: string | null;
+}
+
+const pushDataSchema = z.object({
+  threadId: z.string().min(1),
+  projectId: z.string().min(1).nullish(),
+  serverUrl: z.string().min(1).nullish(),
+  url: z.string().min(1).nullish(),
+});
+
+function originOf(value: string): string | null {
+  try {
+    return new URL(value).origin;
+  } catch {
+    return null;
+  }
+}
+
+/** Lenient read of the notification payload; null when it is not a bb thread. */
+export function parsePushNotificationData(
+  data: unknown,
+): PushNotificationTarget | null {
+  const parsed = pushDataSchema.safeParse(data);
+  if (!parsed.success) return null;
+  const hint = parsed.data.serverUrl ?? parsed.data.url ?? null;
+  return {
+    threadId: parsed.data.threadId,
+    projectId: parsed.data.projectId ?? null,
+    serverUrl: hint ? originOf(hint) : null,
+  };
+}
+
+export interface ResolvePushTargetProfileDeps {
+  profiles: readonly LinkProfileLike[];
+  activeProfileId: string | null;
+  /** True when `threadId` exists on the server (e.g. `GET /threads/:id` is 200). */
+  hasThread(serverUrl: string, threadId: string): Promise<boolean>;
+}
+
+/**
+ * Pick the profile a notification belongs to: the server hint when it names
+ * a saved profile, the only profile when there is one, otherwise the active
+ * profile first and then the others, probing each for the thread.
+ */
+export async function resolvePushTargetProfile(
+  target: PushNotificationTarget,
+  deps: ResolvePushTargetProfileDeps,
+): Promise<LinkProfileLike | null> {
+  const { profiles } = deps;
+  if (profiles.length === 0) return null;
+  if (target.serverUrl) {
+    const match = matchProfileForWebLink(profiles, target.serverUrl, "/");
+    if (match) return match.profile;
+  }
+  if (profiles.length === 1) return profiles[0] ?? null;
+  const ordered = [
+    ...profiles.filter((profile) => profile.id === deps.activeProfileId),
+    ...profiles.filter((profile) => profile.id !== deps.activeProfileId),
+  ];
+  for (const profile of ordered) {
+    try {
+      if (await deps.hasThread(profile.serverUrl, target.threadId)) {
+        return profile;
+      }
+    } catch {
+      // Unreachable server: try the next one.
+    }
+  }
+  return null;
+}
diff --git a/apps/mobile/src/data/notifications/push-registration-controller.test.ts b/apps/mobile/src/data/notifications/push-registration-controller.test.ts
new file mode 100644
index 0000000000..6eb8a0bcc6
--- /dev/null
+++ b/apps/mobile/src/data/notifications/push-registration-controller.test.ts
@@ -0,0 +1,100 @@
+import { describe, expect, it, vi } from "vitest";
+import { createPushRegistrationController } from "./push-registration-controller";
+import type { PushNotificationsModule } from "./push-registration";
+import { createMemoryPushStorage, createPushStore } from "./push-store";
+import type { PushSubscriptionsApi } from "./push-subscriptions-api";
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((r) => {
+    resolve = r;
+  });
+  return { promise, resolve };
+}
+
+function setup() {
+  const store = createPushStore(createMemoryPushStorage());
+  const tokenGate = deferred<string>();
+  const notifications: PushNotificationsModule = {
+    projectId: "eas",
+    platform: "ios",
+    getPermission: async () => "granted",
+    requestPermission: async () => "granted",
+    getExpoPushToken: vi.fn(() => tokenGate.promise),
+    addTokenListener: () => () => undefined,
+    setBadgeCount: async () => undefined,
+  };
+  const api = {
+    register: vi.fn<PushSubscriptionsApi["register"]>(async () => ({
+      subscriptionId: "sub_1",
+    })),
+    unregister: vi.fn<PushSubscriptionsApi["unregister"]>(
+      async () => undefined,
+    ),
+    list: vi.fn<PushSubscriptionsApi["list"]>(async () => []),
+  };
+  const controller = createPushRegistrationController({
+    notifications,
+    api,
+    store,
+    deviceLabel: "phone",
+    now: () => 1,
+  });
+  return { store, notifications, api, controller, tokenGate };
+}
+
+const profile = { id: "p1", serverUrl: "https://a" };
+
+describe("createPushRegistrationController", () => {
+  it("coalesces concurrent syncs for one profile into one in-flight run plus a trailing run", async () => {
+    const { controller, store, notifications, tokenGate, api } = setup();
+    store.setEnabled(profile.id, true);
+    const first = controller.sync(profile);
+    const second = controller.sync(profile);
+    expect(controller.getSnapshot().byProfileId.p1?.syncing).toBe(true);
+    tokenGate.resolve("tok");
+    // Both callers observe the settled state after the trailing run.
+    expect(await first).toEqual({ action: "skipped", reason: "up-to-date" });
+    expect(await second).toEqual({ action: "skipped", reason: "up-to-date" });
+    expect(notifications.getExpoPushToken).toHaveBeenCalledTimes(2);
+    expect(api.register).toHaveBeenCalledTimes(1);
+    expect(controller.getSnapshot().byProfileId.p1).toMatchObject({
+      syncing: false,
+      lastOutcome: { action: "skipped", reason: "up-to-date" },
+    });
+  });
+
+  it("unregisters and forgets profiles removed from the app", async () => {
+    const { controller, store, api, tokenGate } = setup();
+    tokenGate.resolve("tok");
+    store.setEnabled("p1", true);
+    await controller.sync(profile);
+    store.setEnabled("p2", true);
+    await controller.sync({ id: "p2", serverUrl: "https://b" });
+    await controller.reconcileRemovedProfiles(["p2"]);
+    expect(api.unregister).toHaveBeenCalledWith(
+      "https://a",
+      expect.objectContaining({
+        subscriptionId: "sub_1",
+        expoPushToken: "tok",
+      }),
+    );
+    expect(store.registeredProfileIds()).toEqual(["p2"]);
+    expect(store.isEnabled("p1")).toBe(false);
+  });
+
+  it("turning the toggle off removes the server row; on re-registers", async () => {
+    const { controller, store, api, tokenGate } = setup();
+    tokenGate.resolve("tok");
+    expect(await controller.setEnabled(profile, true)).toEqual({
+      action: "registered",
+      expoPushToken: "tok",
+    });
+    expect(store.hasPrompted()).toBe(true);
+    expect(await controller.setEnabled(profile, false)).toEqual({
+      action: "unregistered",
+    });
+    expect(api.unregister).toHaveBeenCalledTimes(1);
+    expect(store.isEnabled(profile.id)).toBe(false);
+  });
+});
diff --git a/apps/mobile/src/data/notifications/push-registration-controller.ts b/apps/mobile/src/data/notifications/push-registration-controller.ts
new file mode 100644
index 0000000000..7017f692cc
--- /dev/null
+++ b/apps/mobile/src/data/notifications/push-registration-controller.ts
@@ -0,0 +1,158 @@
+import {
+  enablePushForProfile,
+  syncPushRegistration,
+  unregisterPushRegistration,
+  type PushPermissionState,
+  type PushSyncDeps,
+  type PushSyncOutcome,
+  type PushSyncProfile,
+} from "./push-registration";
+
+/**
+ * Per-profile sync state the Settings UI renders. `syncing` coalesces
+ * concurrent triggers (profile activation, AppState active, a token roll,
+ * the toggle) into one in-flight sync per profile with one trailing re-run.
+ */
+export interface PushProfileSyncState {
+  syncing: boolean;
+  lastOutcome: PushSyncOutcome | null;
+  permission: PushPermissionState | null;
+}
+
+export interface PushRegistrationControllerSnapshot {
+  byProfileId: Readonly<Record<string, PushProfileSyncState>>;
+}
+
+export interface PushRegistrationController {
+  getSnapshot(): PushRegistrationControllerSnapshot;
+  subscribe(listener: () => void): () => void;
+  /** Reconcile one profile now (coalesced). Resolves with the outcome. */
+  sync(profile: PushSyncProfile): Promise<PushSyncOutcome>;
+  /** Toggle: asks for permission when needed, then syncs. */
+  setEnabled(
+    profile: PushSyncProfile,
+    enabled: boolean,
+  ): Promise<PushSyncOutcome>;
+  /**
+   * Profiles that disappeared from the app but still have a registration:
+   * remove their server rows (by the stored server URL) and forget them.
+   */
+  reconcileRemovedProfiles(currentProfileIds: readonly string[]): Promise<void>;
+  /** The OS rolled the device token: every registered profile re-syncs. */
+  handleTokenRolled(profiles: readonly PushSyncProfile[]): Promise<void>;
+  /** Re-read the OS permission (AppState active: the user may have changed it). */
+  refreshPermission(): Promise<PushPermissionState>;
+}
+
+const IDLE: PushProfileSyncState = {
+  syncing: false,
+  lastOutcome: null,
+  permission: null,
+};
+
+export function createPushRegistrationController(
+  deps: PushSyncDeps,
+): PushRegistrationController {
+  const listeners = new Set<() => void>();
+  let snapshot: PushRegistrationControllerSnapshot = { byProfileId: {} };
+  const inFlight = new Map<
+    string,
+    { promise: Promise<PushSyncOutcome>; rerun: PushSyncProfile | null }
+  >();
+  let permission: PushPermissionState | null = null;
+
+  function patch(profileId: string, next: Partial<PushProfileSyncState>): void {
+    const current = snapshot.byProfileId[profileId] ?? IDLE;
+    snapshot = {
+      byProfileId: {
+        ...snapshot.byProfileId,
+        [profileId]: { ...current, ...next },
+      },
+    };
+    for (const listener of listeners) listener();
+  }
+
+  function broadcastPermission(next: PushPermissionState): void {
+    permission = next;
+    const byProfileId: Record<string, PushProfileSyncState> = {};
+    for (const [id, state] of Object.entries(snapshot.byProfileId)) {
+      byProfileId[id] = { ...state, permission: next };
+    }
+    snapshot = { byProfileId };
+    for (const listener of listeners) listener();
+  }
+
+  async function runSync(profile: PushSyncProfile): Promise<PushSyncOutcome> {
+    patch(profile.id, { syncing: true, permission });
+    const outcome = await syncPushRegistration(deps, profile);
+    patch(profile.id, { syncing: false, lastOutcome: outcome, permission });
+    return outcome;
+  }
+
+  function sync(profile: PushSyncProfile): Promise<PushSyncOutcome> {
+    const existing = inFlight.get(profile.id);
+    if (existing) {
+      // Remember the latest profile record for one trailing run; every
+      // caller resolves with the outcome of the last run.
+      existing.rerun = profile;
+      return existing.promise;
+    }
+    const entry: {
+      promise: Promise<PushSyncOutcome>;
+      rerun: PushSyncProfile | null;
+    } = {
+      promise: Promise.resolve({ action: "skipped", reason: "disabled" }),
+      rerun: null,
+    };
+    entry.promise = (async () => {
+      let outcome = await runSync(profile);
+      while (entry.rerun) {
+        const next = entry.rerun;
+        entry.rerun = null;
+        outcome = await runSync(next);
+      }
+      inFlight.delete(profile.id);
+      return outcome;
+    })();
+    inFlight.set(profile.id, entry);
+    return entry.promise;
+  }
+
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    sync,
+    async setEnabled(profile, enabled) {
+      if (enabled) {
+        const next = await enablePushForProfile(deps, profile.id);
+        broadcastPermission(next);
+      } else {
+        deps.store.setEnabled(profile.id, false);
+      }
+      return sync(profile);
+    },
+    async reconcileRemovedProfiles(currentProfileIds) {
+      const current = new Set(currentProfileIds);
+      for (const profileId of deps.store.registeredProfileIds()) {
+        if (current.has(profileId)) continue;
+        const outcome = await unregisterPushRegistration(deps, profileId);
+        if (outcome.action !== "failed") deps.store.forgetProfile(profileId);
+      }
+    },
+    async handleTokenRolled(profiles) {
+      for (const profile of profiles) {
+        if (deps.store.getRegistration(profile.id)) await sync(profile);
+      }
+    },
+    async refreshPermission() {
+      const next = await deps.notifications.getPermission();
+      if (next !== permission) broadcastPermission(next);
+      return next;
+    },
+  };
+}
diff --git a/apps/mobile/src/data/notifications/push-registration.test.ts b/apps/mobile/src/data/notifications/push-registration.test.ts
new file mode 100644
index 0000000000..ae03064008
--- /dev/null
+++ b/apps/mobile/src/data/notifications/push-registration.test.ts
@@ -0,0 +1,374 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  decidePushSync,
+  enablePushForProfile,
+  shouldReregister,
+  syncPushRegistration,
+  unregisterPushRegistration,
+  type PushNotificationsModule,
+  type PushPermissionState,
+} from "./push-registration";
+import { createMemoryPushStorage, createPushStore } from "./push-store";
+import type { PushSubscriptionsApi } from "./push-subscriptions-api";
+
+interface FakeModuleOptions {
+  projectId?: string | null;
+  permission?: PushPermissionState;
+  token?: string | (() => Promise<string>);
+}
+
+function fakeModule(options: FakeModuleOptions = {}) {
+  let permission: PushPermissionState = options.permission ?? "granted";
+  const listeners = new Set<() => void>();
+  const requestPermissionMock = vi.fn(
+    async (): Promise<PushPermissionState> => {
+      permission = "granted";
+      return permission;
+    },
+  );
+  const module: PushNotificationsModule & {
+    requestPermissionMock: typeof requestPermissionMock;
+    rollToken(): void;
+  } = {
+    projectId:
+      options.projectId === undefined ? "eas-project" : options.projectId,
+    platform: "ios",
+    getPermission: async () => permission,
+    requestPermissionMock,
+    requestPermission: () => requestPermissionMock(),
+    getExpoPushToken: vi.fn(async () => {
+      const token = options.token ?? "ExponentPushToken[abc]";
+      return typeof token === "function" ? token() : token;
+    }),
+    addTokenListener: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    setBadgeCount: async () => undefined,
+    rollToken: () => {
+      for (const listener of listeners) listener();
+    },
+  };
+  return module;
+}
+
+function fakeApi() {
+  const api = {
+    register: vi.fn<PushSubscriptionsApi["register"]>(async () => ({
+      subscriptionId: "sub_1",
+    })),
+    unregister: vi.fn<PushSubscriptionsApi["unregister"]>(
+      async () => undefined,
+    ),
+    list: vi.fn<PushSubscriptionsApi["list"]>(async () => []),
+  };
+  return api;
+}
+
+const profile = { id: "p1", serverUrl: "https://sawyer.getbb.app" };
+
+function setup(moduleOptions?: FakeModuleOptions) {
+  const store = createPushStore(createMemoryPushStorage());
+  const notifications = fakeModule(moduleOptions);
+  const api = fakeApi();
+  let clock = 1_000;
+  const deps = {
+    notifications,
+    api,
+    store,
+    deviceLabel: "Sawyer's iPhone",
+    now: () => clock,
+    refreshAfterMs: 1_000_000,
+  };
+  return {
+    store,
+    notifications,
+    api,
+    deps,
+    advance: (ms: number) => {
+      clock += ms;
+    },
+  };
+}
+
+describe("decidePushSync", () => {
+  const existing = {
+    subscriptionId: "sub_0",
+    expoPushToken: "t",
+    platform: "ios" as const,
+    serverUrl: profile.serverUrl,
+    registeredAt: 0,
+  };
+
+  it("never touches the server while the toggle is off and nothing is registered", () => {
+    expect(
+      decidePushSync({
+        enabled: false,
+        projectId: "x",
+        permission: "granted",
+        existing: null,
+      }),
+    ).toEqual({ action: "skip", reason: "disabled" });
+  });
+
+  it("unregisters when the toggle goes off or the permission is revoked after registering", () => {
+    expect(
+      decidePushSync({
+        enabled: false,
+        projectId: "x",
+        permission: "granted",
+        existing,
+      }),
+    ).toEqual({ action: "unregister" });
+    expect(
+      decidePushSync({
+        enabled: true,
+        projectId: "x",
+        permission: "denied",
+        existing,
+      }),
+    ).toEqual({ action: "unregister" });
+  });
+
+  it("skips gracefully without an EAS project id, even when enabled and granted", () => {
+    expect(
+      decidePushSync({
+        enabled: true,
+        projectId: null,
+        permission: "granted",
+        existing: null,
+      }),
+    ).toEqual({ action: "skip", reason: "no-project-id" });
+  });
+
+  it("does not request permission on its own", () => {
+    expect(
+      decidePushSync({
+        enabled: true,
+        projectId: "x",
+        permission: "undetermined",
+        existing: null,
+      }),
+    ).toEqual({ action: "skip", reason: "permission-undetermined" });
+    expect(
+      decidePushSync({
+        enabled: true,
+        projectId: "x",
+        permission: "denied",
+        existing: null,
+      }),
+    ).toEqual({ action: "skip", reason: "permission-denied" });
+  });
+
+  it("fetches a token once enabled, granted, and configured", () => {
+    expect(
+      decidePushSync({
+        enabled: true,
+        projectId: "x",
+        permission: "granted",
+        existing: null,
+      }),
+    ).toEqual({ action: "fetch-token" });
+  });
+});
+
+describe("shouldReregister", () => {
+  const base = {
+    expoPushToken: "t1",
+    platform: "ios" as const,
+    serverUrl: "https://a",
+    now: 10_000,
+    refreshAfterMs: 5_000,
+  };
+  const existing = {
+    subscriptionId: "sub_0",
+    expoPushToken: "t1",
+    platform: "ios" as const,
+    serverUrl: "https://a",
+    registeredAt: 8_000,
+  };
+
+  it("re-registers on a new token, platform, or server, and when the record is stale", () => {
+    expect(shouldReregister({ ...base, existing: null })).toBe(true);
+    expect(shouldReregister({ ...base, existing })).toBe(false);
+    expect(shouldReregister({ ...base, existing, expoPushToken: "t2" })).toBe(
+      true,
+    );
+    expect(shouldReregister({ ...base, existing, platform: "android" })).toBe(
+      true,
+    );
+    expect(
+      shouldReregister({ ...base, existing, serverUrl: "https://b" }),
+    ).toBe(true);
+    expect(shouldReregister({ ...base, existing, now: 13_000 })).toBe(true);
+  });
+});
+
+describe("syncPushRegistration", () => {
+  it("registers once enabled and granted, then reports up-to-date until the token changes", async () => {
+    const { store, deps, api, notifications } = setup();
+    store.setEnabled(profile.id, true);
+
+    expect(await syncPushRegistration(deps, profile)).toEqual({
+      action: "registered",
+      expoPushToken: "ExponentPushToken[abc]",
+    });
+    expect(api.register).toHaveBeenCalledWith(profile.serverUrl, {
+      expoPushToken: "ExponentPushToken[abc]",
+      platform: "ios",
+      deviceLabel: "Sawyer's iPhone",
+    });
+    expect(store.getRegistration(profile.id)).toMatchObject({
+      subscriptionId: "sub_1",
+      expoPushToken: "ExponentPushToken[abc]",
+      serverUrl: profile.serverUrl,
+      registeredAt: 1_000,
+    });
+
+    expect(await syncPushRegistration(deps, profile)).toEqual({
+      action: "skipped",
+      reason: "up-to-date",
+    });
+    expect(api.register).toHaveBeenCalledTimes(1);
+
+    // The OS rolled the token: the old one is removed, the new one registered.
+    vi.mocked(notifications.getExpoPushToken).mockResolvedValueOnce(
+      "ExponentPushToken[new]",
+    );
+    expect(await syncPushRegistration(deps, profile)).toEqual({
+      action: "registered",
+      expoPushToken: "ExponentPushToken[new]",
+    });
+    expect(api.unregister).toHaveBeenCalledWith(
+      profile.serverUrl,
+      expect.objectContaining({
+        subscriptionId: "sub_1",
+        expoPushToken: "ExponentPushToken[abc]",
+      }),
+    );
+    expect(api.register).toHaveBeenCalledTimes(2);
+  });
+
+  it("refreshes a registration older than the refresh window", async () => {
+    const { store, deps, api, advance } = setup();
+    store.setEnabled(profile.id, true);
+    await syncPushRegistration(deps, profile);
+    advance(1_000_000);
+    expect(await syncPushRegistration(deps, profile)).toMatchObject({
+      action: "registered",
+    });
+    expect(api.register).toHaveBeenCalledTimes(2);
+    // Same token: nothing to unregister.
+    expect(api.unregister).not.toHaveBeenCalled();
+  });
+
+  it("unregisters when the toggle is turned off after a registration", async () => {
+    const { store, deps, api } = setup();
+    store.setEnabled(profile.id, true);
+    await syncPushRegistration(deps, profile);
+    store.setEnabled(profile.id, false);
+    expect(await syncPushRegistration(deps, profile)).toEqual({
+      action: "unregistered",
+    });
+    expect(api.unregister).toHaveBeenCalledWith(
+      profile.serverUrl,
+      expect.objectContaining({ subscriptionId: "sub_1" }),
+    );
+    expect(store.getRegistration(profile.id)).toBeNull();
+    // And stays quiet afterwards.
+    expect(await syncPushRegistration(deps, profile)).toEqual({
+      action: "skipped",
+      reason: "disabled",
+    });
+  });
+
+  it("skips without an EAS project id and never asks the module for a token", async () => {
+    const { store, deps, notifications, api } = setup({ projectId: null });
+    store.setEnabled(profile.id, true);
+    expect(await syncPushRegistration(deps, profile)).toEqual({
+      action: "skipped",
+      reason: "no-project-id",
+    });
+    expect(notifications.getExpoPushToken).not.toHaveBeenCalled();
+    expect(api.register).not.toHaveBeenCalled();
+  });
+
+  it("reports token and registration failures without writing a record", async () => {
+    const { store, deps, api } = setup({
+      token: async () => {
+        throw new Error("offline");
+      },
+    });
+    store.setEnabled(profile.id, true);
+    expect(await syncPushRegistration(deps, profile)).toEqual({
+      action: "failed",
+      step: "token",
+      error: "offline",
+    });
+    expect(store.getRegistration(profile.id)).toBeNull();
+
+    const ok = setup();
+    ok.store.setEnabled(profile.id, true);
+    ok.api.register.mockRejectedValueOnce(new Error("HTTP 500: boom"));
+    expect(await syncPushRegistration(ok.deps, profile)).toEqual({
+      action: "failed",
+      step: "register",
+      error: "HTTP 500: boom",
+    });
+    expect(ok.store.getRegistration(profile.id)).toBeNull();
+    expect(api.register).not.toHaveBeenCalled();
+  });
+
+  it("unregisters a removed profile from the server it was registered with", async () => {
+    const { store, deps, api } = setup();
+    store.setEnabled(profile.id, true);
+    await syncPushRegistration(deps, profile);
+    // The profile is gone from the app; only the id and the record remain.
+    expect(await unregisterPushRegistration(deps, profile.id)).toEqual({
+      action: "unregistered",
+    });
+    expect(api.unregister).toHaveBeenCalledWith(
+      profile.serverUrl,
+      expect.objectContaining({ subscriptionId: "sub_1" }),
+    );
+    expect(store.registeredProfileIds()).toEqual([]);
+  });
+
+  it("keeps the record when unregistering fails so a later sync retries", async () => {
+    const { store, deps, api } = setup();
+    store.setEnabled(profile.id, true);
+    await syncPushRegistration(deps, profile);
+    api.unregister.mockRejectedValueOnce(new Error("offline"));
+    expect(await unregisterPushRegistration(deps, profile.id)).toEqual({
+      action: "failed",
+      step: "unregister",
+      error: "offline",
+    });
+    expect(store.getRegistration(profile.id)).not.toBeNull();
+  });
+});
+
+describe("enablePushForProfile", () => {
+  it("requests the OS permission once and records the toggle and the prompt", async () => {
+    const { store, deps, notifications } = setup({
+      permission: "undetermined",
+    });
+    expect(await enablePushForProfile(deps, profile.id)).toBe("granted");
+    expect(notifications.requestPermissionMock).toHaveBeenCalledTimes(1);
+    expect(store.isEnabled(profile.id)).toBe(true);
+    expect(store.hasPrompted()).toBe(true);
+    // Already granted: no second prompt.
+    await enablePushForProfile(deps, "p2");
+    expect(notifications.requestPermissionMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("leaves the toggle off when the user denies", async () => {
+    const { store, deps, notifications } = setup({
+      permission: "undetermined",
+    });
+    notifications.requestPermissionMock.mockResolvedValueOnce("denied");
+    expect(await enablePushForProfile(deps, profile.id)).toBe("denied");
+    expect(store.isEnabled(profile.id)).toBe(false);
+    expect(store.hasPrompted()).toBe(true);
+  });
+});
diff --git a/apps/mobile/src/data/notifications/push-registration.ts b/apps/mobile/src/data/notifications/push-registration.ts
new file mode 100644
index 0000000000..f4fe0460f8
--- /dev/null
+++ b/apps/mobile/src/data/notifications/push-registration.ts
@@ -0,0 +1,266 @@
+import type { PushPlatform } from "./push-contract";
+import type { PushRegistrationRecord, PushStore } from "./push-store";
+import type { PushSubscriptionsApi } from "./push-subscriptions-api";
+
+/**
+ * Per-profile Expo push registration policy. Pure apart from the injected
+ * notifications module (expo-notifications in the app, a fake in tests) and
+ * the subscriptions API.
+ *
+ * A phone registers its Expo push token with every server profile whose
+ * "Push notifications" toggle is on, once the OS permission is granted and
+ * the app knows its EAS project id (the token cannot be minted without one;
+ * a dev-client built outside EAS reports "push unavailable"). The stored
+ * registration record lets the sync re-register on a token change, refresh
+ * `lastSeenAt` on the server periodically, and unregister a profile the user
+ * removed from the app.
+ */
+export type PushPermissionState = "granted" | "denied" | "undetermined";
+
+export interface PushNotificationsModule {
+  /** EAS project id from the app config; null before the app is built with EAS. */
+  readonly projectId: string | null;
+  readonly platform: PushPlatform;
+  getPermission(): Promise<PushPermissionState>;
+  /** Shows the OS prompt (once); afterwards returns the settled state. */
+  requestPermission(): Promise<PushPermissionState>;
+  getExpoPushToken(projectId: string): Promise<string>;
+  /** Fires when the OS rolls the device token; the Expo token must be re-read. */
+  addTokenListener(listener: () => void): () => void;
+  setBadgeCount(count: number): Promise<void>;
+}
+
+export type PushSkipReason =
+  | "disabled"
+  | "no-project-id"
+  | "permission-undetermined"
+  | "permission-denied"
+  | "up-to-date";
+
+export type PushSyncOutcome =
+  | { action: "registered"; expoPushToken: string }
+  | { action: "unregistered" }
+  | { action: "skipped"; reason: PushSkipReason }
+  | {
+      action: "failed";
+      step: "token" | "register" | "unregister";
+      error: string;
+    };
+
+export interface PushSyncDeps {
+  notifications: PushNotificationsModule;
+  api: PushSubscriptionsApi;
+  store: PushStore;
+  deviceLabel: string;
+  now?: () => number;
+  /** Re-POST an unchanged registration after this long (keeps `lastSeenAt` fresh). */
+  refreshAfterMs?: number;
+}
+
+export interface PushSyncProfile {
+  id: string;
+  serverUrl: string;
+}
+
+/** One day: a live phone re-asserts its subscription daily. */
+export const PUSH_REGISTRATION_REFRESH_MS = 24 * 60 * 60 * 1000;
+
+function describe(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export type PushSyncDecision =
+  | { action: "skip"; reason: Exclude<PushSkipReason, "up-to-date"> }
+  | { action: "unregister" }
+  | { action: "fetch-token" };
+
+/**
+ * What to do before a token is known. Unregistering only happens when the
+ * phone previously registered this profile: the server's state should track
+ * the toggle and the OS permission.
+ */
+export function decidePushSync(input: {
+  enabled: boolean;
+  projectId: string | null;
+  permission: PushPermissionState;
+  existing: PushRegistrationRecord | null;
+}): PushSyncDecision {
+  if (!input.enabled) {
+    return input.existing
+      ? { action: "unregister" }
+      : { action: "skip", reason: "disabled" };
+  }
+  if (input.projectId === null) {
+    return { action: "skip", reason: "no-project-id" };
+  }
+  if (input.permission === "denied") {
+    return input.existing
+      ? { action: "unregister" }
+      : { action: "skip", reason: "permission-denied" };
+  }
+  if (input.permission === "undetermined") {
+    return { action: "skip", reason: "permission-undetermined" };
+  }
+  return { action: "fetch-token" };
+}
+
+/** Whether a fresh token/platform/server or a stale record needs a new POST. */
+export function shouldReregister(input: {
+  existing: PushRegistrationRecord | null;
+  expoPushToken: string;
+  platform: PushPlatform;
+  serverUrl: string;
+  now: number;
+  refreshAfterMs: number;
+}): boolean {
+  const { existing } = input;
+  if (!existing) return true;
+  if (existing.expoPushToken !== input.expoPushToken) return true;
+  if (existing.platform !== input.platform) return true;
+  if (existing.serverUrl !== input.serverUrl) return true;
+  return input.now - existing.registeredAt >= input.refreshAfterMs;
+}
+
+/**
+ * Bring the server's subscription for `profile` in line with the local
+ * toggle, the OS permission, and the current token. Never throws: failures
+ * are reported so the caller can show them in Settings and retry later.
+ */
+export async function syncPushRegistration(
+  deps: PushSyncDeps,
+  profile: PushSyncProfile,
+): Promise<PushSyncOutcome> {
+  const now = deps.now ?? Date.now;
+  const refreshAfterMs = deps.refreshAfterMs ?? PUSH_REGISTRATION_REFRESH_MS;
+  const { notifications, api, store } = deps;
+  const existing = store.getRegistration(profile.id);
+  const decision = decidePushSync({
+    enabled: store.isEnabled(profile.id),
+    projectId: notifications.projectId,
+    permission: await notifications.getPermission(),
+    existing,
+  });
+  if (decision.action === "skip") {
+    return { action: "skipped", reason: decision.reason };
+  }
+  if (decision.action === "unregister") {
+    return unregisterPushRegistration(deps, profile.id);
+  }
+
+  let expoPushToken: string;
+  try {
+    // `decidePushSync` only reaches here with a project id.
+    expoPushToken = await notifications.getExpoPushToken(
+      notifications.projectId ?? "",
+    );
+  } catch (error) {
+    return { action: "failed", step: "token", error: describe(error) };
+  }
+  const platform = notifications.platform;
+  if (
+    !shouldReregister({
+      existing,
+      expoPushToken,
+      platform,
+      serverUrl: profile.serverUrl,
+      now: now(),
+      refreshAfterMs,
+    })
+  ) {
+    return { action: "skipped", reason: "up-to-date" };
+  }
+  // A token or server change leaves a stale row behind on the old server /
+  // for the old token; remove it first (best effort) so the server does not
+  // push to a dead token.
+  if (
+    existing &&
+    (existing.expoPushToken !== expoPushToken ||
+      existing.serverUrl !== profile.serverUrl)
+  ) {
+    try {
+      await api.unregister(existing.serverUrl, existing);
+    } catch {
+      // The new registration below is what matters; the server also prunes
+      // tokens Expo reports as DeviceNotRegistered.
+    }
+  }
+  let subscriptionId: string;
+  try {
+    ({ subscriptionId } = await api.register(profile.serverUrl, {
+      expoPushToken,
+      platform,
+      deviceLabel: deps.deviceLabel,
+    }));
+  } catch (error) {
+    return { action: "failed", step: "register", error: describe(error) };
+  }
+  store.setRegistration(profile.id, {
+    subscriptionId,
+    expoPushToken,
+    platform,
+    serverUrl: profile.serverUrl,
+    registeredAt: now(),
+  });
+  return { action: "registered", expoPushToken };
+}
+
+/**
+ * Remove the phone's subscription for a profile (toggle off, permission
+ * revoked, or the profile was removed from the app — which is why this takes
+ * the id, not the profile: the record remembers the server URL).
+ */
+export async function unregisterPushRegistration(
+  deps: Pick<PushSyncDeps, "api" | "store">,
+  profileId: string,
+): Promise<PushSyncOutcome> {
+  const existing = deps.store.getRegistration(profileId);
+  if (!existing) return { action: "skipped", reason: "disabled" };
+  try {
+    await deps.api.unregister(existing.serverUrl, existing);
+  } catch (error) {
+    return { action: "failed", step: "unregister", error: describe(error) };
+  }
+  deps.store.setRegistration(profileId, null);
+  return { action: "unregistered" };
+}
+
+/**
+ * Turn the toggle on for a profile, asking for the OS permission first when
+ * it was never requested. Returns the permission the app ended up with so
+ * the UI can explain a denial (and deep-link to the system settings).
+ */
+export async function enablePushForProfile(
+  deps: Pick<PushSyncDeps, "notifications" | "store">,
+  profileId: string,
+): Promise<PushPermissionState> {
+  let permission = await deps.notifications.getPermission();
+  if (permission === "undetermined") {
+    permission = await deps.notifications.requestPermission();
+  }
+  deps.store.markPrompted();
+  deps.store.setEnabled(profileId, permission === "granted");
+  return permission;
+}
+
+/** User-facing summary for the Settings row subtitle. */
+export function describePushStatus(input: {
+  projectId: string | null;
+  enabled: boolean;
+  permission: PushPermissionState | null;
+  registration: PushRegistrationRecord | null;
+  lastOutcome: PushSyncOutcome | null;
+}): string {
+  if (input.projectId === null) {
+    return "Push unavailable until the app is built with EAS";
+  }
+  if (!input.enabled) return "Off";
+  if (input.permission === "denied") {
+    return "Notifications are blocked in system settings";
+  }
+  if (input.lastOutcome?.action === "failed") {
+    return `Could not register: ${input.lastOutcome.error}`;
+  }
+  if (input.registration) return "On · registered with this server";
+  if (input.permission === "undetermined") return "Waiting for permission";
+  return "Registering…";
+}
diff --git a/apps/mobile/src/data/notifications/push-store.test.ts b/apps/mobile/src/data/notifications/push-store.test.ts
new file mode 100644
index 0000000000..b5bdf21a73
--- /dev/null
+++ b/apps/mobile/src/data/notifications/push-store.test.ts
@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { createMemoryPushStorage, createPushStore } from "./push-store";
+
+describe("createPushStore", () => {
+  it("persists toggles, registrations and the prompt flag across instances", () => {
+    const storage = createMemoryPushStorage();
+    const store = createPushStore(storage);
+    store.setEnabled("p1", true);
+    store.setRegistration("p1", {
+      subscriptionId: "s1",
+      expoPushToken: "t",
+      platform: "ios",
+      serverUrl: "https://a",
+      registeredAt: 5,
+    });
+    store.setRegistration("p2", {
+      subscriptionId: null,
+      expoPushToken: "t",
+      platform: "ios",
+      serverUrl: "https://b",
+      registeredAt: 6,
+    });
+    store.markPrompted();
+
+    const reloaded = createPushStore(storage);
+    expect(reloaded.isEnabled("p1")).toBe(true);
+    expect(reloaded.isEnabled("p2")).toBe(false);
+    expect(reloaded.getRegistration("p1")?.serverUrl).toBe("https://a");
+    expect([...reloaded.registeredProfileIds()].sort()).toEqual(["p1", "p2"]);
+    expect(reloaded.hasPrompted()).toBe(true);
+  });
+
+  it("forgets a profile's flags and records, and tolerates corrupt entries", () => {
+    const storage = createMemoryPushStorage();
+    const store = createPushStore(storage);
+    store.setEnabled("p1", true);
+    store.setRegistration("p1", {
+      subscriptionId: "s1",
+      expoPushToken: "t",
+      platform: "ios",
+      serverUrl: "https://a",
+      registeredAt: 5,
+    });
+    store.forgetProfile("p1");
+    expect(store.isEnabled("p1")).toBe(false);
+    expect(store.getRegistration("p1")).toBeNull();
+    expect(storage.dump()).toEqual({});
+
+    storage.set("bb.push.registrations", JSON.stringify(["bad"]));
+    storage.set("bb.push.registration.bad", "{not json");
+    expect(createPushStore(storage).registeredProfileIds()).toEqual([]);
+  });
+
+  it("notifies subscribers on every write", () => {
+    const store = createPushStore(createMemoryPushStorage());
+    let calls = 0;
+    const unsubscribe = store.subscribe(() => {
+      calls += 1;
+    });
+    store.setEnabled("p1", true);
+    store.markPrompted();
+    unsubscribe();
+    store.setEnabled("p1", false);
+    expect(calls).toBe(2);
+  });
+});
diff --git a/apps/mobile/src/data/notifications/push-store.ts b/apps/mobile/src/data/notifications/push-store.ts
new file mode 100644
index 0000000000..4e49268a14
--- /dev/null
+++ b/apps/mobile/src/data/notifications/push-store.ts
@@ -0,0 +1,197 @@
+import { pushSubscriptionPlatformSchema } from "@bb/server-contract";
+import { z } from "zod";
+
+/**
+ * Client-local push state, one MMKV store (`bb.preferences`, wiped by the
+ * e2e reset): the per-profile "Push notifications" toggle, the registration
+ * the phone last made for each profile (so a token change re-registers and a
+ * removed profile can still be unregistered by its server URL), and whether
+ * the first-run prompt was shown. Storage is injected (MMKV in the app, a Map
+ * in tests); the store is the single writer and notifies in-process readers.
+ */
+export interface PushStorage {
+  getString(key: string): string | undefined;
+  set(key: string, value: string): void;
+  remove(key: string): void;
+}
+
+export const pushRegistrationRecordSchema = z.object({
+  /** The server row id (`POST` response); null for rows registered before ids were stored. */
+  subscriptionId: z.string().min(1).nullable(),
+  expoPushToken: z.string().min(1),
+  platform: pushSubscriptionPlatformSchema,
+  serverUrl: z.string().min(1),
+  registeredAt: z.number().int().nonnegative(),
+});
+export type PushRegistrationRecord = z.infer<
+  typeof pushRegistrationRecordSchema
+>;
+
+export interface PushStoreSnapshot {
+  enabledProfileIds: readonly string[];
+  registrations: Readonly<Record<string, PushRegistrationRecord>>;
+  prompted: boolean;
+}
+
+export interface PushStore {
+  getSnapshot(): PushStoreSnapshot;
+  subscribe(listener: () => void): () => void;
+  isEnabled(profileId: string): boolean;
+  setEnabled(profileId: string, enabled: boolean): void;
+  getRegistration(profileId: string): PushRegistrationRecord | null;
+  setRegistration(
+    profileId: string,
+    record: PushRegistrationRecord | null,
+  ): void;
+  /** Profiles with a stored registration (including ones removed from the app). */
+  registeredProfileIds(): readonly string[];
+  hasPrompted(): boolean;
+  markPrompted(): void;
+  /** Forget every per-profile flag/record for `profileId`. */
+  forgetProfile(profileId: string): void;
+  /** Re-read storage (after an external wipe such as the e2e reset). */
+  reload(): void;
+}
+
+export const PUSH_ENABLED_KEY_PREFIX = "bb.push.enabled.";
+export const PUSH_REGISTRATION_KEY_PREFIX = "bb.push.registration.";
+export const PUSH_REGISTRATION_INDEX_KEY = "bb.push.registrations";
+export const PUSH_PROMPTED_KEY = "bb.push.prompted";
+export const PUSH_ENABLED_INDEX_KEY = "bb.push.enabledProfiles";
+
+const idListSchema = z.array(z.string().min(1));
+
+function readIdList(storage: PushStorage, key: string): string[] {
+  const raw = storage.getString(key);
+  if (!raw) return [];
+  try {
+    const parsed = idListSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : [];
+  } catch {
+    return [];
+  }
+}
+
+function readRegistration(
+  storage: PushStorage,
+  profileId: string,
+): PushRegistrationRecord | null {
+  const raw = storage.getString(`${PUSH_REGISTRATION_KEY_PREFIX}${profileId}`);
+  if (!raw) return null;
+  try {
+    const parsed = pushRegistrationRecordSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+
+export function createPushStore(storage: PushStorage): PushStore {
+  const listeners = new Set<() => void>();
+
+  function load(): PushStoreSnapshot {
+    const enabledProfileIds = readIdList(
+      storage,
+      PUSH_ENABLED_INDEX_KEY,
+    ).filter(
+      (id) => storage.getString(`${PUSH_ENABLED_KEY_PREFIX}${id}`) === "1",
+    );
+    const registrations: Record<string, PushRegistrationRecord> = {};
+    for (const id of readIdList(storage, PUSH_REGISTRATION_INDEX_KEY)) {
+      const record = readRegistration(storage, id);
+      if (record) registrations[id] = record;
+    }
+    return {
+      enabledProfileIds,
+      registrations,
+      prompted: storage.getString(PUSH_PROMPTED_KEY) === "1",
+    };
+  }
+
+  let snapshot = load();
+
+  function commit(next: PushStoreSnapshot): void {
+    snapshot = next;
+    for (const listener of listeners) listener();
+  }
+
+  function writeIdList(key: string, ids: readonly string[]): void {
+    if (ids.length === 0) storage.remove(key);
+    else storage.set(key, JSON.stringify(ids));
+  }
+
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    isEnabled: (profileId) => snapshot.enabledProfileIds.includes(profileId),
+    setEnabled(profileId, enabled) {
+      const key = `${PUSH_ENABLED_KEY_PREFIX}${profileId}`;
+      const ids = snapshot.enabledProfileIds.filter((id) => id !== profileId);
+      if (enabled) {
+        storage.set(key, "1");
+        ids.push(profileId);
+      } else {
+        storage.remove(key);
+      }
+      writeIdList(PUSH_ENABLED_INDEX_KEY, ids);
+      commit({ ...snapshot, enabledProfileIds: ids });
+    },
+    getRegistration: (profileId) => snapshot.registrations[profileId] ?? null,
+    setRegistration(profileId, record) {
+      const key = `${PUSH_REGISTRATION_KEY_PREFIX}${profileId}`;
+      const registrations = { ...snapshot.registrations };
+      if (record) {
+        storage.set(key, JSON.stringify(record));
+        registrations[profileId] = record;
+      } else {
+        storage.remove(key);
+        delete registrations[profileId];
+      }
+      writeIdList(PUSH_REGISTRATION_INDEX_KEY, Object.keys(registrations));
+      commit({ ...snapshot, registrations });
+    },
+    registeredProfileIds: () => Object.keys(snapshot.registrations),
+    hasPrompted: () => snapshot.prompted,
+    markPrompted() {
+      storage.set(PUSH_PROMPTED_KEY, "1");
+      commit({ ...snapshot, prompted: true });
+    },
+    reload() {
+      commit(load());
+    },
+    forgetProfile(profileId) {
+      storage.remove(`${PUSH_ENABLED_KEY_PREFIX}${profileId}`);
+      storage.remove(`${PUSH_REGISTRATION_KEY_PREFIX}${profileId}`);
+      const enabledProfileIds = snapshot.enabledProfileIds.filter(
+        (id) => id !== profileId,
+      );
+      const registrations = { ...snapshot.registrations };
+      delete registrations[profileId];
+      writeIdList(PUSH_ENABLED_INDEX_KEY, enabledProfileIds);
+      writeIdList(PUSH_REGISTRATION_INDEX_KEY, Object.keys(registrations));
+      commit({ ...snapshot, enabledProfileIds, registrations });
+    },
+  };
+}
+
+/** In-memory storage for tests. */
+export function createMemoryPushStorage(): PushStorage & {
+  dump(): Record<string, string>;
+} {
+  const map = new Map<string, string>();
+  return {
+    getString: (key) => map.get(key),
+    set: (key, value) => {
+      map.set(key, value);
+    },
+    remove: (key) => {
+      map.delete(key);
+    },
+    dump: () => Object.fromEntries(map),
+  };
+}
diff --git a/apps/mobile/src/data/notifications/push-subscriptions-api.ts b/apps/mobile/src/data/notifications/push-subscriptions-api.ts
new file mode 100644
index 0000000000..daaed69657
--- /dev/null
+++ b/apps/mobile/src/data/notifications/push-subscriptions-api.ts
@@ -0,0 +1,72 @@
+import { BbHttpError, createBrowserBbSdk } from "@bb/sdk/browser";
+import type {
+  PushSubscriptionInput,
+  PushSubscriptionRecord,
+  PushSubscriptionRef,
+} from "./push-contract";
+
+/**
+ * `sdk.notifications.pushSubscriptions` keyed by server URL instead of by
+ * profile: a profile the user removed still needs its row deleted, and the
+ * per-profile client may already be disposed by then. Connect profiles
+ * authenticate through the native cookie jar; nothing is added here.
+ */
+export interface PushSubscriptionsApi {
+  /** Upsert by token; resolves with the server row id. */
+  register(
+    serverUrl: string,
+    input: PushSubscriptionInput,
+  ): Promise<{ subscriptionId: string }>;
+  /**
+   * Delete the row (by id when known, else by looking the token up). A row
+   * that is already gone counts as success.
+   */
+  unregister(serverUrl: string, ref: PushSubscriptionRef): Promise<void>;
+  list(
+    serverUrl: string,
+    signal?: AbortSignal,
+  ): Promise<PushSubscriptionRecord[]>;
+}
+
+export function createPushSubscriptionsApi(
+  fetchImpl: typeof fetch,
+): PushSubscriptionsApi {
+  const clients = new Map<string, ReturnType<typeof createBrowserBbSdk>>();
+  function sdkFor(serverUrl: string) {
+    const key = serverUrl.replace(/\/+$/u, "");
+    let sdk = clients.get(key);
+    if (!sdk) {
+      sdk = createBrowserBbSdk({ baseUrl: key, fetch: fetchImpl });
+      clients.set(key, sdk);
+    }
+    return sdk.notifications.pushSubscriptions;
+  }
+
+  async function remove(serverUrl: string, id: string): Promise<void> {
+    try {
+      await sdkFor(serverUrl).remove({ id });
+    } catch (error) {
+      if (error instanceof BbHttpError && error.status === 404) return;
+      throw error;
+    }
+  }
+
+  return {
+    async register(serverUrl, input) {
+      const result = await sdkFor(serverUrl).add(input);
+      return { subscriptionId: result.subscription.id };
+    },
+    async unregister(serverUrl, ref) {
+      if (ref.subscriptionId !== null) {
+        await remove(serverUrl, ref.subscriptionId);
+        return;
+      }
+      const rows = await sdkFor(serverUrl).list();
+      const row = rows.find((r) => r.expoPushToken === ref.expoPushToken);
+      if (row) await remove(serverUrl, row.id);
+    },
+    list(serverUrl, signal) {
+      return sdkFor(serverUrl).list(signal ? { signal } : undefined);
+    },
+  };
+}
diff --git a/apps/mobile/src/notifications/AppBadgeSync.tsx b/apps/mobile/src/notifications/AppBadgeSync.tsx
new file mode 100644
index 0000000000..e6229c2636
--- /dev/null
+++ b/apps/mobile/src/notifications/AppBadgeSync.tsx
@@ -0,0 +1,46 @@
+import { useEffect, useRef, useState } from "react";
+import { AppState, type AppStateStatus } from "react-native";
+import { badgeCountFromSidebar } from "@/data/notifications";
+import { useSidebarBootstrap } from "@/data/sidebar";
+import { getPushNotificationsModule } from "./expo-push-module";
+
+/**
+ * App-icon badge = unread / pending threads on the active server. Written
+ * when the app goes to the background (what the user will see on the home
+ * screen) and cleared while the app is active on the thread list (the user
+ * has seen it) — including the moment the app foregrounds onto it. Requires
+ * an active connection (the sidebar query).
+ */
+export function AppBadgeSync({ pathname }: { pathname: string }) {
+  const { data } = useSidebarBootstrap();
+  const count = data ? badgeCountFromSidebar(data) : null;
+  const countRef = useRef(count);
+  useEffect(() => {
+    countRef.current = count;
+  }, [count]);
+  const notifications = getPushNotificationsModule();
+  const onHome = pathname === "/" || pathname === "";
+  const [appState, setAppState] = useState<AppStateStatus>(
+    AppState.currentState,
+  );
+
+  useEffect(() => {
+    const subscription = AppState.addEventListener("change", (state) => {
+      setAppState(state);
+      if (state === "background" && countRef.current !== null) {
+        void notifications
+          .setBadgeCount(countRef.current)
+          .catch(() => undefined);
+      }
+    });
+    return () => subscription.remove();
+  }, [notifications]);
+
+  useEffect(() => {
+    if (onHome && appState === "active") {
+      void notifications.setBadgeCount(0).catch(() => undefined);
+    }
+  }, [onHome, appState, notifications, count]);
+
+  return null;
+}
diff --git a/apps/mobile/src/notifications/PushNotificationsHost.tsx b/apps/mobile/src/notifications/PushNotificationsHost.tsx
new file mode 100644
index 0000000000..4f0cc845a0
--- /dev/null
+++ b/apps/mobile/src/notifications/PushNotificationsHost.tsx
@@ -0,0 +1,269 @@
+import * as Notifications from "expo-notifications";
+import { usePathname } from "expo-router";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { AppState, type AppStateStatus } from "react-native";
+import {
+  pathnameIsThread,
+  useOpenThreadInProfile,
+  useProfiles,
+  useRealtimeConnectionState,
+} from "@/app-shell";
+import {
+  parsePushNotificationData,
+  resolvePushTargetProfile,
+  type PushNotificationTarget,
+  type PushSyncProfile,
+} from "@/data/notifications";
+import type { ServerProfile } from "@/lib/profiles";
+import { ActionSheet, toast, useSheet } from "@/ui";
+import { AppBadgeSync } from "./AppBadgeSync";
+import { getPushNotificationsModule } from "./expo-push-module";
+import { getPushRegistrationController } from "./push-controller";
+import { getPushStore } from "./push-storage";
+import { hasThreadOnServer } from "./thread-probe";
+import { usePushStoreSnapshot } from "./use-push-store";
+
+/**
+ * Everything push-related that must run while the app is up, mounted once
+ * inside the ProfilesProvider + SheetProvider:
+ *
+ * - keeps the active profile's registration in sync (on connect, on
+ *   AppState active, on a token roll, when the toggle changes) and removes
+ *   registrations of profiles the user deleted;
+ * - routes notification taps (cold start, background, foreground) to the
+ *   thread on the right profile; foreground arrivals become a toast with
+ *   "Open" instead of a system banner;
+ * - mirrors the unread / pending count onto the app icon badge;
+ * - asks for the OS permission once, after the first successful connection
+ *   (never on launch), when the app can actually mint a token.
+ */
+export function PushNotificationsHost() {
+  const { status, profiles, activeProfile, connection } = useProfiles();
+  const realtimeState = useRealtimeConnectionState();
+  const connected = connection !== null && realtimeState === "connected";
+  const controller = getPushRegistrationController();
+  const notifications = getPushNotificationsModule();
+  const storeSnapshot = usePushStoreSnapshot();
+  const openThreadInProfile = useOpenThreadInProfile();
+  const pathname = usePathname();
+
+  // Latest values for listeners that are registered once.
+  const profilesRef = useRef(profiles);
+  const activeProfileIdRef = useRef(activeProfile?.id ?? null);
+  const pathnameRef = useRef(pathname);
+  useEffect(() => {
+    profilesRef.current = profiles;
+    activeProfileIdRef.current = activeProfile?.id ?? null;
+    pathnameRef.current = pathname;
+  }, [profiles, activeProfile, pathname]);
+
+  const syncProfile = useMemo<PushSyncProfile | null>(
+    () =>
+      activeProfile
+        ? { id: activeProfile.id, serverUrl: activeProfile.serverUrl }
+        : null,
+    [activeProfile],
+  );
+  const activeEnabled =
+    syncProfile !== null &&
+    storeSnapshot.enabledProfileIds.includes(syncProfile.id);
+
+  // Foreground arrivals: no system banner; the toast below carries "Open".
+  useEffect(() => {
+    Notifications.setNotificationHandler({
+      handleNotification: async () => ({
+        shouldShowBanner: false,
+        shouldShowList: true,
+        shouldPlaySound: false,
+        shouldSetBadge: false,
+      }),
+    });
+    return () => Notifications.setNotificationHandler(null);
+  }, []);
+
+  const openTarget = useCallback(
+    async (target: PushNotificationTarget) => {
+      const profile = await resolvePushTargetProfile(target, {
+        profiles: profilesRef.current,
+        activeProfileId: activeProfileIdRef.current,
+        hasThread: hasThreadOnServer,
+      });
+      if (!profile) {
+        toast.error("Could not open the thread", {
+          description: "None of your saved servers has it.",
+        });
+        return;
+      }
+      await openThreadInProfile(profile.id, target.threadId);
+    },
+    [openThreadInProfile],
+  );
+
+  // Taps: while running (background or foreground) and the cold-start one.
+  useEffect(() => {
+    const handle = (response: Notifications.NotificationResponse) => {
+      const target = parsePushNotificationData(
+        response.notification.request.content.data,
+      );
+      if (target) void openTarget(target);
+    };
+    const subscription =
+      Notifications.addNotificationResponseReceivedListener(handle);
+    const last = Notifications.getLastNotificationResponse();
+    if (last) {
+      Notifications.clearLastNotificationResponse();
+      handle(last);
+    }
+    return () => subscription.remove();
+  }, [openTarget]);
+
+  // Foreground arrivals → toast with Open (unless that thread is on screen).
+  useEffect(() => {
+    const subscription = Notifications.addNotificationReceivedListener(
+      (notification) => {
+        const content = notification.request.content;
+        const target = parsePushNotificationData(content.data);
+        if (!target) return;
+        if (pathnameIsThread(pathnameRef.current, target.threadId)) return;
+        toast.message(content.title ?? "bb", {
+          description: content.body ?? undefined,
+          duration: 8_000,
+          action: { label: "Open", onClick: () => void openTarget(target) },
+        });
+      },
+    );
+    return () => subscription.remove();
+  }, [openTarget]);
+
+  // Registration sync for the active profile.
+  useEffect(() => {
+    if (!syncProfile || !connected) return;
+    void controller.sync(syncProfile);
+  }, [controller, syncProfile, connected, activeEnabled]);
+
+  // AppState active: the user may have changed the permission in Settings.
+  useEffect(() => {
+    const onChange = (state: AppStateStatus) => {
+      if (state !== "active") return;
+      void controller.refreshPermission().then(() => {
+        if (syncProfile) void controller.sync(syncProfile);
+      });
+    };
+    const subscription = AppState.addEventListener("change", onChange);
+    return () => subscription.remove();
+  }, [controller, syncProfile]);
+
+  // Token roll: every registered profile re-registers.
+  useEffect(
+    () =>
+      notifications.addTokenListener(() => {
+        void controller.handleTokenRolled(
+          profilesRef.current.map((profile) => ({
+            id: profile.id,
+            serverUrl: profile.serverUrl,
+          })),
+        );
+      }),
+    [controller, notifications],
+  );
+
+  // Profiles removed from the app: forget their server rows.
+  useEffect(() => {
+    if (status !== "ready") return;
+    void controller.reconcileRemovedProfiles(profiles.map((p) => p.id));
+  }, [controller, status, profiles]);
+
+  return (
+    <>
+      {connection ? <AppBadgeSync pathname={pathname} /> : null}
+      <FirstRunPrompt
+        profile={activeProfile}
+        connected={connected}
+        available={notifications.projectId !== null}
+        prompted={storeSnapshot.prompted}
+      />
+    </>
+  );
+}
+
+/**
+ * One-time "turn on notifications?" after the first successful connection.
+ * Only when the app can mint a token (EAS project id) and the OS prompt was
+ * never shown; declining or dismissing records the choice (Settings keeps
+ * the toggle).
+ */
+function FirstRunPrompt({
+  profile,
+  connected,
+  available,
+  prompted,
+}: {
+  profile: ServerProfile | null;
+  connected: boolean;
+  available: boolean;
+  prompted: boolean;
+}) {
+  const sheet = useSheet();
+  const controller = getPushRegistrationController();
+  const store = getPushStore();
+  const notifications = getPushNotificationsModule();
+  const [presentedFor, setPresentedFor] = useState<string | null>(null);
+  const shouldAsk =
+    available &&
+    !prompted &&
+    connected &&
+    profile !== null &&
+    presentedFor === null;
+
+  useEffect(() => {
+    if (!shouldAsk || !profile) return;
+    let cancelled = false;
+    void notifications.getPermission().then((permission) => {
+      if (cancelled || permission !== "undetermined") return;
+      setPresentedFor(profile.id);
+      sheet.present();
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [shouldAsk, profile, notifications, sheet]);
+
+  const target = useMemo(
+    () => (profile ? { id: profile.id, serverUrl: profile.serverUrl } : null),
+    [profile],
+  );
+
+  return (
+    <ActionSheet
+      controller={sheet}
+      title="Get notified when a thread needs you?"
+      message="bb can send a push notification when a thread finishes, hits an error, or is waiting for your input. You can change this per server in Settings."
+      actions={[
+        {
+          key: "enable",
+          label: "Turn on notifications",
+          icon: "Zap",
+          onPress: () => {
+            if (!target) return;
+            void controller.setEnabled(target, true).then((outcome) => {
+              if (outcome.action === "failed") {
+                toast.error("Could not turn on notifications", {
+                  description: outcome.error,
+                });
+              }
+            });
+          },
+        },
+        {
+          key: "later",
+          label: "Not now",
+          onPress: () => store.markPrompted(),
+        },
+      ]}
+      cancelLabel={undefined}
+      onDismiss={() => {
+        if (!store.hasPrompted()) store.markPrompted();
+      }}
+    />
+  );
+}
diff --git a/apps/mobile/src/notifications/PushSettingsSection.tsx b/apps/mobile/src/notifications/PushSettingsSection.tsx
new file mode 100644
index 0000000000..0a55325d63
--- /dev/null
+++ b/apps/mobile/src/notifications/PushSettingsSection.tsx
@@ -0,0 +1,78 @@
+import { Linking } from "react-native";
+import { useProfiles } from "@/app-shell";
+import type { ServerProfile } from "@/lib/profiles";
+import { ListRow, Switch, toast } from "@/ui";
+import { usePushRegistration } from "./use-push-registration";
+
+/**
+ * Settings → Notifications: one "Push notifications" switch per saved
+ * server (the phone registers its Expo token with each server separately),
+ * with the registration status underneath. Without an EAS project id the
+ * rows are disabled and explain why.
+ */
+export function PushSettingsRows() {
+  const { profiles } = useProfiles();
+  if (profiles.length === 0) {
+    return (
+      <ListRow
+        title="Push notifications"
+        subtitle="Add a server first"
+        leading="Zap"
+        disabled
+        testID="settings-push-empty"
+      />
+    );
+  }
+  return (
+    <>
+      {profiles.map((profile) => (
+        <PushProfileRow key={profile.id} profile={profile} />
+      ))}
+    </>
+  );
+}
+
+function PushProfileRow({ profile }: { profile: ServerProfile }) {
+  const push = usePushRegistration(profile);
+  const blocked = push.enabled === false && push.permission === "denied";
+  return (
+    <ListRow
+      title={profile.label}
+      subtitle={push.statusText}
+      leading="Zap"
+      disabled={!push.available}
+      onPress={
+        blocked
+          ? () => {
+              void Linking.openSettings();
+            }
+          : undefined
+      }
+      trailing={
+        <Switch
+          checked={push.enabled}
+          disabled={!push.available || push.syncing}
+          onCheckedChange={(next) => {
+            void push.setEnabled(next).then((outcome) => {
+              if (outcome.action === "failed") {
+                toast.error(
+                  next
+                    ? "Could not turn on notifications"
+                    : "Could not turn off notifications",
+                  { description: outcome.error },
+                );
+              } else if (next && push.permission === "denied") {
+                toast.warning("Notifications are blocked", {
+                  description: "Allow them for bb in the system settings.",
+                });
+              }
+            });
+          }}
+          accessibilityLabel={`Push notifications for ${profile.label}`}
+          testID={`settings-push-${profile.id}`}
+        />
+      }
+      testID={`settings-push-row-${profile.id}`}
+    />
+  );
+}
diff --git a/apps/mobile/src/notifications/device-label.ts b/apps/mobile/src/notifications/device-label.ts
new file mode 100644
index 0000000000..3e1b3b53d3
--- /dev/null
+++ b/apps/mobile/src/notifications/device-label.ts
@@ -0,0 +1,12 @@
+import Constants from "expo-constants";
+import { Platform } from "react-native";
+
+/**
+ * Human-readable device name for the server's subscription list (the
+ * dashboard-style "Sawyer's iPhone"). Never includes anything sensitive.
+ */
+export function describeThisDevice(): string {
+  const name = Constants.deviceName?.trim();
+  if (name && name.length > 0) return name.slice(0, 128);
+  return Platform.OS === "android" ? "Android device" : "iPhone";
+}
diff --git a/apps/mobile/src/notifications/expo-push-module.ts b/apps/mobile/src/notifications/expo-push-module.ts
new file mode 100644
index 0000000000..c33547a889
--- /dev/null
+++ b/apps/mobile/src/notifications/expo-push-module.ts
@@ -0,0 +1,98 @@
+import Constants from "expo-constants";
+import * as Notifications from "expo-notifications";
+import { Platform } from "react-native";
+import type {
+  PushNotificationsModule,
+  PushPermissionState,
+  PushPlatform,
+} from "@/data/notifications";
+
+/**
+ * EAS project id from the app config (`extra.eas.projectId`, written by
+ * `eas init` / EAS Build). Without it `getExpoPushTokenAsync` cannot mint a
+ * token, so a dev-client built with plain `expo run:ios` reports push as
+ * unavailable instead of throwing.
+ */
+export function getEasProjectId(): string | null {
+  const extra: unknown = Constants.expoConfig?.extra;
+  if (typeof extra === "object" && extra !== null && "eas" in extra) {
+    const eas: unknown = (extra as { eas?: unknown }).eas;
+    if (typeof eas === "object" && eas !== null && "projectId" in eas) {
+      const projectId: unknown = (eas as { projectId?: unknown }).projectId;
+      if (typeof projectId === "string" && projectId.length > 0) {
+        return projectId;
+      }
+    }
+  }
+  const easConfigId = Constants.easConfig?.projectId;
+  return typeof easConfigId === "string" && easConfigId.length > 0
+    ? easConfigId
+    : null;
+}
+
+function toPermissionState(
+  status: Notifications.NotificationPermissionsStatus,
+): PushPermissionState {
+  if (
+    status.granted ||
+    status.ios?.status === Notifications.IosAuthorizationStatus.PROVISIONAL
+  ) {
+    return "granted";
+  }
+  // `canAskAgain` is false once the user answered the system prompt (iOS
+  // never re-prompts); `undetermined` means the prompt has not been shown.
+  return status.status === "undetermined" || status.canAskAgain
+    ? "undetermined"
+    : "denied";
+}
+
+function currentPlatform(): PushPlatform {
+  return Platform.OS === "android" ? "android" : "ios";
+}
+
+export const ANDROID_DEFAULT_CHANNEL_ID = "threads";
+
+/** expo-notifications behind the injectable contract the data layer uses. */
+export function createExpoPushModule(): PushNotificationsModule {
+  return {
+    projectId: getEasProjectId(),
+    platform: currentPlatform(),
+    async getPermission() {
+      return toPermissionState(await Notifications.getPermissionsAsync());
+    },
+    async requestPermission() {
+      return toPermissionState(
+        await Notifications.requestPermissionsAsync({
+          ios: { allowAlert: true, allowBadge: true, allowSound: true },
+        }),
+      );
+    },
+    async getExpoPushToken(projectId) {
+      if (Platform.OS === "android") {
+        await Notifications.setNotificationChannelAsync(
+          ANDROID_DEFAULT_CHANNEL_ID,
+          {
+            name: "Threads",
+            importance: Notifications.AndroidImportance.MAX,
+          },
+        );
+      }
+      const token = await Notifications.getExpoPushTokenAsync({ projectId });
+      return token.data;
+    },
+    addTokenListener(listener) {
+      const subscription = Notifications.addPushTokenListener(() => listener());
+      return () => subscription.remove();
+    },
+    setBadgeCount(count) {
+      return Notifications.setBadgeCountAsync(count).then(() => undefined);
+    },
+  };
+}
+
+let instance: PushNotificationsModule | null = null;
+
+export function getPushNotificationsModule(): PushNotificationsModule {
+  instance ??= createExpoPushModule();
+  return instance;
+}
diff --git a/apps/mobile/src/notifications/index.ts b/apps/mobile/src/notifications/index.ts
new file mode 100644
index 0000000000..e6b490cb39
--- /dev/null
+++ b/apps/mobile/src/notifications/index.ts
@@ -0,0 +1,17 @@
+// Push notifications (RN glue): expo-notifications behind the data-layer
+// contract, the MMKV push store, the app-wide registration controller, the
+// host component (sync, taps, foreground toasts, badge, first-run prompt),
+// and the Settings rows. Pure policy lives in src/data/notifications.
+export { PushNotificationsHost } from "./PushNotificationsHost";
+export { PushSettingsRows } from "./PushSettingsSection";
+export {
+  getEasProjectId,
+  getPushNotificationsModule,
+} from "./expo-push-module";
+export { getPushRegistrationController } from "./push-controller";
+export { getPushStore, getPushSubscriptionsApi } from "./push-storage";
+export {
+  usePushRegistration,
+  type PushRegistration,
+} from "./use-push-registration";
+export { usePushStoreSnapshot } from "./use-push-store";
diff --git a/apps/mobile/src/notifications/push-controller.ts b/apps/mobile/src/notifications/push-controller.ts
new file mode 100644
index 0000000000..4d500d363d
--- /dev/null
+++ b/apps/mobile/src/notifications/push-controller.ts
@@ -0,0 +1,20 @@
+import {
+  createPushRegistrationController,
+  type PushRegistrationController,
+} from "@/data/notifications";
+import { describeThisDevice } from "./device-label";
+import { getPushNotificationsModule } from "./expo-push-module";
+import { getPushStore, getPushSubscriptionsApi } from "./push-storage";
+
+let instance: PushRegistrationController | null = null;
+
+/** App-wide registration controller over expo-notifications + MMKV + fetch. */
+export function getPushRegistrationController(): PushRegistrationController {
+  instance ??= createPushRegistrationController({
+    notifications: getPushNotificationsModule(),
+    api: getPushSubscriptionsApi(),
+    store: getPushStore(),
+    deviceLabel: describeThisDevice(),
+  });
+  return instance;
+}
diff --git a/apps/mobile/src/notifications/push-storage.ts b/apps/mobile/src/notifications/push-storage.ts
new file mode 100644
index 0000000000..bcd3e9707b
--- /dev/null
+++ b/apps/mobile/src/notifications/push-storage.ts
@@ -0,0 +1,37 @@
+import { createMMKV } from "react-native-mmkv";
+import {
+  createPushStore,
+  createPushSubscriptionsApi,
+  type PushStore,
+  type PushSubscriptionsApi,
+} from "@/data/notifications";
+import { createMobileFetch } from "@/lib/sdk";
+
+let store: PushStore | null = null;
+let api: PushSubscriptionsApi | null = null;
+
+/**
+ * App-wide push store on the shared `bb.preferences` MMKV instance (wiped by
+ * the e2e reset together with the other client-local preferences).
+ */
+export function getPushStore(): PushStore {
+  if (!store) {
+    const mmkv = createMMKV({ id: "bb.preferences" });
+    store = createPushStore({
+      getString: (key) => mmkv.getString(key),
+      set: (key, value) => mmkv.set(key, value),
+      remove: (key) => {
+        mmkv.remove(key);
+      },
+    });
+  }
+  return store;
+}
+
+/** The push-subscription routes over the global fetch + mobile surface header. */
+export function getPushSubscriptionsApi(): PushSubscriptionsApi {
+  api ??= createPushSubscriptionsApi(
+    createMobileFetch((input, init) => fetch(input, init)),
+  );
+  return api;
+}
diff --git a/apps/mobile/src/notifications/thread-probe.ts b/apps/mobile/src/notifications/thread-probe.ts
new file mode 100644
index 0000000000..2495bc66f6
--- /dev/null
+++ b/apps/mobile/src/notifications/thread-probe.ts
@@ -0,0 +1,21 @@
+import { createMobileFetch } from "@/lib/sdk";
+
+const probeFetch = createMobileFetch((input, init) => fetch(input, init));
+
+/**
+ * `GET <serverUrl>/api/v1/threads/:id` → 200? Used to find which saved
+ * server a notification's thread lives on when the payload does not say.
+ * Connect profiles authenticate through the shared cookie jar.
+ */
+export async function hasThreadOnServer(
+  serverUrl: string,
+  threadId: string,
+): Promise<boolean> {
+  const url = `${serverUrl.replace(/\/+$/u, "")}/api/v1/threads/${encodeURIComponent(threadId)}`;
+  const response = await probeFetch(url, {
+    method: "GET",
+    headers: new Headers({ accept: "application/json" }),
+    signal: AbortSignal.timeout(8_000),
+  });
+  return response.ok;
+}
diff --git a/apps/mobile/src/notifications/use-push-registration.ts b/apps/mobile/src/notifications/use-push-registration.ts
new file mode 100644
index 0000000000..88fb6d4303
--- /dev/null
+++ b/apps/mobile/src/notifications/use-push-registration.ts
@@ -0,0 +1,80 @@
+import { useCallback, useEffect, useSyncExternalStore } from "react";
+import {
+  describePushStatus,
+  type PushPermissionState,
+  type PushProfileSyncState,
+  type PushSyncOutcome,
+} from "@/data/notifications";
+import { getPushNotificationsModule } from "./expo-push-module";
+import { getPushRegistrationController } from "./push-controller";
+import { getPushStore } from "./push-storage";
+
+export interface PushRegistration {
+  /** False until the app is built with EAS (no project id → no token). */
+  available: boolean;
+  enabled: boolean;
+  permission: PushPermissionState | null;
+  syncing: boolean;
+  lastOutcome: PushSyncOutcome | null;
+  /** One-line status for the Settings row. */
+  statusText: string;
+  setEnabled(enabled: boolean): Promise<PushSyncOutcome>;
+}
+
+const IDLE_STATE: PushProfileSyncState = {
+  syncing: false,
+  lastOutcome: null,
+  permission: null,
+};
+
+/**
+ * Push registration for one server profile: the "Push notifications" toggle
+ * (asks for the OS permission the first time it is turned on), the sync
+ * state, and a one-line status. The PushNotificationsHost performs the
+ * actual register / re-register / unregister work; this hook drives and
+ * observes it.
+ */
+export function usePushRegistration(profile: {
+  id: string;
+  serverUrl: string;
+}): PushRegistration {
+  const store = getPushStore();
+  const controller = getPushRegistrationController();
+  const notifications = getPushNotificationsModule();
+  const storeSnapshot = useSyncExternalStore(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot,
+  );
+  const controllerSnapshot = useSyncExternalStore(
+    controller.subscribe,
+    controller.getSnapshot,
+    controller.getSnapshot,
+  );
+  useEffect(() => {
+    void controller.refreshPermission();
+  }, [controller]);
+
+  const state = controllerSnapshot.byProfileId[profile.id] ?? IDLE_STATE;
+  const enabled = storeSnapshot.enabledProfileIds.includes(profile.id);
+  const registration = storeSnapshot.registrations[profile.id] ?? null;
+  const setEnabled = useCallback(
+    (next: boolean) => controller.setEnabled(profile, next),
+    [controller, profile],
+  );
+  return {
+    available: notifications.projectId !== null,
+    enabled,
+    permission: state.permission,
+    syncing: state.syncing,
+    lastOutcome: state.lastOutcome,
+    statusText: describePushStatus({
+      projectId: notifications.projectId,
+      enabled,
+      permission: state.permission,
+      registration,
+      lastOutcome: state.lastOutcome,
+    }),
+    setEnabled,
+  };
+}
diff --git a/apps/mobile/src/notifications/use-push-store.ts b/apps/mobile/src/notifications/use-push-store.ts
new file mode 100644
index 0000000000..0f5d3de6a2
--- /dev/null
+++ b/apps/mobile/src/notifications/use-push-store.ts
@@ -0,0 +1,13 @@
+import { useSyncExternalStore } from "react";
+import type { PushStoreSnapshot } from "@/data/notifications";
+import { getPushStore } from "./push-storage";
+
+/** Live view of the push toggles / registrations / prompt flag. */
+export function usePushStoreSnapshot(): PushStoreSnapshot {
+  const store = getPushStore();
+  return useSyncExternalStore(
+    store.subscribe,
+    store.getSnapshot,
+    store.getSnapshot,
+  );
+}
diff --git a/apps/mobile/src/screens/settings/SettingsScreen.tsx b/apps/mobile/src/screens/settings/SettingsScreen.tsx
index 5b11486a79..073ade5c86 100644
--- a/apps/mobile/src/screens/settings/SettingsScreen.tsx
+++ b/apps/mobile/src/screens/settings/SettingsScreen.tsx
@@ -2,6 +2,7 @@ import Constants from "expo-constants";
 import { useRouter } from "expo-router";
 import { Linking } from "react-native";
 import { e2eModeEnabled, resetLocalState, useProfiles } from "@/app-shell";
+import { PushSettingsRows } from "@/notifications";
 import { useTheme } from "@/theme";
 import { ActionSheet, Icon, ListRow, toast, useSheet } from "@/ui";
 import {
@@ -180,6 +181,10 @@ export function SettingsScreen() {
         />
       </SettingsSection>
 
+      <SettingsSection title="Notifications">
+        <PushSettingsRows />
+      </SettingsSection>
+
       <SettingsSection title="Threads">
         <ListRow
           title="Archived threads"
diff --git a/apps/server/src/routes/notifications.ts b/apps/server/src/routes/notifications.ts
new file mode 100644
index 0000000000..9a8ac6bdfe
--- /dev/null
+++ b/apps/server/src/routes/notifications.ts
@@ -0,0 +1,37 @@
+import {
+  publicApiRoutes,
+  typedRoutes,
+  type PublicApiSchema,
+} from "@bb/server-contract";
+import type { Hono } from "hono";
+import { ApiError } from "../errors.js";
+import {
+  listRegisteredPushSubscriptions,
+  registerPushSubscription,
+  removePushSubscription,
+} from "../services/notifications/push-subscriptions.js";
+import type { AppDeps } from "../types.js";
+
+export function registerNotificationRoutes(app: Hono, deps: AppDeps): void {
+  const { del, get, post } = typedRoutes<PublicApiSchema>(app, {
+    onValidationError: (msg) => new ApiError(400, "invalid_request", msg),
+  });
+  const routes = publicApiRoutes.notifications;
+
+  get(routes.listPushSubscriptions, (context) =>
+    context.json({ subscriptions: listRegisteredPushSubscriptions(deps) }),
+  );
+
+  post(routes.registerPushSubscription, (context, payload) => {
+    const result = registerPushSubscription(deps, payload);
+    return context.json(
+      result.subscription,
+      result.outcome === "created" ? 201 : 200,
+    );
+  });
+
+  del(routes.deletePushSubscription, (context) => {
+    removePushSubscription(deps, context.req.param("id"));
+    return context.json({ ok: true as const });
+  });
+}
diff --git a/apps/server/src/server.ts b/apps/server/src/server.ts
index 05e68427f7..f2dbf4d425 100644
--- a/apps/server/src/server.ts
+++ b/apps/server/src/server.ts
@@ -16,6 +16,7 @@ import { ApiError, errorToResponse } from "./errors.js";
 import { registerEnvironmentRoutes } from "./routes/environments.js";
 import { registerFileRoutes } from "./routes/files.js";
 import { registerHostRoutes } from "./routes/hosts.js";
+import { registerNotificationRoutes } from "./routes/notifications.js";
 import { registerProjectRoutes } from "./routes/projects.js";
 import { registerThreadSectionRoutes } from "./routes/thread-sections.js";
 import { registerSystemRoutes } from "./routes/system.js";
@@ -499,6 +500,7 @@ export function createApp(
   registerEnvironmentRoutes(publicApi, deps);
   registerThreadRoutes(publicApi, deps);
   registerSystemRoutes(publicApi, deps, pluginService);
+  registerNotificationRoutes(publicApi, deps);
   registerPluginCatalogRoutes(publicApi, pluginCatalogService);
   registerPluginRoutes(publicApi, deps, pluginService);
   registerSkillsRegistryRoutes(publicApi, deps);
diff --git a/apps/server/src/services/notifications/push-sender.ts b/apps/server/src/services/notifications/push-sender.ts
new file mode 100644
index 0000000000..64dba73758
--- /dev/null
+++ b/apps/server/src/services/notifications/push-sender.ts
@@ -0,0 +1,527 @@
+import {
+  deletePushSubscriptionByToken,
+  getActivePendingInteractionForThread,
+  getThread,
+  listPushSubscriptions,
+  type DbConnection,
+} from "@bb/db";
+import type {
+  ChangedMessage,
+  PendingInteraction,
+  PushNotificationData,
+  PushNotificationKind,
+  PushSubscription,
+} from "@bb/domain";
+import { z } from "zod";
+import type { ServerLogger } from "../../types.js";
+import type { NotificationHub } from "../../ws/hub.js";
+import { toPendingInteraction } from "../interactions/pending-interaction-serialization.js";
+import {
+  getLastThreadErrorMessage,
+  getLastThreadOutput,
+} from "../threads/thread-data.js";
+
+type ThreadRow = NonNullable<ReturnType<typeof getThread>>;
+
+/** Expo accepts at most 100 messages per request. */
+const EXPO_PUSH_BATCH_SIZE = 100;
+/** Burst window per thread: later triggers merge into one push, and two pushes for one thread are never closer than this. */
+const DEFAULT_COALESCE_MS = 2_000;
+const PUSH_TITLE_MAX_LENGTH = 80;
+const PUSH_BODY_MAX_LENGTH = 180;
+const ATTENTION_MEMORY_LIMIT = 10_000;
+/** Most actionable first: one push per flush carries the top kind. */
+const PUSH_KIND_PRIORITY: readonly PushNotificationKind[] = [
+  "pending-interaction",
+  "thread-error",
+  "turn-finished",
+];
+
+/**
+ * Expo Push API ticket response. Tickets line up with the request messages;
+ * a `DeviceNotRegistered` ticket means the token is dead and must be dropped.
+ */
+const expoPushTicketSchema = z.union([
+  z.object({ status: z.literal("ok"), id: z.string().optional() }),
+  z.object({
+    status: z.literal("error"),
+    message: z.string().optional(),
+    details: z
+      .object({ error: z.string().optional() })
+      .passthrough()
+      .optional(),
+  }),
+]);
+const expoPushResponseSchema = z.object({
+  data: z.array(expoPushTicketSchema).optional(),
+  errors: z
+    .array(
+      z.object({ code: z.string().optional(), message: z.string().optional() }),
+    )
+    .optional(),
+});
+
+export interface ExpoPushMessage {
+  to: string;
+  title: string;
+  body: string;
+  data: PushNotificationData;
+  sound: "default";
+  channelId: "default";
+  priority: "high";
+}
+
+export type PushSenderFetch = (
+  url: string,
+  init: { method: "POST"; headers: Record<string, string>; body: string },
+) => Promise<{ ok: boolean; status: number; text(): Promise<string> }>;
+
+export interface CreatePushSenderArgs {
+  db: DbConnection;
+  hub: Pick<NotificationHub, "onChangedMessage">;
+  logger: ServerLogger;
+  /** `BB_PUSH_NOTIFICATIONS`: when false the sender never subscribes. */
+  enabled: boolean;
+  /** `BB_EXPO_PUSH_URL`. */
+  expoPushUrl: string;
+  fetch?: PushSenderFetch;
+  coalesceMs?: number;
+  now?: () => number;
+}
+
+export interface PushSender {
+  start(): void;
+  stop(): void;
+  /** Test hook: wait for every in-flight Expo request to settle. */
+  settle(): Promise<void>;
+}
+
+interface PendingThreadPush {
+  kinds: Set<PushNotificationKind>;
+  /** When the newest trigger landed; a read after it cancels the push. */
+  eventAt: number;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+function firstLine(text: string): string {
+  for (const line of text.split(/\r?\n/u)) {
+    const trimmed = line.trim();
+    if (trimmed.length > 0) {
+      return trimmed;
+    }
+  }
+  return "";
+}
+
+function truncate(text: string, maxLength: number): string {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  return `${text.slice(0, maxLength - 1).trimEnd()}…`;
+}
+
+function threadDisplayTitle(thread: ThreadRow): string {
+  const title = thread.title?.trim();
+  if (title) {
+    return title;
+  }
+  const fallback = thread.titleFallback?.trim();
+  if (fallback) {
+    return fallback;
+  }
+  return `Thread ${thread.id.slice(0, 8)}`;
+}
+
+function isThreadRead(thread: ThreadRow): boolean {
+  return (thread.lastReadAt ?? 0) >= thread.latestAttentionAt;
+}
+
+function describePendingInteraction(interaction: PendingInteraction): string {
+  const payload = interaction.payload;
+  switch (payload.kind) {
+    case "user_question": {
+      const prompt = firstLine(payload.questions[0]?.prompt ?? "");
+      return prompt.length > 0 ? prompt : "The agent has a question for you";
+    }
+    case "approval": {
+      const subject = payload.subject;
+      switch (subject.kind) {
+        case "command":
+          return `Approve command: ${firstLine(subject.command)}`;
+        case "file_change":
+          return "Approve file changes";
+        case "permission_grant":
+          return subject.toolName
+            ? `Grant permissions to ${subject.toolName}`
+            : "Grant additional permissions";
+        case "plan":
+          return "Review the plan before the agent continues";
+      }
+      break;
+    }
+    case "plugin":
+      return payload.title;
+  }
+  return "Waiting for your input";
+}
+
+function pickKind(
+  kinds: ReadonlySet<PushNotificationKind>,
+): PushNotificationKind | null {
+  for (const kind of PUSH_KIND_PRIORITY) {
+    if (kinds.has(kind)) {
+      return kind;
+    }
+  }
+  return null;
+}
+
+function chunk<T>(items: readonly T[], size: number): T[][] {
+  const chunks: T[][] = [];
+  for (let index = 0; index < items.length; index += size) {
+    chunks.push(items.slice(index, index + size));
+  }
+  return chunks;
+}
+
+/**
+ * Fans push-worthy thread changes out to every registered mobile device.
+ *
+ * Triggers (from the hub's change stream): a new pending interaction
+ * (`interactions-changed` with `hasPendingInteraction`), a root thread's
+ * turn finishing or a run failing (any change that advanced
+ * `latestAttentionAt`). Triggers coalesce per thread for `coalesceMs`; at
+ * flush the thread is re-read and the push is dropped when a client already
+ * read it, the interaction was answered, the agent is working again, or the
+ * thread was archived/deleted.
+ */
+export function createPushSender(args: CreatePushSenderArgs): PushSender {
+  const {
+    db,
+    hub,
+    logger,
+    enabled,
+    expoPushUrl,
+    coalesceMs = DEFAULT_COALESCE_MS,
+    now = () => Date.now(),
+  } = args;
+  const fetchImpl: PushSenderFetch =
+    args.fetch ?? ((url, init) => globalThis.fetch(url, init));
+  const pending = new Map<string, PendingThreadPush>();
+  /** Last `latestAttentionAt` seen per thread, to spot a fresh bump. */
+  const seenAttentionAt = new Map<string, number>();
+  const inFlight = new Set<Promise<void>>();
+  let startedAt = 0;
+  let unsubscribe: (() => void) | null = null;
+
+  function rememberAttention(threadId: string, attentionAt: number): void {
+    seenAttentionAt.delete(threadId);
+    seenAttentionAt.set(threadId, attentionAt);
+    if (seenAttentionAt.size > ATTENTION_MEMORY_LIMIT) {
+      const oldest = seenAttentionAt.keys().next().value;
+      if (oldest !== undefined) {
+        seenAttentionAt.delete(oldest);
+      }
+    }
+  }
+
+  function cancel(threadId: string): void {
+    const entry = pending.get(threadId);
+    if (!entry) {
+      return;
+    }
+    clearTimeout(entry.timer);
+    pending.delete(threadId);
+  }
+
+  function schedule(
+    threadId: string,
+    kind: PushNotificationKind,
+    eventAt: number,
+  ): void {
+    const existing = pending.get(threadId);
+    if (existing) {
+      existing.kinds.add(kind);
+      existing.eventAt = Math.max(existing.eventAt, eventAt);
+      return;
+    }
+    // Every flush waits out the window, so two pushes for one thread are
+    // always at least `coalesceMs` apart.
+    const timer = setTimeout(() => {
+      const entry = pending.get(threadId);
+      pending.delete(threadId);
+      if (!entry) {
+        return;
+      }
+      const flush = flushThread(threadId, entry).catch((error: unknown) => {
+        logger.error(
+          { err: error, threadId },
+          "Push notification flush failed",
+        );
+      });
+      inFlight.add(flush);
+      void flush.finally(() => {
+        inFlight.delete(flush);
+      });
+    }, coalesceMs);
+    timer.unref?.();
+    pending.set(threadId, { kinds: new Set([kind]), eventAt, timer });
+  }
+
+  function onThreadAttentionChange(threadId: string): void {
+    const thread = getThread(db, threadId);
+    if (!thread) {
+      cancel(threadId);
+      return;
+    }
+    // First sighting: attention older than this sender (or as old as the
+    // thread itself, which is born read) is history, not a trigger.
+    const previous =
+      seenAttentionAt.get(threadId) ??
+      Math.max(thread.createdAt, startedAt - 1);
+    rememberAttention(threadId, thread.latestAttentionAt);
+    if (isThreadRead(thread)) {
+      const entry = pending.get(threadId);
+      if (entry && (thread.lastReadAt ?? 0) >= entry.eventAt) {
+        cancel(threadId);
+      }
+      return;
+    }
+    if (thread.latestAttentionAt <= previous) {
+      return;
+    }
+    schedule(
+      threadId,
+      thread.status === "error" ? "thread-error" : "turn-finished",
+      thread.latestAttentionAt,
+    );
+  }
+
+  function onChangedMessage(message: ChangedMessage): void {
+    if (message.entity !== "thread" || message.id === undefined) {
+      return;
+    }
+    const threadId = message.id;
+    if (message.changes.includes("thread-deleted")) {
+      cancel(threadId);
+      return;
+    }
+    if (
+      message.changes.includes("interactions-changed") &&
+      message.metadata?.hasPendingInteraction === true
+    ) {
+      schedule(threadId, "pending-interaction", now());
+    }
+    if (
+      message.changes.includes("status-changed") ||
+      message.changes.includes("read-state-changed")
+    ) {
+      onThreadAttentionChange(threadId);
+    }
+  }
+
+  function resolveKind(
+    thread: ThreadRow,
+    entry: PendingThreadPush,
+  ): { kind: PushNotificationKind; body: string } | null {
+    const kinds = new Set(entry.kinds);
+    let interaction: PendingInteraction | null = null;
+    if (kinds.has("pending-interaction")) {
+      const row = getActivePendingInteractionForThread(db, thread.id);
+      if (row && row.status === "pending") {
+        try {
+          interaction = toPendingInteraction(row);
+        } catch (error) {
+          logger.warn(
+            { err: error, threadId: thread.id, interactionId: row.id },
+            "Push notification could not decode the pending interaction",
+          );
+          interaction = null;
+        }
+      }
+      if (!interaction) {
+        kinds.delete("pending-interaction");
+      }
+    }
+    if (isThreadRead(thread) && (thread.lastReadAt ?? 0) >= entry.eventAt) {
+      // A client showed the thread after the trigger: nothing to announce.
+      kinds.delete("turn-finished");
+      kinds.delete("thread-error");
+    }
+    if (kinds.has("turn-finished") && thread.status !== "idle") {
+      kinds.delete("turn-finished");
+    }
+    if (kinds.has("thread-error") && thread.status !== "error") {
+      kinds.delete("thread-error");
+    }
+    const kind = pickKind(kinds);
+    if (kind === null) {
+      return null;
+    }
+    switch (kind) {
+      case "pending-interaction":
+        return {
+          kind,
+          body: interaction
+            ? describePendingInteraction(interaction)
+            : "Waiting for your input",
+        };
+      case "thread-error": {
+        const message = getLastThreadErrorMessage(db, thread.id);
+        return {
+          kind,
+          body: message
+            ? firstLine(message) || "The thread hit an error"
+            : "The thread hit an error",
+        };
+      }
+      case "turn-finished": {
+        const output = getLastThreadOutput(db, thread.id);
+        return {
+          kind,
+          body: output
+            ? firstLine(output) || "Finished and waiting for you"
+            : "Finished and waiting for you",
+        };
+      }
+    }
+  }
+
+  async function flushThread(
+    threadId: string,
+    entry: PendingThreadPush,
+  ): Promise<void> {
+    const thread = getThread(db, threadId);
+    if (
+      !thread ||
+      thread.deletedAt !== null ||
+      thread.archivedAt !== null ||
+      thread.visibility !== "visible"
+    ) {
+      return;
+    }
+    const resolved = resolveKind(thread, entry);
+    if (resolved === null) {
+      return;
+    }
+    const subscriptions = listPushSubscriptions(db);
+    if (subscriptions.length === 0) {
+      return;
+    }
+    const title = truncate(threadDisplayTitle(thread), PUSH_TITLE_MAX_LENGTH);
+    const body = truncate(resolved.body, PUSH_BODY_MAX_LENGTH);
+    const data: PushNotificationData = {
+      kind: resolved.kind,
+      projectId: thread.projectId,
+      threadId: thread.id,
+    };
+    const messages: ExpoPushMessage[] = subscriptions.map((subscription) => ({
+      to: subscription.expoPushToken,
+      title,
+      body,
+      data,
+      sound: "default",
+      channelId: "default",
+      priority: "high",
+    }));
+    for (const batch of chunk(messages, EXPO_PUSH_BATCH_SIZE)) {
+      await sendBatch(batch, subscriptions);
+    }
+  }
+
+  async function sendBatch(
+    batch: readonly ExpoPushMessage[],
+    subscriptions: readonly PushSubscription[],
+  ): Promise<void> {
+    let responseText: string;
+    let status: number;
+    try {
+      const response = await fetchImpl(expoPushUrl, {
+        method: "POST",
+        headers: {
+          accept: "application/json",
+          "content-type": "application/json",
+        },
+        body: JSON.stringify(batch),
+      });
+      status = response.status;
+      responseText = await response.text();
+    } catch (error) {
+      logger.warn(
+        { err: error, count: batch.length },
+        "Expo push request failed",
+      );
+      return;
+    }
+    let parsed: z.infer<typeof expoPushResponseSchema>;
+    try {
+      parsed = expoPushResponseSchema.parse(JSON.parse(responseText));
+    } catch {
+      logger.warn(
+        { status, count: batch.length },
+        "Expo push response was not understood",
+      );
+      return;
+    }
+    if (parsed.errors && parsed.errors.length > 0) {
+      logger.warn(
+        { status, errors: parsed.errors },
+        "Expo push request was rejected",
+      );
+      return;
+    }
+    const tickets = parsed.data ?? [];
+    tickets.forEach((ticket, index) => {
+      if (ticket.status === "ok") {
+        return;
+      }
+      const message = batch[index];
+      if (!message) {
+        return;
+      }
+      if (ticket.details?.error === "DeviceNotRegistered") {
+        const removed = deletePushSubscriptionByToken(db, message.to);
+        const subscription = subscriptions.find(
+          (candidate) => candidate.expoPushToken === message.to,
+        );
+        logger.info(
+          {
+            pushSubscriptionId: subscription?.id ?? null,
+            removed,
+          },
+          "Removed push subscription: device no longer registered",
+        );
+        return;
+      }
+      logger.warn(
+        {
+          error: ticket.details?.error ?? null,
+          message: ticket.message ?? null,
+        },
+        "Expo push ticket reported an error",
+      );
+    });
+  }
+
+  return {
+    start() {
+      if (!enabled || unsubscribe !== null) {
+        return;
+      }
+      startedAt = now();
+      unsubscribe = hub.onChangedMessage(onChangedMessage);
+    },
+    stop() {
+      unsubscribe?.();
+      unsubscribe = null;
+      for (const threadId of [...pending.keys()]) {
+        cancel(threadId);
+      }
+    },
+    async settle() {
+      while (inFlight.size > 0) {
+        await Promise.allSettled([...inFlight]);
+      }
+    },
+  };
+}
diff --git a/apps/server/src/services/notifications/push-subscriptions.ts b/apps/server/src/services/notifications/push-subscriptions.ts
new file mode 100644
index 0000000000..66e6d57317
--- /dev/null
+++ b/apps/server/src/services/notifications/push-subscriptions.ts
@@ -0,0 +1,69 @@
+import {
+  deletePushSubscription,
+  listPushSubscriptions,
+  upsertPushSubscription,
+  type DbConnection,
+} from "@bb/db";
+import type {
+  PushSubscription,
+  RegisterPushSubscriptionRequest,
+} from "@bb/server-contract";
+import { ApiError } from "../../errors.js";
+import type { ServerLogger } from "../../types.js";
+
+export interface PushSubscriptionServiceDeps {
+  db: DbConnection;
+  logger: ServerLogger;
+}
+
+export type RegisterPushSubscriptionResult =
+  | { outcome: "created"; subscription: PushSubscription }
+  | { outcome: "updated"; subscription: PushSubscription };
+
+/** Every device registered for push, oldest first. */
+export function listRegisteredPushSubscriptions(
+  deps: Pick<PushSubscriptionServiceDeps, "db">,
+): PushSubscription[] {
+  return listPushSubscriptions(deps.db);
+}
+
+/**
+ * Register a device token or refresh an existing registration. The request
+ * carries every field explicitly (the contract has no defaults), so the row
+ * is exactly what the device told us.
+ */
+export function registerPushSubscription(
+  deps: PushSubscriptionServiceDeps,
+  request: RegisterPushSubscriptionRequest,
+): RegisterPushSubscriptionResult {
+  const result = upsertPushSubscription(deps.db, {
+    expoPushToken: request.expoPushToken,
+    platform: request.platform,
+    deviceLabel: request.deviceLabel,
+  });
+  if (result.outcome === "created") {
+    deps.logger.info(
+      {
+        pushSubscriptionId: result.subscription.id,
+        platform: result.subscription.platform,
+      },
+      "Registered push subscription",
+    );
+  }
+  return result;
+}
+
+/** Remove a registration by id; 404 when it does not exist. */
+export function removePushSubscription(
+  deps: PushSubscriptionServiceDeps,
+  id: string,
+): void {
+  if (!deletePushSubscription(deps.db, id)) {
+    throw new ApiError(
+      404,
+      "push_subscription_not_found",
+      "Push subscription not found",
+    );
+  }
+  deps.logger.info({ pushSubscriptionId: id }, "Removed push subscription");
+}
diff --git a/apps/server/src/services/skills/builtin-skills/bb-cli/SKILL.md b/apps/server/src/services/skills/builtin-skills/bb-cli/SKILL.md
index 5585174706..87040c89fa 100644
--- a/apps/server/src/services/skills/builtin-skills/bb-cli/SKILL.md
+++ b/apps/server/src/services/skills/builtin-skills/bb-cli/SKILL.md
@@ -126,6 +126,22 @@ message agents, or inspect projects, providers, and environments.
   rendered whole. Older activity loads automatically as you scroll toward the
   top; nothing becomes unreachable.
 
+## Mobile Push Notifications
+
+- The server pushes to registered bb mobile devices through the Expo Push API
+  when a thread gains a pending interaction (approval or question), when a
+  root thread's turn finishes and waits for input, or when a run fails. The
+  push carries the thread title and a one-line preview and opens the thread
+  when tapped; pushes for one thread coalesce over two seconds and are skipped
+  when a client already read the thread or answered the interaction.
+- The mobile app registers its own token after it connects. Inspect or repair
+  the registry with `bb notifications push-subscriptions list`,
+  `bb notifications push-subscriptions add --token <expo-push-token>
+--platform <ios|android> --label <device-name>` (an upsert by token), and
+  `bb notifications push-subscriptions remove <id>`. All accept `--json`.
+- `BB_PUSH_NOTIFICATIONS=false` (startup-only) stops sending while keeping
+  registrations; `BB_EXPO_PUSH_URL` points the sender at a stub for tests.
+
 ## Agent Instructions
 
 - Add `AGENTS.md` to the bb data dir (usually `~/.bb/AGENTS.md`) to inject
diff --git a/apps/server/src/start-server.ts b/apps/server/src/start-server.ts
index ad7ed0b0b7..bafc4c33de 100644
--- a/apps/server/src/start-server.ts
+++ b/apps/server/src/start-server.ts
@@ -23,6 +23,7 @@ import {
 import { createProviderRegistryService } from "./services/providers/provider-registry.js";
 import { resolveAcpAgentCapabilitiesForProviderId } from "./services/system/acp-launch-spec.js";
 import { createTelemetryService } from "./services/system/telemetry.js";
+import { createPushSender } from "./services/notifications/push-sender.js";
 import { TerminalSessionLifecycle } from "./services/terminals/terminal-session-lifecycle.js";
 import { resolveThreadStorageRootPath } from "./services/threads/thread-storage.js";
 import { createLifecycleDedupers } from "./lifecycle-dedupers.js";
@@ -135,6 +136,17 @@ export async function runServer(serverConfig: ServerConfig): Promise<void> {
     logger,
   });
 
+  // Push fan-out listens to the hub's change stream; it needs no daemon
+  // cooperation and nothing about it crosses the host protocol.
+  const pushSender = createPushSender({
+    db,
+    enabled: serverConfig.BB_PUSH_NOTIFICATIONS,
+    expoPushUrl: serverConfig.BB_EXPO_PUSH_URL,
+    hub,
+    logger,
+  });
+  pushSender.start();
+
   const machineAuth = await createMachineAuthService({
     dataDir: serverConfig.BB_DATA_DIR,
     db,
@@ -271,6 +283,7 @@ export async function runServer(serverConfig: ServerConfig): Promise<void> {
     shutdownPromise = (async () => {
       eventLoopStallMonitor.stop();
       clearInterval(sweepInterval);
+      pushSender.stop();
       pluginCatalogService.stopPeriodicRefresh();
       await pluginService.stopPeriodicUpdateChecks();
       await pluginService.stop().catch((error: unknown) => {
diff --git a/apps/server/test/public/public-notifications.test.ts b/apps/server/test/public/public-notifications.test.ts
new file mode 100644
index 0000000000..c6a205d6a0
--- /dev/null
+++ b/apps/server/test/public/public-notifications.test.ts
@@ -0,0 +1,112 @@
+import {
+  pushSubscriptionListResponseSchema,
+  pushSubscriptionSchema,
+} from "@bb/server-contract";
+import { describe, expect, it } from "vitest";
+import { readJson } from "../helpers/json.js";
+import { withTestHarness, type TestAppHarness } from "../helpers/test-app.js";
+
+const PATH = "/api/v1/notifications/push-subscriptions";
+
+async function register(
+  harness: TestAppHarness,
+  body: unknown,
+): Promise<Response> {
+  return await harness.app.request(PATH, {
+    body: JSON.stringify(body),
+    headers: { "content-type": "application/json" },
+    method: "POST",
+  });
+}
+
+describe("public push subscriptions", () => {
+  it("registers, refreshes, lists, and removes device tokens", async () => {
+    await withTestHarness(async (harness) => {
+      const created = await register(harness, {
+        expoPushToken: "ExponentPushToken[abc]",
+        platform: "ios",
+        deviceLabel: "Sawyer's iPhone",
+      });
+      expect(created.status).toBe(201);
+      const subscription = pushSubscriptionSchema.parse(
+        await readJson(created),
+      );
+      expect(subscription).toMatchObject({
+        expoPushToken: "ExponentPushToken[abc]",
+        platform: "ios",
+        deviceLabel: "Sawyer's iPhone",
+      });
+
+      const refreshed = await register(harness, {
+        expoPushToken: "ExponentPushToken[abc]",
+        platform: "ios",
+        deviceLabel: "iPhone 17",
+      });
+      expect(refreshed.status).toBe(200);
+      expect(pushSubscriptionSchema.parse(await readJson(refreshed))).toEqual({
+        ...subscription,
+        deviceLabel: "iPhone 17",
+        lastSeenAt: expect.any(Number),
+      });
+
+      const listed = await harness.app.request(PATH);
+      expect(listed.status).toBe(200);
+      const list = pushSubscriptionListResponseSchema.parse(
+        await readJson(listed),
+      );
+      expect(list.subscriptions.map((row) => row.id)).toEqual([
+        subscription.id,
+      ]);
+
+      const removed = await harness.app.request(`${PATH}/${subscription.id}`, {
+        method: "DELETE",
+      });
+      expect(removed.status).toBe(200);
+      await expect(readJson(removed)).resolves.toEqual({ ok: true });
+
+      const removedAgain = await harness.app.request(
+        `${PATH}/${subscription.id}`,
+        { method: "DELETE" },
+      );
+      expect(removedAgain.status).toBe(404);
+      await expect(readJson(removedAgain)).resolves.toMatchObject({
+        code: "push_subscription_not_found",
+      });
+      expect(
+        pushSubscriptionListResponseSchema.parse(
+          await readJson(await harness.app.request(PATH)),
+        ).subscriptions,
+      ).toEqual([]);
+    });
+  });
+
+  it("rejects incomplete or unknown registration fields", async () => {
+    await withTestHarness(async (harness) => {
+      const missingLabel = await register(harness, {
+        expoPushToken: "ExponentPushToken[abc]",
+        platform: "ios",
+      });
+      expect(missingLabel.status).toBe(400);
+
+      const unknownPlatform = await register(harness, {
+        expoPushToken: "ExponentPushToken[abc]",
+        platform: "web",
+        deviceLabel: "Browser",
+      });
+      expect(unknownPlatform.status).toBe(400);
+
+      const extraField = await register(harness, {
+        expoPushToken: "ExponentPushToken[abc]",
+        platform: "android",
+        deviceLabel: "Pixel",
+        sound: "chime",
+      });
+      expect(extraField.status).toBe(400);
+      expect(
+        pushSubscriptionListResponseSchema.parse(
+          await readJson(await harness.app.request(PATH)),
+        ).subscriptions,
+      ).toEqual([]);
+    });
+  });
+});
diff --git a/apps/server/test/services/push-sender.test.ts b/apps/server/test/services/push-sender.test.ts
new file mode 100644
index 0000000000..fd28ae997b
--- /dev/null
+++ b/apps/server/test/services/push-sender.test.ts
@@ -0,0 +1,471 @@
+import {
+  applyThreadLifecycleEvent,
+  archiveThread,
+  listPushSubscriptions,
+  setPendingInteractionResolved,
+  updateThread,
+  upsertPushSubscription,
+} from "@bb/db";
+import { threadScope, turnScope } from "@bb/domain";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  createPushSender,
+  type ExpoPushMessage,
+  type PushSender,
+  type PushSenderFetch,
+} from "../../src/services/notifications/push-sender.js";
+import {
+  createCommandApprovalPayload,
+  createUserQuestionPayload,
+} from "../helpers/pending-interactions.js";
+import {
+  seedEvent,
+  seedThreadFixture,
+  seedTurnStarted,
+} from "../helpers/seed.js";
+import {
+  createTestAppHarness,
+  testLogger,
+  type TestAppHarness,
+} from "../helpers/test-app.js";
+
+const EXPO_URL = "http://expo.test/push";
+const COALESCE_MS = 50;
+
+interface FakeExpo {
+  fetch: PushSenderFetch;
+  requests: ExpoPushMessage[][];
+  sentAt: number[];
+  /** Per-token ticket overrides; defaults to `ok`. */
+  ticketErrors: Map<string, string>;
+}
+
+function createFakeExpo(): FakeExpo {
+  const requests: ExpoPushMessage[][] = [];
+  const sentAt: number[] = [];
+  const ticketErrors = new Map<string, string>();
+  const fetch: PushSenderFetch = async (url, init) => {
+    expect(url).toBe(EXPO_URL);
+    expect(init.headers["content-type"]).toBe("application/json");
+    const batch = JSON.parse(init.body) as ExpoPushMessage[];
+    requests.push(batch);
+    sentAt.push(Date.now());
+    const data = batch.map((message) => {
+      const error = ticketErrors.get(message.to);
+      return error === undefined
+        ? { status: "ok", id: `ticket-${message.to}` }
+        : {
+            status: "error",
+            message: `Token ${message.to} failed`,
+            details: { error },
+          };
+    });
+    return {
+      ok: true,
+      status: 200,
+      text: async () => JSON.stringify({ data }),
+    };
+  };
+  return { fetch, requests, sentAt, ticketErrors };
+}
+
+function sentMessages(expo: FakeExpo): ExpoPushMessage[] {
+  return expo.requests.flat();
+}
+
+async function waitForCoalesce(sender: PushSender): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, COALESCE_MS * 3));
+  await sender.settle();
+}
+
+describe("push sender", () => {
+  let harness: TestAppHarness;
+  let expo: FakeExpo;
+  let sender: PushSender;
+
+  beforeEach(async () => {
+    harness = await createTestAppHarness();
+    expo = createFakeExpo();
+    sender = createPushSender({
+      db: harness.db,
+      hub: harness.hub,
+      logger: testLogger,
+      enabled: true,
+      expoPushUrl: EXPO_URL,
+      fetch: expo.fetch,
+      coalesceMs: COALESCE_MS,
+    });
+    sender.start();
+    upsertPushSubscription(harness.db, {
+      expoPushToken: "ExponentPushToken[phone]",
+      platform: "ios",
+      deviceLabel: "Phone",
+    });
+  });
+
+  afterEach(async () => {
+    sender.stop();
+    await harness.cleanup();
+  });
+
+  async function seedActiveThread(title = "Fix the flaky test") {
+    const fixture = seedThreadFixture(harness, {
+      thread: { status: "active", title, titleFallback: null },
+    });
+    seedTurnStarted(harness.deps, {
+      threadId: fixture.thread.id,
+      turnId: "turn-1",
+      providerThreadId: "provider-thread-1",
+    });
+    // A thread is born read (lastReadAt = createdAt); let the clock tick so
+    // the turn finishing below lands in a later millisecond, as in production.
+    await new Promise((resolve) => setTimeout(resolve, 2));
+    return fixture;
+  }
+
+  function seedAssistantReply(threadId: string, text: string) {
+    seedEvent(harness.deps, {
+      threadId,
+      providerThreadId: "provider-thread-1",
+      scope: turnScope("turn-1"),
+      sequence: 2,
+      type: "item/completed",
+      data: {
+        item: { type: "agentMessage", id: "assistant-1", text },
+      },
+    });
+  }
+
+  it("pushes a turn-finished preview to every device when a root thread goes idle", async () => {
+    upsertPushSubscription(harness.db, {
+      expoPushToken: "ExponentPushToken[tablet]",
+      platform: "android",
+      deviceLabel: "Tablet",
+    });
+    const { thread, project } = await seedActiveThread();
+    seedAssistantReply(
+      thread.id,
+      "Done: the retry loop was racing the timer.\n\nDetails below.",
+    );
+
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: thread.id,
+      event: { type: "run.succeeded" },
+    });
+    await waitForCoalesce(sender);
+
+    const messages = sentMessages(expo);
+    expect(messages).toHaveLength(2);
+    expect(messages.map((message) => message.to).sort()).toEqual([
+      "ExponentPushToken[phone]",
+      "ExponentPushToken[tablet]",
+    ]);
+    expect(messages[0]).toMatchObject({
+      title: "Fix the flaky test",
+      body: "Done: the retry loop was racing the timer.",
+      data: {
+        kind: "turn-finished",
+        projectId: project.id,
+        threadId: thread.id,
+      },
+      sound: "default",
+      channelId: "default",
+      priority: "high",
+    });
+  });
+
+  it("skips the push when a client read the thread inside the coalesce window", async () => {
+    const { thread } = await seedActiveThread();
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: thread.id,
+      event: { type: "run.succeeded" },
+    });
+    // The web marks the thread read as soon as attention lands while visible.
+    updateThread(harness.db, harness.hub, thread.id, {
+      lastReadAt: Date.now() + 1,
+    });
+    await waitForCoalesce(sender);
+
+    expect(sentMessages(expo)).toEqual([]);
+  });
+
+  it("does not push for marking a thread unread or for child threads finishing", async () => {
+    const parent = await seedActiveThread("Parent");
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: parent.thread.id,
+      event: { type: "run.succeeded" },
+    });
+    await waitForCoalesce(sender);
+    expect(sentMessages(expo)).toHaveLength(1);
+
+    updateThread(harness.db, harness.hub, parent.thread.id, {
+      lastReadAt: Date.now() + 1,
+    });
+    updateThread(harness.db, harness.hub, parent.thread.id, {
+      lastReadAt: null,
+    });
+    await waitForCoalesce(sender);
+    expect(sentMessages(expo)).toHaveLength(1);
+
+    const child = seedThreadFixture(harness, {
+      thread: {
+        status: "active",
+        title: "Child",
+        parentThreadId: parent.thread.id,
+      },
+    });
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: child.thread.id,
+      event: { type: "run.succeeded" },
+    });
+    await waitForCoalesce(sender);
+    expect(sentMessages(expo)).toHaveLength(1);
+  });
+
+  it("coalesces a burst into one push and keeps later pushes a window apart", async () => {
+    const { thread } = await seedActiveThread();
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: thread.id,
+      event: { type: "run.succeeded" },
+    });
+    // A second attention bump in the same window (re-run + finish) merges.
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: thread.id,
+      event: { type: "run.started" },
+    });
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: thread.id,
+      event: { type: "run.succeeded" },
+    });
+    await waitForCoalesce(sender);
+    expect(sentMessages(expo)).toHaveLength(1);
+
+    // Right after a send, the next trigger waits out another window.
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: thread.id,
+      event: { type: "run.started" },
+    });
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: thread.id,
+      event: { type: "run.succeeded" },
+    });
+    await waitForCoalesce(sender);
+    expect(sentMessages(expo)).toHaveLength(2);
+    expect(expo.sentAt[1]! - expo.sentAt[0]!).toBeGreaterThanOrEqual(
+      COALESCE_MS,
+    );
+  });
+
+  it("drops a turn-finished push when the agent is already working again", async () => {
+    const { thread } = await seedActiveThread();
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: thread.id,
+      event: { type: "run.succeeded" },
+    });
+    // A queued message auto-sent before the window closed.
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: thread.id,
+      event: { type: "run.started" },
+    });
+    await waitForCoalesce(sender);
+
+    expect(sentMessages(expo)).toEqual([]);
+  });
+
+  it("pushes the error message when a run fails", async () => {
+    const { thread } = await seedActiveThread("Deploy");
+    seedEvent(harness.deps, {
+      threadId: thread.id,
+      scope: threadScope(),
+      sequence: 2,
+      type: "system/error",
+      data: { message: "Provider exited with code 1\nstack…" },
+    });
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: thread.id,
+      event: { type: "run.failed" },
+    });
+    await waitForCoalesce(sender);
+
+    expect(sentMessages(expo)).toEqual([
+      expect.objectContaining({
+        title: "Deploy",
+        body: "Provider exited with code 1",
+        data: expect.objectContaining({ kind: "thread-error" }),
+      }),
+    ]);
+  });
+
+  it("pushes the question text for a new pending interaction and skips answered ones", async () => {
+    const { thread } = await seedActiveThread("Release");
+    const registered =
+      harness.deps.pendingInteractions.registerPendingInteraction({
+        interaction: {
+          threadId: thread.id,
+          turnId: "turn-1",
+          providerId: "codex",
+          providerThreadId: "provider-thread-1",
+          providerRequestId: "request-1",
+          payload: createUserQuestionPayload({
+            prompt: "Ship to staging or production?",
+          }),
+        },
+      });
+    expect(registered.outcome).toBe("created");
+    await waitForCoalesce(sender);
+    expect(sentMessages(expo)).toEqual([
+      expect.objectContaining({
+        title: "Release",
+        body: "Ship to staging or production?",
+        data: expect.objectContaining({ kind: "pending-interaction" }),
+      }),
+    ]);
+
+    // An approval answered on the desktop before the window closes is silent.
+    const other = seedThreadFixture(harness, {
+      thread: { status: "active", title: "Other" },
+    });
+    seedTurnStarted(harness.deps, {
+      threadId: other.thread.id,
+      turnId: "turn-2",
+      providerThreadId: "provider-thread-2",
+    });
+    const approval =
+      harness.deps.pendingInteractions.registerPendingInteraction({
+        interaction: {
+          threadId: other.thread.id,
+          turnId: "turn-2",
+          providerId: "codex",
+          providerThreadId: "provider-thread-2",
+          providerRequestId: "request-2",
+          payload: createCommandApprovalPayload({ command: "rm -rf dist" }),
+        },
+      });
+    if (approval.outcome !== "created") {
+      throw new Error(`unexpected outcome ${approval.outcome}`);
+    }
+    // Resolve through the data layer: the lifecycle would need a live daemon.
+    setPendingInteractionResolved(harness.db, {
+      id: approval.interaction.id,
+      resolution: JSON.stringify({ decision: "deny" }),
+    });
+    await waitForCoalesce(sender);
+    expect(sentMessages(expo)).toHaveLength(1);
+  });
+
+  it("prefers the interaction over turn-finished when both land together", async () => {
+    const { thread } = await seedActiveThread("Both");
+    harness.deps.pendingInteractions.registerPendingInteraction({
+      interaction: {
+        threadId: thread.id,
+        turnId: "turn-1",
+        providerId: "codex",
+        providerThreadId: "provider-thread-1",
+        providerRequestId: "request-1",
+        payload: createCommandApprovalPayload({ command: "git push" }),
+      },
+    });
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: thread.id,
+      event: { type: "run.succeeded" },
+    });
+    await waitForCoalesce(sender);
+
+    expect(sentMessages(expo)).toEqual([
+      expect.objectContaining({
+        body: "Approve command: git push",
+        data: expect.objectContaining({ kind: "pending-interaction" }),
+      }),
+    ]);
+  });
+
+  it("skips archived threads and deletes subscriptions Expo reports as unregistered", async () => {
+    upsertPushSubscription(harness.db, {
+      expoPushToken: "ExponentPushToken[stale]",
+      platform: "ios",
+      deviceLabel: "Old phone",
+    });
+    expo.ticketErrors.set("ExponentPushToken[stale]", "DeviceNotRegistered");
+
+    const archived = await seedActiveThread("Archived");
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: archived.thread.id,
+      event: { type: "run.succeeded" },
+    });
+    archiveThread(harness.db, harness.hub, archived.thread.id);
+    await waitForCoalesce(sender);
+    expect(sentMessages(expo)).toEqual([]);
+
+    const live = await seedActiveThread("Live");
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: live.thread.id,
+      event: { type: "run.succeeded" },
+    });
+    await waitForCoalesce(sender);
+    expect(sentMessages(expo)).toHaveLength(2);
+    expect(
+      listPushSubscriptions(harness.db).map((row) => row.expoPushToken),
+    ).toEqual(["ExponentPushToken[phone]"]);
+  });
+
+  it("batches more than 100 devices into several Expo requests", async () => {
+    for (let index = 0; index < 120; index += 1) {
+      upsertPushSubscription(harness.db, {
+        expoPushToken: `ExponentPushToken[device-${index}]`,
+        platform: "ios",
+        deviceLabel: `Device ${index}`,
+      });
+    }
+    const { thread } = await seedActiveThread();
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: thread.id,
+      event: { type: "run.succeeded" },
+    });
+    await waitForCoalesce(sender);
+
+    expect(expo.requests.map((batch) => batch.length)).toEqual([100, 21]);
+  });
+
+  it("stays silent when disabled and survives Expo outages", async () => {
+    const disabledExpo = createFakeExpo();
+    const disabled = createPushSender({
+      db: harness.db,
+      hub: harness.hub,
+      logger: testLogger,
+      enabled: false,
+      expoPushUrl: EXPO_URL,
+      fetch: disabledExpo.fetch,
+      coalesceMs: COALESCE_MS,
+    });
+    disabled.start();
+    const warn = vi.fn();
+    sender.stop();
+    sender = createPushSender({
+      db: harness.db,
+      hub: harness.hub,
+      logger: { ...testLogger, warn },
+      enabled: true,
+      expoPushUrl: EXPO_URL,
+      fetch: async () => {
+        throw new Error("ECONNREFUSED");
+      },
+      coalesceMs: COALESCE_MS,
+    });
+    sender.start();
+
+    const { thread } = await seedActiveThread();
+    applyThreadLifecycleEvent(harness.db, harness.hub, {
+      threadId: thread.id,
+      event: { type: "run.succeeded" },
+    });
+    await waitForCoalesce(sender);
+    await waitForCoalesce(disabled);
+
+    expect(disabledExpo.requests).toEqual([]);
+    expect(warn).toHaveBeenCalledWith(
+      expect.objectContaining({ count: 1 }),
+      "Expo push request failed",
+    );
+    disabled.stop();
+  });
+});
diff --git a/docs/configuration.md b/docs/configuration.md
index 0754ea4f77..639e47a101 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -87,8 +87,8 @@ set of startup-only server or launcher env entries is:
   `BB_INFERENCE_FALLBACK`, and `BB_INHERITED_SKILLS_ROOTS`
 - `BB_LOG_LEVEL`, `BB_MANAGED_DEV_BUILTIN_PLUGIN_HOT_RELOAD`,
   `BB_MARKETPLACE_URL`, `BB_POSTHOG_API_KEY`, and `BB_TELEMETRY`
-- `BB_SERVER_BIND_HOST`, `BB_SERVER_PORT`, `BB_TRANSCRIPTION`, and all
-  `BB_FF_*` feature flags
+- `BB_PUSH_NOTIFICATIONS`, `BB_EXPO_PUSH_URL`, `BB_SERVER_BIND_HOST`,
+  `BB_SERVER_PORT`, `BB_TRANSCRIPTION`, and all `BB_FF_*` feature flags
 
 Setting or unsetting one still runs the reload for any other pending changes,
 but the running processes keep their current values. Apply it with a full
@@ -127,6 +127,8 @@ signal it, so a stale file left by a crash cannot stop an unrelated process.
 | `BB_INFERENCE`          | `bb-app config`                                    | Optional                | Primary server-side helper model in `provider/model` format. Defaults to `codex/gpt-5.6-luna`; the Codex helper route uses no reasoning.                                                                                                                                                                                                                                                              |
 | `BB_INFERENCE_FALLBACK` | `bb-app config`                                    | Optional                | Helper model used after a transient primary timeout, rate limit, or service-unavailable failure. Defaults to `codex/gpt-5.4-mini`.                                                                                                                                                                                                                                                                    |
 | `BB_TRANSCRIPTION`      | `bb-app config`                                    | Optional                | Voice transcription model in `provider/model` format. Defaults to `codex/gpt-transcribe`.                                                                                                                                                                                                                                                                                                             |
+| `BB_PUSH_NOTIFICATIONS` | `bb-app env`, or environment                       | Startup-only            | Send push notifications to bb mobile devices registered with `bb notifications push-subscriptions` through the Expo Push API. Defaults to `true`; set `false` to stop sending while keeping the registrations. A full launcher or desktop app restart is required.                                                                                                                                    |
+| `BB_EXPO_PUSH_URL`      | `bb-app env`, or environment                       | Startup-only testing    | Expo Push API endpoint the server posts push messages to. Defaults to `https://exp.host/--/api/v2/push/send`; point it at a local stub to exercise push delivery without Expo. A full launcher or desktop app restart is required.                                                                                                                                                                    |
 | `BB_MARKETPLACE_URL`    | `bb-app env`, or environment                       | Startup-only testing    | Manifest URL of the reserved `bb-community` plugin marketplace, which lists as BB Community. Defaults to `https://getbb.app/marketplace/v1/marketplace.json`; point it at a local file server to test catalog refreshes. It sets only the reserved `bb-community` marketplace; other marketplaces are added at runtime with `bb marketplace add`. A full launcher or desktop app restart is required. |
 | `BB_SERVER_URL`         | `bb-app config`                                    | Remote CLI/host use     | Server URL for standalone `bb` CLI and `host-daemon` commands on the current machine. The CLI defaults to `http://127.0.0.1:38886` when unset.                                                                                                                                                                                                                                                        |
 | `BB_SERVER_BIND_HOST`   | `bb-app env`, environment, or `--server-bind-host` | Startup-only            | Server listener host. Defaults to `127.0.0.1`; accepts only `127.0.0.1` or `0.0.0.0`. A full launcher or desktop app restart is required; until then, a previous `0.0.0.0` listener remains exposed. This is not a `bb-app config` key.                                                                                                                                                               |
@@ -144,6 +146,26 @@ selected browser `MediaDevices` device id in localStorage as
 `bb.voiceInput.audioInputDeviceId`; it does not change `bb-app config` or the
 server-side transcription model.
 
+The server pushes notifications to bb mobile devices through the Expo Push
+API when a thread gains a pending interaction (approval or question), when a
+root thread's turn finishes and waits for input, or when a run fails. Each
+push carries the thread title and a one-line preview and opens the thread when
+tapped. Pushes for one thread coalesce over a two-second window and are skipped
+when a client read the thread or answered the interaction in the meantime. The
+mobile app registers its Expo push token after it connects; inspect or repair
+the registry from an agent or terminal with:
+
+```sh
+bb notifications push-subscriptions list [--json]
+bb notifications push-subscriptions add --token <expo-push-token> --platform <ios|android> --label <device-name> [--json]
+bb notifications push-subscriptions remove <id> [--json]
+```
+
+`add` is an upsert by token. Tokens Expo reports as no longer registered are
+removed automatically after a failed delivery. `BB_PUSH_NOTIFICATIONS=false`
+stops sending while keeping the registrations, and `BB_EXPO_PUSH_URL` points
+the sender at a stub for testing; both are startup-only.
+
 The builtin Keep Awake plugin has one autosaving configuration page with an
 enable switch and an all-or-selected host picker. On selected macOS hosts it
 runs `/usr/bin/caffeinate -i -w <worker-pid>` while enabled, preventing system
diff --git a/docs/platform-support.md b/docs/platform-support.md
index 5b6433b25d..bbcfe4322c 100644
--- a/docs/platform-support.md
+++ b/docs/platform-support.md
@@ -53,9 +53,9 @@ talks to a server over the same HTTP + WebSocket contract as the web app.
 - Distribution: developer builds from source (Xcode 26.2, iOS 26 simulator
   runtime) today; TestFlight / Play builds go through EAS once the Expo
   account exists (see `apps/mobile/README.md`). No store release yet.
-- Push notifications arrive in a later PR; they will need an EAS project,
-  APNs / FCM credentials, a physical device, and a server that can reach
-  `exp.host`.
+- Push notifications need an EAS project, APNs / FCM credentials, a physical
+  device, and a server that can reach `exp.host`; the server side
+  (`/notifications/push-subscriptions`, `BB_PUSH_NOTIFICATIONS`) is in place.
 
 Not available on the phone (use the web app or desktop for these):
 
diff --git a/packages/bb-app/src/launcher.ts b/packages/bb-app/src/launcher.ts
index f4bf5d041d..f241501413 100644
--- a/packages/bb-app/src/launcher.ts
+++ b/packages/bb-app/src/launcher.ts
@@ -106,6 +106,7 @@ const STARTUP_ONLY_MANAGED_ENV_KEYS = new Set<string>([
   "BB_APP_URL",
   "BB_DATA_DIR",
   "BB_DEV_APP_PORT",
+  "BB_EXPO_PUSH_URL",
   "BB_EXTERNAL_URL",
   "BB_HOST_DAEMON_PORT",
   "BB_INFERENCE",
@@ -114,6 +115,7 @@ const STARTUP_ONLY_MANAGED_ENV_KEYS = new Set<string>([
   "BB_LOG_LEVEL",
   "BB_MANAGED_DEV_BUILTIN_PLUGIN_HOT_RELOAD",
   "BB_POSTHOG_API_KEY",
+  "BB_PUSH_NOTIFICATIONS",
   "BB_SERVER_BIND_HOST",
   "BB_SERVER_PORT",
   "BB_TELEMETRY",
@@ -1478,11 +1480,11 @@ Usage:
 
 Startup-only server and launcher keys:
   BB_APP_SURFACE, BB_APP_URL, BB_DATA_DIR, BB_DEV_APP_PORT,
-  BB_EXTERNAL_URL, BB_HOST_DAEMON_PORT, BB_INFERENCE,
+  BB_EXPO_PUSH_URL, BB_EXTERNAL_URL, BB_HOST_DAEMON_PORT, BB_INFERENCE,
   BB_INFERENCE_FALLBACK, BB_INHERITED_SKILLS_ROOTS, BB_LOG_LEVEL,
   BB_MANAGED_DEV_BUILTIN_PLUGIN_HOT_RELOAD, BB_POSTHOG_API_KEY,
-  BB_SERVER_BIND_HOST, BB_SERVER_PORT, BB_TELEMETRY, BB_TRANSCRIPTION,
-  and BB_FF_* feature flags.
+  BB_PUSH_NOTIFICATIONS, BB_SERVER_BIND_HOST, BB_SERVER_PORT,
+  BB_TELEMETRY, BB_TRANSCRIPTION, and BB_FF_* feature flags.
   Changes require a full bb-app restart with bb-app stop && bb-app start,
   or a desktop app restart. BB_APP_URL, BB_INFERENCE,
   BB_INFERENCE_FALLBACK, and BB_TRANSCRIPTION can instead be changed live
diff --git a/packages/bb-app/src/public-sdk.ts b/packages/bb-app/src/public-sdk.ts
index af054ac3dc..0572abc957 100644
--- a/packages/bb-app/src/public-sdk.ts
+++ b/packages/bb-app/src/public-sdk.ts
@@ -68,6 +68,7 @@ export class BBSdk implements BbSdk {
   readonly files: BbSdk["files"];
   readonly guide: BbSdk["guide"];
   readonly hosts: BbSdk["hosts"];
+  readonly notifications: BbSdk["notifications"];
   readonly plugins: BbSdk["plugins"];
   readonly projects: BbSdk["projects"];
   readonly providers: BbSdk["providers"];
@@ -86,6 +87,7 @@ export class BBSdk implements BbSdk {
     this.files = sdk.files;
     this.guide = sdk.guide;
     this.hosts = sdk.hosts;
+    this.notifications = sdk.notifications;
     this.plugins = sdk.plugins;
     this.projects = sdk.projects;
     this.providers = sdk.providers;
diff --git a/packages/config/src/env-vars.ts b/packages/config/src/env-vars.ts
index f920268611..fc17fed6aa 100644
--- a/packages/config/src/env-vars.ts
+++ b/packages/config/src/env-vars.ts
@@ -220,6 +220,20 @@ export const BB_MARKETPLACE_URL_ENV = defineEnvVar<string>({
   parse: parseOptionalUrlEnvValue,
 });
 
+export const BB_PUSH_NOTIFICATIONS_ENV = defineEnvVar<boolean>({
+  description:
+    "Send push notifications to registered bb mobile devices through the Expo Push API. Set to false to disable sending; registrations are still stored.",
+  name: "BB_PUSH_NOTIFICATIONS",
+  parse: parseBooleanEnvValue,
+});
+
+export const BB_EXPO_PUSH_URL_ENV = defineEnvVar<string>({
+  description:
+    "Expo Push API endpoint the server posts push messages to. Point it at a local stub to test without exp.host.",
+  name: "BB_EXPO_PUSH_URL",
+  parse: parseRequiredUrlEnvValue,
+});
+
 export const BB_INFERENCE_ENV = defineEnvVar<string>({
   description: "Inference model used for server-side completions",
   name: "BB_INFERENCE",
@@ -373,6 +387,8 @@ export const DEFAULT_BB_DEV_APP_HOST = "";
 /** Published by the registry repository through the getbb.app worker's R2 route. */
 export const DEFAULT_BB_MARKETPLACE_URL =
   "https://getbb.app/marketplace/v1/marketplace.json";
+export const DEFAULT_BB_PUSH_NOTIFICATIONS = true;
+export const DEFAULT_BB_EXPO_PUSH_URL = "https://exp.host/--/api/v2/push/send";
 export const DEFAULT_BB_INFERENCE = DEFAULTS.inferenceModel;
 export const DEFAULT_BB_INFERENCE_FALLBACK = DEFAULTS.inferenceFallbackModel;
 export const DEFAULT_BB_TRANSCRIPTION = DEFAULTS.transcriptionModel;
diff --git a/packages/config/src/server.ts b/packages/config/src/server.ts
index 3af987be93..70086f3c90 100644
--- a/packages/config/src/server.ts
+++ b/packages/config/src/server.ts
@@ -12,23 +12,27 @@ import {
   BB_APP_URL_ENV,
   BB_APP_SURFACE_ENV,
   BB_APP_VERSION_ENV,
+  BB_EXPO_PUSH_URL_ENV,
   BB_EXTERNAL_URL_ENV,
   BB_INHERITED_SKILLS_ROOTS_ENV,
   BB_INFERENCE_FALLBACK_ENV,
   BB_INFERENCE_ENV,
   BB_MARKETPLACE_URL_ENV,
   BB_POSTHOG_API_KEY_ENV,
+  BB_PUSH_NOTIFICATIONS_ENV,
   BB_SERVER_BIND_HOST_ENV,
   BB_TELEMETRY_ENV,
   BB_TRANSCRIPTION_ENV,
   DEFAULT_BB_APP_URL,
   DEFAULT_BB_APP_SURFACE,
   DEFAULT_BB_APP_VERSION,
+  DEFAULT_BB_EXPO_PUSH_URL,
   DEFAULT_BB_EXTERNAL_URL,
   DEFAULT_BB_INFERENCE_FALLBACK,
   DEFAULT_BB_INFERENCE,
   DEFAULT_BB_MARKETPLACE_URL,
   DEFAULT_BB_POSTHOG_API_KEY,
+  DEFAULT_BB_PUSH_NOTIFICATIONS,
   DEFAULT_BB_SERVER_BIND_HOST,
   DEFAULT_BB_TELEMETRY,
   DEFAULT_BB_TRANSCRIPTION,
@@ -48,12 +52,14 @@ export interface ServerConfig
   BB_APP_SURFACE: AppSurface;
   BB_APP_VERSION: string;
   BB_DEV_APP_PORT?: number;
+  BB_EXPO_PUSH_URL: string;
   BB_EXTERNAL_URL: string;
   BB_HOST_DAEMON_PORT: number;
   BB_INHERITED_SKILLS_ROOTS: string[];
   BB_INFERENCE: string;
   BB_INFERENCE_FALLBACK: string;
   BB_POSTHOG_API_KEY: string;
+  BB_PUSH_NOTIFICATIONS: boolean;
   BB_MARKETPLACE_URL: string;
   BB_SERVER_BIND_HOST: ServerBindHost;
   BB_TELEMETRY: boolean;
@@ -117,6 +123,12 @@ export function loadServerConfig(
       definition: BB_APP_VERSION_ENV,
       env: loader.env,
     }),
+    BB_EXPO_PUSH_URL: readEnvVarWithDefault({
+      context: loader.context,
+      defaultValue: DEFAULT_BB_EXPO_PUSH_URL,
+      definition: BB_EXPO_PUSH_URL_ENV,
+      env: loader.env,
+    }),
     BB_EXTERNAL_URL: readEnvVarWithDefault({
       context: loader.context,
       defaultValue: DEFAULT_BB_EXTERNAL_URL,
@@ -159,6 +171,12 @@ export function loadServerConfig(
       definition: BB_POSTHOG_API_KEY_ENV,
       env: loader.env,
     }),
+    BB_PUSH_NOTIFICATIONS: readEnvVarWithDefault({
+      context: loader.context,
+      defaultValue: DEFAULT_BB_PUSH_NOTIFICATIONS,
+      definition: BB_PUSH_NOTIFICATIONS_ENV,
+      env: loader.env,
+    }),
     BB_SERVER_BIND_HOST: readEnvVarWithDefault({
       context: loader.context,
       defaultValue: DEFAULT_BB_SERVER_BIND_HOST,
diff --git a/packages/config/test/config.test.ts b/packages/config/test/config.test.ts
index 0faf623f09..70ee0b5f22 100644
--- a/packages/config/test/config.test.ts
+++ b/packages/config/test/config.test.ts
@@ -308,12 +308,39 @@ describe("consumer-specific config", () => {
     expect(serverConfig.BB_INFERENCE_FALLBACK).toBe("codex/gpt-5.4-mini");
     expect(serverConfig.BB_TRANSCRIPTION).toBe("codex/gpt-transcribe");
     expect(serverConfig.OPENAI_API_KEY).toBe("test-openai-key");
+    expect(serverConfig.BB_PUSH_NOTIFICATIONS).toBe(true);
+    expect(serverConfig.BB_EXPO_PUSH_URL).toBe(
+      "https://exp.host/--/api/v2/push/send",
+    );
     expect(serverConfig.featureFlags).toEqual({
       placeholder: false,
       timelineWindowEventBudget: 1_500,
     });
   });
 
+  it("reads push notification overrides", () => {
+    const serverConfig = loadServerConfig({
+      env: createServerRuntimeEnv({
+        BB_PUSH_NOTIFICATIONS: "false",
+        BB_EXPO_PUSH_URL: "http://127.0.0.1:4999/push",
+      }),
+    });
+
+    expect(serverConfig.BB_PUSH_NOTIFICATIONS).toBe(false);
+    expect(serverConfig.BB_EXPO_PUSH_URL).toBe("http://127.0.0.1:4999/push");
+
+    expect(() =>
+      loadServerConfig({
+        env: createServerRuntimeEnv({ BB_EXPO_PUSH_URL: "not-a-url" }),
+      }),
+    ).toThrow(/BB_EXPO_PUSH_URL/u);
+    expect(() =>
+      loadServerConfig({
+        env: createServerRuntimeEnv({ BB_PUSH_NOTIFICATIONS: "maybe" }),
+      }),
+    ).toThrow(/BB_PUSH_NOTIFICATIONS/u);
+  });
+
   it("defaults the server bind host to loopback", () => {
     const serverConfig = loadServerConfig({
       env: createServerRuntimeEnv({
diff --git a/packages/db/drizzle/0104_push_subscriptions.sql b/packages/db/drizzle/0104_push_subscriptions.sql
new file mode 100644
index 0000000000..be8107d485
--- /dev/null
+++ b/packages/db/drizzle/0104_push_subscriptions.sql
@@ -0,0 +1,10 @@
+CREATE TABLE `push_subscriptions` (
+	`id` text PRIMARY KEY NOT NULL,
+	`expo_push_token` text NOT NULL,
+	`platform` text NOT NULL,
+	`device_label` text NOT NULL,
+	`created_at` integer NOT NULL,
+	`last_seen_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `push_subscriptions_expo_push_token_idx` ON `push_subscriptions` (`expo_push_token`);
\ No newline at end of file
diff --git a/packages/db/drizzle/meta/0104_snapshot.json b/packages/db/drizzle/meta/0104_snapshot.json
new file mode 100644
index 0000000000..65df782837
--- /dev/null
+++ b/packages/db/drizzle/meta/0104_snapshot.json
@@ -0,0 +1,3772 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "9bf26003-5eb5-450b-9a76-69bf7924ba97",
+  "prevId": "67842c38-c4d3-43d1-ac01-87a19a58edd4",
+  "tables": {
+    "app_settings": {
+      "name": "app_settings",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "caffeinate": {
+          "name": "caffeinate",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "show_keyboard_hints": {
+          "name": "show_keyboard_hints",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "steer_active_thread_on_enter": {
+          "name": "steer_active_thread_on_enter",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "show_unhandled_provider_events": {
+          "name": "show_unhandled_provider_events",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "codex_memory_enabled": {
+          "name": "codex_memory_enabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "claude_code_memory_enabled": {
+          "name": "claude_code_memory_enabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "codex_subagents_disabled": {
+          "name": "codex_subagents_disabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "claude_code_subagents_disabled": {
+          "name": "claude_code_subagents_disabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "claude_code_workflows_disabled": {
+          "name": "claude_code_workflows_disabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "keybinding_overrides": {
+          "name": "keybinding_overrides",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'[]'"
+        },
+        "onboarding_completed_at": {
+          "name": "onboarding_completed_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "app_settings_values": {
+      "name": "app_settings_values",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "app_theme": {
+      "name": "app_theme",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "theme_id": {
+          "name": "theme_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "favicon_color": {
+          "name": "favicon_color",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'default'"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "apikey": {
+      "name": "apikey",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "start": {
+          "name": "start",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "prefix": {
+          "name": "prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "referenceId": {
+          "name": "referenceId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "refillInterval": {
+          "name": "refillInterval",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "refillAmount": {
+          "name": "refillAmount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "lastRefillAt": {
+          "name": "lastRefillAt",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rateLimitEnabled": {
+          "name": "rateLimitEnabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rateLimitTimeWindow": {
+          "name": "rateLimitTimeWindow",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rateLimitMax": {
+          "name": "rateLimitMax",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "requestCount": {
+          "name": "requestCount",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "remaining": {
+          "name": "remaining",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "lastRequest": {
+          "name": "lastRequest",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "expiresAt": {
+          "name": "expiresAt",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updatedAt": {
+          "name": "updatedAt",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "permissions": {
+          "name": "permissions",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "metadata": {
+          "name": "metadata",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "configId": {
+          "name": "configId",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "apikey_key_unique": {
+          "name": "apikey_key_unique",
+          "columns": [
+            "key"
+          ],
+          "isUnique": true
+        },
+        "apikey_reference_id_idx": {
+          "name": "apikey_reference_id_idx",
+          "columns": [
+            "referenceId"
+          ],
+          "isUnique": false
+        },
+        "apikey_config_id_idx": {
+          "name": "apikey_config_id_idx",
+          "columns": [
+            "configId"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "apikey_referenceId_user_id_fk": {
+          "name": "apikey_referenceId_user_id_fk",
+          "tableFrom": "apikey",
+          "tableTo": "user",
+          "columnsFrom": [
+            "referenceId"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "user": {
+      "name": "user",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "emailVerified": {
+          "name": "emailVerified",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "image": {
+          "name": "image",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "createdAt": {
+          "name": "createdAt",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updatedAt": {
+          "name": "updatedAt",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "user_email_unique": {
+          "name": "user_email_unique",
+          "columns": [
+            "email"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "environments": {
+      "name": "environments",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "host_id": {
+          "name": "host_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "path": {
+          "name": "path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "managed": {
+          "name": "managed",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "is_git_repo": {
+          "name": "is_git_repo",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "is_worktree": {
+          "name": "is_worktree",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "branch_name": {
+          "name": "branch_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "base_branch": {
+          "name": "base_branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "default_branch": {
+          "name": "default_branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "merge_base_branch": {
+          "name": "merge_base_branch",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "destroy_attempt_id": {
+          "name": "destroy_attempt_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "retire_requested_at": {
+          "name": "retire_requested_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "workspace_provision_type": {
+          "name": "workspace_provision_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'provisioning'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "environments_project_host_path_idx": {
+          "name": "environments_project_host_path_idx",
+          "columns": [
+            "project_id",
+            "host_id",
+            "path"
+          ],
+          "isUnique": true
+        },
+        "environments_host_path_lookup_idx": {
+          "name": "environments_host_path_lookup_idx",
+          "columns": [
+            "host_id",
+            "path"
+          ],
+          "isUnique": false
+        },
+        "environments_project_idx": {
+          "name": "environments_project_idx",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": false
+        },
+        "environments_status_idx": {
+          "name": "environments_status_idx",
+          "columns": [
+            "status"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "environments_project_id_projects_id_fk": {
+          "name": "environments_project_id_projects_id_fk",
+          "tableFrom": "environments",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "environments_host_id_hosts_id_fk": {
+          "name": "environments_host_id_hosts_id_fk",
+          "tableFrom": "environments",
+          "tableTo": "hosts",
+          "columnsFrom": [
+            "host_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "events": {
+      "name": "events",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "thread_id": {
+          "name": "thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "environment_id": {
+          "name": "environment_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "scope_kind": {
+          "name": "scope_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "turn_id": {
+          "name": "turn_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "provider_thread_id": {
+          "name": "provider_thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sequence": {
+          "name": "sequence",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "item_id": {
+          "name": "item_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "item_kind": {
+          "name": "item_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "parent_tool_call_id": {
+          "name": "parent_tool_call_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "data": {
+          "name": "data",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'{}'"
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "events_thread_sequence_idx": {
+          "name": "events_thread_sequence_idx",
+          "columns": [
+            "thread_id",
+            "sequence"
+          ],
+          "isUnique": true
+        },
+        "events_tool_call_parent_lookup_idx": {
+          "name": "events_tool_call_parent_lookup_idx",
+          "columns": [
+            "thread_id",
+            "item_id",
+            "sequence"
+          ],
+          "isUnique": false,
+          "where": "\"events\".\"item_kind\" = 'toolCall'"
+        },
+        "events_parent_tool_call_thread_parent_sequence_idx": {
+          "name": "events_parent_tool_call_thread_parent_sequence_idx",
+          "columns": [
+            "thread_id",
+            "parent_tool_call_id",
+            "sequence"
+          ],
+          "isUnique": false,
+          "where": "\"events\".\"parent_tool_call_id\" IS NOT NULL"
+        },
+        "events_thread_type_item_kind_sequence_idx": {
+          "name": "events_thread_type_item_kind_sequence_idx",
+          "columns": [
+            "thread_id",
+            "type",
+            "item_kind",
+            "sequence"
+          ],
+          "isUnique": false
+        },
+        "events_background_task_thread_type_item_sequence_idx": {
+          "name": "events_background_task_thread_type_item_sequence_idx",
+          "columns": [
+            "thread_id",
+            "type",
+            "item_id",
+            "sequence"
+          ],
+          "isUnique": false,
+          "where": "\"events\".\"item_kind\" = 'backgroundTask'"
+        },
+        "events_thread_type_sequence_idx": {
+          "name": "events_thread_type_sequence_idx",
+          "columns": [
+            "thread_id",
+            "type",
+            "sequence"
+          ],
+          "isUnique": false
+        },
+        "events_thread_turn_type_item_sequence_idx": {
+          "name": "events_thread_turn_type_item_sequence_idx",
+          "columns": [
+            "thread_id",
+            "turn_id",
+            "type",
+            "item_id",
+            "sequence"
+          ],
+          "isUnique": false
+        },
+        "events_item_lifecycle_thread_item_sequence_idx": {
+          "name": "events_item_lifecycle_thread_item_sequence_idx",
+          "columns": [
+            "thread_id",
+            "item_id",
+            "sequence"
+          ],
+          "isUnique": false,
+          "where": "\"events\".\"type\" IN ('item/started', 'item/completed', 'item/backgroundTask/completed')"
+        },
+        "events_environment_idx": {
+          "name": "events_environment_idx",
+          "columns": [
+            "environment_id"
+          ],
+          "isUnique": false
+        },
+        "events_completed_item_truncation_idx": {
+          "name": "events_completed_item_truncation_idx",
+          "columns": [
+            "item_kind",
+            "created_at",
+            "id"
+          ],
+          "isUnique": false,
+          "where": "\"events\".\"type\" = 'item/completed'"
+        },
+        "events_goal_thread_sequence_idx": {
+          "name": "events_goal_thread_sequence_idx",
+          "columns": [
+            "thread_id",
+            "sequence"
+          ],
+          "isUnique": false,
+          "where": "\"events\".\"type\" IN ('thread/goal/updated', 'thread/goal/cleared')"
+        }
+      },
+      "foreignKeys": {
+        "events_thread_id_threads_id_fk": {
+          "name": "events_thread_id_threads_id_fk",
+          "tableFrom": "events",
+          "tableTo": "threads",
+          "columnsFrom": [
+            "thread_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "events_environment_id_environments_id_fk": {
+          "name": "events_environment_id_environments_id_fk",
+          "tableFrom": "events",
+          "tableTo": "environments",
+          "columnsFrom": [
+            "environment_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "events_scope_shape_check": {
+          "name": "events_scope_shape_check",
+          "value": "(\n        (\"events\".\"scope_kind\" = 'turn' AND \"events\".\"turn_id\" IS NOT NULL)\n        OR\n        (\"events\".\"scope_kind\" = 'thread' AND \"events\".\"turn_id\" IS NULL)\n      )"
+        }
+      }
+    },
+    "host_daemon_sessions": {
+      "name": "host_daemon_sessions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "host_id": {
+          "name": "host_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "instance_id": {
+          "name": "instance_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "host_name": {
+          "name": "host_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "host_type": {
+          "name": "host_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "data_dir": {
+          "name": "data_dir",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "protocol_version": {
+          "name": "protocol_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "heartbeat_interval_ms": {
+          "name": "heartbeat_interval_ms",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "lease_timeout_ms": {
+          "name": "lease_timeout_ms",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "lease_expires_at": {
+          "name": "lease_expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "closed_at": {
+          "name": "closed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "close_reason": {
+          "name": "close_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "host_daemon_sessions_host_status_idx": {
+          "name": "host_daemon_sessions_host_status_idx",
+          "columns": [
+            "host_id",
+            "status"
+          ],
+          "isUnique": false
+        },
+        "host_daemon_sessions_host_latest_idx": {
+          "name": "host_daemon_sessions_host_latest_idx",
+          "columns": [
+            "host_id",
+            "updated_at",
+            "created_at",
+            "id"
+          ],
+          "isUnique": false
+        },
+        "host_daemon_sessions_closed_prune_idx": {
+          "name": "host_daemon_sessions_closed_prune_idx",
+          "columns": [
+            "status",
+            "closed_at",
+            "id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "host_daemon_sessions_host_id_hosts_id_fk": {
+          "name": "host_daemon_sessions_host_id_hosts_id_fk",
+          "tableFrom": "host_daemon_sessions",
+          "tableTo": "hosts",
+          "columnsFrom": [
+            "host_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "hosts": {
+      "name": "hosts",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "connect_machine_id": {
+          "name": "connect_machine_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "max_permission_mode": {
+          "name": "max_permission_mode",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'full'"
+        },
+        "destroyed_at": {
+          "name": "destroyed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_seen_at": {
+          "name": "last_seen_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_rejected_protocol_version": {
+          "name": "last_rejected_protocol_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "hosts_last_seen_idx": {
+          "name": "hosts_last_seen_idx",
+          "columns": [
+            "last_seen_at"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "plugins": {
+      "name": "plugins",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source": {
+          "name": "source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "provenance": {
+          "name": "provenance",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'direct'"
+        },
+        "catalog_entry_id": {
+          "name": "catalog_entry_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "catalog_marketplace_name": {
+          "name": "catalog_marketplace_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_kind": {
+          "name": "source_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'path'"
+        },
+        "source_path": {
+          "name": "source_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_builtin_name": {
+          "name": "source_builtin_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_npm_package": {
+          "name": "source_npm_package",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_npm_registry": {
+          "name": "source_npm_registry",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_npm_requested_spec": {
+          "name": "source_npm_requested_spec",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_npm_spec_kind": {
+          "name": "source_npm_spec_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_git_url": {
+          "name": "source_git_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_git_subdirectory": {
+          "name": "source_git_subdirectory",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_git_requested_ref": {
+          "name": "source_git_requested_ref",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_git_ref_kind": {
+          "name": "source_git_ref_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_git_range": {
+          "name": "source_git_range",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_git_tag_prefix": {
+          "name": "source_git_tag_prefix",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_git_resolved_tag": {
+          "name": "source_git_resolved_tag",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "npm_resolved_version": {
+          "name": "npm_resolved_version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "npm_integrity": {
+          "name": "npm_integrity",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "git_resolved_commit": {
+          "name": "git_resolved_commit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_update_check_at": {
+          "name": "last_update_check_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "available_compatible_version": {
+          "name": "available_compatible_version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "newest_incompatible_version": {
+          "name": "newest_incompatible_version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "update_status_detail": {
+          "name": "update_status_detail",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_failure_version": {
+          "name": "last_failure_version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_failure_at": {
+          "name": "last_failure_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_failure_detail": {
+          "name": "last_failure_detail",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "active_artifact_id": {
+          "name": "active_artifact_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "normalization_version": {
+          "name": "normalization_version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "root_dir": {
+          "name": "root_dir",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "version": {
+          "name": "version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "removed_at": {
+          "name": "removed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "installed_at": {
+          "name": "installed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "plugins_active_artifact_id_plugin_artifacts_id_fk": {
+          "name": "plugins_active_artifact_id_plugin_artifacts_id_fk",
+          "tableFrom": "plugins",
+          "tableTo": "plugin_artifacts",
+          "columnsFrom": [
+            "active_artifact_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "maintenance_scan_cursors": {
+      "name": "maintenance_scan_cursors",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "policy": {
+          "name": "policy",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "version": {
+          "name": "version",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "item_kind": {
+          "name": "item_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "output_path": {
+          "name": "output_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_created_at": {
+          "name": "last_created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "last_event_id": {
+          "name": "last_event_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "''"
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "maintenance_scan_cursors_path_idx": {
+          "name": "maintenance_scan_cursors_path_idx",
+          "columns": [
+            "policy",
+            "version",
+            "item_kind",
+            "output_path"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "pending_interactions": {
+      "name": "pending_interactions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "thread_id": {
+          "name": "thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "origin_kind": {
+          "name": "origin_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'provider'"
+        },
+        "turn_id": {
+          "name": "turn_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "provider_thread_id": {
+          "name": "provider_thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "provider_request_id": {
+          "name": "provider_request_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "plugin_id": {
+          "name": "plugin_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "renderer_id": {
+          "name": "renderer_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload": {
+          "name": "payload",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "resolution": {
+          "name": "resolution",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status_reason": {
+          "name": "status_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "expires_at": {
+          "name": "expires_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "resolved_at": {
+          "name": "resolved_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "pending_interactions_provider_request_idx": {
+          "name": "pending_interactions_provider_request_idx",
+          "columns": [
+            "provider_id",
+            "provider_thread_id",
+            "provider_request_id"
+          ],
+          "isUnique": true
+        },
+        "pending_interactions_thread_created_idx": {
+          "name": "pending_interactions_thread_created_idx",
+          "columns": [
+            "thread_id",
+            "created_at"
+          ],
+          "isUnique": false
+        },
+        "pending_interactions_thread_status_created_idx": {
+          "name": "pending_interactions_thread_status_created_idx",
+          "columns": [
+            "thread_id",
+            "status",
+            "created_at"
+          ],
+          "isUnique": false
+        },
+        "pending_interactions_status_created_idx": {
+          "name": "pending_interactions_status_created_idx",
+          "columns": [
+            "status",
+            "created_at"
+          ],
+          "isUnique": false
+        },
+        "pending_interactions_plugin_status_created_idx": {
+          "name": "pending_interactions_plugin_status_created_idx",
+          "columns": [
+            "plugin_id",
+            "status",
+            "created_at"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "pending_interactions_thread_id_threads_id_fk": {
+          "name": "pending_interactions_thread_id_threads_id_fk",
+          "tableFrom": "pending_interactions",
+          "tableTo": "threads",
+          "columnsFrom": [
+            "thread_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "plugin_artifacts": {
+      "name": "plugin_artifacts",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "plugin_id": {
+          "name": "plugin_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_kind": {
+          "name": "source_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "npm_resolved_version": {
+          "name": "npm_resolved_version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "git_resolved_commit": {
+          "name": "git_resolved_commit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "git_checkout_root": {
+          "name": "git_checkout_root",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "path": {
+          "name": "path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "integrity": {
+          "name": "integrity",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "content_hash": {
+          "name": "content_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "validation_result": {
+          "name": "validation_result",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "validated_at": {
+          "name": "validated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "plugin_artifacts_plugin_idx": {
+          "name": "plugin_artifacts_plugin_idx",
+          "columns": [
+            "plugin_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "plugin_kv": {
+      "name": "plugin_kv",
+      "columns": {
+        "plugin_id": {
+          "name": "plugin_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {
+        "plugin_kv_plugin_id_key_pk": {
+          "columns": [
+            "plugin_id",
+            "key"
+          ],
+          "name": "plugin_kv_plugin_id_key_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "plugin_marketplace_icons": {
+      "name": "plugin_marketplace_icons",
+      "columns": {
+        "marketplace_name": {
+          "name": "marketplace_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "entry_id": {
+          "name": "entry_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_url": {
+          "name": "source_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "content_type": {
+          "name": "content_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "etag": {
+          "name": "etag",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "content_hash": {
+          "name": "content_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "bytes": {
+          "name": "bytes",
+          "type": "blob",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {
+        "plugin_marketplace_icons_marketplace_name_entry_id_pk": {
+          "columns": [
+            "marketplace_name",
+            "entry_id"
+          ],
+          "name": "plugin_marketplace_icons_marketplace_name_entry_id_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "plugin_marketplaces": {
+      "name": "plugin_marketplaces",
+      "columns": {
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_kind": {
+          "name": "source_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'https'"
+        },
+        "manifest_url": {
+          "name": "manifest_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_git_ref": {
+          "name": "source_git_ref",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_git_commit": {
+          "name": "source_git_commit",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "manifest_json": {
+          "name": "manifest_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "etag": {
+          "name": "etag",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_modified": {
+          "name": "last_modified",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_successful_refresh_at": {
+          "name": "last_successful_refresh_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_attempted_refresh_at": {
+          "name": "last_attempted_refresh_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "plugin_schedules": {
+      "name": "plugin_schedules",
+      "columns": {
+        "plugin_id": {
+          "name": "plugin_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cron": {
+          "name": "cron",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "next_run_at": {
+          "name": "next_run_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_run_at": {
+          "name": "last_run_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_status": {
+          "name": "last_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {
+        "plugin_schedules_plugin_id_name_pk": {
+          "columns": [
+            "plugin_id",
+            "name"
+          ],
+          "name": "plugin_schedules_plugin_id_name_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "plugin_settings": {
+      "name": "plugin_settings",
+      "columns": {
+        "plugin_id": {
+          "name": "plugin_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {
+        "plugin_settings_plugin_id_key_pk": {
+          "columns": [
+            "plugin_id",
+            "key"
+          ],
+          "name": "plugin_settings_plugin_id_key_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "plugin_state_snapshots": {
+      "name": "plugin_state_snapshots",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "plugin_id": {
+          "name": "plugin_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "from_artifact_id": {
+          "name": "from_artifact_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "to_artifact_id": {
+          "name": "to_artifact_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "snapshot_path": {
+          "name": "snapshot_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "database_path": {
+          "name": "database_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "state_path": {
+          "name": "state_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "secrets_path": {
+          "name": "secrets_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "registration_path": {
+          "name": "registration_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rollback_candidate_version": {
+          "name": "rollback_candidate_version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rollback_source_fingerprint": {
+          "name": "rollback_source_fingerprint",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rollback_bb_version": {
+          "name": "rollback_bb_version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rollback_sdk_version": {
+          "name": "rollback_sdk_version",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "rollback_detail": {
+          "name": "rollback_detail",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "retained_until": {
+          "name": "retained_until",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "plugin_state_snapshots_plugin_idx": {
+          "name": "plugin_state_snapshots_plugin_idx",
+          "columns": [
+            "plugin_id"
+          ],
+          "isUnique": false
+        },
+        "plugin_state_snapshots_retention_idx": {
+          "name": "plugin_state_snapshots_retention_idx",
+          "columns": [
+            "retained_until"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_execution_defaults": {
+      "name": "project_execution_defaults",
+      "columns": {
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "model": {
+          "name": "model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "service_tier": {
+          "name": "service_tier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "reasoning_level": {
+          "name": "reasoning_level",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "permission_mode": {
+          "name": "permission_mode",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_execution_defaults_project_idx": {
+          "name": "project_execution_defaults_project_idx",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_execution_defaults_project_id_projects_id_fk": {
+          "name": "project_execution_defaults_project_id_projects_id_fk",
+          "tableFrom": "project_execution_defaults",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "project_sources": {
+      "name": "project_sources",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "host_id": {
+          "name": "host_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "path": {
+          "name": "path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_default": {
+          "name": "is_default",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "project_sources_project_idx": {
+          "name": "project_sources_project_idx",
+          "columns": [
+            "project_id"
+          ],
+          "isUnique": false
+        },
+        "project_sources_host_idx": {
+          "name": "project_sources_host_idx",
+          "columns": [
+            "host_id"
+          ],
+          "isUnique": false
+        },
+        "project_sources_project_host_idx": {
+          "name": "project_sources_project_host_idx",
+          "columns": [
+            "project_id",
+            "host_id"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "project_sources_project_id_projects_id_fk": {
+          "name": "project_sources_project_id_projects_id_fk",
+          "tableFrom": "project_sources",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "project_sources_host_id_hosts_id_fk": {
+          "name": "project_sources_host_id_hosts_id_fk",
+          "tableFrom": "project_sources",
+          "tableTo": "hosts",
+          "columnsFrom": [
+            "host_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {
+        "project_sources_shape_check": {
+          "name": "project_sources_shape_check",
+          "value": "(\n        \"project_sources\".\"type\" = 'local_path' AND \"project_sources\".\"host_id\" IS NOT NULL AND \"project_sources\".\"path\" IS NOT NULL\n      )"
+        }
+      }
+    },
+    "projects": {
+      "name": "projects",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'standard'"
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "git_remote_url": {
+          "name": "git_remote_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_key": {
+          "name": "sort_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'V'"
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "projects_updated_idx": {
+          "name": "projects_updated_idx",
+          "columns": [
+            "updated_at"
+          ],
+          "isUnique": false
+        },
+        "projects_deleted_idx": {
+          "name": "projects_deleted_idx",
+          "columns": [
+            "deleted_at"
+          ],
+          "isUnique": false
+        },
+        "projects_sort_idx": {
+          "name": "projects_sort_idx",
+          "columns": [
+            "sort_key",
+            "id"
+          ],
+          "isUnique": false
+        },
+        "projects_personal_singleton_idx": {
+          "name": "projects_personal_singleton_idx",
+          "columns": [
+            "kind"
+          ],
+          "isUnique": true,
+          "where": "\"projects\".\"kind\" = 'personal'"
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "prompt_history_entries": {
+      "name": "prompt_history_entries",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "thread_id": {
+          "name": "thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "scope": {
+          "name": "scope",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "request_sequence": {
+          "name": "request_sequence",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "input": {
+          "name": "input",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "prompt_history_entries_thread_request_idx": {
+          "name": "prompt_history_entries_thread_request_idx",
+          "columns": [
+            "thread_id",
+            "request_sequence"
+          ],
+          "isUnique": true
+        },
+        "prompt_history_entries_project_scope_created_idx": {
+          "name": "prompt_history_entries_project_scope_created_idx",
+          "columns": [
+            "project_id",
+            "scope",
+            "created_at",
+            "request_sequence",
+            "id"
+          ],
+          "isUnique": false
+        },
+        "prompt_history_entries_thread_scope_created_idx": {
+          "name": "prompt_history_entries_thread_scope_created_idx",
+          "columns": [
+            "thread_id",
+            "scope",
+            "created_at",
+            "request_sequence",
+            "id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "prompt_history_entries_project_id_projects_id_fk": {
+          "name": "prompt_history_entries_project_id_projects_id_fk",
+          "tableFrom": "prompt_history_entries",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "prompt_history_entries_thread_id_threads_id_fk": {
+          "name": "prompt_history_entries_thread_id_threads_id_fk",
+          "tableFrom": "prompt_history_entries",
+          "tableTo": "threads",
+          "columnsFrom": [
+            "thread_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "push_subscriptions": {
+      "name": "push_subscriptions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "expo_push_token": {
+          "name": "expo_push_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "platform": {
+          "name": "platform",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "device_label": {
+          "name": "device_label",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_seen_at": {
+          "name": "last_seen_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "push_subscriptions_expo_push_token_idx": {
+          "name": "push_subscriptions_expo_push_token_idx",
+          "columns": [
+            "expo_push_token"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "queued_thread_messages": {
+      "name": "queued_thread_messages",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "thread_id": {
+          "name": "thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "content": {
+          "name": "content",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "sender_thread_id": {
+          "name": "sender_thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "model": {
+          "name": "model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "reasoning_level": {
+          "name": "reasoning_level",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "permission_mode": {
+          "name": "permission_mode",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "service_tier": {
+          "name": "service_tier",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "group_with_next": {
+          "name": "group_with_next",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "claimed_at": {
+          "name": "claimed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "claim_token": {
+          "name": "claim_token",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sort_key": {
+          "name": "sort_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "queued_thread_messages_thread_created_idx": {
+          "name": "queued_thread_messages_thread_created_idx",
+          "columns": [
+            "thread_id",
+            "created_at",
+            "id"
+          ],
+          "isUnique": false
+        },
+        "queued_thread_messages_thread_sort_idx": {
+          "name": "queued_thread_messages_thread_sort_idx",
+          "columns": [
+            "thread_id",
+            "sort_key",
+            "id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "queued_thread_messages_thread_id_threads_id_fk": {
+          "name": "queued_thread_messages_thread_id_threads_id_fk",
+          "tableFrom": "queued_thread_messages",
+          "tableTo": "threads",
+          "columnsFrom": [
+            "thread_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "system_experiments": {
+      "name": "system_experiments",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "terminal_sessions": {
+      "name": "terminal_sessions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "thread_id": {
+          "name": "thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "environment_id": {
+          "name": "environment_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "host_id": {
+          "name": "host_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "daemon_session_id": {
+          "name": "daemon_session_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "initial_cwd": {
+          "name": "initial_cwd",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "cols": {
+          "name": "cols",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "rows": {
+          "name": "rows",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "exit_code": {
+          "name": "exit_code",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "close_reason": {
+          "name": "close_reason",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_user_input_at": {
+          "name": "last_user_input_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "terminal_sessions_thread_status_updated_idx": {
+          "name": "terminal_sessions_thread_status_updated_idx",
+          "columns": [
+            "thread_id",
+            "status",
+            "updated_at"
+          ],
+          "isUnique": false
+        },
+        "terminal_sessions_environment_status_idx": {
+          "name": "terminal_sessions_environment_status_idx",
+          "columns": [
+            "environment_id",
+            "status"
+          ],
+          "isUnique": false
+        },
+        "terminal_sessions_host_status_idx": {
+          "name": "terminal_sessions_host_status_idx",
+          "columns": [
+            "host_id",
+            "status"
+          ],
+          "isUnique": false
+        },
+        "terminal_sessions_daemon_session_idx": {
+          "name": "terminal_sessions_daemon_session_idx",
+          "columns": [
+            "daemon_session_id"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "terminal_sessions_thread_id_threads_id_fk": {
+          "name": "terminal_sessions_thread_id_threads_id_fk",
+          "tableFrom": "terminal_sessions",
+          "tableTo": "threads",
+          "columnsFrom": [
+            "thread_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "terminal_sessions_environment_id_environments_id_fk": {
+          "name": "terminal_sessions_environment_id_environments_id_fk",
+          "tableFrom": "terminal_sessions",
+          "tableTo": "environments",
+          "columnsFrom": [
+            "environment_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "terminal_sessions_host_id_hosts_id_fk": {
+          "name": "terminal_sessions_host_id_hosts_id_fk",
+          "tableFrom": "terminal_sessions",
+          "tableTo": "hosts",
+          "columnsFrom": [
+            "host_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "terminal_sessions_daemon_session_id_host_daemon_sessions_id_fk": {
+          "name": "terminal_sessions_daemon_session_id_host_daemon_sessions_id_fk",
+          "tableFrom": "terminal_sessions",
+          "tableTo": "host_daemon_sessions",
+          "columnsFrom": [
+            "daemon_session_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "thread_dynamic_context_file_states": {
+      "name": "thread_dynamic_context_file_states",
+      "columns": {
+        "thread_id": {
+          "name": "thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "file_key": {
+          "name": "file_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "content_status": {
+          "name": "content_status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "content_hash": {
+          "name": "content_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "shown_at": {
+          "name": "shown_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "thread_dynamic_context_file_states_thread_file_idx": {
+          "name": "thread_dynamic_context_file_states_thread_file_idx",
+          "columns": [
+            "thread_id",
+            "file_key"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "thread_dynamic_context_file_states_thread_id_threads_id_fk": {
+          "name": "thread_dynamic_context_file_states_thread_id_threads_id_fk",
+          "tableFrom": "thread_dynamic_context_file_states",
+          "tableTo": "threads",
+          "columnsFrom": [
+            "thread_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "thread_search_segments": {
+      "name": "thread_search_segments",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "thread_id": {
+          "name": "thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_kind": {
+          "name": "source_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_key": {
+          "name": "source_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "source_seq": {
+          "name": "source_seq",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "text": {
+          "name": "text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "thread_search_segments_source_idx": {
+          "name": "thread_search_segments_source_idx",
+          "columns": [
+            "thread_id",
+            "source_kind",
+            "source_key"
+          ],
+          "isUnique": true
+        },
+        "thread_search_segments_thread_source_seq_idx": {
+          "name": "thread_search_segments_thread_source_seq_idx",
+          "columns": [
+            "thread_id",
+            "source_seq"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {
+        "thread_search_segments_thread_id_threads_id_fk": {
+          "name": "thread_search_segments_thread_id_threads_id_fk",
+          "tableFrom": "thread_search_segments",
+          "tableTo": "threads",
+          "columnsFrom": [
+            "thread_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "thread_sections": {
+      "name": "thread_sections",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "thread_sections_name_idx": {
+          "name": "thread_sections_name_idx",
+          "columns": [
+            "name"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "thread_tabs": {
+      "name": "thread_tabs",
+      "columns": {
+        "thread_id": {
+          "name": "thread_id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "tabs_json": {
+          "name": "tabs_json",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "revision": {
+          "name": "revision",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "thread_tabs_thread_id_threads_id_fk": {
+          "name": "thread_tabs_thread_id_threads_id_fk",
+          "tableFrom": "thread_tabs",
+          "tableTo": "threads",
+          "columnsFrom": [
+            "thread_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "threads": {
+      "name": "threads",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "project_id": {
+          "name": "project_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "environment_id": {
+          "name": "environment_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "provider_id": {
+          "name": "provider_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "model_override": {
+          "name": "model_override",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "reasoning_level_override": {
+          "name": "reasoning_level_override",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "title": {
+          "name": "title",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "title_fallback": {
+          "name": "title_fallback",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "section_id": {
+          "name": "section_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'starting'"
+        },
+        "parent_thread_id": {
+          "name": "parent_thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "source_thread_id": {
+          "name": "source_thread_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "origin_kind": {
+          "name": "origin_kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "origin_plugin_id": {
+          "name": "origin_plugin_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "visibility": {
+          "name": "visibility",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": "'visible'"
+        },
+        "archived_at": {
+          "name": "archived_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "pinned_at": {
+          "name": "pinned_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "pin_sort_key": {
+          "name": "pin_sort_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "deleted_at": {
+          "name": "deleted_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_read_at": {
+          "name": "last_read_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "latest_attention_at": {
+          "name": "latest_attention_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "threads_project_updated_idx": {
+          "name": "threads_project_updated_idx",
+          "columns": [
+            "project_id",
+            "updated_at"
+          ],
+          "isUnique": false
+        },
+        "threads_project_archived_deleted_idx": {
+          "name": "threads_project_archived_deleted_idx",
+          "columns": [
+            "project_id",
+            "archived_at",
+            "deleted_at",
+            "id"
+          ],
+          "isUnique": false
+        },
+        "threads_pin_sort_idx": {
+          "name": "threads_pin_sort_idx",
+          "columns": [
+            "archived_at",
+            "deleted_at",
+            "pin_sort_key",
+            "id"
+          ],
+          "isUnique": false,
+          "where": "\"threads\".\"pinned_at\" IS NOT NULL"
+        },
+        "threads_environment_idx": {
+          "name": "threads_environment_idx",
+          "columns": [
+            "environment_id"
+          ],
+          "isUnique": false
+        },
+        "threads_parent_idx": {
+          "name": "threads_parent_idx",
+          "columns": [
+            "parent_thread_id"
+          ],
+          "isUnique": false
+        },
+        "threads_source_origin_idx": {
+          "name": "threads_source_origin_idx",
+          "columns": [
+            "source_thread_id",
+            "origin_kind"
+          ],
+          "isUnique": false
+        },
+        "threads_origin_plugin_archived_idx": {
+          "name": "threads_origin_plugin_archived_idx",
+          "columns": [
+            "origin_plugin_id",
+            "archived_at"
+          ],
+          "isUnique": false
+        },
+        "threads_section_archived_deleted_idx": {
+          "name": "threads_section_archived_deleted_idx",
+          "columns": [
+            "section_id",
+            "archived_at",
+            "deleted_at",
+            "id"
+          ],
+          "isUnique": false
+        },
+        "threads_archived_status_idx": {
+          "name": "threads_archived_status_idx",
+          "columns": [
+            "archived_at",
+            "status"
+          ],
+          "isUnique": false
+        },
+        "threads_environment_archived_deleted_idx": {
+          "name": "threads_environment_archived_deleted_idx",
+          "columns": [
+            "environment_id",
+            "archived_at",
+            "deleted_at"
+          ],
+          "isUnique": false
+        },
+        "threads_active_maintenance_idx": {
+          "name": "threads_active_maintenance_idx",
+          "columns": [
+            "status"
+          ],
+          "isUnique": false,
+          "where": "\"threads\".\"deleted_at\" IS NULL"
+        }
+      },
+      "foreignKeys": {
+        "threads_project_id_projects_id_fk": {
+          "name": "threads_project_id_projects_id_fk",
+          "tableFrom": "threads",
+          "tableTo": "projects",
+          "columnsFrom": [
+            "project_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "cascade",
+          "onUpdate": "no action"
+        },
+        "threads_environment_id_environments_id_fk": {
+          "name": "threads_environment_id_environments_id_fk",
+          "tableFrom": "threads",
+          "tableTo": "environments",
+          "columnsFrom": [
+            "environment_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "threads_section_id_thread_sections_id_fk": {
+          "name": "threads_section_id_thread_sections_id_fk",
+          "tableFrom": "threads",
+          "tableTo": "thread_sections",
+          "columnsFrom": [
+            "section_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "threads_parent_thread_id_threads_id_fk": {
+          "name": "threads_parent_thread_id_threads_id_fk",
+          "tableFrom": "threads",
+          "tableTo": "threads",
+          "columnsFrom": [
+            "parent_thread_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        },
+        "threads_source_thread_id_threads_id_fk": {
+          "name": "threads_source_thread_id_threads_id_fk",
+          "tableFrom": "threads",
+          "tableTo": "threads",
+          "columnsFrom": [
+            "source_thread_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "set null",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}
\ No newline at end of file
diff --git a/packages/db/drizzle/meta/_journal.json b/packages/db/drizzle/meta/_journal.json
index 737f48e3d3..6906c8b1c2 100644
--- a/packages/db/drizzle/meta/_journal.json
+++ b/packages/db/drizzle/meta/_journal.json
@@ -729,6 +729,13 @@
       "when": 1787181956957,
       "tag": "0103_wandering_mongoose",
       "breakpoints": true
+    },
+    {
+      "idx": 104,
+      "version": "6",
+      "when": 1787184676789,
+      "tag": "0104_push_subscriptions",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file
diff --git a/packages/db/src/data/index.ts b/packages/db/src/data/index.ts
index 6e599d7185..ae5c1b97f8 100644
--- a/packages/db/src/data/index.ts
+++ b/packages/db/src/data/index.ts
@@ -591,3 +591,17 @@ export type {
   DropDeferredLegacyTablesResult,
   RunIncrementalVacuumArgs,
 } from "./maintenance.js";
+
+export {
+  deletePushSubscription,
+  deletePushSubscriptionByToken,
+  getPushSubscription,
+  getPushSubscriptionByToken,
+  listPushSubscriptions,
+  upsertPushSubscription,
+} from "./push-subscriptions.js";
+export type {
+  PushSubscriptionRow,
+  UpsertPushSubscriptionInput,
+  UpsertPushSubscriptionResult,
+} from "./push-subscriptions.js";
diff --git a/packages/db/src/data/push-subscriptions.ts b/packages/db/src/data/push-subscriptions.ts
new file mode 100644
index 0000000000..fd1aa3ff4b
--- /dev/null
+++ b/packages/db/src/data/push-subscriptions.ts
@@ -0,0 +1,124 @@
+import { asc, eq } from "drizzle-orm";
+import type { PushSubscription, PushSubscriptionPlatform } from "@bb/domain";
+import type { DbConnection, DbQueryConnection } from "../connection.js";
+import { createPushSubscriptionId } from "../ids.js";
+import { pushSubscriptions } from "../schema.js";
+
+export type PushSubscriptionRow = PushSubscription;
+
+export interface UpsertPushSubscriptionInput {
+  expoPushToken: string;
+  platform: PushSubscriptionPlatform;
+  deviceLabel: string;
+}
+
+export type UpsertPushSubscriptionResult =
+  | { outcome: "created"; subscription: PushSubscriptionRow }
+  | { outcome: "updated"; subscription: PushSubscriptionRow };
+
+/** Every registered device, oldest first, for listings and push fan-out. */
+export function listPushSubscriptions(
+  db: DbQueryConnection,
+): PushSubscriptionRow[] {
+  return db
+    .select()
+    .from(pushSubscriptions)
+    .orderBy(asc(pushSubscriptions.createdAt), asc(pushSubscriptions.id))
+    .all();
+}
+
+export function getPushSubscription(
+  db: DbQueryConnection,
+  id: string,
+): PushSubscriptionRow | null {
+  return (
+    db
+      .select()
+      .from(pushSubscriptions)
+      .where(eq(pushSubscriptions.id, id))
+      .get() ?? null
+  );
+}
+
+export function getPushSubscriptionByToken(
+  db: DbQueryConnection,
+  expoPushToken: string,
+): PushSubscriptionRow | null {
+  return (
+    db
+      .select()
+      .from(pushSubscriptions)
+      .where(eq(pushSubscriptions.expoPushToken, expoPushToken))
+      .get() ?? null
+  );
+}
+
+/**
+ * Register a device token, or refresh the existing row for that token: the
+ * label and `lastSeenAt` move, the id and `createdAt` stay stable so clients
+ * can keep the id they were first handed.
+ */
+export function upsertPushSubscription(
+  db: DbConnection,
+  input: UpsertPushSubscriptionInput,
+): UpsertPushSubscriptionResult {
+  const now = Date.now();
+  return db.transaction((tx) => {
+    const existing = tx
+      .select()
+      .from(pushSubscriptions)
+      .where(eq(pushSubscriptions.expoPushToken, input.expoPushToken))
+      .get();
+    if (existing) {
+      const subscription = tx
+        .update(pushSubscriptions)
+        .set({
+          deviceLabel: input.deviceLabel,
+          platform: input.platform,
+          lastSeenAt: Math.max(now, existing.lastSeenAt),
+        })
+        .where(eq(pushSubscriptions.id, existing.id))
+        .returning()
+        .get();
+      return { outcome: "updated", subscription: subscription ?? existing };
+    }
+    const subscription = tx
+      .insert(pushSubscriptions)
+      .values({
+        id: createPushSubscriptionId(),
+        expoPushToken: input.expoPushToken,
+        platform: input.platform,
+        deviceLabel: input.deviceLabel,
+        createdAt: now,
+        lastSeenAt: now,
+      })
+      .returning()
+      .get();
+    return { outcome: "created", subscription };
+  });
+}
+
+/** Returns true when a row was removed. */
+export function deletePushSubscription(db: DbConnection, id: string): boolean {
+  return (
+    db
+      .delete(pushSubscriptions)
+      .where(eq(pushSubscriptions.id, id))
+      .returning({ id: pushSubscriptions.id })
+      .get() !== undefined
+  );
+}
+
+/** Returns true when a row was removed. */
+export function deletePushSubscriptionByToken(
+  db: DbConnection,
+  expoPushToken: string,
+): boolean {
+  return (
+    db
+      .delete(pushSubscriptions)
+      .where(eq(pushSubscriptions.expoPushToken, expoPushToken))
+      .returning({ id: pushSubscriptions.id })
+      .get() !== undefined
+  );
+}
diff --git a/packages/db/src/ids.ts b/packages/db/src/ids.ts
index 19fa7f8036..08a4b2f55d 100644
--- a/packages/db/src/ids.ts
+++ b/packages/db/src/ids.ts
@@ -69,3 +69,7 @@ export function createHostDaemonSessionId(): string {
 export function createTerminalSessionId(): string {
   return createId("term");
 }
+
+export function createPushSubscriptionId(): string {
+  return createId("push");
+}
diff --git a/packages/db/src/index.ts b/packages/db/src/index.ts
index 842f908f0a..95f92a10f2 100644
--- a/packages/db/src/index.ts
+++ b/packages/db/src/index.ts
@@ -22,6 +22,7 @@ export {
   createProjectId,
   createPromptHistoryEntryId,
   createProjectSourceId,
+  createPushSubscriptionId,
   createTerminalSessionId,
   createThreadId,
   createThreadProvisioningId,
diff --git a/packages/db/src/schema.ts b/packages/db/src/schema.ts
index 5d31ad2a17..d8d5913e06 100644
--- a/packages/db/src/schema.ts
+++ b/packages/db/src/schema.ts
@@ -21,6 +21,7 @@ import type {
   PermissionMode,
   PromptHistoryScope,
   ProjectSourceType,
+  PushSubscriptionPlatform,
   ReasoningLevel,
   ServiceTier,
   TerminalSessionCloseReason,
@@ -1038,3 +1039,24 @@ export const pendingInteractions = sqliteTable(
     ),
   ],
 );
+
+// Expo push tokens registered by bb mobile devices. One row per token: a
+// device that registers again refreshes its label and `last_seen_at` instead
+// of adding a row, so the push sender never double-delivers to one phone. The
+// server deletes a row when Expo reports the token as `DeviceNotRegistered`.
+export const pushSubscriptions = sqliteTable(
+  "push_subscriptions",
+  {
+    id: text("id").primaryKey(),
+    expoPushToken: text("expo_push_token").notNull(),
+    platform: text("platform").$type<PushSubscriptionPlatform>().notNull(),
+    deviceLabel: text("device_label").notNull(),
+    createdAt: integer("created_at").notNull(),
+    lastSeenAt: integer("last_seen_at").notNull(),
+  },
+  (table) => [
+    uniqueIndex("push_subscriptions_expo_push_token_idx").on(
+      table.expoPushToken,
+    ),
+  ],
+);
diff --git a/packages/db/test/data/push-subscriptions.test.ts b/packages/db/test/data/push-subscriptions.test.ts
new file mode 100644
index 0000000000..56413305a3
--- /dev/null
+++ b/packages/db/test/data/push-subscriptions.test.ts
@@ -0,0 +1,110 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  createConnection,
+  deletePushSubscription,
+  deletePushSubscriptionByToken,
+  getPushSubscription,
+  getPushSubscriptionByToken,
+  listPushSubscriptions,
+  migrate,
+  upsertPushSubscription,
+  type DbConnection,
+} from "../../src/index.js";
+
+describe("push subscriptions data", () => {
+  let db: DbConnection;
+
+  beforeEach(() => {
+    db = createConnection(":memory:");
+    migrate(db);
+  });
+
+  afterEach(() => {
+    db.$client.close();
+    vi.useRealTimers();
+  });
+
+  it("re-registering a token refreshes the row instead of adding one", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(1_000);
+    const created = upsertPushSubscription(db, {
+      expoPushToken: "ExponentPushToken[abc]",
+      platform: "ios",
+      deviceLabel: "Sawyer's iPhone",
+    });
+    expect(created.outcome).toBe("created");
+    expect(created.subscription).toMatchObject({
+      expoPushToken: "ExponentPushToken[abc]",
+      platform: "ios",
+      deviceLabel: "Sawyer's iPhone",
+      createdAt: 1_000,
+      lastSeenAt: 1_000,
+    });
+    expect(created.subscription.id).toMatch(/^push_/);
+
+    vi.setSystemTime(5_000);
+    const updated = upsertPushSubscription(db, {
+      expoPushToken: "ExponentPushToken[abc]",
+      platform: "ios",
+      deviceLabel: "iPhone 17",
+    });
+    expect(updated.outcome).toBe("updated");
+    expect(updated.subscription).toEqual({
+      ...created.subscription,
+      deviceLabel: "iPhone 17",
+      lastSeenAt: 5_000,
+    });
+    expect(listPushSubscriptions(db)).toEqual([updated.subscription]);
+  });
+
+  it("lists oldest first and looks up by id or token", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(10);
+    const first = upsertPushSubscription(db, {
+      expoPushToken: "ExponentPushToken[first]",
+      platform: "android",
+      deviceLabel: "Pixel",
+    }).subscription;
+    vi.setSystemTime(20);
+    const second = upsertPushSubscription(db, {
+      expoPushToken: "ExponentPushToken[second]",
+      platform: "ios",
+      deviceLabel: "iPhone",
+    }).subscription;
+
+    expect(listPushSubscriptions(db).map((row) => row.id)).toEqual([
+      first.id,
+      second.id,
+    ]);
+    expect(getPushSubscription(db, second.id)).toEqual(second);
+    expect(getPushSubscription(db, "push_missing")).toBeNull();
+    expect(
+      getPushSubscriptionByToken(db, "ExponentPushToken[first]"),
+    ).toEqual(first);
+    expect(getPushSubscriptionByToken(db, "ExponentPushToken[nope]")).toBeNull();
+  });
+
+  it("deletes by id or token and reports whether a row existed", () => {
+    const row = upsertPushSubscription(db, {
+      expoPushToken: "ExponentPushToken[abc]",
+      platform: "ios",
+      deviceLabel: "iPhone",
+    }).subscription;
+    const other = upsertPushSubscription(db, {
+      expoPushToken: "ExponentPushToken[def]",
+      platform: "ios",
+      deviceLabel: "iPad",
+    }).subscription;
+
+    expect(deletePushSubscription(db, row.id)).toBe(true);
+    expect(deletePushSubscription(db, row.id)).toBe(false);
+    expect(deletePushSubscriptionByToken(db, "ExponentPushToken[def]")).toBe(
+      true,
+    );
+    expect(deletePushSubscriptionByToken(db, "ExponentPushToken[def]")).toBe(
+      false,
+    );
+    expect(listPushSubscriptions(db)).toEqual([]);
+    expect(getPushSubscription(db, other.id)).toBeNull();
+  });
+});
diff --git a/packages/db/test/migrate.test.ts b/packages/db/test/migrate.test.ts
index 57aa4d4609..9aaaede397 100644
--- a/packages/db/test/migrate.test.ts
+++ b/packages/db/test/migrate.test.ts
@@ -298,7 +298,8 @@ function dropRewindAddedTables(db: DbConnection): void {
   // of that rewind so the forward re-migrate can re-create them: the automations
   // tables (added by 0039/0041), app_theme (added by 0042), the thread section
   // schema (thread section columns + thread_sections table), thread tabs, and
-  // normalized plugin persistence tables.
+  // normalized plugin persistence tables, and push subscriptions (0104).
+  dropPushSubscriptionsTable(db);
   db.$client.prepare("DROP TABLE IF EXISTS thread_tabs").run();
   db.$client.prepare("DROP TABLE IF EXISTS automation_runs").run();
   db.$client.prepare("DROP TABLE IF EXISTS automations").run();
@@ -680,6 +681,15 @@ function dropMarketplaceCatalogSchema(db: DbConnection): void {
   }
 }
 
+/**
+ * Migration 0104 adds the push_subscriptions table. Every rewind that clears
+ * journal rows at or before it must drop the table too, or migrate() replays
+ * the CREATE against a DB that already has it.
+ */
+function dropPushSubscriptionsTable(db: DbConnection): void {
+  db.$client.prepare("DROP TABLE IF EXISTS push_subscriptions").run();
+}
+
 function dropEventParentToolCallIdColumn(db: DbConnection): void {
   const columns = db.$client
     .prepare<[], TableInfoRow>("PRAGMA table_info(events)")
@@ -787,6 +797,7 @@ function dropQueuedMessageSenderThreadIdColumn(db: DbConnection): void {
 /** Tables created by migrations after 0023, dropped so migrate() re-applies. */
 function dropPost0023Tables(db: DbConnection): void {
   dropEventParentToolCallIdColumn(db);
+  dropPushSubscriptionsTable(db);
   dropEnvironmentRetireRequestedAtColumn(db);
   dropPluginArtifactGitCheckoutRootColumn(db);
   dropProjectGitRemoteUrlColumn(db);
@@ -1696,6 +1707,7 @@ describe("migrate", () => {
     dropEnvironmentRetireRequestedAtColumn(db);
     dropPluginArtifactGitCheckoutRootColumn(db);
     dropMarketplaceCatalogSchema(db);
+    dropPushSubscriptionsTable(db);
     dropEventParentToolCallIdColumn(db);
     // Delete by the journal timestamp, not a hash substring: migration hashes
     // are hex and can contain "0085" by coincidence.
@@ -1991,6 +2003,7 @@ describe("migrate", () => {
       dropEnvironmentRetireRequestedAtColumn(db);
       dropPluginArtifactGitCheckoutRootColumn(db);
       dropMarketplaceCatalogSchema(db);
+      dropPushSubscriptionsTable(db);
       dropEventParentToolCallIdColumn(db);
 
       restoreLegacyThreadOriginColumn(db);
@@ -2395,6 +2408,7 @@ describe("migrate", () => {
       dropEnvironmentRetireRequestedAtColumn(db);
       dropPluginArtifactGitCheckoutRootColumn(db);
       dropMarketplaceCatalogSchema(db);
+      dropPushSubscriptionsTable(db);
       dropEventParentToolCallIdColumn(db);
 
       restoreLegacyThreadOriginColumn(db);
@@ -2496,6 +2510,7 @@ describe("migrate", () => {
       dropEnvironmentRetireRequestedAtColumn(db);
       dropPluginArtifactGitCheckoutRootColumn(db);
       dropMarketplaceCatalogSchema(db);
+      dropPushSubscriptionsTable(db);
       dropEventParentToolCallIdColumn(db);
 
       restoreLegacyThreadOriginColumn(db);
@@ -5085,6 +5100,7 @@ describe("migrate", () => {
       });
 
       dropEventParentToolCallIdColumn(db);
+      dropPushSubscriptionsTable(db);
       db.$client
         .prepare<DeleteMigrationParameters>(
           "DELETE FROM __drizzle_migrations WHERE created_at >= ?",
diff --git a/packages/domain/src/index.ts b/packages/domain/src/index.ts
index fd32fbcf1e..7b5f65ad7a 100644
--- a/packages/domain/src/index.ts
+++ b/packages/domain/src/index.ts
@@ -35,6 +35,7 @@ export * from "./provider-event.js";
 export * from "./provider-fork.js";
 export * from "./provider-model-catalog.js";
 export * from "./provider-types.js";
+export * from "./push-subscription.js";
 export * from "./raw-thread-id.js";
 export * from "./reasoning-efforts.js";
 export * from "./reasoning-level.js";
diff --git a/packages/domain/src/push-subscription.ts b/packages/domain/src/push-subscription.ts
new file mode 100644
index 0000000000..2d81cffe62
--- /dev/null
+++ b/packages/domain/src/push-subscription.ts
@@ -0,0 +1,52 @@
+import { z } from "zod";
+
+/**
+ * Expo push tokens registered by bb mobile devices. The server keeps one row
+ * per token and fans every push-worthy thread change out to all of them; the
+ * APNs/FCM credentials live in the EAS project, never in bb.
+ */
+export const pushSubscriptionPlatformValues = ["ios", "android"] as const;
+export const pushSubscriptionPlatformSchema = z.enum(
+  pushSubscriptionPlatformValues,
+);
+export type PushSubscriptionPlatform = z.infer<
+  typeof pushSubscriptionPlatformSchema
+>;
+
+export const pushSubscriptionSchema = z
+  .object({
+    id: z.string().min(1),
+    expoPushToken: z.string().min(1),
+    platform: pushSubscriptionPlatformSchema,
+    deviceLabel: z.string(),
+    createdAt: z.number().int().nonnegative(),
+    /** Last time the device (re-)registered this token. */
+    lastSeenAt: z.number().int().nonnegative(),
+  })
+  .strict();
+export type PushSubscription = z.infer<typeof pushSubscriptionSchema>;
+
+/**
+ * Why a push was sent. `pending-interaction` is a new approval/question the
+ * agent is blocked on, `turn-finished` a root thread that stopped and wants
+ * input, `thread-error` a run that failed.
+ */
+export const pushNotificationKindValues = [
+  "pending-interaction",
+  "turn-finished",
+  "thread-error",
+] as const;
+export const pushNotificationKindSchema = z.enum(pushNotificationKindValues);
+export type PushNotificationKind = z.infer<typeof pushNotificationKindSchema>;
+
+/**
+ * The `data` payload of every bb push message. Clients route a tap to the
+ * thread with it; parse leniently (`pushNotificationDataSchema.safeParse`)
+ * because an older app can receive a newer server's payload.
+ */
+export const pushNotificationDataSchema = z.object({
+  kind: pushNotificationKindSchema,
+  projectId: z.string().min(1),
+  threadId: z.string().min(1),
+});
+export type PushNotificationData = z.infer<typeof pushNotificationDataSchema>;
diff --git a/packages/sdk/src/areas/notifications.ts b/packages/sdk/src/areas/notifications.ts
new file mode 100644
index 0000000000..d31cfc8bb9
--- /dev/null
+++ b/packages/sdk/src/areas/notifications.ts
@@ -0,0 +1,78 @@
+import type {
+  DeletePushSubscriptionResponse,
+  PushSubscription,
+  RegisterPushSubscriptionRequest,
+} from "@bb/server-contract";
+import {
+  deletePushSubscriptionResponseSchema,
+  pushSubscriptionListResponseSchema,
+  pushSubscriptionSchema,
+} from "@bb/server-contract";
+import { signalRequestArgs, type CreateSdkAreaArgs } from "./common.js";
+
+export interface PushSubscriptionListArgs {
+  signal?: AbortSignal;
+}
+export type PushSubscriptionListResult = PushSubscription[];
+
+/** Every field is required: the device reports its own platform and name. */
+export type PushSubscriptionAddArgs = RegisterPushSubscriptionRequest;
+export interface PushSubscriptionAddResult {
+  /** `true` when the token was new, `false` when an existing row was refreshed. */
+  created: boolean;
+  subscription: PushSubscription;
+}
+
+export interface PushSubscriptionRemoveArgs {
+  id: string;
+}
+export type PushSubscriptionRemoveResult = DeletePushSubscriptionResponse;
+
+export interface PushSubscriptionsArea {
+  /** Register an Expo push token, or refresh the registration for a known one. */
+  add(args: PushSubscriptionAddArgs): Promise<PushSubscriptionAddResult>;
+  list(args?: PushSubscriptionListArgs): Promise<PushSubscriptionListResult>;
+  remove(
+    args: PushSubscriptionRemoveArgs,
+  ): Promise<PushSubscriptionRemoveResult>;
+}
+
+export interface NotificationsArea {
+  /** Devices the server pushes thread updates to through the Expo Push API. */
+  pushSubscriptions: PushSubscriptionsArea;
+}
+
+export function createNotificationsArea(
+  args: CreateSdkAreaArgs,
+): NotificationsArea {
+  const { transport } = args;
+  // Resolve lazily, like every other area: the CLI test harness builds the SDK
+  // over a partial hono client, and an eager dereference here would throw for
+  // every command that never touches notifications.
+  const endpoint = () => transport.api.v1.notifications["push-subscriptions"];
+  const pushSubscriptions: PushSubscriptionsArea = {
+    async add(input) {
+      const response = await transport.resolve(
+        endpoint().$post({ json: input }),
+      );
+      const body: unknown = await response.json();
+      return {
+        created: response.status === 201,
+        subscription: pushSubscriptionSchema.parse(body),
+      };
+    },
+    async list(input) {
+      const body = await transport.readJson(
+        endpoint().$get({}, ...signalRequestArgs(input?.signal)),
+      );
+      return pushSubscriptionListResponseSchema.parse(body).subscriptions;
+    },
+    async remove(input) {
+      const body = await transport.readJson(
+        endpoint()[":id"].$delete({ param: { id: input.id } }),
+      );
+      return deletePushSubscriptionResponseSchema.parse(body);
+    },
+  };
+  return { pushSubscriptions };
+}
diff --git a/packages/sdk/src/core.ts b/packages/sdk/src/core.ts
index 4e79fcefa1..b043822d84 100644
--- a/packages/sdk/src/core.ts
+++ b/packages/sdk/src/core.ts
@@ -6,6 +6,10 @@ import {
 import { createFilesArea, type FilesArea } from "./areas/files.js";
 import type { GuideArea } from "./areas/guide.js";
 import { createHostsArea, type HostsArea } from "./areas/hosts.js";
+import {
+  createNotificationsArea,
+  type NotificationsArea,
+} from "./areas/notifications.js";
 import { createProjectsArea, type ProjectsArea } from "./areas/projects.js";
 import { createProvidersArea, type ProvidersArea } from "./areas/providers.js";
 import { createPluginsArea, type PluginsArea } from "./areas/plugins.js";
@@ -42,6 +46,7 @@ export interface BbSdkAreas extends BbRealtime {
   environments: EnvironmentsArea;
   files: FilesArea;
   hosts: HostsArea;
+  notifications: NotificationsArea;
   projects: ProjectsArea;
   plugins: PluginsArea;
   providers: ProvidersArea;
@@ -72,6 +77,7 @@ export function createBbSdk(
     environments: createEnvironmentsArea(sdkContext),
     files: createFilesArea(sdkContext),
     hosts: createHostsArea(sdkContext),
+    notifications: createNotificationsArea(sdkContext),
     subscribe(args) {
       return realtime.subscribe(args);
     },
diff --git a/packages/sdk/src/public-types.ts b/packages/sdk/src/public-types.ts
index 3eb352b9d8..b2e7af0898 100644
--- a/packages/sdk/src/public-types.ts
+++ b/packages/sdk/src/public-types.ts
@@ -8,6 +8,10 @@ export type {
   PermissionMode,
   PromptInput,
   PromptTextMention,
+  PushNotificationData,
+  PushNotificationKind,
+  PushSubscription,
+  PushSubscriptionPlatform,
   ReasoningLevel,
   ServiceTier,
   ThreadStatus,
@@ -26,6 +30,7 @@ export type * from "./areas/environments.js";
 export type * from "./areas/files.js";
 export type * from "./areas/guide.js";
 export type * from "./areas/hosts.js";
+export type * from "./areas/notifications.js";
 export type * from "./areas/plugins.js";
 export type * from "./areas/projects.js";
 export type * from "./areas/providers.js";
diff --git a/packages/sdk/test/public-types.test.ts b/packages/sdk/test/public-types.test.ts
index cd1ee49cca..5ae9bf5d12 100644
--- a/packages/sdk/test/public-types.test.ts
+++ b/packages/sdk/test/public-types.test.ts
@@ -16,6 +16,7 @@ import type {
   ProjectFileContentResult as RootProjectFileContent,
   ProjectGetResult as RootProjectGet,
   ProjectWorkspaceRoutingArgs as RootProjectWorkspaceRoutingArgs,
+  PushSubscriptionAddResult as RootPushSubscriptionAddResult,
   ProviderListArgs as RootProviderListArgs,
   ProviderListResult as RootProviderList,
   ProviderModelsArgs as RootProviderModelsArgs,
@@ -44,6 +45,7 @@ import type {
   ProjectFileContentResult as BrowserProjectFileContent,
   ProjectGetResult as BrowserProjectGet,
   ProjectWorkspaceRoutingArgs as BrowserProjectWorkspaceRoutingArgs,
+  PushSubscriptionAddResult as BrowserPushSubscriptionAddResult,
   ProviderListArgs as BrowserProviderListArgs,
   ProviderListResult as BrowserProviderList,
   ProviderModelsArgs as BrowserProviderModelsArgs,
@@ -71,6 +73,7 @@ import type {
   ProjectFileContentResult as CoreProjectFileContent,
   ProjectGetResult as CoreProjectGet,
   ProjectWorkspaceRoutingArgs as CoreProjectWorkspaceRoutingArgs,
+  PushSubscriptionAddResult as CorePushSubscriptionAddResult,
   ProviderListArgs as CoreProviderListArgs,
   ProviderListResult as CoreProviderList,
   ProviderModelsArgs as CoreProviderModelsArgs,
@@ -98,6 +101,7 @@ import type {
   ProjectFileContentResult as NodeProjectFileContent,
   ProjectGetResult as NodeProjectGet,
   ProjectWorkspaceRoutingArgs as NodeProjectWorkspaceRoutingArgs,
+  PushSubscriptionAddResult as NodePushSubscriptionAddResult,
   ProviderListArgs as NodeProviderListArgs,
   ProviderListResult as NodeProviderList,
   ProviderModelsArgs as NodeProviderModelsArgs,
@@ -125,6 +129,7 @@ interface RootSurface {
   projectFileContent: RootProjectFileContent;
   projectGet: RootProjectGet;
   projectWorkspaceRoutingArgs: RootProjectWorkspaceRoutingArgs;
+  pushSubscriptionAdd: RootPushSubscriptionAddResult;
   providerList: RootProviderList;
   providerListArgs: RootProviderListArgs;
   providerModelsArgs: RootProviderModelsArgs;
@@ -152,6 +157,7 @@ interface BrowserSurface {
   projectFileContent: BrowserProjectFileContent;
   projectGet: BrowserProjectGet;
   projectWorkspaceRoutingArgs: BrowserProjectWorkspaceRoutingArgs;
+  pushSubscriptionAdd: BrowserPushSubscriptionAddResult;
   providerList: BrowserProviderList;
   providerListArgs: BrowserProviderListArgs;
   providerModelsArgs: BrowserProviderModelsArgs;
@@ -179,6 +185,7 @@ interface CoreSurface {
   projectFileContent: CoreProjectFileContent;
   projectGet: CoreProjectGet;
   projectWorkspaceRoutingArgs: CoreProjectWorkspaceRoutingArgs;
+  pushSubscriptionAdd: CorePushSubscriptionAddResult;
   providerList: CoreProviderList;
   providerListArgs: CoreProviderListArgs;
   providerModelsArgs: CoreProviderModelsArgs;
@@ -206,6 +213,7 @@ interface NodeSurface {
   projectFileContent: NodeProjectFileContent;
   projectGet: NodeProjectGet;
   projectWorkspaceRoutingArgs: NodeProjectWorkspaceRoutingArgs;
+  pushSubscriptionAdd: NodePushSubscriptionAddResult;
   providerList: NodeProviderList;
   providerListArgs: NodeProviderListArgs;
   providerModelsArgs: NodeProviderModelsArgs;
@@ -225,6 +233,7 @@ type ExpectedBbSdkKey =
   | "files"
   | "guide"
   | "hosts"
+  | "notifications"
   | "plugins"
   | "projects"
   | "providers"
@@ -269,6 +278,9 @@ type ExpectedFilesKey =
 
 type ExpectedGuideKey = "render";
 
+type ExpectedNotificationsKey = "pushSubscriptions";
+type ExpectedPushSubscriptionsKey = "add" | "list" | "remove";
+
 type ExpectedHostsKey =
   | "cloneDefaultPath"
   | "createJoinCode"
@@ -503,6 +515,12 @@ describe("SDK public type entrypoints", () => {
     expectTypeOf<keyof RootBbSdk["files"]>().toEqualTypeOf<ExpectedFilesKey>();
     expectTypeOf<keyof RootBbSdk["guide"]>().toEqualTypeOf<ExpectedGuideKey>();
     expectTypeOf<keyof RootBbSdk["hosts"]>().toEqualTypeOf<ExpectedHostsKey>();
+    expectTypeOf<
+      keyof RootBbSdk["notifications"]
+    >().toEqualTypeOf<ExpectedNotificationsKey>();
+    expectTypeOf<
+      keyof RootBbSdk["notifications"]["pushSubscriptions"]
+    >().toEqualTypeOf<ExpectedPushSubscriptionsKey>();
     expectTypeOf<
       keyof RootBbSdk["plugins"]
     >().toEqualTypeOf<ExpectedPluginsKey>();
diff --git a/packages/sdk/test/sdk.test.ts b/packages/sdk/test/sdk.test.ts
index ad85ccd291..6c47126104 100644
--- a/packages/sdk/test/sdk.test.ts
+++ b/packages/sdk/test/sdk.test.ts
@@ -1801,4 +1801,87 @@ describe("@bb/sdk", () => {
       },
     ]);
   });
+
+  it("manages push subscriptions through the notifications area", async () => {
+    const subscription = {
+      id: "push_123",
+      expoPushToken: "ExponentPushToken[abc]",
+      platform: "ios",
+      deviceLabel: "Phone",
+      createdAt: 1,
+      lastSeenAt: 2,
+    };
+    const queue = createFetchQueue([
+      { body: subscription, status: 201 },
+      { body: { ...subscription, lastSeenAt: 3 } },
+      { body: { subscriptions: [subscription] } },
+      { body: { ok: true } },
+      {
+        body: {
+          code: "push_subscription_not_found",
+          message: "Push subscription not found",
+        },
+        status: 404,
+      },
+    ]);
+    const sdk = createBbSdk({
+      transport: createHttpTransport({
+        baseUrl: "http://bb.test",
+        fetch: queue.fetch,
+        runtime: "node",
+      }),
+    });
+    const request = {
+      expoPushToken: "ExponentPushToken[abc]",
+      platform: "ios" as const,
+      deviceLabel: "Phone",
+    };
+
+    await expect(
+      sdk.notifications.pushSubscriptions.add(request),
+    ).resolves.toEqual({ created: true, subscription });
+    await expect(
+      sdk.notifications.pushSubscriptions.add(request),
+    ).resolves.toEqual({
+      created: false,
+      subscription: { ...subscription, lastSeenAt: 3 },
+    });
+    await expect(sdk.notifications.pushSubscriptions.list()).resolves.toEqual([
+      subscription,
+    ]);
+    await expect(
+      sdk.notifications.pushSubscriptions.remove({ id: "push_123" }),
+    ).resolves.toEqual({ ok: true });
+    await expect(
+      sdk.notifications.pushSubscriptions.remove({ id: "push_123" }),
+    ).rejects.toMatchObject({ status: 404 });
+
+    expect(queue.requests).toEqual([
+      {
+        bodyText: JSON.stringify(request),
+        method: "POST",
+        url: "http://bb.test/api/v1/notifications/push-subscriptions",
+      },
+      {
+        bodyText: JSON.stringify(request),
+        method: "POST",
+        url: "http://bb.test/api/v1/notifications/push-subscriptions",
+      },
+      {
+        bodyText: undefined,
+        method: "GET",
+        url: "http://bb.test/api/v1/notifications/push-subscriptions",
+      },
+      {
+        bodyText: undefined,
+        method: "DELETE",
+        url: "http://bb.test/api/v1/notifications/push-subscriptions/push_123",
+      },
+      {
+        bodyText: undefined,
+        method: "DELETE",
+        url: "http://bb.test/api/v1/notifications/push-subscriptions/push_123",
+      },
+    ]);
+  });
 });
diff --git a/packages/server-contract/src/api-types.ts b/packages/server-contract/src/api-types.ts
index e990d98654..518e998d9e 100644
--- a/packages/server-contract/src/api-types.ts
+++ b/packages/server-contract/src/api-types.ts
@@ -4,6 +4,7 @@ export * from "./api/skills.js";
 export * from "./api/environments.js";
 export * from "./api/files.js";
 export * from "./api/hosts.js";
+export * from "./api/notifications.js";
 export * from "./api/plugins.js";
 export * from "./api/system.js";
 export * from "./api/terminals.js";
diff --git a/packages/server-contract/src/api/notifications.ts b/packages/server-contract/src/api/notifications.ts
new file mode 100644
index 0000000000..dec941c4fc
--- /dev/null
+++ b/packages/server-contract/src/api/notifications.ts
@@ -0,0 +1,66 @@
+import { z } from "zod";
+import {
+  pushSubscriptionPlatformSchema,
+  pushSubscriptionSchema,
+} from "@bb/domain";
+
+export {
+  pushNotificationDataSchema,
+  pushNotificationKindSchema,
+  pushNotificationKindValues,
+  pushSubscriptionPlatformSchema,
+  pushSubscriptionPlatformValues,
+  pushSubscriptionSchema,
+} from "@bb/domain";
+export type {
+  PushNotificationData,
+  PushNotificationKind,
+  PushSubscription,
+  PushSubscriptionPlatform,
+} from "@bb/domain";
+
+// Expo tokens look like `ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]`; the cap
+// only bounds request size.
+export const EXPO_PUSH_TOKEN_MAX_LENGTH = 512;
+export const PUSH_SUBSCRIPTION_DEVICE_LABEL_MAX_LENGTH = 120;
+
+/**
+ * Registers a device for push, or refreshes its row when the token is already
+ * known (same id, new label and `lastSeenAt`). Every field is required: the
+ * device knows its own platform and name, and the server never guesses them.
+ */
+export const registerPushSubscriptionRequestSchema = z
+  .object({
+    expoPushToken: z.string().trim().min(1).max(EXPO_PUSH_TOKEN_MAX_LENGTH),
+    platform: pushSubscriptionPlatformSchema,
+    deviceLabel: z
+      .string()
+      .trim()
+      .min(1)
+      .max(PUSH_SUBSCRIPTION_DEVICE_LABEL_MAX_LENGTH),
+  })
+  .strict();
+export type RegisterPushSubscriptionRequest = z.infer<
+  typeof registerPushSubscriptionRequestSchema
+>;
+
+export const pushSubscriptionListResponseSchema = z
+  .object({
+    subscriptions: z.array(pushSubscriptionSchema),
+  })
+  .strict();
+export type PushSubscriptionListResponse = z.infer<
+  typeof pushSubscriptionListResponseSchema
+>;
+
+export const pushSubscriptionResponseSchema = pushSubscriptionSchema;
+export type PushSubscriptionResponse = z.infer<
+  typeof pushSubscriptionResponseSchema
+>;
+
+export const deletePushSubscriptionResponseSchema = z
+  .object({ ok: z.literal(true) })
+  .strict();
+export type DeletePushSubscriptionResponse = z.infer<
+  typeof deletePushSubscriptionResponseSchema
+>;
diff --git a/packages/server-contract/src/public-api.ts b/packages/server-contract/src/public-api.ts
index 648eb2c9a3..cf35fc3d84 100644
--- a/packages/server-contract/src/public-api.ts
+++ b/packages/server-contract/src/public-api.ts
@@ -218,6 +218,13 @@ import type {
   ThreadTabsResponse,
   UpdateThreadTabsRequest,
 } from "./api/thread-tabs.js";
+import type {
+  DeletePushSubscriptionResponse,
+  PushSubscriptionListResponse,
+  PushSubscriptionResponse,
+  RegisterPushSubscriptionRequest,
+} from "./api/notifications.js";
+import { registerPushSubscriptionRequestSchema } from "./api/notifications.js";
 import { updateThreadTabsRequestSchema } from "./api/thread-tabs.js";
 import {
   closeTerminalRequestSchema,
@@ -1315,6 +1322,35 @@ export const publicApiRoutes = {
     }),
   },
 
+  notifications: {
+    listPushSubscriptions: defineRoute({
+      path: "/notifications/push-subscriptions",
+      method: "get",
+      request: noRequest(),
+      response: jsonResponse<PushSubscriptionListResponse>(),
+    }),
+    // Upsert by token: 201 when the token is new, 200 when it was refreshed.
+    registerPushSubscription: defineRoute({
+      path: "/notifications/push-subscriptions",
+      method: "post",
+      request: jsonRequest<EmptyInput, RegisterPushSubscriptionRequest>(
+        registerPushSubscriptionRequestSchema,
+      ),
+      response: [
+        jsonResponse<PushSubscriptionResponse>({ status: 201 }),
+        jsonResponse<PushSubscriptionResponse>(),
+      ],
+    }),
+    deletePushSubscription: defineRoute({
+      path: "/notifications/push-subscriptions/:id",
+      method: "delete",
+      request: noRequest<PathId>(),
+      response: [
+        jsonResponse<DeletePushSubscriptionResponse>(),
+        jsonResponse<ApiError>({ status: 404 }),
+      ],
+    }),
+  },
   system: {
     attention: defineRoute({
       path: "/system/attention",
diff --git a/packages/templates/src/templates/bb-guide-customization.md b/packages/templates/src/templates/bb-guide-customization.md
index bcd8fa5d09..e6b5086f79 100644
--- a/packages/templates/src/templates/bb-guide-customization.md
+++ b/packages/templates/src/templates/bb-guide-customization.md
@@ -1,8 +1,8 @@
 ---
 kind: instruction
 title: bb Guide — Customization
-summary: Command reference for customizing the bb app color palette and keyboard shortcuts.
-intent: Explain the CLI theme surface and server-backed app customization.
+summary: Command reference for customizing the bb app color palette, keyboard shortcuts, and mobile push notifications.
+intent: Explain the CLI theme surface, server-backed app customization, and push-notification device registration.
 editingNotes: Keep flags accurate against the CLI implementation. Theme details live in the bb-cli skill's references/theming.md.
 ---
 Customization commands
@@ -144,6 +144,30 @@ same resolved bindings. The complete default table is in docs/configuration.md.
   bb settings keyboard set <command> <shortcut|disabled>
   bb settings keyboard reset [command]
 
+Mobile push notifications
+
+The server pushes thread updates to registered bb mobile devices through the
+Expo Push API: a new pending interaction (approval or question), a root thread
+whose turn finished and is waiting for you, and a run that failed. Each push
+carries the thread title plus a short preview (the question, the first line of
+the reply, or the error) and opens the thread when tapped. Pushes for one
+thread coalesce over a two-second window and are skipped when a client read
+the thread or answered the interaction in the meantime. The bb mobile app
+registers its Expo push token automatically after it connects; the commands
+below inspect and repair that registry.
+
+  bb notifications push-subscriptions list
+  bb notifications push-subscriptions add --token <expo-push-token>
+      --platform <ios|android> --label <device-name>
+  bb notifications push-subscriptions remove <id>
+
+`add` is an upsert by token: a known token refreshes its label and last-seen
+time and keeps its id. Expo tokens that are no longer registered are removed
+automatically after a failed delivery. `BB_PUSH_NOTIFICATIONS=false` (startup
+only) stops sending while keeping registrations; `BB_EXPO_PUSH_URL` points the
+sender at a stub for testing. Add --json to any of these commands for
+machine-readable output.
+
 Host files and voice transcription
 
   bb file read|write|list|paths|mkdir|move|remove ...
diff --git a/packages/templates/src/templates/bb-guide-overview.md b/packages/templates/src/templates/bb-guide-overview.md
index 3564c0449a..8053359f80 100644
--- a/packages/templates/src/templates/bb-guide-overview.md
+++ b/packages/templates/src/templates/bb-guide-overview.md
@@ -44,7 +44,8 @@ Run `bb guide <chapter>` for command details:
   projects             Project CRUD and sources
   machines             Listing and targeting execution machines
   terminals            Persistent PTY sessions across all supported scopes
-  customization        Theming the app palette
+  customization        Theming the app palette, settings, mobile push
+                       notifications
   plugins              Installing plugins, plugin marketplaces, and their
                        contributed bb commands
   automations          Scheduling and editing recurring or one-shot work
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 1f4877dc13..a71bff1596 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -18109,7 +18109,9 @@ snapshots:
       metro-runtime: 0.84.5
     transitivePeerDependencies:
       - '@babel/core'
+      - bufferutil
       - supports-color
+      - utf-8-validate
 
   '@react-native/normalize-colors@0.86.2': {}