@@ -163,6 +163,7 @@ jobs:
           test/features/onboarding/hosted_app_gate_environment_test.dart
           test/features/settings/builderlab_account_row_test.dart
           test/features/onboarding/hosted_journeys_test.dart
+          test/features/onboarding/hosted_backup_consent_test.dart
           test/features/onboarding/onboarding_sign_out_test.dart
           test/features/onboarding/hosted_communities_test.dart
           test/features/pairing/pairing_hosted_handoff_test.dart
 
@@ -4,6 +4,7 @@ import 'package:flutter_hooks/flutter_hooks.dart';
 import 'package:hooks_riverpod/hooks_riverpod.dart';
 
 import '../../shared/hosted/hosted_flow.dart';
+import '../../shared/hosted/hosted_environment.dart';
 import '../../shared/widgets/onboarding_step_page.dart';
 import '../../shared/widgets/bee_loading_mark.dart';
 import '../../shared/widgets/onboarding_loading_page.dart';
@@ -90,6 +91,20 @@ class HostedConnectSheet extends HookConsumerWidget {
                   ? 'Create a new Buzz identity, or import the identity you already use.'
                   : 'Bring your existing Buzz identity from your other device.'
             : 'Your identity hasn’t been backed up yet. Bring it from your other device to keep using the same Buzz account.',
+      HostedFlowStage.confirmBackup =>
+        flow.bindingOnly
+            ? 'Link this identity to the receiving Builderlab account? '
+                  'This app cannot change the linked identity later. '
+                  'No backup is uploaded by this browser handoff. '
+                  'Cancelling stops setup; it does not undo any earlier linking.'
+            : 'Allow Builderlab to link this identity to your account and upload '
+                  'an encrypted copy of your secret key (nsec) to '
+                  '${HostedEnvironment.origin.host}? Builderlab can decrypt this backup. '
+                  'Anyone signed in to this account can recover the key and use your '
+                  'identity, including on self-hosted relays. '
+                  'This app cannot change the linked identity later. '
+                  'Joining requires a backup. Cancelling stops setup; it does not undo '
+                  'any earlier linking or upload, including an upload whose confirmation was lost.',
       HostedFlowStage.chooseCommunities => 'Select a community',
       HostedFlowStage.communityConflict =>
         '${flow.addingCommunityName} is already saved with a different identity. '
@@ -145,6 +160,37 @@ class HostedConnectSheet extends HookConsumerWidget {
       ],
       if (!fullScreen) Text(message, style: context.textTheme.bodyLarge),
       const SizedBox(height: Grid.sm),
+      if (stage == HostedFlowStage.confirmBackup) ...[
+        Text(
+          flow.backupAccountEmail == null
+              ? 'We couldn’t identify the receiving account. Sign out and sign in again before continuing.'
+              : 'Receiving account: ${flow.backupAccountEmail}',
+          style: context.textTheme.bodyLarge,
+        ),
+        const SizedBox(height: Grid.twelve),
+        SelectableText(
+          fullNpub(flow.backupPubkey ?? '') ?? '',
+          style: context.textTheme.bodySmall,
+        ),
+        const SizedBox(height: Grid.twelve),
+        FilledButton(
+          style: actionStyle,
+          onPressed: flow.confirmBackup,
+          child: Text(
+            flow.bindingOnly ? 'Link and continue' : 'Back up and continue',
+          ),
+        ),
+        TextButton(
+          style: actionStyle,
+          onPressed: () => flow.leave(),
+          child: const Text('Cancel setup'),
+        ),
+        TextButton(
+          style: actionStyle,
+          onPressed: flow.signOutAccount,
+          child: const Text('Sign out'),
+        ),
+      ],
       for (final choice in flow.identityChoices)
         Padding(
           padding: const EdgeInsets.only(bottom: Grid.sm),
@@ -186,7 +232,9 @@ class HostedConnectSheet extends HookConsumerWidget {
         ),
         const SizedBox(height: Grid.twelve),
         Text(
-          'We’ll securely back it up so your next sign-in is easier.',
+          flow.bindingOnly
+              ? 'This links the identity to your Builderlab account. This app cannot change it later. No backup is uploaded by this browser handoff.'
+              : 'New identities are linked to your Builderlab account and backed up automatically. This app cannot change the linked identity later. Existing keys require confirmation before backup.',
           textAlign: TextAlign.center,
           style: context.textTheme.bodySmall,
         ),
@@ -253,6 +301,7 @@ class HostedConnectSheet extends HookConsumerWidget {
           stage != HostedFlowStage.acceptPolicy &&
           stage != HostedFlowStage.chooseIdentity &&
           stage != HostedFlowStage.setupIdentity &&
+          stage != HostedFlowStage.confirmBackup &&
           stage != HostedFlowStage.chooseCommunities &&
           stage != HostedFlowStage.communityConflict &&
           stage != HostedFlowStage.complete &&
@@ -282,6 +331,8 @@ class HostedConnectSheet extends HookConsumerWidget {
                   ? 'Create or import a Buzz identity'
                   : 'Import your Buzz identity'
             : 'Bring your identity with you',
+      HostedFlowStage.confirmBackup =>
+        flow.bindingOnly ? 'Link your identity?' : 'Back up your secret key?',
       HostedFlowStage.chooseIdentity => 'Choose your identity',
       HostedFlowStage.working =>
         flow.addingCommunityName == null
 
@@ -175,15 +175,18 @@ class AccountIdentityStore implements BackupIdentity {
 
   /// Authorization runs under the identity writer lock and must not reenter it.
   /// A completed but unacknowledged write is reused on retry, never regenerated.
+  /// [onGenerated] runs only after this call confirmed a newly generated key.
   Future<AccountIdentitySnapshot?> generateIfAbsent({
     required Future<bool> Function() authorize,
+    void Function()? onGenerated,
   }) => _serialized(() async {
     final existing = await _read();
     if (existing != null) return existing.snapshot;
     if (!await authorize()) return null;
     final keys = nostr.Keys.generate();
     final record = _Record(keys.nsec, keys.public, null);
     await _write(record);
+    onGenerated?.call();
     return record.snapshot;
   });
 
 
@@ -22,13 +22,15 @@ import 'web_connect_binding.dart';
 import 'hosted_join_policy.dart';
 
 part 'hosted_flow_identity_recovery.dart';
+part 'hosted_flow_backup_consent.dart';
 
 enum HostedFlowStage {
   idle,
   working,
   signIn,
   chooseIdentity,
   setupIdentity,
+  confirmBackup,
   chooseCommunities,
   communityConflict,
   acceptPolicy,
@@ -139,6 +141,9 @@ class HostedFlow extends ChangeNotifier {
 
   String? requiredIdentityPubkey;
   String? _pairedPubkey;
+  ({String subject, String pubkey})? _pendingBackup;
+  String? _pendingImport;
+  String? get backupPubkey => _pendingBackup?.pubkey;
   SensitiveActionPolicy? pairedSensitiveActionPolicy;
   List<AddCommunityDeepLink> communities = const [];
   Set<String> selectedRelays = const {};
@@ -180,6 +185,8 @@ class HostedFlow extends ChangeNotifier {
   int _generation = 0;
 
   int _nextGeneration() {
+    _pendingBackup = null;
+    _pendingImport = null;
     _failedRelay = null;
     _cancelPolicy();
     _cancelProfile();
@@ -544,45 +551,13 @@ class HostedFlow extends ChangeNotifier {
     return _enqueue(() => _continue(generation, selectedPubkey: pubkey));
   }
 
-  /// Create explicitly from setup, or beside the saved identities offered.
-  Future<void> createIdentity() {
-    if ((_target == null && !accountOnly) ||
-        !canCreateIdentity ||
-        (stage != HostedFlowStage.setupIdentity &&
-            stage != HostedFlowStage.chooseIdentity)) {
-      return Future.value();
-    }
-    final offered = {for (final item in identityChoices) item.pubkey};
-    final generation = _nextGeneration();
-    _set(HostedFlowStage.working);
-    return _enqueue(
-      () => _continue(generation, createNew: true, offered: offered),
-    );
-  }
-
-  /// Import through the secure store, rechecking the account binding.
-  /// Errors propagate to the import sheet without discarding the setup choice.
-  Future<void> importIdentity(String nsec) {
-    final generation = _generation;
-    final subject = account.account?.subject;
-    if (stage != HostedFlowStage.setupIdentity || subject == null) {
-      throw AccountFailure.unavailable;
-    }
-    return _queue.run(() async {
-      bool current() =>
-          !_disposed &&
-          generation == _generation &&
-          account.account?.subject == subject;
-      if (!current()) throw AccountFailure.unavailable;
-      await identity.resolve(isCurrent: current, importNsec: nsec);
-    });
-  }
-
   Future<void> _continue(
     int generation, {
     String? selectedPubkey,
     bool createNew = false,
+    ({String subject, String pubkey})? approvedBackup,
     Set<String> offered = const {},
+    String? importNsec,
   }) async {
     final target = _target;
     final session = account.account;
@@ -607,8 +582,19 @@ class HostedFlow extends ChangeNotifier {
     var resolved = await identity.resolve(
       isCurrent: _isCurrent(generation),
       selectedPubkey: selectedPubkey ?? _pairedPubkey,
+      importNsec: importNsec,
+      canAdopt: (pubkey) =>
+          approvedBackup == (subject: session.subject, pubkey: pubkey),
     );
     if (_disposed || generation != _generation) return;
+    if (resolved.state == HostedIdentityState.needsConsent) {
+      _presentBackupConsent(
+        session.subject,
+        resolved.pubkey!,
+        importNsec: importNsec,
+      );
+      return;
+    }
     if (_importRequested &&
         {
           HostedIdentityState.ready,
@@ -643,34 +629,43 @@ class HostedFlow extends ChangeNotifier {
         isCurrent: _isCurrent(generation),
         createNew: true,
         offered: offered,
+        canAdopt: (pubkey) =>
+            approvedBackup == (subject: session.subject, pubkey: pubkey),
       );
     }
+    if (_disposed || generation != _generation) return;
+    if (resolved.state == HostedIdentityState.needsConsent) {
+      _presentBackupConsent(session.subject, resolved.pubkey!);
+      return;
+    }
+    if (resolved.generated && resolved.pubkey != null) {
+      approvedBackup = (subject: session.subject, pubkey: resolved.pubkey!);
+    }
     if (_pairedPubkey != null && resolved.pubkey != _pairedPubkey) {
       _set(HostedFlowStage.blocked, HostedFlowProblem.identityMismatch);
       return;
     }
+    if (target is NostrBindDeepLink &&
+        !await _allowBackup(
+          resolved,
+          session.subject,
+          generation,
+          canSealBackup,
+          approvedBackup: approvedBackup,
+        )) {
+      return;
+    }
     if (target is! NostrBindDeepLink) {
       for (var step = 0; step < 2; step++) {
         if (_disposed || generation != _generation) return;
-        if (!canSealBackup) {
-          final saved = await store.read();
-          if (_disposed || generation != _generation) return;
-          final needsNewBackup =
-              resolved.state == HostedIdentityState.needsSetup ||
-              resolved.state == HostedIdentityState.needsBackup ||
-              (resolved.state == HostedIdentityState.needsBinding &&
-                  !(saved?.hasBackupFor(
-                        backend: HostedEnvironment.origin.origin,
-                        subject: session.subject,
-                      ) ??
-                      false));
-          if (needsNewBackup) {
-            _set(
-              HostedFlowStage.blocked,
-              HostedFlowProblem.unsupportedPlatform,
-            );
-            return;
-          }
+        if (!await _allowBackup(
+          resolved,
+          session.subject,
+          generation,
+          canSealBackup,
+          approvedBackup: approvedBackup,
+        )) {
+          return;
         }
         if (resolved.state == HostedIdentityState.needsBinding &&
             resolved.pubkey != null) {