path: root/docs/superpowers/plans/2026-11-02-compose-entry.md

# Compose UI overhaul, step 3: Entry view. Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Replace the legacy `DecryptActivity` with a Compose entry view behind `MainActivity`'s `EntryRoute`: header (avatar, name, folder), top bar (back, edit, overflow), a first group with password, username and one-time code (countdown bar), a second group with the extra fields. The list navigates to it, `LaunchActivity` shortcuts start on it. Decryption, the passphrase cache, biometric unlock, clipboard handling and the auto-close timer behave as before.

**Architecture:** `EntryRoute(filePath)` (absolute path) gets its own `EntryViewModel` through `hiltViewModel()`. The ViewModel ports `DecryptActivity`'s unlock flow (cache, passphrase prompt, retries, decryption off the main thread, auto-close timer) and holds the decrypted `PasswordEntry` in Compose state only: never in saved state or a route, dropped by the timer and when the back stack entry is popped (its ViewModel is cleared). The activity-bound parts stay in the destination composable: the biometric prompt (needs the `FragmentActivity`), the PGP key import and editor launchers, the clipboard and share intents, and `FLAG_SECURE`, set on the window while the destination is composed. The screen itself is a stateless composable fed by a small pure model (`EntryFields`). `BasePGPActivity` keeps what `PasswordCreationActivity` and `AutofillDecryptActivity` need; its clipboard and `.gpg-id` helpers become top-level `FragmentActivity` extensions in the same file, so `MainActivity` can call them too and the subclasses compile unchanged. `DecryptActivity` and everything only it used are deleted.

**Tech Stack:** Kotlin 2.4.21, Compose BOM 2024.09.03 (Material 3 1.3.0: `TopAppBar`, `LinearProgressIndicator(progress = { })`, `AlertDialog(properties = ...)`), navigation-compose 2.8.9 (type-safe `popUpTo<T>`), `hilt-navigation-compose` 1.2.0, androidx.biometric (unchanged), kotlinx-collections-immutable. No new dependencies.

Spec: `docs/superpowers/specs/2026-11-02-compose-ui-overhaul-design.md`. Earlier plans: `docs/superpowers/plans/2026-11-02-compose-foundation.md`, `docs/superpowers/plans/2026-11-02-compose-list.md`.

## Decisions taken in this plan

- **Entry state lives in a ViewModel scoped to the route's back stack entry.** Reasons: Hilt injects the crypto stack there (the destination composable cannot `@Inject`); `viewModelScope` is cancelled exactly when the entry is popped, which is also when the decrypted entry must go; a theme or locale change (which still recreates `MainActivity`) keeps the decrypted view instead of prompting again. Rotation does not recreate at all (`configChanges="orientation|screenSize"`, kept). The ViewModel takes a `Context` per call (`applicationContext`) and holds no `Context` field (lint `StaticFieldLeak`).
- **FLAG_SECURE:** the entry destination adds the flag in a `DisposableEffect` and clears it on dispose. In this step no two secret-showing destinations are ever composed together (entry to entry transitions do not exist), so a plain add/clear pair is enough; it is `ponytail:` marked so step 4 counts instead if the editor destination can overlap the entry during a transition. The list is not `FLAG_SECURE` today (only `BasePGPActivity` and `PasswordDialog` set it) and stays so. The passphrase dialog sets `SecureFlagPolicy.SecureOn` explicitly.
- **Path check:** routes from the list come from the app's own listing, routes from `LaunchActivity` passed `isFileInRepo`. The destination checks `isFileInRepo` once more before decrypting (the spec asks the entry route to be validated) and closes otherwise.
- **Back and close:** system back is the `NavHost` default (pop to the list, or leave the app when the entry is the start destination). The top bar back, the auto-close timer, a cancelled prompt and too many wrong passphrases all call one `onClose`: pop when there is a previous entry, else `finish()`. It acts only when its entry is on top, so the timer cannot race a back press into a double pop. The list's tap uses the same "only from the top entry" guard as folders, so a double tap does not push the entry twice.
- **Edit:** the top bar edit button starts the legacy `PasswordCreationActivity` for a result, with exactly the extras `DecryptActivity` passed. On `RESULT_OK` (saved) the entry route is popped and the list shows, refreshed by its resume effect; when the entry was the start destination (shortcut), the list root replaces it instead of finishing. No reopen, no second passphrase prompt. Cancelling the editor returns to the unchanged view. (Maintainer decision 3.)
- **Password visibility:** the password row starts revealed or masked per the existing "Show the password" setting (`SHOW_PASSWORD`, default on, as the old screen did); the eye toggles it. (Maintainer decision 2.)
- **Clipboard:** the password and one-time code copy buttons use `copyPasswordToClipboard` (sensitive flag plus the `ClipboardService` clear timer, the mechanism the old "Copy password" menu item used). Username, extra fields and the name use `copyTextToClipboard` (sensitive flag, no timer), as before. (Maintainer decision 1.) "Automatically copy password" (`COPY_ON_DECRYPT`) is kept.
- **OTP countdown:** `Totp` gains `period`, so the bar shows `remainingTime / period`. The label keeps the existing `otp_label_format` ("OTP (expires in %ds)"), which also gives screen readers the countdown the bar cannot.
- **Overflow menu:** "Copy name" (the old screen copied the name on a long press of the title, which a top bar has no room for) and "Share as plaintext" (chooser, as before). The old "Copy password" item is dropped: the password row has the same button.
- **Passphrase dialog:** a Compose `AlertDialog` replaces `PasswordDialog` here (same title, field, "Clear cached password on screen-off" box, "Wrong password" error, Enter submits). The typed passphrase is held in `remember`, never `rememberSaveable`. `PasswordDialog` stays for `AutofillDecryptActivity` until step 7.
- **`BasePGPActivity`:** `copyTextToClipboard`, `copyPasswordToClipboard` and `getPGPIdentifiers` move out of the class into top-level `FragmentActivity` extensions in `BasePGPActivity.kt` (same package, so `PasswordCreationActivity` needs no change; `AutofillDecryptActivity` gains one import). `copyPasswordToClipboard` reads `sharedPrefs` instead of the injected `settings`; both are the same preferences file. The `name` property, used only by `DecryptActivity`, is removed. Everything else stays for `PasswordCreationActivity` (step 4) and `AutofillDecryptActivity` (step 7).
- **Small fixes, recorded:** a cached passphrase that fails is not tried again (the old flow looped on it forever); after the third failed attempt the screen closes instead of calling `finish()` and still showing the dialog; dismissing the "No keys imported" dialog closes the entry instead of leaving an empty screen; reading the file and `isPasswordProtected` run on the IO dispatcher.

## Feature parity (old `DecryptActivity` / `BasePGPActivity` behavior)

| Behavior today | Decision |
|---|---|
| `FLAG_SECURE` on the whole decrypt activity | Port: on while the entry destination is composed, off on the list |
| Title = entry name; header with folder path and name | Port: header with letter avatar, name, folder ("Password store" at the root) |
| Long press on the name copies it | Port as overflow "Copy name" |
| Biometric prompt "Unlock passphrase cache" when the cache feature is on and the device can authenticate | Port unchanged (`BiometricAuthenticator`, same title) |
| Biometric cancelled, failed or unavailable: passphrase prompt | Port |
| `requireKeysExist`: "No keys imported" dialog, Import opens `PGPKeyImportActivity`, success continues, failure finishes | Port as Compose dialog; dismissing it now closes the entry |
| `.gpg-id` lookup up to the store root, snackbars for short or invalid IDs | Port (`getPGPIdentifiers` extension, same messages) |
| Cache cleared on first use after app start or screen off when "Automatically clear" is on | Port |
| Cached passphrase used after a successful biometric prompt | Port; a cached passphrase that fails is not retried (old code looped) |
| Key without passphrase: decrypt with an empty one | Port |
| `PasswordDialog`: field, cache box (only with the cache on), "Wrong password" error, Enter submits, `FLAG_SECURE`, cancel finishes | Port as Compose dialog (`SecureOn`, passphrase only in `remember`); cancel closes the entry. `PasswordDialog` kept for autofill |
| At most 3 passphrase prompts | Port (now really closes after the third) |
| Passphrase cached after a successful prompt following a biometric success; "clear on screen off" choice saved | Port |
| Decryption on the IO dispatcher | Port (`CryptoRepository.decrypt` unchanged; file read and key check also moved off main) |
| Fields: password (eye toggle, `SHOW_PASSWORD` initial state, JetBrains Mono, tap copies), OTP (label with seconds, copy), username (copy), free-form extras (copy) | Port in the spec's order: password, username, OTP in the first group; extras in the second. Monospace kept for the password. Password and one-time code copies start the clear timer |
| OTP refreshed every second | Port (`PasswordEntry.totp` flow) plus a countdown bar |
| "Automatically copy password" on decrypt | Port |
| Auto-close after "Password copy timeout" (`GENERAL_SHOW_TIME`, default 60 s, 0 = never) | Port: the ViewModel drops the entry and the destination closes (leaves the app when it was the start destination) |
| Menu: Edit (legacy editor, then finish) | Port as top bar icon; saving returns to the list (the list root when opened from a shortcut), cancelling returns to the view |
| Menu: Share as plaintext (always a chooser) | Port (overflow) |
| Menu: Copy password | Drop: duplicate of the password row's copy button |
| Up arrow | Port (top bar back) |
| Rotation recreates the screen and asks again | Changed: rotation keeps the view (`configChanges`); theme or locale change keeps it too (ViewModel) |
| Dynamic shortcut added when opened from the list | Port (`MainActivity.addShortcut`) |
| `DecryptActivity`, `decrypt_layout.xml`, `item_field.xml`, `menu/pgp_handler.xml`, `drawable/divider.xml`, `FieldItemAdapter`, `FieldItem`, upstream's unused `ViewPasswordScreen.kt` | Delete (Task 6) |
| `BasePGPActivity`: `repoPath`, `fullPath`, key import, injected `settings`, `repository`, `dispatcherProvider`, `FLAG_SECURE`, path helpers in the companion | Keep for `PasswordCreationActivity` and `AutofillDecryptActivity` |
| `BasePGPActivity.name` | Delete (only `DecryptActivity` used it) |
| Text selection of field values (old `textIsSelectable`) | Dropped: the copy buttons set the sensitive clipboard flag, selection toolbar copies would not |
| `TotpModule` | Also installed in `ViewModelComponent` (needed for `PasswordEntry.Factory` in the ViewModel) |

Left for later steps because other legacy screens still use them: `PasswordDialog` and `dialog_password_entry.xml` (`AutofillDecryptActivity`, step 7), `EditPasswordScreen.kt`, `PasswordField.kt`/`CopyButton`, `APSAppBar.kt` and the ui:compose `PasswordItem.kt` (unused upstream WIP, step 4 or 8), `BasePGPActivity` (steps 4 and 7).

## Lessons from step 2, designed in

- `android:configChanges="orientation|screenSize"` on `MainActivity` stays; the plan relies on it only for rotation. Work that must survive a theme change lives in `viewModelScope`, not `activity.lifecycleScope`.
- Slack compose-lint: no composable members on the activity (`EntryDestination` and `EntryScreen` are top-level and take the activity as a parameter, like `ListDestination`); every public composable has `modifier: Modifier = Modifier` as its first optional parameter; the only collection parameter is inside `EntryFields` (`ImmutableList`, class marked `@Immutable`); the ViewModel is not passed down.
- Accessibility: every `IconButton` has a content description (back, edit, more options, show or hide password, copy); there is no FAB on this screen. `LetterAvatar` clears its own semantics, so the name is read once.
- Focus: the entry screen has no text field; the passphrase dialog requests focus inside its own window, so nothing is left focused when the list comes back (the list's own return handling from step 2 then applies).
- Decryption and entry file IO never run on the main thread.

**Conventions for every task**

- New files get this header:
  ```kotlin
  /*
   * Copyright (C) 2026 Danilo M. <danix@danix.xyz>
   * SPDX-License-Identifier: GPL-3.0-only
   */
  ```
- Commits are GPG-signed (default config, never disable). End each message with
  `Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>`.
- No em dashes in docs, comments or commit messages.
- Before each commit run `./gradlew spotlessApply`, then the step's checks.
- Work on the `compose` branch.

---

### Task 1: OTP period and the entry model (TDD)

**Files:**
- Modify: `format/common/src/main/kotlin/app/passwordstore/data/passfile/Totp.kt`
- Modify: `format/common/src/main/kotlin/app/passwordstore/data/passfile/PasswordEntry.kt`
- Modify: `format/common/src/test/kotlin/app/passwordstore/data/passfile/PasswordEntryTest.kt`
- Create: `app/src/main/java/app/passwordstore/ui/entry/EntryModel.kt`
- Test: `app/src/test/java/app/passwordstore/ui/entry/EntryModelTest.kt`

- [ ] **Step 1: Failing test for the period**

In `PasswordEntryTest.kt`, inside `generatesOtpFromTotpUri`, after
`assertEquals(30.seconds, otp.remainingTime)` add:

```kotlin
      assertEquals(30.seconds, otp.period)
```

Run: `./gradlew :format:common:test --tests app.passwordstore.data.passfile.PasswordEntryTest`
Expected: compilation FAILS with `Unresolved reference 'period'`.

- [ ] **Step 2: Add the period**

Replace the body of `Totp.kt` after the package line with:

```kotlin
import kotlin.time.Duration

/** A TOTP code, how long it stays valid, and the full period it was generated for. */
public data class Totp(
  public val value: String,
  public val remainingTime: Duration,
  public val period: Duration,
)
```

In `PasswordEntry.kt`, `calculateTotp`, replace

```kotlin
      .mapBoth({ code -> Ok(Totp(code, remainingTime)) }, ::Err)
```

with

```kotlin
      .mapBoth({ code -> Ok(Totp(code, remainingTime, totpPeriod.seconds)) }, ::Err)
```

(`totpPeriod` is a `Long`; `kotlin.time.Duration.Companion.seconds` is already imported.)

Run: `./gradlew :format:common:test`
Expected: `BUILD SUCCESSFUL`, all format tests pass. (`format:common` has no metalava API file;
only `autofill-parser` does, so the public constructor change needs no API update.)

- [ ] **Step 3: Failing test for the entry model**

`app/src/test/java/app/passwordstore/ui/entry/EntryModelTest.kt`:

```kotlin
/*
 * Copyright (C) 2026 Danilo M. <danix@danix.xyz>
 * SPDX-License-Identifier: GPL-3.0-only
 */

package app.passwordstore.ui.entry

import app.passwordstore.data.passfile.PasswordEntry
import app.passwordstore.data.passfile.Totp
import app.passwordstore.util.time.UserClock
import app.passwordstore.util.totp.UriTotpFinder
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertNull
import kotlin.test.assertTrue
import kotlin.time.Duration.Companion.seconds

class EntryModelTest {

  private fun entry(content: String) =
    PasswordEntry(UserClock(), UriTotpFinder(), content.encodeToByteArray())

  @Test
  fun firstGroupAndExtrasInFileOrder() {
    val fields =
      entryFields(entry("hunter2\nusername: alice\nurl: https://example.org\npin: 1234\n"))
    assertEquals("hunter2", fields.password)
    assertEquals("alice", fields.username)
    assertEquals(listOf("url" to "https://example.org", "pin" to "1234"), fields.extras)
  }

  @Test
  fun blankPasswordAndMissingUsernameAreLeftOut() {
    val fields = entryFields(entry("\nnote: none\n"))
    assertNull(fields.password)
    assertNull(fields.username)
    assertEquals(listOf("note" to "none"), fields.extras)
  }

  @Test
  fun otpUriIsNotAnExtraField() {
    val fields =
      entryFields(
        entry(
          "s3cret\notpauth://totp/example.com:carol?secret=JBSWY3DPEHPK3PXP&issuer=example.com\n"
        )
      )
    assertEquals("s3cret", fields.password)
    assertTrue(fields.extras.isEmpty())
  }

  @Test
  fun fractionLeftOfTheOtpPeriod() {
    assertEquals(1f, Totp("123456", 30.seconds, 30.seconds).fractionLeft())
    assertEquals(0.5f, Totp("123456", 15.seconds, 30.seconds).fractionLeft())
  }
}
```

Run: `./gradlew :app:testDebugUnitTest --tests app.passwordstore.ui.entry.EntryModelTest`
Expected: compilation FAILS with `Unresolved reference 'entryFields'` and `'fractionLeft'`.

- [ ] **Step 4: The model**

`app/src/main/java/app/passwordstore/ui/entry/EntryModel.kt`:

```kotlin
/*
 * Copyright (C) 2026 Danilo M. <danix@danix.xyz>
 * SPDX-License-Identifier: GPL-3.0-only
 */

package app.passwordstore.ui.entry

import androidx.compose.runtime.Immutable
import app.passwordstore.data.passfile.PasswordEntry
import app.passwordstore.data.passfile.Totp
import kotlinx.collections.immutable.ImmutableList
import kotlinx.collections.immutable.toImmutableList

/**
 * What the entry view shows. [password] and [username] open the first group (the one-time code
 * joins them from the entry's TOTP flow); [extras] are the remaining `key: value` lines in file
 * order, plus lines that are not `key: value` under the parser's "Extra Content" key. Blank values
 * are null, so their rows are not shown.
 */
@Immutable
data class EntryFields(
  val password: String?,
  val username: String?,
  val extras: ImmutableList<Pair<String, String>>,
)

fun entryFields(entry: PasswordEntry): EntryFields =
  EntryFields(
    password = entry.password?.takeIf { it.isNotBlank() },
    username = entry.username?.takeIf { it.isNotBlank() },
    extras = entry.extraContent.toList().toImmutableList(),
  )

/** Share of the code's lifetime left: 1 right after it was generated, toward 0 at expiry. */
fun Totp.fractionLeft(): Float = (remainingTime / period).toFloat()
```

(`PasswordEntry.extraContent` already leaves out the password line, the first username line and
TOTP lines, and is a `LinkedHashMap`, so file order holds.)

Run: `./gradlew :app:testDebugUnitTest --tests app.passwordstore.ui.entry.EntryModelTest`
Expected: `BUILD SUCCESSFUL`, 4 tests passed.

- [ ] **Step 5: Build and commit**

Run: `./gradlew spotlessApply && CI=1 ./gradlew :format:common:test :app:assembleDebug :app:testDebugUnitTest`
Expected: `BUILD SUCCESSFUL`.

```bash
git add format/common/src app/src/main/java/app/passwordstore/ui/entry/EntryModel.kt \
  app/src/test/java/app/passwordstore/ui/entry/EntryModelTest.kt
git commit -m "feat(app): add the entry view model and the OTP period

Totp now carries its period, so the entry view can draw how much of the
code's lifetime is left. EntryFields groups a decrypted entry the way the
spec lays it out.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
```

---

### Task 2: PGP clipboard and identifier helpers become activity extensions

`MainActivity` is not a `BasePGPActivity`, but the entry view needs the same clipboard and
`.gpg-id` behavior. Moving the three helpers out of the class, unchanged, into top-level
`FragmentActivity` extensions in the same file keeps one implementation. Calls inside
`BasePGPActivity` subclasses resolve to the extensions with the activity as implicit receiver,
so `PasswordCreationActivity` and `DecryptActivity` (same package) compile unchanged.

**Files:**
- Modify (replace whole file): `app/src/main/java/app/passwordstore/ui/crypto/BasePGPActivity.kt`
- Modify: `app/src/main/java/app/passwordstore/ui/autofill/AutofillDecryptActivity.kt`

- [ ] **Step 1: BasePGPActivity**

Replace `app/src/main/java/app/passwordstore/ui/crypto/BasePGPActivity.kt` with:

```kotlin
/*
 * Copyright © 2014-2024 The Android Password Store Authors. All Rights Reserved.
 * SPDX-License-Identifier: GPL-3.0-only
 */

package app.passwordstore.ui.crypto

import android.content.ClipData
import android.content.Intent
import android.content.SharedPreferences
import android.os.Build
import android.os.Bundle
import android.os.PersistableBundle
import android.view.WindowManager
import androidx.activity.result.contract.ActivityResultContracts.StartActivityForResult
import androidx.annotation.CallSuper
import androidx.annotation.StringRes
import androidx.appcompat.app.AppCompatActivity
import androidx.fragment.app.FragmentActivity
import androidx.lifecycle.lifecycleScope
import app.passwordstore.R
import app.passwordstore.crypto.PGPIdentifier
import app.passwordstore.data.crypto.CryptoRepository
import app.passwordstore.data.repo.PasswordRepository
import app.passwordstore.injection.prefs.SettingsPreferences
import app.passwordstore.ui.pgp.PGPKeyImportActivity
import app.passwordstore.util.coroutines.DispatcherProvider
import app.passwordstore.util.extensions.clipboard
import app.passwordstore.util.extensions.getString
import app.passwordstore.util.extensions.sharedPrefs
import app.passwordstore.util.extensions.snackbar
import app.passwordstore.util.extensions.unsafeLazy
import app.passwordstore.util.services.ClipboardService
import app.passwordstore.util.settings.Constants
import app.passwordstore.util.settings.PreferenceKeys
import com.google.android.material.dialog.MaterialAlertDialogBuilder
import dagger.hilt.android.AndroidEntryPoint
import java.io.File
import javax.inject.Inject
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext

@Suppress("Registered")
@AndroidEntryPoint
open class BasePGPActivity : AppCompatActivity() {

  /** Full path to the repository */
  val repoPath by unsafeLazy { intent.getStringExtra("REPO_PATH")!! }

  /** Full path to the password file being worked on */
  val fullPath by unsafeLazy { intent.getStringExtra("FILE_PATH")!! }

  /**
   * Name of the password file
   *
   * Converts personal/auth.foo.org/john_doe@example.org.gpg to john_doe.example.org
   */
  val name: String by unsafeLazy { File(fullPath).nameWithoutExtension }

  /** Action to invoke if [keyImportAction] succeeds. */
  private var onKeyImport: (() -> Unit)? = null
  private val keyImportAction =
    registerForActivityResult(StartActivityForResult()) {
      if (it.resultCode == RESULT_OK) {
        onKeyImport?.invoke()
        onKeyImport = null
      } else {
        finish()
      }
    }

  /** [SharedPreferences] instance used by subclasses to persist settings */
  @SettingsPreferences @Inject lateinit var settings: SharedPreferences
  @Inject lateinit var repository: CryptoRepository
  @Inject lateinit var dispatcherProvider: DispatcherProvider

  /**
   * [onCreate] sets the window up with the right flags to prevent auth leaks through screenshots or
   * recent apps screen.
   */
  @CallSuper
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    window.setFlags(WindowManager.LayoutParams.FLAG_SECURE, WindowManager.LayoutParams.FLAG_SECURE)
  }

  /**
   * Function to execute [onKeysExist] only if there are PGP keys imported in the app's key manager.
   */
  fun requireKeysExist(onKeysExist: () -> Unit) {
    lifecycleScope.launch {
      val hasKeys = repository.hasKeys()
      if (!hasKeys) {
        withContext(dispatcherProvider.main()) {
          MaterialAlertDialogBuilder(this@BasePGPActivity)
            .setTitle(resources.getString(R.string.no_keys_imported_dialog_title))
            .setMessage(resources.getString(R.string.no_keys_imported_dialog_message))
            .setPositiveButton(resources.getString(R.string.button_label_import)) { _, _ ->
              onKeyImport = onKeysExist
              keyImportAction.launch(Intent(this@BasePGPActivity, PGPKeyImportActivity::class.java))
            }
            .show()
        }
      } else {
        onKeysExist()
      }
    }
  }

  companion object {

    const val EXTRA_FILE_PATH = "FILE_PATH"
    const val EXTRA_REPO_PATH = "REPO_PATH"

    /** Gets the relative path to the repository */
    fun getRelativePath(fullPath: String, repositoryPath: String): String =
      fullPath.replace(repositoryPath, "").replace("/+".toRegex(), "/")

    /** Gets the Parent path, relative to the repository */
    fun getParentPath(fullPath: String, repositoryPath: String): String {
      val relativePath = getRelativePath(fullPath, repositoryPath)
      val index = relativePath.lastIndexOf("/")
      return "/${relativePath.substring(startIndex = 0, endIndex = index + 1)}/"
        .replace("/+".toRegex(), "/")
    }

    /** /path/to/store/social/facebook.gpg -> social/facebook */
    @JvmStatic
    fun getLongName(fullPath: String, repositoryPath: String, basename: String): String {
      var relativePath = getRelativePath(fullPath, repositoryPath)
      return if (relativePath.isNotEmpty() && relativePath != "/") {
        // remove preceding '/'
        relativePath = relativePath.substring(1)
        if (relativePath.endsWith('/')) {
          relativePath + basename
        } else {
          "$relativePath/$basename"
        }
      } else {
        basename
      }
    }
  }
}

/**
 * Copies provided [text] to the clipboard, flagged sensitive. Below Android 11 it also shows a
 * snackbar, which can be disabled by passing [showSnackbar] as false.
 */
fun FragmentActivity.copyTextToClipboard(
  text: String?,
  showSnackbar: Boolean = true,
  @StringRes snackbarTextRes: Int = R.string.clipboard_copied_text,
) {
  val clipboard = clipboard ?: return
  val clip = ClipData.newPlainText("pgp_handler_result_pm", text)
  clip.description.extras =
    PersistableBundle().apply { putBoolean("android.content.extra.IS_SENSITIVE", true) }
  clipboard.setPrimaryClip(clip)
  if (showSnackbar && Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
    snackbar(message = resources.getString(snackbarTextRes))
  }
}

/**
 * Copies a provided [password] string to the clipboard. This wraps [copyTextToClipboard] and
 * starts off an instance of [ClipboardService] to provide a way of clearing the clipboard.
 */
fun FragmentActivity.copyPasswordToClipboard(password: String?) {
  copyTextToClipboard(password)
  val clearAfter =
    sharedPrefs.getString(PreferenceKeys.GENERAL_SHOW_TIME)?.toIntOrNull()
      ?: Constants.DEFAULT_DECRYPTION_TIMEOUT

  if (clearAfter != 0) {
    val service =
      Intent(this, ClipboardService::class.java).apply {
        action = ClipboardService.ACTION_START
        putExtra(ClipboardService.EXTRA_NOTIFICATION_TIME, clearAfter)
      }
    startForegroundService(service)
  }
}

/**
 * Get a list of available [PGPIdentifier]s for the current password repository. This method
 * throws when no identifiers were able to be parsed. If this method returns null, it means that an
 * invalid identifier was encountered and further execution must stop to let the user correct the
 * problem.
 */
fun FragmentActivity.getPGPIdentifiers(subDir: String): List<PGPIdentifier>? {
  val repoRoot = PasswordRepository.getRepositoryDirectory()
  val gpgIdentifierFile =
    File(repoRoot, subDir).findTillRoot(".gpg-id", repoRoot)
      ?: File(repoRoot, ".gpg-id").apply { createNewFile() }
  val gpgIdentifiers =
    gpgIdentifierFile
      .readLines()
      .filter { it.isNotBlank() }
      .map { line ->
        PGPIdentifier.fromString(line)
          ?: run {
            // The line being empty means this is most likely an empty `.gpg-id`
            // file we created. Skip the validation so we can make the user add a
            // real ID.
            if (line.isEmpty()) return@run
            // Apparently `gpg-id` being the first line is also acceptable?
            if (line == "gpg-id") return@run
            if (line.removePrefix("0x").matches("[a-fA-F0-9]{8}".toRegex())) {
              snackbar(message = resources.getString(R.string.short_gpg_id))
            } else {
              snackbar(message = resources.getString(R.string.invalid_gpg_id))
            }
            return null
          }
      }
      .filterIsInstance<PGPIdentifier>()
  if (gpgIdentifiers.isEmpty()) {
    error("Failed to parse identifiers from .gpg-id: ${gpgIdentifierFile.readText()}")
  }
  return gpgIdentifiers
}

@Suppress("ReturnCount")
private fun File.findTillRoot(fileName: String, rootPath: File): File? {
  val gpgFile = File(this, fileName)
  if (gpgFile.exists()) return gpgFile

  if (this.absolutePath == rootPath.absolutePath) {
    return null
  }
  val parent = parentFile
  return if (parent != null && parent.exists()) {
    parent.findTillRoot(fileName, rootPath)
  } else {
    null
  }
}
```

(`name` stays until Task 6: `DecryptActivity` still uses it.)

- [ ] **Step 2: Autofill imports the moved helper**

In `AutofillDecryptActivity.kt`, after `import app.passwordstore.ui.crypto.PasswordDialog` add:

```kotlin
import app.passwordstore.ui.crypto.getPGPIdentifiers
```

- [ ] **Step 3: Build, lint, commit**

Run: `./gradlew spotlessApply && CI=1 ./gradlew :app:assembleDebug :app:testDebugUnitTest :app:lintDebug`
Expected: `BUILD SUCCESSFUL`. If the compiler reports an unresolved `getPGPIdentifiers`,
`copyTextToClipboard` or `copyPasswordToClipboard` in a file outside `ui/crypto/`, add the
matching `import app.passwordstore.ui.crypto.<name>` there (the grep below should show none).

```bash
grep -rnE 'copyTextToClipboard|copyPasswordToClipboard|getPGPIdentifiers' app/src/main --include=*.kt | grep -v '/ui/crypto/'
```
Expected: only the `AutofillDecryptActivity.kt` import and call.

```bash
git add app/src/main/java/app/passwordstore/ui/crypto/BasePGPActivity.kt \
  app/src/main/java/app/passwordstore/ui/autofill/AutofillDecryptActivity.kt
git commit -m "refactor(app): make the PGP clipboard and .gpg-id helpers extensions

The Compose entry view lives in MainActivity, which is not a
BasePGPActivity. The helpers move unchanged to FragmentActivity
extensions in the same file, so the existing subclasses keep calling
them as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
```

---

### Task 3: Entry ViewModel

Ports `DecryptActivity`'s unlock flow, minus the parts that need the activity (biometric prompt,
`.gpg-id` snackbars, launchers, clipboard), which the destination does in Task 5.

**Files:**
- Create: `app/src/main/java/app/passwordstore/ui/entry/EntryViewModel.kt`

- [ ] **Step 1: The ViewModel**

`app/src/main/java/app/passwordstore/ui/entry/EntryViewModel.kt`:

```kotlin
/*
 * Copyright (C) 2026 Danilo M. <danix@danix.xyz>
 * SPDX-License-Identifier: GPL-3.0-only
 */

package app.passwordstore.ui.entry

import android.content.Context
import android.content.SharedPreferences
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.setValue
import androidx.core.content.edit
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import app.passwordstore.Application.Companion.screenWasOff
import app.passwordstore.crypto.PGPIdentifier
import app.passwordstore.data.crypto.CryptoRepository
import app.passwordstore.data.crypto.PGPPassphraseCache
import app.passwordstore.data.passfile.PasswordEntry
import app.passwordstore.injection.prefs.SettingsPreferences
import app.passwordstore.util.auth.BiometricAuthenticator.Result as BiometricResult
import app.passwordstore.util.coroutines.DispatcherProvider
import app.passwordstore.util.extensions.getString
import app.passwordstore.util.features.Feature.EnablePGPPassphraseCache
import app.passwordstore.util.features.Features
import app.passwordstore.util.settings.Constants
import app.passwordstore.util.settings.PreferenceKeys
import com.github.michaelbull.result.onFailure
import com.github.michaelbull.result.runCatching
import dagger.hilt.android.lifecycle.HiltViewModel
import java.io.ByteArrayOutputStream
import java.io.File
import javax.inject.Inject
import kotlin.time.Duration.Companion.seconds
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import logcat.LogPriority.ERROR
import logcat.asLog
import logcat.logcat

/** The dialog the entry destination shows, if any. */
enum class EntryPrompt {
  None,
  NoKeys,
  Passphrase,
  WrongPassphrase,
}

/**
 * Decrypts one entry as the old decrypt screen did: passphrase cache, passphrase prompt with
 * retries, then the auto-close timer. The decrypted [entry] lives only in memory: never in saved
 * state or a route argument. The timer drops it, and so does popping the destination (its back
 * stack entry clears this ViewModel). Holds no Context; calls take one and use the application
 * context.
 */
@HiltViewModel
class EntryViewModel
@Inject
constructor(
  private val repository: CryptoRepository,
  private val entryFactory: PasswordEntry.Factory,
  private val passphraseCache: PGPPassphraseCache,
  private val features: Features,
  @SettingsPreferences private val settings: SharedPreferences,
  private val dispatcherProvider: DispatcherProvider,
) : ViewModel() {

  var entry by mutableStateOf<PasswordEntry?>(null)
    private set

  var prompt by mutableStateOf(EntryPrompt.None)
    private set

  /** Set when the destination must close: timer, cancelled prompt, too many wrong passphrases. */
  var closed by mutableStateOf(false)
    private set

  /** Initial state of the passphrase dialog's "clear on screen off" box. */
  var clearCache by mutableStateOf(true)
    private set

  val cacheEnabled: Boolean
    get() = features.isEnabled(EnablePGPPassphraseCache)

  private var started = false
  private var copyOnDecrypt = false
  private var retries = 0
  private var auth: BiometricResult = BiometricResult.CanceledByUser
  private var ids: List<PGPIdentifier> = emptyList()
  private var file: File? = null

  /** True the first time only: a recreated activity must not run the unlock flow again. */
  fun start(): Boolean {
    if (started) return false
    started = true
    return true
  }

  /** False, with the "no keys" prompt up, while no PGP key is imported. */
  suspend fun checkKeys(): Boolean {
    val hasKeys = repository.hasKeys()
    if (!hasKeys) prompt = EntryPrompt.NoKeys
    return hasKeys
  }

  /** Continues after the biometric prompt (or without one) with its [auth] result. */
  fun unlock(file: File, ids: List<PGPIdentifier>, auth: BiometricResult, context: Context) {
    this.file = file
    this.ids = ids
    this.auth = auth
    val app = context.applicationContext
    viewModelScope.launch { next(isError = false, app) }
  }

  fun submit(passphrase: String, clearCache: Boolean, context: Context) {
    prompt = EntryPrompt.None
    this.clearCache = clearCache
    val app = context.applicationContext
    viewModelScope.launch {
      if (decrypt(passphrase, app) && auth is BiometricResult.Success) {
        runCatching {
            passphraseCache.cachePassphrase(app, ids.first(), passphrase)
            settings.edit { putBoolean(PreferenceKeys.CLEAR_PASSPHRASE_CACHE, clearCache) }
          }
          .onFailure { e -> logcat { e.asLog() } }
      }
    }
  }

  fun dismissPrompt() {
    prompt = EntryPrompt.None
  }

  fun cancel() {
    prompt = EntryPrompt.None
    closed = true
  }

  /** True once after a decryption when "Automatically copy password" is on. */
  fun takeCopyOnDecrypt(): Boolean = copyOnDecrypt.also { copyOnDecrypt = false }

  override fun onCleared() {
    entry = null
  }

  private suspend fun next(isError: Boolean, context: Context) {
    when (auth) {
      // Handled inside the biometric prompt.
      BiometricResult.Retry -> Unit
      is BiometricResult.Success -> {
        // Clear the cache on first use after app start or after the screen was off; this also
        // purges a stale cache after caching was disabled in the PGP settings.
        clearCache = settings.getBoolean(PreferenceKeys.CLEAR_PASSPHRASE_CACHE, true)
        if (screenWasOff && clearCache) {
          passphraseCache.clearAllCachedPassphrases(context)
          screenWasOff = false
        }
        // A cached passphrase that just failed is not tried again (the old screen looped on it).
        val cached =
          if (isError) null else passphraseCache.retrieveCachedPassphrase(context, ids.first())
        if (cached != null) decrypt(cached, context) else ask(isError, context)
      }
      else -> ask(isError, context)
    }
  }

  private suspend fun ask(isError: Boolean, context: Context) {
    if (retries >= MAX_RETRIES) {
      closed = true
      return
    }
    retries++
    if (withContext(dispatcherProvider.io()) { repository.isPasswordProtected(ids) }) {
      prompt = if (isError) EntryPrompt.WrongPassphrase else EntryPrompt.Passphrase
    } else {
      decrypt(passphrase = "", context)
    }
  }

  /** Decrypts off the main thread; a failure goes back to [next] with an error. */
  private suspend fun decrypt(passphrase: String, context: Context): Boolean {
    val source = file ?: return false
    val bytes = withContext(dispatcherProvider.io()) { source.readBytes() }
    val out = ByteArrayOutputStream()
    val result = repository.decrypt(passphrase, ids, bytes.inputStream(), out)
    if (!result.isOk) {
      logcat(ERROR) { result.error.stackTraceToString() }
      next(isError = true, context)
      return false
    }
    copyOnDecrypt = settings.getBoolean(PreferenceKeys.COPY_ON_DECRYPT, false)
    entry = withContext(dispatcherProvider.io()) { entryFactory.create(out.toByteArray()) }
    startTimer()
    return true
  }

  /** Drops the entry and closes after the "Password copy timeout" setting (0 = never). */
  private fun startTimer() {
    val timeout =
      settings.getString(PreferenceKeys.GENERAL_SHOW_TIME)?.toIntOrNull()
        ?: Constants.DEFAULT_DECRYPTION_TIMEOUT
    if (timeout == 0) return
    viewModelScope.launch {
      delay(timeout.seconds)
      entry = null
      closed = true
    }
  }

  private companion object {
    const val MAX_RETRIES = 3
  }
}
```

- [ ] **Step 2: Build, lint, commit**

Run: `./gradlew spotlessApply && CI=1 ./gradlew :app:assembleDebug :app:lintDebug`
Expected: `BUILD SUCCESSFUL` (the ViewModel is not used yet; Hilt still generates its factory).
If `when (auth)` reports `Retry` as needing `is`, write `is BiometricResult.Retry -> Unit`.

```bash
git add app/src/main/java/app/passwordstore/ui/entry/EntryViewModel.kt
git commit -m "feat(app): add the entry ViewModel

Ports the decrypt screen's unlock flow: passphrase cache after a
biometric success, passphrase prompt with three tries, decryption off
the main thread and the auto-close timer. The decrypted entry is held in
memory only and dropped by the timer or when the destination is popped.
A cached passphrase that fails is no longer retried in a loop.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
```

---

### Task 4: Entry screen (stateless UI), field row options and strings

**Files:**
- Modify (replace whole file): `ui/compose/src/main/kotlin/app/passwordstore/ui/compose/FieldRow.kt`
- Create: `app/src/main/java/app/passwordstore/ui/entry/EntryScreen.kt`
- Modify: `app/src/main/res/values/strings.xml`
- Modify: `app/src/main/res/values-it/strings.xml`

- [ ] **Step 1: FieldRow: initial reveal state and a monospace password**

`FieldRow` has no callers yet. Replace
`ui/compose/src/main/kotlin/app/passwordstore/ui/compose/FieldRow.kt` with:

```kotlin
/*
 * Copyright (C) 2026 Danilo M. <danix@danix.xyz>
 * SPDX-License-Identifier: GPL-3.0-only
 */

package app.passwordstore.ui.compose

import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.saveable.rememberSaveable
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.text.font.Font
import androidx.compose.ui.text.font.FontFamily
import app.passwordstore.ui.compose.preview.ThemePreviews
import app.passwordstore.ui.compose.theme.APSTheme
import app.passwordstore.ui.compose.theme.SpacingLarge
import app.passwordstore.ui.compose.theme.SpacingMedium

/** Content descriptions for [FieldRow]'s buttons, supplied by the app's translated strings. */
public data class FieldRowLabels(val copy: String, val show: String, val hide: String)

/** Masked values (passwords) use a monospace face, so 0 and O, l and 1 stay apart. */
private val Monospace = FontFamily(Font(R.font.jetbrainsmono_nl_regular))

/**
 * A labelled value with an optional copy button. When [masked] is true the value is hidden behind
 * dots until the reveal toggle is pressed, unless [initiallyRevealed] shows it from the start.
 */
@Composable
public fun FieldRow(
  label: String,
  value: String,
  labels: FieldRowLabels,
  modifier: Modifier = Modifier,
  masked: Boolean = false,
  initiallyRevealed: Boolean = false,
  onCopy: (() -> Unit)? = null,
) {
  var revealed by rememberSaveable { mutableStateOf(initiallyRevealed) }
  Row(
    modifier
      .fillMaxWidth()
      .padding(
        start = SpacingLarge,
        end = SpacingMedium,
        top = SpacingMedium,
        bottom = SpacingMedium,
      ),
    verticalAlignment = Alignment.CenterVertically,
  ) {
    Column(Modifier.weight(1f)) {
      Text(
        label,
        style = MaterialTheme.typography.labelMedium,
        color = MaterialTheme.colorScheme.onSurfaceVariant,
      )
      val style = MaterialTheme.typography.bodyLarge
      Text(
        if (masked && !revealed) "•".repeat(10) else value,
        style = if (masked) style.copy(fontFamily = Monospace) else style,
      )
    }
    if (masked)
      IconButton(onClick = { revealed = !revealed }) {
        Icon(
          painterResource(
            if (revealed) R.drawable.baseline_visibility_off_24
            else R.drawable.baseline_visibility_24
          ),
          contentDescription = if (revealed) labels.hide else labels.show,
        )
      }
    if (onCopy != null)
      IconButton(onClick = onCopy) {
        Icon(painterResource(R.drawable.ic_content_copy), contentDescription = labels.copy)
      }
  }
}

@ThemePreviews
@Composable
private fun FieldRowPreview() {
  val labels = FieldRowLabels("Copy", "Show", "Hide")
  APSTheme {
    GroupedSurface {
      FieldRow("Password", "hunter2", labels, masked = true, onCopy = {})
      FieldRow("Username", "you", labels, onCopy = {})
    }
  }
}
```

(The JetBrains Mono font was used only by the old `FieldItemAdapter` and an autofill layout;
`FieldRow` keeps it used once the adapter is deleted in Task 6.)

- [ ] **Step 2: Strings**

In `app/src/main/res/values/strings.xml`, before `</resources>`, add:

```xml

  <!-- Compose entry view -->
  <string name="entry_back">Back</string>
  <string name="entry_show_password">Show password</string>
  <string name="entry_hide_password">Hide password</string>
  <string name="entry_copy_name">Copy name</string>
```

In `app/src/main/res/values-it/strings.xml`, before `</resources>`, add:

```xml

  <!-- Compose entry view -->
  <string name="entry_back">Indietro</string>
  <string name="entry_show_password">Mostra password</string>
  <string name="entry_hide_password">Nascondi password</string>
  <string name="entry_copy_name">Copia nome</string>
```

Everything else the screen shows already exists in both locales: `password`, `username`,
`otp_label_format`, `copy_label`, `copy_password`, `edit_password`, `share_as_plaintext`,
`list_more_options`, `list_store_root`.

- [ ] **Step 3: The screen**

`app/src/main/java/app/passwordstore/ui/entry/EntryScreen.kt`:

```kotlin
/*
 * Copyright (C) 2026 Danilo M. <danix@danix.xyz>
 * SPDX-License-Identifier: GPL-3.0-only
 */

package app.passwordstore.ui.entry

import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.rememberScrollState
import androidx.compose.foundation.verticalScroll
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.automirrored.filled.ArrowBack
import androidx.compose.material.icons.filled.MoreVert
import androidx.compose.material3.DropdownMenu
import androidx.compose.material3.DropdownMenuItem
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.LinearProgressIndicator
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.getValue
import androidx.compose.runtime.key
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.painterResource
import androidx.compose.ui.res.stringResource
import app.passwordstore.R
import app.passwordstore.ui.compose.FieldRow
import app.passwordstore.ui.compose.FieldRowLabels
import app.passwordstore.ui.compose.GroupedSurface
import app.passwordstore.ui.compose.LetterAvatar
import app.passwordstore.ui.compose.theme.SpacingLarge
import app.passwordstore.ui.compose.theme.SpacingMedium

/**
 * One entry: header (avatar, name, [folder] relative to the store root, "" at the root), then the
 * password, username and one-time code, then the extra fields. [fields] is null until decrypted;
 * [otp] is null when the entry has no TOTP. [onCopySecret] (password, one-time code) is separate
 * from [onCopy] because only those copies start the clipboard clear timer.
 */
@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun EntryScreen(
  name: String,
  folder: String,
  fields: EntryFields?,
  otp: String?,
  otpSecondsLeft: Long,
  otpFractionLeft: Float,
  showPassword: Boolean,
  onBack: () -> Unit,
  onEdit: () -> Unit,
  onShare: () -> Unit,
  onCopyName: () -> Unit,
  onCopySecret: (String) -> Unit,
  onCopy: (String) -> Unit,
  modifier: Modifier = Modifier,
) {
  var menu by remember { mutableStateOf(false) }
  val labels =
    FieldRowLabels(
      copy = stringResource(R.string.copy_label),
      show = stringResource(R.string.entry_show_password),
      hide = stringResource(R.string.entry_hide_password),
    )
  Scaffold(
    modifier = modifier,
    topBar = {
      TopAppBar(
        title = {},
        navigationIcon = {
          IconButton(onClick = onBack) {
            Icon(Icons.AutoMirrored.Filled.ArrowBack, stringResource(R.string.entry_back))
          }
        },
        actions = {
          if (fields != null)
            IconButton(onClick = onEdit) {
              Icon(
                painterResource(R.drawable.ic_edit_24dp),
                contentDescription = stringResource(R.string.edit_password),
              )
            }
          Box {
            IconButton(onClick = { menu = true }) {
              Icon(Icons.Filled.MoreVert, stringResource(R.string.list_more_options))
            }
            DropdownMenu(expanded = menu, onDismissRequest = { menu = false }) {
              DropdownMenuItem(
                text = { Text(stringResource(R.string.entry_copy_name)) },
                onClick = {
                  menu = false
                  onCopyName()
                },
              )
              if (fields?.password != null)
                DropdownMenuItem(
                  text = { Text(stringResource(R.string.share_as_plaintext)) },
                  onClick = {
                    menu = false
                    onShare()
                  },
                  leadingIcon = {
                    Icon(painterResource(R.drawable.ic_share_24dp), contentDescription = null)
                  },
                )
            }
          }
        },
      )
    },
  ) { padding ->
    Column(Modifier.padding(padding).fillMaxSize().verticalScroll(rememberScrollState())) {
      Row(
        Modifier.fillMaxWidth().padding(horizontal = SpacingLarge, vertical = SpacingMedium),
        verticalAlignment = Alignment.CenterVertically,
      ) {
        LetterAvatar(name)
        Column(Modifier.weight(1f).padding(start = SpacingLarge)) {
          Text(name, style = MaterialTheme.typography.titleLarge)
          Text(
            if (folder.isEmpty()) stringResource(R.string.list_store_root) else folder,
            style = MaterialTheme.typography.bodyMedium,
            color = MaterialTheme.colorScheme.onSurfaceVariant,
          )
        }
      }
      if (fields != null) {
        if (fields.password != null || fields.username != null || otp != null)
          GroupedSurface(Modifier.fillMaxWidth()) {
            if (fields.password != null)
              FieldRow(
                label = stringResource(R.string.password),
                value = fields.password,
                labels = labels.copy(copy = stringResource(R.string.copy_password)),
                masked = true,
                initiallyRevealed = showPassword,
                onCopy = { onCopySecret(fields.password) },
              )
            if (fields.username != null)
              FieldRow(
                label = stringResource(R.string.username),
                value = fields.username,
                labels = labels,
                onCopy = { onCopy(fields.username) },
              )
            if (otp != null) {
              FieldRow(
                label = stringResource(R.string.otp_label_format, otpSecondsLeft),
                value = otp,
                labels = labels,
                onCopy = { onCopySecret(otp) },
              )
              LinearProgressIndicator(
                progress = { otpFractionLeft },
                modifier =
                  Modifier.fillMaxWidth()
                    .padding(start = SpacingLarge, end = SpacingLarge, bottom = SpacingMedium),
              )
            }
          }
        if (fields.extras.isNotEmpty())
          GroupedSurface(Modifier.fillMaxWidth()) {
            fields.extras.forEach { (label, value) ->
              key(label) { FieldRow(label, value, labels, onCopy = { onCopy(value) }) }
            }
          }
      }
    }
  }
}
```

- [ ] **Step 4: Build, lint, commit**

Run: `./gradlew spotlessApply && CI=1 ./gradlew :app:assembleDebug :app:lintDebug :ui:compose:lintDebug`
Expected: `BUILD SUCCESSFUL`. If `Icons.AutoMirrored.Filled.ArrowBack` does not resolve, use
`painterResource(R.drawable.ic_arrow_back_black_24dp)` with the same content description. If a
compose-lint rule fires on `EntryScreen`'s parameters, follow its message (the usual fix is
parameter order: required, then `modifier`, then optional).

```bash
git add ui/compose/src/main/kotlin/app/passwordstore/ui/compose/FieldRow.kt \
  app/src/main/java/app/passwordstore/ui/entry/EntryScreen.kt \
  app/src/main/res/values/strings.xml app/src/main/res/values-it/strings.xml
git commit -m "feat(app): add the Compose entry screen

Header with avatar, name and folder; password, username and one-time
code with a countdown bar in the first group; extra fields in the second.
FieldRow can start revealed (the \"Show the password\" setting) and shows
masked values in JetBrains Mono, as the old screen did.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
```

---

### Task 5: Entry destination and navigation

After this task the list and the shortcuts open entries in Compose. `DecryptActivity` still
compiles but nothing starts it (deleted in Task 6).

**Files:**
- Create: `app/src/main/java/app/passwordstore/ui/entry/EntryDestination.kt`
- Modify (replace whole file): `app/src/main/java/app/passwordstore/ui/main/MainActivity.kt`
- Modify: `app/src/main/java/app/passwordstore/ui/list/ListDestination.kt`

- [ ] **Step 1: The destination**

`app/src/main/java/app/passwordstore/ui/entry/EntryDestination.kt`:

```kotlin
/*
 * Copyright (C) 2026 Danilo M. <danix@danix.xyz>
 * SPDX-License-Identifier: GPL-3.0-only
 */

package app.passwordstore.ui.entry

import android.app.Activity
import android.content.Intent
import android.view.WindowManager
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.activity.result.contract.ActivityResultContracts.StartActivityForResult
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.selection.toggleable
import androidx.compose.foundation.text.KeyboardActions
import androidx.compose.foundation.text.KeyboardOptions
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Checkbox
import androidx.compose.material3.OutlinedTextField
import androidx.compose.material3.Text
import androidx.compose.material3.TextButton
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.produceState
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.focus.FocusRequester
import androidx.compose.ui.focus.focusRequester
import androidx.compose.ui.res.stringResource
import androidx.compose.ui.semantics.Role
import androidx.compose.ui.text.input.ImeAction
import androidx.compose.ui.text.input.KeyboardType
import androidx.compose.ui.text.input.PasswordVisualTransformation
import androidx.compose.ui.window.DialogProperties
import androidx.compose.ui.window.SecureFlagPolicy
import androidx.hilt.navigation.compose.hiltViewModel
import app.passwordstore.R
import app.passwordstore.data.passfile.PasswordEntry
import app.passwordstore.data.passfile.Totp
import app.passwordstore.data.repo.PasswordRepository
import app.passwordstore.ui.crypto.BasePGPActivity
import app.passwordstore.ui.crypto.BasePGPActivity.Companion.getParentPath
import app.passwordstore.ui.crypto.PasswordCreationActivity
import app.passwordstore.ui.crypto.copyPasswordToClipboard
import app.passwordstore.ui.crypto.copyTextToClipboard
import app.passwordstore.ui.crypto.getPGPIdentifiers
import app.passwordstore.ui.main.LaunchActivity
import app.passwordstore.ui.main.MainActivity
import app.passwordstore.ui.pgp.PGPKeyImportActivity
import app.passwordstore.util.auth.BiometricAuthenticator
import app.passwordstore.util.auth.BiometricAuthenticator.Result as BiometricResult
import app.passwordstore.util.extensions.sharedPrefs
import app.passwordstore.util.settings.PreferenceKeys
import java.io.File

/**
 * One entry: wires [EntryScreen] to the [viewModel], the biometric and passphrase prompts, the
 * clipboard and the legacy editor. [onClose] leaves the destination; [onSaved] runs after the
 * editor saved the entry (the host returns to the list).
 */
@Composable
fun EntryDestination(
  activity: MainActivity,
  file: File,
  onClose: () -> Unit,
  onSaved: () -> Unit,
  modifier: Modifier = Modifier,
  viewModel: EntryViewModel = hiltViewModel(),
) {
  val root = PasswordRepository.getRepositoryDirectory()

  // Secrets stay out of screenshots and recents while this destination is composed.
  // ponytail: plain add/clear, fine while no other secret-showing destination can overlap this
  // one in a transition; count in MainActivity once the editor (step 4) becomes a destination.
  DisposableEffect(Unit) {
    activity.window.addFlags(WindowManager.LayoutParams.FLAG_SECURE)
    onDispose { activity.window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE) }
  }

  // Routes come from the app's own listing or from LaunchActivity's check; check once more.
  val inRepo = remember(file) { LaunchActivity.isFileInRepo(file.path, root) }
  LaunchedEffect(inRepo) { if (!inRepo) onClose() }
  if (!inRepo) return

  fun unlock() {
    val ids =
      activity.getPGPIdentifiers(getParentPath(file.absolutePath, root.absolutePath)) ?: return
    if (viewModel.cacheEnabled && BiometricAuthenticator.canAuthenticate(activity)) {
      BiometricAuthenticator.authenticate(
        activity,
        R.string.biometric_prompt_title_gpg_passphrase_cache,
      ) { result ->
        viewModel.unlock(file, ids, result, activity)
      }
    } else {
      viewModel.unlock(file, ids, BiometricResult.CanceledByUser, activity)
    }
  }

  val keyImport =
    rememberLauncherForActivityResult(StartActivityForResult()) { result ->
      if (result.resultCode == Activity.RESULT_OK) unlock() else onClose()
    }
  val editor =
    rememberLauncherForActivityResult(StartActivityForResult()) { result ->
      if (result.resultCode == Activity.RESULT_OK) onSaved()
    }

  // ponytail: a theme or locale change while the biometric prompt is up loses that prompt's
  // callback (the flow already counts as started); back out and reopen the entry.
  LaunchedEffect(Unit) { if (viewModel.start() && viewModel.checkKeys()) unlock() }
  LaunchedEffect(viewModel.closed) { if (viewModel.closed) onClose() }

  val entry = viewModel.entry
  LaunchedEffect(entry) {
    val password = entry?.password
    if (viewModel.takeCopyOnDecrypt() && !password.isNullOrBlank()) {
      activity.copyPasswordToClipboard(password)
    }
  }
  val fields = remember(entry) { entry?.let(::entryFields) }
  val totp by
    produceState<Totp?>(null, entry) {
      if (entry != null && entry.hasTotp()) entry.totp.collect { value = it }
    }
  val folder =
    remember(file) {
      file.canonicalFile.parentFile?.relativeTo(root.canonicalFile)?.path.orEmpty()
    }
  val showPassword = remember {
    activity.sharedPrefs.getBoolean(PreferenceKeys.SHOW_PASSWORD, true)
  }

  Box(modifier) {
    EntryScreen(
      name = file.nameWithoutExtension,
      folder = folder,
      fields = fields,
      otp = totp?.value,
      otpSecondsLeft = totp?.remainingTime?.inWholeSeconds ?: 0L,
      otpFractionLeft = totp?.fractionLeft() ?: 0f,
      showPassword = showPassword,
      onBack = onClose,
      onEdit = { entry?.let { editor.launch(editIntent(activity, file, root, it)) } },
      onShare = { fields?.password?.let { activity.startActivity(shareIntent(activity, it)) } },
      onCopyName = { activity.copyTextToClipboard(file.nameWithoutExtension) },
      onCopySecret = { activity.copyPasswordToClipboard(it) },
      onCopy = { activity.copyTextToClipboard(it) },
    )

    when (viewModel.prompt) {
      EntryPrompt.None -> Unit
      EntryPrompt.NoKeys ->
        AlertDialog(
          onDismissRequest = viewModel::cancel,
          title = { Text(stringResource(R.string.no_keys_imported_dialog_title)) },
          text = { Text(stringResource(R.string.no_keys_imported_dialog_message)) },
          confirmButton = {
            TextButton(
              onClick = {
                viewModel.dismissPrompt()
                keyImport.launch(Intent(activity, PGPKeyImportActivity::class.java))
              }
            ) {
              Text(stringResource(R.string.button_label_import))
            }
          },
        )
      EntryPrompt.Passphrase,
      EntryPrompt.WrongPassphrase ->
        PassphraseDialog(
          wrong = viewModel.prompt == EntryPrompt.WrongPassphrase,
          cacheEnabled = viewModel.cacheEnabled,
          clearCache = viewModel.clearCache,
          onSubmit = { passphrase, clear -> viewModel.submit(passphrase, clear, activity) },
          onCancel = viewModel::cancel,
        )
    }
  }
}

/** Asks for the PGP passphrase, as the old `PasswordDialog` did. */
@Composable
private fun PassphraseDialog(
  wrong: Boolean,
  cacheEnabled: Boolean,
  clearCache: Boolean,
  onSubmit: (passphrase: String, clearCache: Boolean) -> Unit,
  onCancel: () -> Unit,
) {
  // remember, never rememberSaveable: the passphrase must not reach saved state.
  var passphrase by remember { mutableStateOf("") }
  var clear by remember { mutableStateOf(clearCache) }
  var error by remember { mutableStateOf(wrong) }
  val focus = remember { FocusRequester() }
  AlertDialog(
    onDismissRequest = onCancel,
    properties = DialogProperties(securePolicy = SecureFlagPolicy.SecureOn),
    title = { Text(stringResource(R.string.password)) },
    text = {
      Column {
        OutlinedTextField(
          value = passphrase,
          onValueChange = {
            passphrase = it
            error = false
          },
          modifier = Modifier.focusRequester(focus),
          label = { Text(stringResource(R.string.password)) },
          supportingText =
            if (error) {
              { Text(stringResource(R.string.git_operation_wrong_password)) }
            } else null,
          isError = error,
          singleLine = true,
          visualTransformation = PasswordVisualTransformation(),
          keyboardOptions =
            KeyboardOptions(keyboardType = KeyboardType.Password, imeAction = ImeAction.Done),
          keyboardActions = KeyboardActions(onDone = { onSubmit(passphrase, clear) }),
        )
        if (cacheEnabled)
          Row(
            Modifier.toggleable(value = clear, role = Role.Checkbox, onValueChange = { clear = it }),
            verticalAlignment = Alignment.CenterVertically,
          ) {
            Checkbox(checked = clear, onCheckedChange = null)
            Text(stringResource(R.string.clear_cached_password_on_screen_off))
          }
      }
      LaunchedEffect(Unit) { focus.requestFocus() }
    },
    confirmButton = {
      TextButton(onClick = { onSubmit(passphrase, clear) }) {
        Text(stringResource(R.string.dialog_ok))
      }
    },
  )
}

/** The legacy editor, filled exactly as the old decrypt screen filled it. */
private fun editIntent(activity: Activity, file: File, root: File, entry: PasswordEntry): Intent =
  Intent(activity, PasswordCreationActivity::class.java)
    .setAction(Intent.ACTION_VIEW)
    .putExtra(BasePGPActivity.EXTRA_FILE_PATH, getParentPath(file.absolutePath, root.absolutePath))
    .putExtra(BasePGPActivity.EXTRA_REPO_PATH, root.absolutePath)
    .putExtra(PasswordCreationActivity.EXTRA_FILE_NAME, file.nameWithoutExtension)
    .putExtra(PasswordCreationActivity.EXTRA_USERNAME, entry.username)
    .putExtra(PasswordCreationActivity.EXTRA_PASSWORD, entry.password)
    .putExtra(PasswordCreationActivity.EXTRA_EXTRA_CONTENT, entry.extraContentWithoutUsername)
    .putExtra(PasswordCreationActivity.EXTRA_EDITING, true)

/** Always a chooser, so the user can still cancel. */
private fun shareIntent(activity: Activity, password: String): Intent =
  Intent.createChooser(
    Intent(Intent.ACTION_SEND).putExtra(Intent.EXTRA_TEXT, password).setType("text/plain"),
    activity.getText(R.string.send_plaintext_password_to),
  )
```

(`root.absolutePath` and `file.absolutePath` as `REPO_PATH`/`FILE_PATH`, not canonical paths:
the editor hashes `"$repoPath/..."` for the recently-used history, and those keys were written
with absolute paths. The header folder uses canonical paths only for display.)

- [ ] **Step 2: The list hands entries to the host**

In `ListDestination.kt`:

Replace the KDoc sentence
` * legacy activities and the store operations. [onOpenFolder] takes a path relative to the root.`
with
` * legacy activities and the store operations. [onOpenFolder] takes a path relative to the root,`
` * [onOpenEntry] an entry file.`

In the parameter list, replace

```kotlin
  onOpenFolder: (relativePath: String) -> Unit,
  modifier: Modifier = Modifier,
```

with

```kotlin
  onOpenFolder: (relativePath: String) -> Unit,
  onOpenEntry: (File) -> Unit,
  modifier: Modifier = Modifier,
```

and in the `ListScreen(...)` call replace

```kotlin
      onOpenEntry = { entry ->
        activity.recordUse(File(entry))
        activity.openEntry(File(entry))
      },
```

with

```kotlin
      onOpenEntry = { entry ->
        activity.recordUse(File(entry))
        onOpenEntry(File(entry))
      },
```

- [ ] **Step 3: MainActivity**

Replace `app/src/main/java/app/passwordstore/ui/main/MainActivity.kt` with:

```kotlin
/*
 * Copyright (C) 2026 Danilo M. <danix@danix.xyz>
 * SPDX-License-Identifier: GPL-3.0-only
 */

package app.passwordstore.ui.main

import android.content.Intent
import android.os.Bundle
import androidx.activity.compose.setContent
import androidx.navigation.compose.NavHost
import androidx.navigation.compose.composable
import androidx.navigation.compose.rememberNavController
import androidx.navigation.toRoute
import app.passwordstore.data.password.PasswordItem
import app.passwordstore.data.repo.PasswordRepository
import app.passwordstore.ui.compose.theme.APSTheme
import app.passwordstore.ui.crypto.BasePGPActivity
import app.passwordstore.ui.crypto.PasswordCreationActivity
import app.passwordstore.ui.entry.EntryDestination
import app.passwordstore.ui.git.base.BaseGitActivity
import app.passwordstore.ui.list.ListDestination
import app.passwordstore.ui.list.folderMoves
import app.passwordstore.ui.onboarding.activity.OnboardingActivity
import app.passwordstore.ui.settings.SettingsActivity
import app.passwordstore.util.extensions.launchActivity
import app.passwordstore.util.extensions.sharedPrefs
import app.passwordstore.util.settings.AuthMode
import app.passwordstore.util.settings.PreferenceKeys
import app.passwordstore.util.shortcuts.ShortcutHandler
import com.github.michaelbull.result.onFailure
import dagger.hilt.android.AndroidEntryPoint
import java.io.File
import javax.inject.Inject
import kotlinx.collections.immutable.ImmutableList
import kotlinx.collections.immutable.persistentListOf
import kotlinx.serialization.Serializable

/**
 * The password list of the folder at [path], relative to the store root ("" is the root). The back
 * stack holds one entry per folder level.
 */
@Serializable data class ListRoute(val path: String = "")

/**
 * One entry, by absolute path. Paths from [LaunchActivity] passed [LaunchActivity.isFileInRepo];
 * the entry destination checks again before decrypting.
 */
@Serializable data class EntryRoute(val filePath: String)

/**
 * Single-activity host for the Compose UI. Not exported: it is only started by [LaunchActivity],
 * after its biometric gate and path check. Extends [BaseGitActivity] (an AppCompatActivity, so also
 * the FragmentActivity BiometricPrompt needs) because the git operations require one; it hosts no
 * fragments.
 */
@AndroidEntryPoint
class MainActivity : BaseGitActivity() {

  @Inject lateinit var shortcutHandler: ShortcutHandler

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    val filePath = intent.getStringExtra(BasePGPActivity.EXTRA_FILE_PATH)
    val start: Any = if (filePath != null) EntryRoute(filePath) else ListRoute()
    setContent {
      APSTheme {
        val nav = rememberNavController()
        NavHost(nav, startDestination = start) {
          composable<ListRoute> { entry ->
            val path = entry.toRoute<ListRoute>().path
            ListDestination(
              activity = this@MainActivity,
              path = path,
              onOpenFolder = { target ->
                // Only the folder on top may move the stack: a double tap must not push twice.
                if (nav.currentBackStackEntry?.id == entry.id) {
                  val (pops, pushes) = folderMoves(path, target)
                  repeat(pops) { nav.popBackStack() }
                  pushes.forEach { nav.navigate(ListRoute(it)) }
                }
              },
              onOpenEntry = { file ->
                if (nav.currentBackStackEntry?.id == entry.id) {
                  addShortcut(file)
                  nav.navigate(EntryRoute(file.absolutePath))
                }
              },
            )
          }
          composable<EntryRoute> { entry ->
            EntryDestination(
              activity = this@MainActivity,
              file = File(entry.toRoute<EntryRoute>().filePath),
              onClose = {
                // Only the entry on top closes: the auto-close timer can race a back press.
                if (nav.currentBackStackEntry?.id == entry.id) {
                  if (nav.previousBackStackEntry == null) finish() else nav.popBackStack()
                }
              },
              onSaved = {
                // Back to the list, which re-reads the store on resume. Opened from a shortcut,
                // the entry has no list below it: the list root replaces it.
                if (nav.currentBackStackEntry?.id == entry.id) {
                  if (nav.previousBackStackEntry != null) nav.popBackStack()
                  else nav.navigate(ListRoute()) { popUpTo<EntryRoute> { inclusive = true } }
                }
              },
            )
          }
        }
      }
    }
  }

  /** Re-reads the store; starts onboarding and returns false when there is none yet. */
  fun checkStore(): Boolean {
    PasswordRepository.initialize()
    if (sharedPrefs.getBoolean(PreferenceKeys.REPOSITORY_INITIALIZED, false)) return true
    launchActivity(OnboardingActivity::class.java)
    return false
  }

  /** Git actions offered in the list's menu, chosen as the old list chose its menu. */
  fun gitOps(): ImmutableList<GitOp> =
    when {
      gitSettings.authMode == AuthMode.None -> persistentListOf(GitOp.PULL)
      PasswordRepository.isGitRepo() -> persistentListOf(GitOp.SYNC, GitOp.PULL, GitOp.PUSH)
      else -> persistentListOf()
    }

  /** Runs [op]; failures show the usual git error dialog. */
  suspend fun runGit(op: GitOp) {
    launchGitOperation(op).onFailure { promptOnErrorHandler(it) }
  }

  /** Adds [file] to the launcher's dynamic shortcuts, as opening it from the list always did. */
  fun addShortcut(file: File) {
    val item = entryItem(file)
    shortcutHandler.addDynamicShortcut(item, item.createAuthEnabledIntent(this))
  }

  fun pinEntry(file: File) {
    val item = entryItem(file)
    shortcutHandler.addPinnedShortcut(item, item.createAuthEnabledIntent(this))
  }

  fun createEntry(dir: File) {
    startActivity(
      Intent(this, PasswordCreationActivity::class.java)
        .putExtra(BasePGPActivity.EXTRA_FILE_PATH, dir.absolutePath)
        .putExtra(
          BasePGPActivity.EXTRA_REPO_PATH,
          PasswordRepository.getRepositoryDirectory().absolutePath,
        )
    )
  }

  fun openSettings() {
    launchActivity(SettingsActivity::class.java)
  }

  private fun entryItem(file: File) =
    PasswordItem.newPassword(file.name, file, PasswordRepository.getRepositoryDirectory())
}
```

(`LegacyScreen` is gone: `EntryRoute` was its last caller, and its comment said the last port
deletes it. Later steps start not-yet-ported screens with plain intents from their callers, as
the list already does.)

- [ ] **Step 4: Build and smoke check**

Run: `./gradlew spotlessApply && CI=1 ./gradlew :app:assembleDebug :app:testDebugUnitTest :app:lintDebug`
Expected: `BUILD SUCCESSFUL`. If `popUpTo<EntryRoute>` does not resolve, use
`popUpTo(entry.destination.id) { inclusive = true }` (same effect: the current entry is the
top one). If lint flags the early `return` in `EntryDestination`, wrap everything after it in
`if (inRepo) { ... }` instead.

With the emulator from Task 7 running and the store cloned (`export ANDROID_SERIAL=emulator-5554`
first; a phone may be connected), `./gradlew :app:installDebug`, open the app, tap `example.org`,
enter `test`: the entry view shows `hunter2` (`adb exec-out uiautomator dump /dev/tty | grep -o
'text="hunter2"'`). Back returns to the list. Full checks are in Task 7.

- [ ] **Step 5: Commit**

```bash
git add app/src/main/java/app/passwordstore/ui/entry/EntryDestination.kt \
  app/src/main/java/app/passwordstore/ui/main/MainActivity.kt \
  app/src/main/java/app/passwordstore/ui/list/ListDestination.kt
git commit -m "feat(app): show the Compose entry view in MainActivity

The list navigates to EntryRoute and shortcuts start on it, replacing the
legacy decrypt screen. FLAG_SECURE is on while an entry is composed and
off on the list; the route is checked with isFileInRepo again before
decrypting. Saving in the editor returns to the list. Password and one-time
code copies start the clipboard clear timer.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
```

---

### Task 6: Remove DecryptActivity and what only it used

**Files:**
- Delete: `app/src/main/java/app/passwordstore/ui/crypto/DecryptActivity.kt`
- Delete: `app/src/main/java/app/passwordstore/ui/crypto/ViewPasswordScreen.kt`
- Delete: `app/src/main/java/app/passwordstore/ui/adapters/FieldItemAdapter.kt`
- Delete: `app/src/main/java/app/passwordstore/data/password/FieldItem.kt`
- Delete: `app/src/main/res/layout/decrypt_layout.xml`, `item_field.xml`
- Delete: `app/src/main/res/menu/pgp_handler.xml`
- Delete: `app/src/main/res/drawable/divider.xml`
- Modify: `app/src/main/java/app/passwordstore/ui/crypto/BasePGPActivity.kt`
- Modify: `app/src/main/AndroidManifest.xml`
- Modify: `app/lint-baseline.xml`
- Modify: `AGENTS.md`
- Modify: `docs/superpowers/specs/2026-11-02-compose-ui-overhaul-design.md`

Kept on purpose: `PasswordDialog` and `dialog_password_entry.xml` (autofill), `EditPasswordScreen.kt`,
`PasswordField.kt`, `APSAppBar.kt`, ui:compose `PasswordItem.kt` (later steps).

- [ ] **Step 1: Drop `name` from BasePGPActivity**

In `BasePGPActivity.kt`, delete:

```kotlin
  /**
   * Name of the password file
   *
   * Converts personal/auth.foo.org/john_doe@example.org.gpg to john_doe.example.org
   */
  val name: String by unsafeLazy { File(fullPath).nameWithoutExtension }

```

(`File` stays imported: `getPGPIdentifiers` uses it.)

- [ ] **Step 2: Manifest**

In `app/src/main/AndroidManifest.xml`, delete:

```xml
    <activity
      android:name=".ui.crypto.DecryptActivity"
      android:exported="false" />

```

- [ ] **Step 3: Delete the files**

```bash
git rm app/src/main/java/app/passwordstore/ui/crypto/DecryptActivity.kt \
  app/src/main/java/app/passwordstore/ui/crypto/ViewPasswordScreen.kt \
  app/src/main/java/app/passwordstore/ui/adapters/FieldItemAdapter.kt \
  app/src/main/java/app/passwordstore/data/password/FieldItem.kt \
  app/src/main/res/layout/decrypt_layout.xml \
  app/src/main/res/layout/item_field.xml \
  app/src/main/res/menu/pgp_handler.xml \
  app/src/main/res/drawable/divider.xml
```

- [ ] **Step 4: Lint baseline**

`app/lint-baseline.xml` has two `DenyListedApi` issues located in `FieldItemAdapter.kt`. Remove
both `<issue>` blocks:

```bash
perl -0pi -e 's/\n    <issue\n        id="DenyListedApi"\n(?:(?!<\/issue>).)*?FieldItemAdapter\.kt(?:(?!<\/issue>).)*?<\/issue>\n//gs' app/lint-baseline.xml
grep -c FieldItemAdapter app/lint-baseline.xml
```
Expected: `0`, and `git diff app/lint-baseline.xml` shows exactly two removed `<issue>` blocks.

- [ ] **Step 5: Nothing refers to the removed code**

```bash
grep -rnwE 'DecryptActivity|DecryptLayoutBinding|ItemFieldBinding|FieldItemAdapter|FieldItem|ViewPasswordScreen|openEntry' app/src
grep -rnE 'R\.menu\.pgp_handler\b|@drawable/divider|R\.drawable\.divider' app/src
```
Expected: no output from either (`AutofillDecryptActivity` does not match `-w DecryptActivity`).

- [ ] **Step 6: AGENTS.md and the spec**

In `AGENTS.md`, "Verified facts and gotchas", replace

```
- `LaunchActivity` is exported and forwards `FILE_PATH` to `DecryptActivity` (not exported)
  only after `isFileInRepo` checks it canonically resolves inside the store.
```

with

```
- `LaunchActivity` is exported and forwards `FILE_PATH` to `MainActivity` (not exported) only
  after `isFileInRepo` checks it canonically resolves inside the store; `MainActivity` opens it as
  `EntryRoute`, whose destination checks it again before decrypting.
```

In the spec, section "Entry view", replace

```
- Second group: remaining extra fields, copy where it makes sense.
```

with

```
- Second group: remaining extra fields, copy where it makes sense.
- Overflow: copy name, share as plaintext. The password starts masked or shown per the existing
  "Show the password" setting. Saving in the editor returns to the list. Password and one-time
  code copies are cleared from the clipboard after the timeout.
```

- [ ] **Step 7: Full local check**

Run:
```bash
./gradlew spotlessApply
CI=1 ./gradlew spotlessCheck test -PslimTests :app:assembleDebug :app:assembleRelease \
  lint metalavaCheckCompatibilityRelease
```
Expected: `BUILD SUCCESSFUL`. If lint reports further unused resources, they were used only by
the deleted files: delete them (strings from every `values*/strings.xml`, since a string left
only in a translation is an `ExtraTranslation` error) and re-run. If it reports an issue in a
file from Tasks 1 to 5, fix it there and include it in this commit.

- [ ] **Step 8: Commit**

```bash
git add -A app/src/main app/lint-baseline.xml AGENTS.md \
  docs/superpowers/specs/2026-11-02-compose-ui-overhaul-design.md
git commit -m "refactor(app): remove the legacy decrypt screen

The Compose entry view replaces DecryptActivity, its layouts, menu and
field adapter, and upstream's unused ViewPasswordScreen. BasePGPActivity
keeps what the editor and autofill still need.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>"
```

---

### Task 7: Emulator check and push

No real store or keys: the e2e environment from AGENTS.md only. A physical phone may be
connected over USB: every `adb` and Gradle install command in this task targets the emulator
through `ANDROID_SERIAL`; never touch the phone. The PIN `1234` below is the emulator's own test
PIN, never the owner's.

- [ ] **Step 1: Server, emulator, unlock, clean install**

```bash
export ANDROID_SERIAL=emulator-5554
scripts/e2e-env.sh up
$ANDROID_HOME/emulator/emulator -avd aps-test -no-window -no-audio -no-boot-anim \
  -no-snapshot-save -gpu swiftshader_indirect &
adb wait-for-device
until [ "$(adb shell getprop sys.boot_completed | tr -d '\r')" = 1 ]; do sleep 2; done
adb shell input keyevent KEYCODE_WAKEUP; adb shell input keyevent 82
adb shell input text 1234; adb shell input keyevent 66
for s in animator_duration_scale transition_animation_scale window_animation_scale; do
  adb shell settings put global $s 0; done
adb shell settings put secure autofill_service null
adb uninstall xyz.danix.hardenedpass.debug || true
./gradlew :app:installDebug
scripts/e2e-env.sh push-keys
OUT=$(mktemp -d)
```

(`ANDROID_HOME` is the `sdk.dir` from `local.properties`. `push-keys` only after the unlock.
`installDebug` and `adb` both honor `ANDROID_SERIAL`. The uninstall also avoids a signature
mismatch between checkouts, see AGENTS.md.)

Helpers for this shell:

```bash
ui() { adb exec-out uiautomator dump /dev/tty; }
center() { local b; b=$(ui | grep -o "<node [^>]*$1[^>]*>" | head -1 | grep -o 'bounds="[^"]*"' | grep -oE '[0-9]+' | tr '\n' ' '); [ -n "$b" ] || { echo "not found: $1" >&2; return 1; }; set -- $b; echo "$(( ($1 + $3) / 2 )) $(( ($2 + $4) / 2 ))"; }
tap() { local c; c=$(center "$1") && adb shell input tap $c; sleep 1; }
seen() { ui | grep -q "$1" && echo "ok: $1" || echo "MISSING: $1"; }
top() { adb shell dumpsys activity activities | grep topResumedActivity; }
open() { adb shell am start -n xyz.danix.hardenedpass.debug/app.passwordstore.ui.main.LaunchActivity; sleep 3; }
secure() { adb shell dumpsys window windows | awk '/Window #/{w=($0 ~ /ui\.main\.MainActivity/)} w && /fl=/{print (/SECURE/ ? "secure" : "not secure"); w=0}'; }
pass() { tap 'class="android.widget.EditText"'; adb shell input text "$1"; tap 'text="OK"'; sleep 2; }
STORE=/data/user/0/xyz.danix.hardenedpass.debug/files/store
```

- [ ] **Step 2: Onboarding and clone**

`open`, then go through onboarding as in step 2's plan: "Let's Go", "Clone Remote Repo",
Repository URL `ssh://git@10.0.2.2:2222/srv/git/store.git`, authentication mode "SSH key", Save;
import the SSH key `aps-e2e-ssh-key` from Download when asked, accept the host key, then
"Select key" and import `aps-e2e-pgp-key.asc` from Download.
Expected afterwards: `top` shows `MainActivity`; `seen 'text="example.org"'` prints `ok`;
`secure` prints `not secure` (the list is not `FLAG_SECURE`).

- [ ] **Step 3: Open from the list, passphrase prompt, fields, FLAG_SECURE**

```bash
tap 'text="example.org"'; top                       # MainActivity, no DecryptActivity
seen 'class="android.widget.EditText"'              # passphrase dialog
pass wrong; seen 'text="Wrong password"'
pass test
seen 'text="hunter2"'; seen 'text="alice"'; seen 'text="url"'; seen 'text="https://example.org"'
seen 'text="Password store"'; seen 'content-desc="Edit password"'
secure
adb exec-out screencap -p > "$OUT/entry.png"
```
Expected: every `seen` prints `ok`; `top` shows `MainActivity`; `secure` prints `secure`;
`$OUT/entry.png` is black (open it to check).

- [ ] **Step 4: Reveal toggle and copies**

```bash
tap 'content-desc="Hide password"'; seen 'text="••••••••••"'
tap 'content-desc="Show password"'; seen 'text="hunter2"'
tap 'content-desc="Copy password"'
adb shell dumpsys activity services xyz.danix.hardenedpass.debug | grep -c ClipboardService
tap 'content-desc="Copy"'                           # first plain copy: the username row
```
Expected: `ok` for both `seen`; the `grep -c` prints at least `1` (the clear timer started).
The username copy starts no timer (maintainer decision 1).

- [ ] **Step 5: Back clears the view; pasted username; reopen asks again**

```bash
adb shell input keyevent 4; sleep 1; secure; seen 'text="otp"'
adb exec-out screencap -p > "$OUT/list.png"
tap 'text="Search"'; adb shell input keyevent 279; seen 'text="alice"'
adb shell input keyevent 4; adb shell input keyevent 4
tap 'text="example.org"'; seen 'class="android.widget.EditText"'
pass test; seen 'text="hunter2"'
```
Expected: `not secure` after back, `$OUT/list.png` shows the list (not black); the paste puts
`alice` in the search field; reopening shows the passphrase dialog again (the decrypted entry
went with the popped destination).

- [ ] **Step 6: Rotation keeps the view**

```bash
adb shell settings put system accelerometer_rotation 0; adb shell settings put system user_rotation 1
sleep 2; seen 'text="hunter2"'; seen 'class="android.widget.EditText"'; secure
adb shell settings put system user_rotation 0; sleep 2
```
Expected: `ok: text="hunter2"`, `MISSING: class="android.widget.EditText"` (no new prompt),
`secure`.

- [ ] **Step 7: Edit through the legacy editor, back to the list**

```bash
tap 'content-desc="Edit password"'; top             # PasswordCreationActivity
tap 'resource-id="xyz.danix.hardenedpass.debug:id/extra_content"'
adb shell input keyevent KEYCODE_MOVE_END; adb shell input keyevent 66
adb shell input text 'note:%sedited'
tap 'content-desc="Save"' || tap 'text="Save"'
sleep 3; top; seen 'text="otp"'; seen 'class="android.widget.EditText"'; secure
tap 'text="example.org"'; pass test; seen 'text="note"'; seen 'text="edited"'
adb shell input keyevent 4; sleep 1; seen 'text="otp"'
```
Expected: the editor opens with the entry filled in; after Save, `MainActivity` is on top showing
the list (`ok: text="otp"`), with no passphrase dialog (`MISSING: ...EditText`) and `not secure`.
Reopening the entry shows the new `note` field; back returns to the list.

- [ ] **Step 8: OTP entry (by eye) and its clipboard clear**

```bash
tap 'text="otp"'; tap 'text="example.com"'; pass test
adb emu screenrecord screenshot "$OUT"
python3 -c 'import hmac,hashlib,struct,time,base64;k=base64.b32decode("JBSWY3DPEHPK3PXP");h=hmac.new(k,struct.pack(">Q",int(time.time())//30),hashlib.sha1).digest();o=h[-1]&15;print("%06d"%((struct.unpack(">I",h[o:o+4])[0]&0x7fffffff)%1000000))'
secure
```
The OTP screen never goes idle, so `uiautomator dump` fails on it (AGENTS.md) and `screencap`
is black (`FLAG_SECURE`). The emulator console screenshot (`adb emu screenrecord screenshot`)
grabs the host-side display; open the PNG it wrote in `$OUT`. Expected: password `s3cret`, a row
"OTP (expires in Ns)" whose code matches the Python output (same 30 s window), a progress bar
under it shrinking with N; `secure` prints `secure`. If the console screenshot is black too or
unsupported, start the emulator with a window (needs the host's `libbsd`, AGENTS.md) and check
by eye, or leave this item to the maintainer.

Copy the code and check that it is cleared after the timeout (unset, so 60 s). Read the OTP
row's copy icon position from the screenshot (its pixels are the device's) and tap it:

```bash
adb shell input tap X Y                     # X Y: center of the OTP row's copy icon
COPIED=$(date +%s)
adb shell dumpsys activity services xyz.danix.hardenedpass.debug | grep -c ClipboardService
adb shell input keyevent 4; adb shell input keyevent 4; sleep 1
tap 'text="Search"'; adb shell input keyevent 279; ui | grep -oE 'text="[0-9]{6}"'
adb shell input keyevent 4; adb shell input keyevent 4
sleep $(( 65 - ($(date +%s) - COPIED) ))
adb shell dumpsys activity services xyz.danix.hardenedpass.debug | grep -c ClipboardService
tap 'text="Search"'; adb shell input keyevent 279; ui | grep -oE 'text="[0-9]{6}"'
adb shell input keyevent 4; adb shell input keyevent 4
```
Expected: the first `grep -c` prints at least `1` (the clear timer started for the code, as for
the password); the first paste puts the six-digit code in the search field; after the timeout
the second `grep -c` prints `0` and the second paste prints nothing (the clipboard was cleared).
The list is back at the root.

- [ ] **Step 9: Shortcut start, back leaves the app; path outside the store**

```bash
adb shell am force-stop xyz.danix.hardenedpass.debug
adb shell am start -n xyz.danix.hardenedpass.debug/app.passwordstore.ui.main.LaunchActivity \
  -a DECRYPT_PASS --es FILE_PATH "$STORE/work/mail.example.org.gpg"; sleep 3
pass test; seen 'text="correct horse battery staple"'; seen 'text="bob"'; seen 'text="work"'; secure
adb shell input keyevent 4; sleep 1; adb shell dumpsys window | grep mCurrentFocus
adb shell am force-stop xyz.danix.hardenedpass.debug
adb shell am start -n xyz.danix.hardenedpass.debug/app.passwordstore.ui.main.LaunchActivity \
  -a DECRYPT_PASS --es FILE_PATH "$STORE/../shared_prefs/xyz.danix.hardenedpass.debug_preferences.xml"
sleep 3; seen 'text="otp"'; secure
adb shell am force-stop xyz.danix.hardenedpass.debug
adb shell am start -n xyz.danix.hardenedpass.debug/app.passwordstore.ui.main.LaunchActivity \
  -a DECRYPT_PASS --es FILE_PATH "$STORE/work/mail.example.org.gpg"; sleep 3
pass test; tap 'content-desc="Edit password"'
tap 'resource-id="xyz.danix.hardenedpass.debug:id/extra_content"'
adb shell input keyevent KEYCODE_MOVE_END; adb shell input keyevent 66
adb shell input text 'note:%sshortcut'
tap 'content-desc="Save"' || tap 'text="Save"'
sleep 3; top; seen 'text="otp"'; seen 'content-desc="Password store"'; secure
adb shell input keyevent 4; sleep 1; adb shell dumpsys window | grep mCurrentFocus
open
```
Expected: the shortcut opens the entry directly (`ok` for all, `secure`); back leaves the app
(`mCurrentFocus` outside `xyz.danix.hardenedpass.debug`); the outside path opens the list
(`ok: text="otp"`, `not secure`). Saving an entry opened from a shortcut lands on the list root
(`MainActivity`, `ok` for both, `not secure`) instead of closing the app; back from there leaves
the app.

- [ ] **Step 10: Biometric unlock and the passphrase cache**

Fingerprint (once per AVD): `adb shell dumpsys fingerprint | grep -o '"count":[0-9]*'`. If it
prints nothing or `"count":0`, enroll: `adb shell am start -a android.settings.FINGERPRINT_ENROLL`,
enter the emulator PIN `1234`, follow the screens (dump them to find the buttons) and run
`adb emu finger touch 1` until enrollment completes; then `open`.

```bash
tap 'content-desc="More options"'; tap 'text="Settings"'; tap 'text="PGP settings"'
tap 'text="Enable passphrase caching"'; sleep 1; adb emu finger touch 1; sleep 1
adb shell input keyevent 4; adb shell input keyevent 4; sleep 1
tap 'text="example.org"'; seen 'text="Unlock passphrase cache"'
adb emu finger touch 1; sleep 1
seen 'text="Clear cached password on screen-off"'
tap 'text="Clear cached password on screen-off"'      # uncheck: keep the cache across screen off
pass test; seen 'text="hunter2"'
adb shell input keyevent 4; sleep 1
tap 'text="example.org"'; adb emu finger touch 1; sleep 2
seen 'text="hunter2"'; seen 'class="android.widget.EditText"'
adb shell input keyevent 4; sleep 1
tap 'text="example.org"'; adb shell input keyevent 4; sleep 1
seen 'class="android.widget.EditText"'; adb shell input keyevent 4; sleep 1; seen 'text="otp"'
```
Expected, in order: the cache switch turns on after the fingerprint; opening the entry shows the
"Unlock passphrase cache" prompt; after the touch, the passphrase dialog shows the cache box; the
entry decrypts. Reopening with a touch decrypts without a dialog (`ok: hunter2`, `MISSING:
EditText`). Cancelling the biometric prompt with back falls back to the passphrase dialog;
cancelling that closes the entry (`ok: text="otp"`).

- [ ] **Step 11: Auto-close timer**

```bash
tap 'content-desc="More options"'; tap 'text="Settings"'; tap 'text="Passwords"'
tap 'text="Password copy timeout"'; adb shell input keyevent KEYCODE_MOVE_END
for i in 1 2 3 4; do adb shell input keyevent 67; done; adb shell input text 10; tap 'text="OK"'
adb shell input keyevent 4; adb shell input keyevent 4; sleep 1
tap 'text="example.org"'; adb emu finger touch 1; sleep 2; seen 'text="hunter2"'
sleep 12; seen 'text="otp"'; secure
```
Expected: the entry opens, then about 10 s later the list is back (`ok: text="otp"`) and the
window is `not secure`.

- [ ] **Step 12: Tear down and push**

```bash
adb shell settings put system user_rotation 0; adb shell settings put system accelerometer_rotation 1
adb uninstall xyz.danix.hardenedpass.debug
adb shell rm -f /sdcard/Download/aps-e2e-ssh-key /sdcard/Download/aps-e2e-pgp-key.asc
adb emu kill
scripts/e2e-env.sh down
unset ANDROID_SERIAL
rm -rf "$OUT"
git push
```

Expected: push succeeds to every `origin` push URL.

---

## Self-review notes

- **Spec coverage for step 3:** `EntryRoute` is a real Compose destination in `MainActivity`,
  opened from the list by navigation and from `LaunchActivity` as the start destination (Task 5);
  back pops to the list or leaves the app (Task 5, checked in Task 7 steps 5 and 9). Header,
  top bar with back, edit and overflow, first group password (masked or shown, reveal, copy),
  username (copy), OTP with countdown bar (copy), second group extras with copy (Tasks 1, 4).
  Strings in `values/` and `values-it/` (Task 4; Italian uses existing translations for
  everything but the four new strings). `FLAG_SECURE` only while an entry is composed, explicit on
  the passphrase dialog; the list stays unflagged (Task 5,
  checked in Task 7 steps 3, 5, 7, 8, 9, 11). Decrypted content only in ViewModel memory, dropped on
  pop and by the timer; not in saved state, not in routes; passphrase only in `remember`
  (Tasks 3, 5). Passphrase cache, biometric flow and clipboard handling reuse the existing code
  paths unchanged (Tasks 2, 3). `isFileInRepo` re-checked in the destination (Task 5).
  `DecryptActivity` deleted; `BasePGPActivity` reduced to what the editor and autofill need
  (Tasks 2, 6). TDD for the pure logic: field grouping and OTP fraction (Task 1). Full local CI
  (Task 6). Emulator check covering every listed scenario (Task 7).
- **Parity summary:** ported: `FLAG_SECURE`, header, biometric cache unlock, no-keys import,
  `.gpg-id` checks, cache clearing on screen off, cached passphrase, empty passphrase for
  unprotected keys, passphrase dialog with cache box and error, three tries, caching after
  success, decryption off main, all fields with copy, monospace password, `SHOW_PASSWORD`,
  OTP refresh, `COPY_ON_DECRYPT`, auto-close timer, edit, share, up, dynamic shortcut. Changed:
  name copy moves from long press to the overflow; saving in the editor returns to the list
  (the list root when started from a shortcut); rotation and
  theme changes keep the view; password and one-time code copies always start the clear timer.
  Dropped: the "Copy
  password" menu item (same as the row's button). Fixed: cached-passphrase loop, dialog after the
  last retry, dismissed no-keys dialog leaving an empty screen.
- **Deliberate shortcuts (`ponytail:`):** a theme or locale change during the biometric prompt
  loses that prompt's callback; `FLAG_SECURE` is a plain add/clear until step 4 can overlap two
  secret-showing destinations (both Task 5).

## Maintainer decisions (2026-11-02)

1. Clipboard: the password and the one-time code copies are cleared after the timeout, with the
   timer and mechanism the password copy already uses (`copyPasswordToClipboard`,
   `ClipboardService`). Username and extra fields are not cleared. Applied in Tasks 4 and 5,
   checked in Task 7 steps 4 and 8.
2. Password visibility: follow the "Show the password" setting, as planned.
3. After saving in the editor: back to the list (pop the entry route; when the entry was the
   start destination, navigate to the list root instead of finishing). No reopen, no new
   passphrase prompt. The reopen logic (`RETURN_EXTRA_CREATED_FILE` handling, the entry to entry
   replacement and the counted `FLAG_SECURE` it needed) is removed. Applied in Task 5, checked in
   Task 7 steps 7 and 9.