diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 96a0fbbe10..55e3b31a74 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -50,6 +50,11 @@ android {
         execution = "ANDROIDX_TEST_ORCHESTRATOR"
         // Robolectric 이 병합된 매니페스트·리소스를 읽어야 NavHost 를 실제 컴포지션으로 띄울 수 있다 (#1601).
         unitTests.isIncludeAndroidResources = true
+        unitTests.all {
+            // 여러 SDK의 앱 리소스를 읽은 뒤에도 후속 테스트의 샌드박스를 생성할 수 있어야 한다.
+            // 기본 512 MB에서는 API 33 알림 권한 테스트의 리소스 로딩이 OOM으로 실패한다 (#2200).
+            it.maxHeapSize = "1g"
+        }
         managedDevices {
             localDevices {
                 create("pixel2Api26") {
diff --git a/app/src/main/res/values-v29/themes.xml b/app/src/main/res/values-v29/themes.xml
new file mode 100644
index 0000000000..4232750e1d
--- /dev/null
+++ b/app/src/main/res/values-v29/themes.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <!-- API 29 이상은 시스템 생체 인증창을 사용하므로 기존 Activity 테마를 유지한다. -->
+    <style name="Theme.Afternotefe.Main" parent="android:Theme.Material.Light.NoActionBar" />
+</resources>
diff --git a/app/src/main/res/values/themes.xml b/app/src/main/res/values/themes.xml
index 9b2b71e273..c7475ebf71 100644
--- a/app/src/main/res/values/themes.xml
+++ b/app/src/main/res/values/themes.xml
@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
 
-    <!-- Compose/일반 Activity용 (스플래시 이후 postSplashScreenTheme) -->
-    <style name="Theme.Afternotefe.Main" parent="android:Theme.Material.Light.NoActionBar" />
+    <!-- API 26·27 및 일부 API 28 기기의 AndroidX 지문 대화상자는 AppCompat 테마 속성이 필요하다. -->
+    <style name="Theme.Afternotefe.Main" parent="Theme.AppCompat.Light.NoActionBar" />
 
     <!-- 런처(MainActivity) 전용: Theme.SplashScreen + installSplashScreen() -->
     <style name="Theme.Afternotefe.Starting" parent="Theme.SplashScreen">
@@ -19,4 +19,4 @@
         <!-- windowLightNavigationBar 는 API 27+ 라 values-v27/ 에 둔다 (minSdk 26). -->
         <item name="android:windowLightStatusBar">true</item>
     </style>
-</resources>
\ No newline at end of file
+</resources>
diff --git a/app/src/test/java/com/afternote/afternote_fe/BiometricDialogThemeTest.kt b/app/src/test/java/com/afternote/afternote_fe/BiometricDialogThemeTest.kt
new file mode 100644
index 0000000000..8744dce378
--- /dev/null
+++ b/app/src/test/java/com/afternote/afternote_fe/BiometricDialogThemeTest.kt
@@ -0,0 +1,100 @@
+package com.afternote.afternote_fe
+
+import android.app.Activity
+import android.app.Application
+import android.app.Dialog
+import android.content.Context
+import android.content.DialogInterface
+import android.os.Looper
+import android.util.TypedValue
+import android.widget.Button
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+
+/** 실제 앱 테마로 AndroidX 지문 대화상자와 같은 AppCompat dialog를 생성한다. */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [26, 27, 28], application = Application::class)
+class BiometricDialogThemeTest {
+    @Test
+    fun `API26부터 28 앱 테마는 AppCompat 인증 대화상자를 띄우고 닫을 수 있다`() {
+        val controller = Robolectric.buildActivity(Activity::class.java)
+        controller.get().setTheme(R.style.Theme_Afternotefe_Main)
+        controller.setup()
+        val activity = controller.get()
+        var canceled = false
+        val dialog = createAppCompatDialog(activity) { canceled = true }
+
+        try {
+            // 플랫폼 Material 테마만 있으면 show()에서 AppCompat 테마 요구 예외가 발생한다.
+            dialog.show()
+            assertTrue(dialog.isShowing)
+            dialog.findViewById<Button>(android.R.id.button2).performClick()
+            shadowOf(Looper.getMainLooper()).idle()
+            assertTrue(canceled)
+            assertFalse(dialog.isShowing)
+        } finally {
+            dialog.dismiss()
+            controller.pause().stop().destroy()
+        }
+    }
+
+    @Test
+    @Config(sdk = [29, 30, 35])
+    fun `API29 이상은 플랫폼 라이트 테마와 액션바 없는 동작을 유지한다`() {
+        val controller = Robolectric.buildActivity(Activity::class.java)
+        controller.get().setTheme(R.style.Theme_Afternotefe_Main)
+        controller.setup()
+        val activity = controller.get()
+        val dialog =
+            android.app.AlertDialog
+                .Builder(activity)
+                .setTitle("본인 인증")
+                .setNegativeButton(android.R.string.cancel, null)
+                .create()
+
+        try {
+            val attributes =
+                activity.obtainStyledAttributes(
+                    intArrayOf(android.R.attr.isLightTheme, android.R.attr.windowActionBar, android.R.attr.windowNoTitle),
+                )
+            try {
+                assertTrue(attributes.getBoolean(0, false))
+                assertFalse(attributes.getBoolean(1, true))
+                assertTrue(attributes.getBoolean(2, false))
+            } finally {
+                attributes.recycle()
+            }
+            assertFalse(activity.theme.resolveAttribute(androidx.appcompat.R.attr.windowActionBar, TypedValue(), true))
+            dialog.show()
+            assertTrue(dialog.isShowing)
+            dialog.getButton(android.app.AlertDialog.BUTTON_NEGATIVE).performClick()
+            shadowOf(Looper.getMainLooper()).idle()
+            assertFalse(dialog.isShowing)
+        } finally {
+            dialog.dismiss()
+            controller.pause().stop().destroy()
+        }
+    }
+
+    private fun createAppCompatDialog(
+        context: Context,
+        onCancel: () -> Unit,
+    ): Dialog {
+        // AppCompat는 biometric의 runtime 의존이다. 테스트용 compile 의존을 늘리지 않고
+        // 실제 라이브러리의 공개 Builder API를 호출한다.
+        val builderClass = Class.forName("androidx.appcompat.app.AlertDialog\$Builder")
+        val builder = builderClass.getConstructor(Context::class.java).newInstance(context)
+        builderClass.getMethod("setTitle", CharSequence::class.java).invoke(builder, "지문 인증")
+        builderClass.getMethod("setMessage", CharSequence::class.java).invoke(builder, "지문 센서를 터치하세요")
+        builderClass
+            .getMethod("setNegativeButton", Int::class.javaPrimitiveType, DialogInterface.OnClickListener::class.java)
+            .invoke(builder, android.R.string.cancel, DialogInterface.OnClickListener { _, _ -> onCancel() })
+        return builderClass.getMethod("create").invoke(builder) as Dialog
+    }
+}
diff --git a/core/common/src/main/kotlin/com/afternote/core/common/biometric/BiometricAuth.kt b/core/common/src/main/kotlin/com/afternote/core/common/biometric/BiometricAuth.kt
index 535c0cfe86..8bfa12ad92 100644
--- a/core/common/src/main/kotlin/com/afternote/core/common/biometric/BiometricAuth.kt
+++ b/core/common/src/main/kotlin/com/afternote/core/common/biometric/BiometricAuth.kt
@@ -1,5 +1,6 @@
 package com.afternote.core.common.biometric
 
+import android.os.Build
 import android.util.Log
 import androidx.biometric.BiometricManager
 import androidx.biometric.BiometricManager.Authenticators.BIOMETRIC_STRONG
@@ -55,8 +56,10 @@ public sealed interface BiometricAuthResult {
  *   `MainActivity`는 반드시 `FragmentActivity`(또는 `AppCompatActivity`)를 상속해야 한다.
  * - [BiometricPrompt]는 UI 컴포넌트이므로 본문을 [Dispatchers.Main.immediate]에서 실행해,
  *   호출 코루틴이 백그라운드 디스패처에 있어도 초기화·실행이 메인 스레드로 수렴하도록 한다.
- * - 성공은 콜백의 boolean 이 아니라 [confirmWithCryptoOperation] 의 암호 연산 성사로 확정한다.
- *   프롬프트를 거치지 않고 성공 콜백만 가로챈 경우 사용자 인증에 묶인 키를 쓸 수 없어 연산이 실패한다.
+ * - 성공 콜백의 cipher는 [confirmWithCryptoOperation]으로 연산을 검증한다.
+ *   API 30 이상에서 앱 소유 CryptoObject를 준비한 경우에는 사용자 인증에 묶인 키이므로
+ *   인증 없이 성공 콜백만 가로채 호출하면 연산이 실패한다. AndroidX의 내부 cipher에는
+ *   이 인증 결합을 가정하지 않으며, 플랫폼 프롬프트의 강한 생체 인증 결과를 따른다.
  */
 public suspend fun FragmentActivity.authenticateBiometric(
     title: String,
@@ -66,12 +69,15 @@ public suspend fun FragmentActivity.authenticateBiometric(
     withContext(Dispatchers.Main.immediate) {
         suspendCancellableCoroutine { continuation ->
             val biometricManager = BiometricManager.from(this@authenticateBiometric)
-            val authenticators = BIOMETRIC_STRONG or DEVICE_CREDENTIAL
+            // Android 9·10은 STRONG과 기기 자격의 조합을 지원하지 않는다.
+            // 강도를 낮추지 않고 이 두 버전에서만 생체 인증을 단독 사용한다.
+            val biometricOnly = Build.VERSION.SDK_INT in Build.VERSION_CODES.P..Build.VERSION_CODES.Q
+            val authenticators = if (biometricOnly) BIOMETRIC_STRONG else BIOMETRIC_STRONG or DEVICE_CREDENTIAL
 
             when (biometricManager.canAuthenticate(authenticators)) {
                 BiometricManager.BIOMETRIC_SUCCESS -> {
-                    // API 26~29 에서는 DEVICE_CREDENTIAL 허용자와 CryptoObject 를 함께 쓸 수 없다.
-                    // 이때는 관문 없이 인증하고, 성공 확정은 cipher 부재로 통과시킨다.
+                    // 앱 소유 CryptoObject는 기존 API 30 이상 정책을 유지한다.
+                    // API 28~29의 STRONG 강제는 AndroidX 프롬프트가 담당한다.
                     val cryptoObject = if (isBiometricCryptoSupported) createBiometricCryptoObject() else null
 
                     val promptInfo =
@@ -80,7 +86,11 @@ public suspend fun FragmentActivity.authenticateBiometric(
                             .setTitle(title)
                             .setSubtitle(subtitle)
                             .setAllowedAuthenticators(authenticators)
-                            .build()
+                            .apply {
+                                if (biometricOnly) {
+                                    setNegativeButtonText(getString(android.R.string.cancel))
+                                }
+                            }.build()
 
                     val biometricPrompt =
                         BiometricPrompt(
diff --git a/core/common/src/main/kotlin/com/afternote/core/common/biometric/BiometricCryptoGate.kt b/core/common/src/main/kotlin/com/afternote/core/common/biometric/BiometricCryptoGate.kt
index 9688a5db95..8a54b27f8b 100644
--- a/core/common/src/main/kotlin/com/afternote/core/common/biometric/BiometricCryptoGate.kt
+++ b/core/common/src/main/kotlin/com/afternote/core/common/biometric/BiometricCryptoGate.kt
@@ -25,15 +25,16 @@ private val TRANSFORMATION =
 private val CRYPTO_CHALLENGE = "afternote-biometric-gate".toByteArray()
 
 /**
- * `CryptoObject` 를 동반한 인증이 가능한 API 레벨인지.
+ * 앱 소유 `CryptoObject` 를 동반하는 인증 경로인지.
  *
- * `androidx.biometric` 1.1.0 의 `authenticate(promptInfo, cryptoObject)` 는 허용자에
+ * `androidx.biometric` 의 `authenticate(promptInfo, cryptoObject)` 는 허용자에
  * `DEVICE_CREDENTIAL` 이 포함된 채 API 30 미만이면 다음 메시지로 `IllegalArgumentException` 을 던진다.
  *
  * > Crypto-based authentication is not supported for device credential prior to API 30.
  *
- * minSdk 는 26 이고 기기 잠금(PIN·패턴)만 등록한 사용자를 막지 않는 것이 현 정책이므로,
- * API 26~29 에서는 허용자 조합을 유지한 채 `CryptoObject` 없이 인증한다.
+ * API 26~27은 기존 기기 자격 폴백을 유지한다. API 28~29는 강한 생체 인증만 허용하며
+ * 강도 제한에 필요한 내부 CryptoObject는 AndroidX가 준비한다.
+ * 앱 소유 CryptoObject의 사용 범위는 기존과 같이 API 30 이상으로 유지한다.
  */
 val isBiometricCryptoSupported: Boolean
     get() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.R
@@ -51,13 +52,15 @@ fun createBiometricCryptoObject(): BiometricPrompt.CryptoObject? =
         .getOrNull()
 
 /**
- * 인증 성공 콜백이 받은 [cipher] 로 실제 암호 연산을 수행해 인증을 확정한다.
+ * 인증 성공 콜백이 받은 [cipher] 로 실제 암호 연산이 가능한지 검증한다.
  *
- * 키가 `setUserAuthenticationRequired(true)` 로 만들어져 있어, 프롬프트를 거치지 않은 채
- * 성공 콜백만 가로채 호출한 경우에는 이 연산이 `UserNotAuthenticatedException` 으로 실패한다.
- * 즉 성패 boolean 이 아니라 암호 연산의 성사 여부가 인증의 근거가 된다.
+ * [createBiometricCryptoObject]의 앱 소유 키는 `setUserAuthenticationRequired(true)`로
+ * 만들어져 있어, 프롬프트를 거치지 않고 성공 콜백만 가로채 호출하면 이 연산이 실패한다.
+ * AndroidX가 강도 제한을 위해 준비하는 내부 cipher는 사용자 인증에 묶인 키가 아니므로
+ * 같은 연산을 수행하더라도 그 연산 자체를 사용자 인증의 추가 증거로 간주하지 않는다.
  *
- * [cipher] 가 null 인 경로(API 26~29 폴백)는 검증할 대상이 없으므로 통과시킨다.
+ * [cipher] 가 null 인 폴백은 검증할 대상이 없으므로 통과시킨다.
+ * API 30 미만에도 AndroidX가 내부 cipher를 반환하면 동일한 암호 연산으로 검증한다.
  * 실패 원인을 호출 측이 기록할 수 있도록 예외를 삼키지 않고 [Result] 로 실어 보낸다.
  *
  * **거부는 `UserNotAuthenticatedException` 으로 오지 않는다.** API 35 실측(2026-08-26)에서
diff --git a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyMakingApi29Test.kt b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyMakingApi29Test.kt
index f61c37fc07..697b5fc549 100644
--- a/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyMakingApi29Test.kt
+++ b/feature/setting/presentation/src/test/kotlin/com/afternote/feature/setting/presentation/passkey/PassKeyMakingApi29Test.kt
@@ -1,6 +1,11 @@
 package com.afternote.feature.setting.presentation.passkey
 
 import android.app.KeyguardManager
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.CancellationSignal
+import android.os.Handler
+import android.os.Looper
 import androidx.biometric.BiometricManager
 import androidx.biometric.BiometricManager.Authenticators.BIOMETRIC_STRONG
 import androidx.biometric.BiometricManager.Authenticators.DEVICE_CREDENTIAL
@@ -12,6 +17,7 @@ import androidx.compose.ui.test.assertIsEnabled
 import androidx.compose.ui.test.junit4.v2.createComposeRule
 import androidx.compose.ui.test.onNodeWithText
 import androidx.compose.ui.test.performClick
+import androidx.fragment.app.DialogFragment
 import androidx.fragment.app.FragmentActivity
 import androidx.lifecycle.ViewModelProvider
 import com.afternote.core.common.biometric.BiometricAuthResult
@@ -25,16 +31,21 @@ import com.afternote.feature.setting.domain.SettingAccountRepository
 import com.afternote.feature.setting.domain.SettingNotificationRepository
 import com.afternote.feature.setting.domain.testing.FakeSettingAccountRepository
 import com.afternote.feature.setting.domain.testing.FakeSettingNotificationRepository
-import com.afternote.feature.setting.presentation.R
 import dagger.hilt.android.AndroidEntryPoint
 import dagger.hilt.android.testing.BindValue
 import dagger.hilt.android.testing.HiltAndroidRule
 import dagger.hilt.android.testing.HiltAndroidTest
 import dagger.hilt.android.testing.HiltTestApplication
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.CoroutineStart
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.runBlocking
 import org.junit.After
 import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
 import org.junit.Assert.assertThrows
 import org.junit.Assert.assertTrue
 import org.junit.Before
@@ -45,16 +56,29 @@ import org.robolectric.Robolectric
 import org.robolectric.RobolectricTestRunner
 import org.robolectric.Shadows.shadowOf
 import org.robolectric.android.controller.ActivityController
+import org.robolectric.annotation.ClassName
 import org.robolectric.annotation.Config
+import org.robolectric.annotation.Implementation
+import org.robolectric.annotation.Implements
 import org.robolectric.shadow.api.Shadow
 import org.robolectric.shadows.ShadowBiometricManager
 import org.robolectric.shadows.ShadowBuild
+import org.robolectric.shadows.ShadowFingerprintManager
+import org.robolectric.util.ReflectionHelpers
+import org.robolectric.util.ReflectionHelpers.ClassParameter
+import java.util.concurrent.Executor
+import javax.crypto.Cipher
+import javax.crypto.spec.SecretKeySpec
 import javax.inject.Inject
 
-/** Android 10에서 #2202가 바꾼 크래시와 오류 팝업 경로를 실제 AndroidX 구현으로 확인한다. */
+/** AndroidX의 실제 사전 검사와 프롬프트 구성을 통과한 뒤 framework 콜백을 전달한다. */
 @RunWith(RobolectricTestRunner::class)
 @HiltAndroidTest
-@Config(sdk = [29], application = HiltTestApplication::class)
+@Config(
+    sdk = [29],
+    application = HiltTestApplication::class,
+    shadows = [RecordingBiometricPrompt::class, RecordingFingerprintManager::class],
+)
 class PassKeyMakingApi29Test {
     @get:Rule(order = 0)
     val hiltRule = HiltAndroidRule(this)
@@ -94,6 +118,7 @@ class PassKeyMakingApi29Test {
 
     @Before
     fun setUp() {
+        RecordedBiometricSession.reset()
         hiltRule.inject()
         runBlocking { profileCache.savePasskeyRegistered(false) }
     }
@@ -119,7 +144,8 @@ class PassKeyMakingApi29Test {
     }
 
     @Test
-    fun `공용 래퍼는 API29의 미지원 조합을 크래시 대신 오류로 반환한다`() {
+    @Config(sdk = [26, 27, 28, 29, 30, 35])
+    fun `공용 래퍼는 지원되는 강도와 취소 정책으로 프롬프트를 열고 사용자 취소를 전달한다`() {
         val activity = secureBiometricActivity()
         val messages =
             BiometricMessages(
@@ -130,23 +156,129 @@ class PassKeyMakingApi29Test {
                 notAvailable = "unsupported authenticators",
                 verificationFailed = "verification failed",
             )
+        lateinit var result: Deferred<BiometricAuthResult>
 
         composeRule.runOnIdle {
-            val result = runBlocking { activity.authenticateBiometric("패스키 인증", "본인 인증", messages) }
+            result =
+                CoroutineScope(Dispatchers.Main.immediate).async(start = CoroutineStart.UNDISPATCHED) {
+                    activity.authenticateBiometric("패스키 인증", "본인 인증", messages)
+                }
+        }
+        composeRule.waitUntil { RecordedBiometricSession.authenticationStarts == 1 }
+        composeRule.runOnIdle {
+            val fragment = activity.supportFragmentManager.fragments.single { it.javaClass.simpleName == "BiometricFragment" }
+            val biometricViewModel = ReflectionHelpers.getField<Any>(fragment, "mViewModel")
+            // AndroidX가 실제로 받아 보관한 PromptInfo를 읽는다. 앱 선언의 공개 범위는 바꾸지 않는다.
+            val promptInfo = ReflectionHelpers.getField<BiometricPrompt.PromptInfo>(biometricViewModel, "mPromptInfo")
+            val biometricOnly = Build.VERSION.SDK_INT in 28..29
+            assertEquals(
+                if (biometricOnly) BIOMETRIC_STRONG else BIOMETRIC_STRONG or DEVICE_CREDENTIAL,
+                promptInfo.allowedAuthenticators,
+            )
+            assertEquals(
+                if (biometricOnly) activity.getString(android.R.string.cancel) else "",
+                promptInfo.negativeButtonText.toString(),
+            )
+            assertFalse(result.isCompleted)
+            RecordedBiometricSession.error(BiometricPrompt.ERROR_USER_CANCELED, "user canceled")
+        }
+        shadowOf(Looper.getMainLooper()).idle()
+        composeRule.waitForIdle()
+        composeRule.waitUntil { result.isCompleted }
+        assertEquals(BiometricAuthResult.Canceled, runBlocking { result.await() })
+        assertEquals(false, runBlocking { profileCache.isPasskeyRegisteredFlow().first() })
+    }
 
-            assertEquals(BiometricAuthResult.Error(messages.notAvailable), result)
+    @Test
+    @Config(sdk = [28])
+    fun `API28 Samsung crypto 인증은 AppCompat 지문 대화상자를 열고 취소할 수 있다`() {
+        val activity = secureBiometricActivity()
+        ShadowBuild.setManufacturer("samsung")
+        ShadowBuild.setModel("SM-G960F")
+        // Robolectric의 AndroidKeyStore 대신 일반 cipher로 실제 AndroidX crypto 경로를 연다.
+        val cipher =
+            Cipher.getInstance("AES/CBC/PKCS5Padding").apply {
+                init(Cipher.ENCRYPT_MODE, SecretKeySpec(ByteArray(16), "AES"))
+            }
+        var errorCode: Int? = null
+        composeRule.runOnIdle {
+            val prompt =
+                BiometricPrompt(
+                    activity,
+                    Executor { it.run() },
+                    object : BiometricPrompt.AuthenticationCallback() {
+                        override fun onAuthenticationError(
+                            code: Int,
+                            errString: CharSequence,
+                        ) {
+                            errorCode = code
+                        }
+                    },
+                )
+            val promptInfo =
+                BiometricPrompt.PromptInfo
+                    .Builder()
+                    .setTitle("패스키 인증")
+                    .setAllowedAuthenticators(BIOMETRIC_STRONG)
+                    .setNegativeButtonText(activity.getString(android.R.string.cancel))
+                    .build()
+            prompt.authenticate(promptInfo, BiometricPrompt.CryptoObject(cipher))
+        }
+        composeRule.waitUntil { RecordedBiometricSession.authenticationStarts == 1 }
+        composeRule.runOnIdle {
+            val dialog =
+                activity.supportFragmentManager.fragments.single { it.javaClass.simpleName == "FingerprintDialogFragment" }
+                    as DialogFragment
+            assertTrue(dialog.requireDialog().isShowing)
+            RecordedBiometricSession.error(BiometricPrompt.ERROR_USER_CANCELED, "user canceled")
         }
+        shadowOf(Looper.getMainLooper()).idle()
+        composeRule.waitForIdle()
+        assertEquals(BiometricPrompt.ERROR_USER_CANCELED, errorCode)
+        assertEquals(false, runBlocking { profileCache.isPasskeyRegisteredFlow().first() })
     }
 
     @Test
-    fun `활성화된 지문 인증 버튼은 미지원 오류를 표시하고 패스키를 등록하지 않는다`() {
+    fun `API29 지문 불일치와 사용자 취소는 패스키 저장이나 화면 이동을 하지 않는다`() {
         val activity = secureBiometricActivity()
+        val viewModel = showPasskeyScreen(activity)
+        composeRule.onNodeWithText("지문 인증하기").assertIsEnabled().performClick()
+        composeRule.waitUntil { RecordedBiometricSession.authenticationStarts == 1 }
+
+        composeRule.runOnIdle { RecordedBiometricSession.failure() }
+        assertNotRegistered(viewModel)
+        composeRule.runOnIdle { RecordedBiometricSession.error(BiometricPrompt.ERROR_USER_CANCELED, "user canceled") }
+        composeRule.onNodeWithText("지문 인증하기").assertIsEnabled()
+        composeRule.onNodeWithText("user canceled").assertDoesNotExist()
+        assertNotRegistered(viewModel)
+    }
+
+    @Test
+    fun `API29 실제 프롬프트의 오류를 닫고 재시도해도 실패는 패스키를 등록하지 않는다`() {
+        val activity = secureBiometricActivity()
+        val viewModel = showPasskeyScreen(activity)
+        val errorMessage = "sensor unavailable"
+        composeRule.onNodeWithText("지문 인증하기").assertIsEnabled().performClick()
+        composeRule.waitUntil { RecordedBiometricSession.authenticationStarts == 1 }
+        composeRule.runOnIdle { RecordedBiometricSession.error(BiometricPrompt.ERROR_HW_UNAVAILABLE, errorMessage) }
+
+        composeRule.onNodeWithText(errorMessage).assertIsDisplayed()
+        assertNotRegistered(viewModel)
+        composeRule.onNodeWithText("확인").performClick()
+        composeRule.onNodeWithText(errorMessage).assertDoesNotExist()
+        composeRule.onNodeWithText("지문 인증하기").assertIsEnabled().performClick()
+        composeRule.waitUntil { RecordedBiometricSession.authenticationStarts == 2 }
+        composeRule.runOnIdle { RecordedBiometricSession.error(BiometricPrompt.ERROR_HW_UNAVAILABLE, errorMessage) }
+        composeRule.onNodeWithText(errorMessage).assertIsDisplayed()
+        assertNotRegistered(viewModel)
+    }
+
+    private var backCalls = 0
+    private var passwordCalls = 0
+
+    private fun showPasskeyScreen(activity: FragmentActivity): PassKeyViewModel {
         val viewModel = ViewModelProvider(activity)[PassKeyViewModel::class.java]
         composeRule.waitUntil { viewModel.isPasskeyRegistered.value == false }
-        var backCalls = 0
-        var passwordCalls = 0
-        val unavailableMessage = activity.getString(R.string.setting_biometric_not_available)
-
         composeRule.setContent {
             CompositionLocalProvider(LocalContext provides activity) {
                 AfternoteTheme {
@@ -158,10 +290,10 @@ class PassKeyMakingApi29Test {
                 }
             }
         }
+        return viewModel
+    }
 
-        composeRule.onNodeWithText("지문 인증하기").assertIsEnabled().performClick()
-
-        composeRule.onNodeWithText(unavailableMessage).assertIsDisplayed()
+    private fun assertNotRegistered(viewModel: PassKeyViewModel) {
         composeRule.onNodeWithText("패스키 생성이 완료되었습니다").assertDoesNotExist()
         composeRule.runOnIdle {
             assertEquals(false, viewModel.isPasskeyRegistered.value)
@@ -169,18 +301,13 @@ class PassKeyMakingApi29Test {
             assertEquals(0, passwordCalls)
         }
         assertEquals(false, runBlocking { profileCache.isPasskeyRegisteredFlow().first() })
-        composeRule.onNodeWithText("확인").performClick()
-        composeRule.onNodeWithText(unavailableMessage).assertDoesNotExist()
-        composeRule.onNodeWithText("지문 인증하기").assertIsEnabled().performClick()
-        composeRule.onNodeWithText(unavailableMessage).assertIsDisplayed()
-        composeRule.runOnIdle { assertEquals(false, viewModel.isPasskeyRegistered.value) }
-        assertEquals(false, runBlocking { profileCache.isPasskeyRegisteredFlow().first() })
     }
 
     private fun secureBiometricActivity(): FragmentActivity {
         val activity =
             Robolectric
                 .buildActivity(BiometricTestActivity::class.java)
+                .also { it.get().setTheme(androidx.appcompat.R.style.Theme_AppCompat) }
                 .setup()
                 .also { activityController = it }
                 .get()
@@ -188,22 +315,99 @@ class PassKeyMakingApi29Test {
             setIsKeyguardSecure(true)
             setIsDeviceSecure(true)
         }
-        // AndroidX Biometric 1.1.0의 강한 생체 인증 보장 기기 목록에 있는 모델을 사용한다.
-        ShadowBuild.setModel("Pixel 4")
-        Shadow
-            .extract<ShadowBiometricManager>(
-                activity.getSystemService(android.hardware.biometrics.BiometricManager::class.java),
-            ).setCanAuthenticate(true)
-
-        // 실제 AVD에서 버튼이 비활성이라 미도달했던 경로를 열린 상태로 검증한다.
+        // 모델 허용 목록에 기대지 않고 등록된 지문이 있는 일반 기기를 구성한다.
+        ShadowBuild.setModel("generic")
+        shadowOf(activity.packageManager).setSystemFeature(PackageManager.FEATURE_FINGERPRINT, true)
+        Shadow.extract<ShadowFingerprintManager>(activity.getSystemService("fingerprint")).apply {
+            setIsHardwareDetected(true)
+            setDefaultFingerprints(1)
+        }
+        if (Build.VERSION.SDK_INT >= 29) {
+            Shadow
+                .extract<ShadowBiometricManager>(
+                    activity.getSystemService(android.hardware.biometrics.BiometricManager::class.java),
+                ).setCanAuthenticate(true)
+        }
+
+        // AndroidX 결과를 대역으로 바꾸지 않고 실제 라이브러리 사전 검사를 통과해야 한다.
         assertEquals(BiometricManager.BIOMETRIC_SUCCESS, BiometricManager.from(activity).canAuthenticate(BIOMETRIC_STRONG))
-        assertEquals(
-            BiometricManager.BIOMETRIC_ERROR_UNSUPPORTED,
-            BiometricManager.from(activity).canAuthenticate(BIOMETRIC_STRONG or DEVICE_CREDENTIAL),
-        )
+        if (Build.VERSION.SDK_INT in 28..29) {
+            assertEquals(
+                BiometricManager.BIOMETRIC_ERROR_UNSUPPORTED,
+                BiometricManager.from(activity).canAuthenticate(BIOMETRIC_STRONG or DEVICE_CREDENTIAL),
+            )
+        }
         return activity
     }
 }
 
 @AndroidEntryPoint
 class BiometricTestActivity : FragmentActivity()
+
+/** 실제 AndroidX 프롬프트가 호출하는 Android framework 경계만 기록한다. */
+private object RecordedBiometricSession {
+    var authenticationStarts = 0
+    lateinit var error: (Int, String) -> Unit
+    lateinit var failure: () -> Unit
+
+    fun reset() {
+        authenticationStarts = 0
+        error = { _, _ -> error("인증이 시작되지 않았다") }
+        failure = { error("인증이 시작되지 않았다") }
+    }
+}
+
+@Implements(value = android.hardware.biometrics.BiometricPrompt::class, minSdk = 28)
+class RecordingBiometricPrompt {
+    @Implementation
+    fun authenticate(
+        cancel: CancellationSignal,
+        executor: Executor,
+        callback: android.hardware.biometrics.BiometricPrompt.AuthenticationCallback,
+    ) {
+        RecordedBiometricSession.authenticationStarts++
+        RecordedBiometricSession.error = { code, message -> executor.execute { callback.onAuthenticationError(code, message) } }
+        RecordedBiometricSession.failure = { executor.execute { callback.onAuthenticationFailed() } }
+        cancel.setOnCancelListener {
+            executor.execute { callback.onAuthenticationError(BiometricPrompt.ERROR_CANCELED, "canceled") }
+        }
+    }
+
+    @Implementation
+    fun authenticate(
+        crypto: android.hardware.biometrics.BiometricPrompt.CryptoObject,
+        cancel: CancellationSignal,
+        executor: Executor,
+        callback: android.hardware.biometrics.BiometricPrompt.AuthenticationCallback,
+    ) {
+        authenticate(cancel, executor, callback)
+    }
+}
+
+// compileSdk 37은 삭제 예정 framework FingerprintManager를 공개 stub에서 제외한다.
+// Robolectric의 API 26~29 framework 경계는 클래스 이름으로 지정한다.
+@Implements(className = "android.hardware.fingerprint.FingerprintManager")
+class RecordingFingerprintManager : ShadowFingerprintManager() {
+    @Implementation
+    fun authenticate(
+        @ClassName("android.hardware.fingerprint.FingerprintManager\$CryptoObject") crypto: Any?,
+        cancel: CancellationSignal?,
+        flags: Int,
+        @ClassName("android.hardware.fingerprint.FingerprintManager\$AuthenticationCallback") callback: Any,
+        handler: Handler?,
+    ) {
+        RecordedBiometricSession.authenticationStarts++
+        RecordedBiometricSession.error = { code, message ->
+            ReflectionHelpers.callInstanceMethod<Any?>(
+                callback,
+                "onAuthenticationError",
+                ClassParameter.from(Int::class.javaPrimitiveType, code),
+                ClassParameter.from(CharSequence::class.java, message),
+            )
+        }
+        RecordedBiometricSession.failure = {
+            ReflectionHelpers.callInstanceMethod<Any?>(callback, "onAuthenticationFailed")
+        }
+        cancel?.setOnCancelListener { RecordedBiometricSession.error(BiometricPrompt.ERROR_CANCELED, "canceled") }
+    }
+}
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 20863e0487..b5aca90c3b 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -1,6 +1,7 @@
 [versions]
 agp = "9.3.2"
-biometric = "1.1.0"
+# Core 1.19의 FingerprintManagerCompat는 no-op이므로 내부 호환 구현이 있는 Biometric이 필요하다.
+biometric = "1.4.0-alpha07"
 exifinterface = "1.4.2"
 coreKtx = "1.19.0"
 fragmentKtx = "1.8.9"