feat: device list and revoke with the jti followed through refresh

GET /devices lists the caller's confirmed and used device sessions (PHP's fields, device_name from the stored name or the user agent, is_current for the session the request's token belongs to). DELETE /devices/{id} marks the session revoked and blacklists the device token's jti for its whole refresh window in one transaction. POST /refresh hands a used session's jwt_jti over to the refreshed token (classes.HandOverDeviceJTI), so a device that refreshed before the revoke is signed out too.
feat: device authorization by QR or short code
2026-10-26 10:19:25 +01:00 · 2026-10-26 10:14:48 +01:00 · 2026-10-26 10:08:57 +01:00 · 2026-10-26 10:03:59 +01:00 · 2026-10-26 09:55:48 +01:00
31 changed files with 2309 additions and 49 deletions
--- a/README.md
+++ b/README.md
@@ -12,21 +12,26 @@ Module `git.golem15.com/golem15/sm-user-plugin`, package `user`, plugin ID `gole

 The plugin is a compiled SummerCMS plugin. Its `init` registers it with the framework, so an application loads it by listing it in `summer.yaml`; `summer build` then emits the blank import above into the application's `plugins.gen.go`.

-It owns the `users` table extensions, `user_throttle`, `jwt_blacklist`, `user_api_tokens`, `golem15_user_oauth_identities`, `golem15_user_organisations`, `user_groups`, `users_groups`, `golem15_user_frontend_permissions`, `golem15_user_backend_links` and `golem15_user_backend_link_requests`, the JSON API under `/_user/api/v1`, and the Users, User Groups and Organisations screens of the admin. It is a core plugin shared by several applications, so its routes, payloads, table names, migration IDs, permission codes and config keys are a contract: change them only in a backwards-compatible way.
+It owns the `users` table extensions, `user_throttle`, `jwt_blacklist`, `user_api_tokens`, `golem15_user_oauth_identities`, `golem15_user_organisations`, `user_groups`, `users_groups`, `golem15_user_frontend_permissions`, `golem15_user_backend_links`, `golem15_user_backend_link_requests` and `golem15_user_device_auth_sessions`, the JSON API under `/_user/api/v1`, and the Users, User Groups and Organisations screens of the admin. It is a core plugin shared by several applications, so its routes, payloads, table names, migration IDs, permission codes and config keys are a contract: change them only in a backwards-compatible way.

 ## Features

 - **Registration and activation.** `POST /register`, `POST /activate`, `POST /activate-by-code`. Registration can be switched off and throttled; `activate_mode` is `auto`, `user` (a mailed code) or `admin`, with codes from `IssueActivationCode` and `VerifyActivationCode`. A `/register` body sets only the `User.RegisterFillable` columns: `name`, `surname`, `email`, `password` (stored as its hash), `preferred_locale` and `marketing_consent`. It cannot set `organisation_id` or `organisation_role` (membership is the administrator's or the application's), `is_onboarded`, `must_change_password`, or the activation, reset, address proof, handle and permission columns; other keys are ignored (they still reach `RegisterEvent.Payload`). `created_ip_address` and `last_ip_address` are server-set from the client address only. With `require_activation` on (the default), `POST /login` refuses an account that is not activated with the same 401 invalid-login answer as a wrong password and counts the attempt for the login throttle. Such an account is activated by the mailed code (`POST /activate-by-code` answers with a token), by the invitation link or by an administrator. `POST /activate` serves the sessions of not-activated accounts, which exist when `require_activation` is off. `Login` checks in this order: a ban or an active suspension (`RejectIfThrottled`), the password, the activation, then the deactivation restore.
 - **JWT sessions.** `POST /login`, `GET /fetch`, `POST /refresh`, `POST /logout`. Boot registers the `jwt` guard with the framework's `bouncer.Registry` and exposes it as the `jwt.auth` middleware for other plugins. The guard reads the session cookies `classes.SessionCookieNames()` lists and resolves the published `bouncer.BlacklistStore` on every request. Boot installs the plugin's GORM hooks (`classes.RegisterHooks`), publishes the Postgres `jwt_blacklist` store (`bouncer.NewPostgresBlacklist`) and starts its background sweep, which prunes the blacklist, through `lagoon.OnDatabase`. Under `summer serve`, which publishes the database after Boot, they take effect when `lagoon.Publish` runs, before the router is built; when the database is already published they take effect at once. While no store is published, no token counts as blacklisted. `POST /logout` ends the session however the token travels: the bearer header, or only the `token` or `auth_token` cookie the guard also reads. Every session token the request carries goes to the Postgres `jwt_blacklist` until its refresh window closes (the later of `exp` and `iat` plus `refresh_ttl`, plus a minute), so the guard refuses it on the next request and `POST /refresh` cannot revive it after the access token expired; a token whose access lifetime passed is revoked too while it could still be refreshed. The answer, a 401 included, expires the `auth.cookie.*` token cookie (the one `golem15.sociallogin`'s `token_cookie` sets), and any other session cookie the request carries, with that cookie's path, domain, SameSite and Secure. `POST /refresh` loads the token's user and refuses (401, `Could not refresh token`, `User not found`) a deactivated or banned user and a token issued before the user's `tokens_valid_after`; a suspension alone does not stop a refresh. `GET /fetch`, `POST /refresh`, `POST /update` and `POST /change-password`, like the plugin's other signed-in routes, read the session token as the `jwt` guard does: the bearer header first, then the `token` and `auth_token` cookies, so a cookie-only session works on them and a bearer header wins when both are sent. A `POST /refresh` whose token came from the `auth.cookie.*` cookie (`auth.cookie.name`, default `token`) with no bearer header gets that cookie back with the rotated token: the cookie has the `bouncer.LoadCookieConfig` attributes, HttpOnly and Max-Age `refresh_ttl`, and the answer is `{}`, so the token never reaches JavaScript. This holds whoever wrote the cookie (this plugin's `golem15.user.jwt.token_cookie`, `golem15.sociallogin`'s `token_cookie` or the application); a frontend that writes the `token` cookie itself and refreshes through it gets it back HttpOnly, without a body token, so such a frontend sends the bearer header to keep rotating in the body. A refresh carried by the bearer header (a cookie sent with it included) or by the other session cookie answers `{"token": …}` and writes no cookie; the old token is blacklisted after `golem15.user.jwt.blacklist_grace`, so that caller stores the new token itself. A refused refresh writes and forgets no cookie. When `bouncer.LoadCookieConfig` refuses the `auth.cookie` block, a cookie-carried refresh answers the opaque 500 before anything is rotated; a bearer refresh never reads that block. Keep `auth.cookie.name` at `token` or `auth_token`, the cookies the guard reads. With `golem15.user.jwt.token_cookie` on, `POST /login`, `POST /register` (when it signs the new account in) and `POST /activate-by-code` set that HttpOnly session cookie (`bouncer.LoadCookieConfig` attributes, Max-Age `refresh_ttl`) and leave `token` out of the body; `user`, and `message` on activate-by-code, stay. With it off (the default) the token is in the body and no cookie is set. SameSite stays the `auth.cookie` setting (`lax` by default) and there is no CSRF token, so do not set `same_site: none` for this cookie. With the key on, a broken `auth.cookie` block answers those three routes with the opaque 500 before they sign in, create or activate anything. Personal API tokens (`POST /tokens`) are not sessions and are unaffected. A cookie-carried session relies on the cookie's SameSite attribute against cross-site requests (the `auth.cookie` default is `lax`), as on the `jwt.auth` routes.
+- **Login gates.** Register publishes a `*classes.LoginGates` registry. Another plugin (a two-factor plugin, for example) looks it up with `app.Lookup[*classes.LoginGates]()` and adds a `classes.LoginGate` in its Boot. `POST /login` consults the gates through `controllers.CheckLoginGates` after the password, activation and throttle checks (and the bcrypt rehash) and before it restores a deactivated account, sends the reactivate mail, stamps `last_seen` and mints the token. A gate sees a `classes.LoginAttempt` (`User`, `Source`, the already-read login body as `Fields`, `Request`). A nil result allows the sign-in; a `classes.LoginGateResult` replaces the token response with its `Status` (0 means 200) and `Body`, for example `{"two_factor_required":true,"challenge_token":…,"available_methods":[…],"expires_at":…}`, and no token is issued, no account is restored and no login event fires. A gate error fails closed with the opaque 500. Without a gate, `/login` answers exactly as before. `POST /refresh` never consults the gates.
+- **Login event.** Every sign-in that issued a session token fires `classes.LoginEvent` (`classes.LoginEventName`, `golem15.user.login`, PHP's name) with `User` and `Source` (`LoginSourcePassword`, `LoginSourceSocial`, `LoginSourcePasskey`, `LoginSourceTwoFactor`, `LoginSourceDevice`), after the token was minted. `POST /login` fires it with `password`; another plugin that completes a sign-in fires it through `controllers.FireLoginEvent`. A listener error is logged and never fails the sign-in. Refresh and `/register` fire none.
+- **Password-change hook.** A password reset, the user's own `POST /change-password` and an administrator setting a password on the Users screen fire `classes.AccessRevokedEvent` inside the write's transaction (see Access revocation); `(*AccessRevokedEvent).PasswordChanged()` reports these three reasons. A two-factor plugin listens to it to revoke trusted devices; a listener error rolls the password write back. The bcrypt rehash on login and a new account fire nothing.
 - **Password reset and change.** `POST /forgot-password` answers the same body for known and unknown addresses; `POST /reset-password` consumes a code from `IssueResetCode`. `POST /change-password` requires the current password. With `golem15.user.password.public_routes` false, `POST /login`, `POST /forgot-password` and `POST /reset-password` are not registered, so they answer the router's own 404 like any unknown path (any method, so no 405 shows they exist), while the `controllers` handlers stay exported.
 - **Must-change-password lock.** The `user:require-password-change` console command flags an account. The flag rides on the authenticated principal (`bouncer.Principal.MustChangePassword`) for guards and other plugins to act on, and a successful `POST /change-password` clears it.
 - **Login throttling.** Failed logins are counted per user and client address in `user_throttle` (`CheckAndRecordLogin`, `RejectIfThrottled`) and suspend the account for a configured time. The client address is `surf.ClientIP` with the framework's `http.trusted_proxies`, as for the `/register` IP limit and the `user-api` rate limit: behind a listed reverse proxy it is the `X-Forwarded-For` client, otherwise the connection address, and an `X-Forwarded-For` header from any other peer is ignored. A deployment behind a proxy lists the proxy's address in `http.trusted_proxies`; otherwise every visitor shares the proxy's counter.
+- **Device authorization.** A device without a keyboard (a TV, a desktop app) signs in by QR code or short code, PHP's flow with its paths and bodies. It calls `POST /devices/initiate` (no session; optional `device_name`, at most 255 characters) and gets `{"success":true,"data":{"token","short_code","auth_url","expires_at"}}`: a 64-character token, a short code `XXXX-XXXX` over `23456789ABCDEFGHJKMNPQRSTUVWXYZ`, the page to show as a QR code (`golem15.user.device_auth.auth_url`, default `{frontend_url}/device/scan/{token}`) and the expiry (`golem15.user.device_auth.ttl_minutes`, default 5). A signed-in user opens that page, or types the short code, and the site calls `POST /devices/authorize` with the user's session token and `short_code` (any case, hyphen optional) or `token`; there is no second-factor check, the user already passed it at sign-in. The device polls `GET /devices/status/{token}`: `pending`, then on the first poll after the authorization `{"success":true,"data":{"status":"confirmed","user_id",…,"message":"Device authorized - complete login","token":<session JWT>,"user":<payload>}}`, exactly once (one guarded `UPDATE` moves the session from `confirmed` to `used`, so of concurrent polls one gets the token), then `used`. A pending or confirmed session past its expiry answers PHP's flat `{"success":true,"status":"expired","message":"Authorization session has expired"}`; a used or revoked session never turns into expired. The statuses are `pending`, `confirmed`, `used`, `expired` and `revoked`. Only the SHA-256 of the device token is stored (column `token`, `golem15_user_device_auth_sessions`), with the jti of the session token the device received (`jwt_jti`). The hand-over fires the login event with source `device`. Each initiate deletes up to 500 pending or expired sessions that expired over an hour ago. The token travels in the status URL, so a reverse proxy that logs paths records it; it is one-time and lives `ttl_minutes`. A signed-in user lists their devices with `GET /devices` (`{"success":true,"devices":[{"id","device_name","device_ip","authorized_at","last_activity","is_current"}]}`, confirmed and used sessions, most recent activity first; `device_name` is the stored name or one parsed from the user agent; `is_current` marks the session whose token the request carries) and revokes one with `DELETE /devices/{id}` (`{"success":true,"message":"Device revoked successfully"}`, 404 `{"error":"Device not found"}` for another user's session). A revoke marks the session `revoked` and blacklists the jti of the session token the device holds for the token's whole refresh window, so the device is signed out at once and cannot refresh. `POST /refresh` moves a used session's `jwt_jti` to the refreshed token (`classes.HandOverDeviceJTI`), so a device that refreshed before the revoke is signed out too. With `golem15.user.jwt.blacklist_grace` above 0, two concurrent refreshes of one token can fork a device's token lineage and only one fork is followed; a password change still ends both through `tokens_valid_after`. The device routes check the session inside the handler and answer PHP's 401 `{"error":"Unauthorized"}`.
 - **Rate limiting.** Every route runs behind the `user-api` bucket: 120 requests a minute per authenticated user, or per client IP for anonymous calls.
 - **Profile.** `POST /update`, `POST /marketing-consent`, `POST /avatar` and `POST /avatar/remove` (the avatar is stored through the framework's attachment storage).
 - **Deactivation and bans.** Deactivation is self-service and reversible: a password login or a `golem15.sociallogin` sign-in restores a deactivated account and sends the reactivate mail, and an administrator can restore it too. It ends every earlier session JWT and personal API token of the user (`RevokeUserAccess` stamps `tokens_valid_after` and revokes the `user_api_tokens` rows), so the user signs in again and gets a fresh token, while the old API tokens stay revoked. A ban is the lock: password login, social sign-in and `POST /refresh` refuse a banned user, and banning revokes the user's sessions and API tokens. A banned user's account link answers no administrator (`LinkedBackendUser`). Neither unban nor restore revives a token. Activation gates login, deactivation does not: while `require_activation` is on, an account that is both deactivated and not activated is refused and stays deactivated, with no reactivate mail. Upgrade note: accounts deactivated or banned before this version keep their API tokens until they are deactivated or banned again (both actions are idempotent) or `RevokeUserAccess` runs for them.
 - **Organisations.** The `Organisation` model and the `organisation_id` and `organisation_role` user columns, as a foreign-key target for other plugins. An organisation has a name, a slug (filled from the name by `Slugify` when it is left empty), a description, an avatar, a logo and its members: the users whose `organisation_id` points at it. The logo is a second public image attachment (`logo`, `models.OrganisationLogoField`), kept in `system_files` like the avatar. The plugin serves no frontend organisation payload, so applications that build one add the logo with `classes.OrganisationLogoFields(ctx, app, org)`, which answers `has_logo` (bool), `logo` (the attachment's disk name, or null) and `logo_url` (a 256 px thumbnail URL, `classes.OrganisationLogoSize`, or null), the keys the user payload uses for its avatar; `classes.OrganisationLogoURL(ctx, app, org, size)` answers the URL at any size (the thumbnail, or the original file's public URL when the thumbnail fails, as `AvatarURL` does) and false when there is no logo or no file bucket. `organisation_role` belongs to that membership: the admin clears it whenever a user's organisation changes (see the Organisations screen), and an application that sets `organisation_id` itself sets or clears the role with it.
 - **User groups.** The `user_groups` table (seeded with the `guest` and `registered` groups, as in PHP) and the `users_groups` membership pivot, the `UserGroup` model and the `User.Groups` relation, which is never serialized. `UserGroupCodes` and `HasGroupCode` let other plugins check membership server-side, for example a site-admin check on the group code `admin`. No user API route reads or writes groups, and the user payload still answers `"groups":[]`. Membership is written in one place only: the `groups` field of the admin user form. Apart from that, rows leave `users_groups` only when a user or a group is deleted for good. The admin Users list can filter by group.
 - **Admin screens.** The plugin registers the Users screen with the framework's admin (`pact.HasAdminControllers`, controller ID `golem15.user.users`), the port of the WinterCMS `Users` controller: a list with search, the group, registration date and activated filters and row states (deactivated, banned, not activated); a read-only preview with a status hint; and a form with name, email, a password with confirmation, an optional invitation mail, the user's groups, the organisation, the avatar and the user's frontend permissions. Bulk actions activate, deactivate, restore, ban and unban users; the preview offers activate, unban and unsuspend while they apply. Deactivating is the soft delete, and deactivate and ban both end the user's earlier sessions and personal API tokens (see Deactivation and bans); the delete button and the bulk delete remove a user for good, together with the throttle rows, group memberships and attachments. A user created in the admin starts not activated. There is no impersonation and no guest account.
+- **Admin: Reset 2FA.** The Users screen declares the record action `reset_two_factor` ("Reset 2FA", danger confirmation) behind the backend permission `golem15.users.reset_two_factor`, which no role has by default. A two-factor plugin backs it by publishing a `classes.TwoFactorAdmin` (`app.Publish[classes.TwoFactorAdmin](svc)`): the screen looks the service up on every request and offers the action only when one is published and its `HasTwoFactor` reports a second factor for the user, so an application without a two-factor plugin never shows it. Running it calls the service's `Reset` in the action's transaction.
 - **User Groups screen.** Controller ID `golem15.user.usergroups`, the port of the WinterCMS `UserGroups` controller, behind `golem15.users.access_groups`: a list with the name, code, creation date and number of members, and a form with the name, the code (letters, digits, underscore and hyphen; unique), a description and the group's frontend permissions as checkboxes, stored in `user_groups.permissions` as a JSON object of code to `1`. A group can be deleted from its form; its memberships go with it and its members stay. The screen never changes who is in a group.
 - **Organisations screen.** Controller ID `golem15.user.organisations`, the port of the WinterCMS `Organisations` controller, behind `golem15.users.access_users`: a list and a form with the name, slug, description, avatar and logo (an image upload), and on an existing organisation the Members tab. Adding a member sets that user's `organisation_id` and removing one clears it; both also clear the user's `organisation_role`, so a role never moves to another organisation or outlives the membership. A user is never deleted. Only users without an organisation can be added, so a user moves by being removed from one organisation and added to the other (or through the organisation field of the user form, where a save that changes the organisation, to another one or to none, clears `organisation_role` unless the same save writes it). Deleting an organisation clears `organisation_id` and `organisation_role` of its members first, and removes its avatar and logo attachments with it (the files once the delete commits).
 - **Privileged groups.** The groups whose code is listed in `golem15.user.privileged_groups` (default `admin`) are privileged: an application may treat their members as site administrators. Three things therefore need the backend permission `golem15.users.manage_privileged_groups` on top of the screen's own permission, and answer 403 without it, saving nothing. First, membership: adding a privileged group to a user or removing it, on create and on update of the user form. An administrator without the permission sees those groups locked in the field and can still change the user's other groups. Second, the code: creating a group with a privileged code, changing a group's code to or from a privileged one, and deleting a privileged group. Its name, description and frontend permissions need only `golem15.users.access_groups`. Codes compare case-sensitively, and a group without a code is never privileged. Third, the member's account, which is protected against takeover: changing that user's email or password, and deleting them for good, needs the backend permission `golem15.users.manage_privileged_groups` on top of `golem15.users.access_users`. Without it the request answers 403 and nothing is saved; a bulk delete that contains such a user deletes none of the selected users. Everything else on such a user (name, organisation, avatar, frontend permissions, activate, deactivate, restore, ban, unban, unsuspend) needs only `golem15.users.access_users`. `PrivilegedGroupCodes`, `IsPrivilegedCode`, `PrivilegedGroupIDs` and `IsPrivilegedMember` expose the rule to other code.
@@ -128,6 +133,11 @@ All routes are mounted under `/_user/api/v1` with the `throttle:user-api` middle
 | `POST /backend-link/show` | `controllers.BackendLinkShowPost` |
 | `POST /backend-link/confirm` | `controllers.BackendLinkConfirm` (`jwt.auth`) |
 | `GET /token/me` | `controllers.TokenMe` (`user.api_token`, `user.scope:read`) |
+| `POST /devices/initiate` | `controllers.DeviceInitiate` |
+| `GET /devices/status/{token}` | `controllers.DeviceStatus` |
+| `POST /devices/authorize` | `controllers.DeviceAuthorize` (session token checked in the handler, 401 `{"error":"Unauthorized"}`) |
+| `GET /devices` | `controllers.DeviceIndex` (session token checked in the handler) |
+| `DELETE /devices/{id}` | `controllers.DeviceDestroy` (session token checked in the handler; `id` is `[0-9]+`) |

 `/fetch`, `/refresh`, `/update`, `/change-password`, `/activate`, `/marketing-consent`, `/avatar`, `/avatar/remove` and the `jwt.auth` routes read the session token from the bearer header, then the `token` and `auth_token` cookies.

@@ -155,7 +165,7 @@ The three screens are served by the framework's generic admin API under `<admin
 | Navigation | main item `user` (order 555) with the side items `users`, `usergroups` and `organisations`, each shown to an administrator who holds its permission |
 | Relation manager | `members` on `golem15.user.organisations` (link and unlink) |
 | Bulk actions (Users) | `activate`, `deactivate`, `restore`, `ban`, `unban`, and the built-in delete; `deactivate` and `ban` also revoke the selected users' sessions and personal API tokens |
-| Record actions (Users) | `activate`, `unban`, `unsuspend` |
+| Record actions (Users) | `activate`, `unban`, `unsuspend`, and `reset_two_factor` (danger, behind `golem15.users.reset_two_factor`, offered only while a published `classes.TwoFactorAdmin` reports a second factor) |
 | Record actions (Administrators, `summercms.cabana.users`) | `link_frontend_account` (asks for the frontend user's email) and `unlink_frontend_account` (danger), both behind `golem15.users.manage_backend_links`, from `AdminActionExtensions` |
 | My account section | `frontend_account` with the actions `link` and `unlink`, from `AccountContributions` |

@@ -171,6 +181,7 @@ Backend permissions, all on the tab `golem15.user::lang.plugin.tab`:
 | `golem15.users.impersonate_user` | `developer` | Registered for roles that already name it; impersonation is not available. |
 | `golem15.users.manage_privileged_groups` | none | Adding a privileged group to a user or removing it; creating, re-coding or deleting a privileged group; changing the email or password of a privileged-group member, and deleting one for good. Only a superuser or a role that was granted it holds it. |
 | `golem15.users.manage_backend_links` | none | Linking a frontend account to another administrator, and unlinking one, on the Administrators screen. Only a superuser or a role that was granted it holds it. |
+| `golem15.users.reset_two_factor` | none | The Users screen's "Reset 2FA" record action, which removes every second factor of a user through the two-factor plugin's `classes.TwoFactorAdmin`. Only a superuser or a role that was granted it holds it. |

 Migrations added for the admin, all additive:

@@ -204,6 +215,12 @@ Migrations added for the frontend account link, all additive:
 |----|------|
 | `202610220001_create_golem15_user_backend_links` | the tables `golem15_user_backend_links` (`user_id` unique, cascade FK to `users`; `backend_user_id` unique, cascade FK to `backend_users`; `linked_by` FK to `backend_users`, set null on delete; `created_at`) and `golem15_user_backend_link_requests` (`code_hash` `CHAR(64)` unique, `backend_user_id` cascade FK, `expires_at`, `used_at`, `created_at`). The `backend_users` keys are added when that table exists, which it does whenever the application migrates through `lagoon.Migrate`. |

+Migration added for device authorization, additive:
+
+| ID | Adds |
+|----|------|
+| `202610260001_create_device_auth_sessions` | the table `golem15_user_device_auth_sessions` with PHP's columns (`token` holding the SHA-256 hex of the device token, unique; `short_code` unique; `user_id` nullable, cascade FK to `users`; `status` checked against the five statuses; `expires_at`, `device_ip`, `device_user_agent`, `device_name`, `auth_ip`, `confirmed_at`, `used_at`, `session_id`, `last_activity_at`) plus `jwt_jti`, indexed on `user_id`, `status`, `expires_at` and `jwt_jti`; rollback drops it |
+
 Packages:

 - `controllers`: the route handlers above, `AdminControllers` (the admin controller list), `PermissionAccessUsers` and `PermissionAccessGroups`, plus the registration steps `POST /register` runs, for other plugins:
@@ -215,7 +232,10 @@ Packages:
  - `IssueToken(app, user, r)` mints the session JWT as `/register` and `/login` do.
  - `BackendLinkShow`, `BackendLinkShowPost`, `BackendLinkConfirm` and `TokenMe`, the handlers of the account link and `/token/me` routes.
  - `APIArray(ctx, app, user)` builds the user payload, extended by `GetApiArrayEvent` listeners.
-  - `FinishLogin(ctx, app, db, user, ip)` runs the steps `POST /login` takes after authentication, for a caller that authenticated the user another way (a social sign-in): it restores a soft-deleted account and sends the reactivate mail, records `ip` as `last_ip_address` and touches `last_seen` (a failure there is only logged). It checks no password, throttle, activation or ban and fires no event; the caller does those checks.
+  - `FinishLogin(ctx, app, db, user, ip)` runs the steps `POST /login` takes after authentication, for a caller that authenticated the user another way (a social sign-in): it restores a soft-deleted account and sends the reactivate mail, records `ip` as `last_ip_address` and touches `last_seen` (a failure there is only logged). It checks no password, throttle, activation or ban and fires no event; the caller does those checks, consults the login gates before it and fires the login event after it minted the token.
+  - `CheckLoginGates(ctx, app, attempt)` consults the published `*classes.LoginGates` (none published allows the sign-in) and returns its answer: nil allows, a `*classes.LoginGateResult` replaces the token response, an error must fail the sign-in closed. A social-login plugin calls it before it issues a token.
+  - `FireLoginEvent(ctx, app, user, source)` fires `classes.LoginEvent` and returns the listeners' error; call it after the token was minted and log the error.
+  - `DeviceInitiate`, `DeviceStatus`, `DeviceAuthorize`, `DeviceIndex` and `DeviceDestroy`, the device authorization handlers (see Device authorization).
  - `RegistrationSettings(app)` returns `allow_registration`, `use_register_throttle`, `activate_mode` and `require_activation` with their defaults (`true`, `true`, `auto`, `true`), and `RegistrationsFromIP(ctx, db, ip)` counts the accounts created from an IP in the last 60 minutes (`/register` refuses at 3 with the throttle on).
  - `RefreshTTL(app)` is the refresh window, `golem15.user.jwt.refresh_ttl` minutes (default 20160), and `RemoteIP(r)` the host part of `r.RemoteAddr`, with no proxy handling (`/login` and `/register` use `surf.ClientIP` with `http.trusted_proxies`).
 - `classes`: `JWTSecret`, `GormUsers` (the `bouncer.UserProvider`), `LookupByEmail`, `UserPermissionGrants`, `UserGroupCodes`, `HasGroupCode`, `APITokenPrefix`, `MintAPIToken`, `MintAPITokenFor`, `HashAPIToken` and `RevokeAPIToken`, the member token scope catalog `APITokenScope`, `APITokenScopeCatalog` (`Scopes`, `Allowed`), `CompileAPITokenScopes`, `APITokenScopesFor` and the test seam `ResetDeclaredAPITokenScopes`, plus the activation/reset, throttle, mail locale and event helpers. `RegisterEvent` carries `User` and `Payload map[string]any`, a read-only copy of the register input without the password keys. For the admin and for other plugins it also has:
@@ -233,9 +253,13 @@ Packages:
  - `BackendLinks` (`CreateLinkRequest`, `LinkRequestByCode`, `ConfirmLinkRequest`, `SetLink`, `RemoveLink`, `LinkFor`, `LinkOf`, `LinkedBackendUser`, `RegisterBackendLinkListeners`), its errors `ErrLinkRequestNotFound`, `ErrLinkRequestUsed`, `ErrLinkRequestExpired`, `ErrStaleSession`, `ErrAlreadyLinked`, `ErrBackendUserUnavailable` and `ErrFrontendUserUnavailable`, the events `BackendLinkedEvent` / `BackendLinkedEventName` and `BackendUnlinkedEvent` / `BackendUnlinkedEventName`, `BackendLinkRequestTTL(app)`, `DefaultBackendLinkRequestTTL`, `FrontendURL(app)`, `BackendLinkPagePath(app)`, `DefaultBackendLinkPagePath`, `BackendLinksFor(app)` (the published service, or one over the app) and `BackendDisplayName(admin)`.
  - `PermissionManageBackendLinks`, `FrontendPermissionCatalog(ctx, app, db)`, `MCPUserGuard`, `FireSubjectChanged(ctx, app, guard, userID, kind)` and `FireSubjectChangedAfterCommit(ctx, app, tx, guard, userID, kind)` with the guard names `SubjectGuardUser` and `SubjectGuardBackend`, and `FireSubjectEvent(ctx, app, ev)` and `FireSubjectEventAfterCommit(ctx, app, tx, ev)`, which fire a whole `pact.MCPSubjectChanged` (with `TokenID` or `ClientID` to end only one token's or one client's sessions).
  - `AccessRevokedEvent` / `AccessRevokedEventName` and `FireAccessRevoked(ctx, app, tx, userIDs, before, reason)` (see Access revocation).
+  - `LoginAttempt`, `LoginGateResult`, `LoginGate` (`CheckLogin(ctx, attempt)`), `LoginGates` with `NewLoginGates()`, `Add(gate)` and `Check(ctx, attempt)`, the login-gate seam (see Login gates), and the sources `LoginSourcePassword`, `LoginSourceSocial`, `LoginSourcePasskey`, `LoginSourceTwoFactor` and `LoginSourceDevice`.
+  - `LoginEvent` / `LoginEventName` (see Login event).
+  - `DeviceShortCodeAlphabet`, `NewDeviceToken()`, `NewDeviceShortCode()`, `NormalizeDeviceShortCode(s)`, `DeviceAuthTTL(app)`, `DeviceAuthURL(app, token)`, `DeviceDisplayName(stored, userAgent)` and `HandOverDeviceJTI(ctx, db, oldJTI, newJTI)` (moves a used session to a refreshed token's jti; `POST /refresh` calls it), the device authorization helpers; device tokens are hashed with `HashAPIToken`.
+  - `TwoFactorAdmin` (`HasTwoFactor(ctx, tx, userID)`, `Reset(ctx, tx, user)`) and `PermissionResetTwoFactor`, the Reset 2FA slot (see Admin: Reset 2FA), and `(*AccessRevokedEvent).PasswordChanged()` (see Password-change hook).
  - `HandleGenerator`, `AssignHandle(ctx, db, user)`, `CreatedEvent` / `CreatedEventName`, `DeletingEvent` / `DeletingEventName`, `DeactivatingEvent` / `DeactivatingEventName`, `AuthorizeUser` and `RegisterUserAuthorizer`.
 - `middleware`: `APITokenGuard`, `Scope`, `Permission` and `BearerToken`.
- `models`: `User`, `Throttle`, `Organisation`, `UserGroup`, `UsersGroup` (the `users_groups` pivot), `APIToken`, `OAuthIdentity`, `FrontendPermission`, `BackendLink`, `BackendLinkRequest` and `PermissionSet`. `PermissionSet` reads a stored permission column tolerantly (NULL, an empty string, `[]`, numeric strings) and writes a JSON object of integers; `ParsePermissionSet` and `PermissionSet.Text` do the same for a column that is a plain string on its model. `UserGroup.UsersCount` is filled only by a query that selects `users_count` (the admin list does). `Organisation.Members` is the relation behind the members manager, `Organisation.AttachRelations` declares its avatar (`OrganisationAvatarField`) and its logo (`OrganisationLogoField`), and `Slugify` is the slug rule. `User.FilterScope` answers the admin list scope `FilterByGroup`, and `User.AttachRelations` declares the avatar (`AvatarField`). `User.RegisterFillable` is the registration allow-list; `User.Fillable` is the wider mass-assignment backstop of the admin Users form (cabana intersects it with the form's fields) and of trusted application code.
+- `models`: `User`, `Throttle`, `Organisation`, `UserGroup`, `UsersGroup` (the `users_groups` pivot), `APIToken`, `OAuthIdentity`, `FrontendPermission`, `BackendLink`, `BackendLinkRequest`, `DeviceAuthSession` (with `DeviceStatusPending`, `DeviceStatusConfirmed`, `DeviceStatusUsed`, `DeviceStatusExpired` and `DeviceStatusRevoked`) and `PermissionSet`. `PermissionSet` reads a stored permission column tolerantly (NULL, an empty string, `[]`, numeric strings) and writes a JSON object of integers; `ParsePermissionSet` and `PermissionSet.Text` do the same for a column that is a plain string on its model. `UserGroup.UsersCount` is filled only by a query that selects `users_count` (the admin list does). `Organisation.Members` is the relation behind the members manager, `Organisation.AttachRelations` declares its avatar (`OrganisationAvatarField`) and its logo (`OrganisationLogoField`), and `Slugify` is the slug rule. `User.FilterScope` answers the admin list scope `FilterByGroup`, and `User.AttachRelations` declares the avatar (`AvatarField`). `User.RegisterFillable` is the registration allow-list; `User.Fillable` is the wider mass-assignment backstop of the admin Users form (cabana intersects it with the form's fields) and of trusted application code.
 - `updates`: the gormigrate migrations, returned by `updates.All()`.
 - `console`: `RequirePasswordChange`, `BackfillHandles` and `APITokenCommands`.

@@ -266,7 +290,9 @@ Defaults live in `config/config.yaml` and are merged under `golem15.user.*`. Any
 | `golem15.user.password.public_routes` | `true` | When `false`, `POST /login`, `POST /forgot-password` and `POST /reset-password` are not registered and answer 404 like any unknown path; `POST /register` (still gated by `allow_registration` and guarded by `golem15.user.turnstile`) and every other route stay. It is read when the routes are built, so a change needs a restart. It takes `true` or `false`, also as a string (`SUMMER_GOLEM15__USER__PASSWORD__PUBLIC_ROUTES=false`); an empty value means `true`; any other value fails boot. |
 | `golem15.user.api_tokens.prefix` | `usr_` | Prefix for newly minted and accepted shared API-token secrets. Override an existing application's legacy prefix without creating a plugin-specific token table. |
 | `golem15.user.privileged_groups` | `[admin]` | Codes of the privileged user groups. Membership of such a group, the group's code and its delete, and the email, password and permanent delete of its members need `golem15.users.manage_privileged_groups`. Read on every request. An empty list protects no group. |
-| `golem15.user.frontend_url` | `""` | The site the plugin's own links point to: the account link page is this URL + `backend_links.page_path` + `#code=<code>`. Empty falls back to `app.url`; a trailing slash is dropped. |
+| `golem15.user.frontend_url` | `""` | The site the plugin's own links point to: the account link page is this URL + `backend_links.page_path` + `#code=<code>`, and it fills `{frontend_url}` in `device_auth.auth_url`. Empty falls back to `app.url`; a trailing slash is dropped. |
+| `golem15.user.device_auth.auth_url` | `{frontend_url}/device/scan/{token}` | The `auth_url` a device shows as its QR code, where a signed-in user authorizes it. `{frontend_url}` is `golem15.user.frontend_url` (else `app.url`, no trailing slash) and `{token}` the device token. |
+| `golem15.user.device_auth.ttl_minutes` | `5` | Minutes a device session can be authorized and handed over. |
 | `golem15.user.backend_links.page_path` | `/link-admin` | The site page that confirms an account link. A value without a leading `/` gets one. |
 | `golem15.user.backend_links.request_ttl` | `10m` | How long a link request an administrator starts on My account stays usable (a Go duration). A value that does not parse or is not positive fails boot. |
 | `golem15.user.turnstile` | `""` | Cloudflare Turnstile on `POST /login` and `POST /register` (only `/register` while `golem15.user.password.public_routes` is false). Empty adds nothing; `open` or `closed` appends the framework's `turnstile:open` or `turnstile:closed` middleware to those two routes only (summercms v0.3.0 and later; secret in `turnstile.secret`, token in the `turnstile_token` field). `open` lets requests pass when Cloudflare is unreachable, `closed` refuses them. Any other value fails boot. |
--- a/admin_permissions.go
+++ b/admin_permissions.go
@@ -16,7 +16,9 @@ const userPermissionTab = "golem15.user::lang.plugin.tab"
 // or password of a privileged-group member or delete one. The sixth
 // (classes.PermissionManageBackendLinks) has no default role either: it
 // links and unlinks another administrator's frontend account on the
-// Administrators screen.
+// Administrators screen. The seventh (classes.PermissionResetTwoFactor) has
+// no default role either: it runs the Users screen's "Reset 2FA" action,
+// which a two-factor plugin backs.
 func (*Plugin) Permissions() []pact.Permission {
 	return []pact.Permission{
 		{
@@ -53,5 +55,10 @@ func (*Plugin) Permissions() []pact.Permission {
 			Tab:   userPermissionTab,
 			Label: "golem15.user::lang.plugin.manage_backend_links",
 		},
+		{
+			Code:  classes.PermissionResetTwoFactor,
+			Tab:   userPermissionTab,
+			Label: "golem15.user::lang.plugin.reset_two_factor",
+		},
 	}
 }
--- a/admin_registration_test.go
+++ b/admin_registration_test.go
@@ -29,7 +29,7 @@ var langKey = regexp.MustCompile(`golem15\.user::lang\.[a-z0-9_]+(\.[a-z0-9_]+)+
 func TestAdminRegistration(t *testing.T) {
 	plugin := &Plugin{}

-	// The six permission codes, each on the plugin's tab.
+	// The seven permission codes, each on the plugin's tab.
 	var codes []string
 	for _, permission := range plugin.Permissions() {
 		codes = append(codes, permission.Code)
@@ -40,15 +40,15 @@ func TestAdminRegistration(t *testing.T) {
 	wantCodes := []string{
 		"golem15.users.access_users", "golem15.users.access_groups", "golem15.users.access_settings",
 		"golem15.users.impersonate_user", "golem15.users.manage_privileged_groups",
-		"golem15.users.manage_backend_links",
+		"golem15.users.manage_backend_links", "golem15.users.reset_two_factor",
 	}
 	if !reflect.DeepEqual(codes, wantCodes) {
 		t.Fatalf("permission codes = %v, want %v", codes, wantCodes)
 	}
-	// The privileged-groups and backend-links permissions have no default
-	// role: nobody holds them until they are granted on purpose.
+	// The privileged-groups, backend-links and reset-2FA permissions have no
+	// default role: nobody holds them until they are granted on purpose.
 	for _, permission := range plugin.Permissions() {
-		if privileged := permission.Code == permManagePrivileged || permission.Code == permManageBackendLinks; privileged != (len(permission.Roles) == 0) {
+		if privileged := permission.Code == permManagePrivileged || permission.Code == permManageBackendLinks || permission.Code == permResetTwoFactor; privileged != (len(permission.Roles) == 0) {
 			t.Fatalf("permission %s has roles %v", permission.Code, permission.Roles)
 		}
 	}
--- a/admin_users_edge_test.go
+++ b/admin_users_edge_test.go
@@ -250,6 +250,14 @@ func TestAdminUsersControllerGuards(t *testing.T) {
 				if action.Name == "activate" {
 					continue // reads the record only
 				}
+				if action.Name == "reset_two_factor" {
+					// No classes.TwoFactorAdmin is published, so it reads
+					// nothing and is simply not offered.
+					if applies, err := action.Applies(ctx, user); applies || err != nil {
+						t.Fatalf("applies reset_two_factor without a service = %v, %v", applies, err)
+					}
+					continue
+				}
 				_, err := action.Applies(ctx, user)
 				wantPlainError(t, "applies "+action.Name, err)
 			}
--- a/admin_users_test.go
+++ b/admin_users_test.go
@@ -50,6 +50,7 @@ func TestAdminUsersTracer(t *testing.T) {
 		"golem15.users.access_users@developer", "golem15.users.access_groups@developer",
 		"golem15.users.access_settings@developer", "golem15.users.impersonate_user@developer",
 		classes.PermissionManagePrivilegedGroups + "@-", classes.PermissionManageBackendLinks + "@-",
+		classes.PermissionResetTwoFactor + "@-",
 	}; !reflect.DeepEqual(codes, want) || classes.PermissionManagePrivilegedGroups != permManagePrivileged {
 		t.Fatalf("permissions = %v", codes)
 	}
@@ -610,7 +611,7 @@ func TestAdminUserActions(t *testing.T) {
 			registered = append(registered, action.Name)
 		}
 	}
-	if want := []string{"activate", "unban", "unsuspend"}; !reflect.DeepEqual(registered, want) {
+	if want := []string{"activate", "unban", "unsuspend", "reset_two_factor"}; !reflect.DeepEqual(registered, want) {
 		t.Fatalf("record actions = %v, want %v", registered, want)
 	}
 	var form struct {
--- a/classes/device_auth.go
+++ b/classes/device_auth.go
@@ -0,0 +1,144 @@
+package classes
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/base64"
+	"strings"
+	"time"
+
+	"git.golem15.com/golem15/summercms/modules/backpack"
+	"gorm.io/gorm"
+)
+
+// DeviceShortCodeAlphabet is the alphabet of device short codes (PHP's
+// recovery-code alphabet: no 0, 1, I, L or O).
+const DeviceShortCodeAlphabet = "23456789ABCDEFGHJKMNPQRSTUVWXYZ"
+
+// defaultDeviceAuthURL is golem15.user.device_auth.auth_url when unset.
+const defaultDeviceAuthURL = "{frontend_url}/device/scan/{token}"
+
+// defaultDeviceAuthTTL is golem15.user.device_auth.ttl_minutes when unset.
+const defaultDeviceAuthTTL = 5 * time.Minute
+
+// NewDeviceToken returns a fresh device token: 48 bytes from crypto/rand as
+// unpadded base64url, 64 characters. Store only its HashAPIToken.
+func NewDeviceToken() (string, error) {
+	var b [48]byte
+	if _, err := rand.Read(b[:]); err != nil {
+		return "", err
+	}
+	return base64.RawURLEncoding.EncodeToString(b[:]), nil
+}
+
+// NewDeviceShortCode returns a fresh short code XXXX-XXXX, eight characters
+// drawn uniformly from DeviceShortCodeAlphabet with crypto/rand (rejection
+// sampling, no modulo bias).
+func NewDeviceShortCode() (string, error) {
+	n := len(DeviceShortCodeAlphabet)
+	limit := 256 - 256%n // largest multiple of n that fits a byte
+	out := make([]byte, 0, 9)
+	var buf [16]byte
+	for len(out) < 9 {
+		if _, err := rand.Read(buf[:]); err != nil {
+			return "", err
+		}
+		for _, c := range buf {
+			if int(c) >= limit {
+				continue
+			}
+			if len(out) == 4 {
+				out = append(out, '-')
+			}
+			out = append(out, DeviceShortCodeAlphabet[int(c)%n])
+			if len(out) == 9 {
+				break
+			}
+		}
+	}
+	return string(out), nil
+}
+
+// NormalizeDeviceShortCode turns what a user typed into the stored form
+// XXXX-XXXX: upper case, spaces and hyphens removed, exactly eight
+// characters of DeviceShortCodeAlphabet. It reports false otherwise.
+func NormalizeDeviceShortCode(s string) (string, bool) {
+	s = strings.ToUpper(s)
+	s = strings.NewReplacer(" ", "", "-", "").Replace(s)
+	if len(s) != 8 {
+		return "", false
+	}
+	for i := 0; i < len(s); i++ {
+		if strings.IndexByte(DeviceShortCodeAlphabet, s[i]) < 0 {
+			return "", false
+		}
+	}
+	return s[:4] + "-" + s[4:], true
+}
+
+// DeviceAuthTTL is how long a device authorization session can be
+// authorized and handed over: golem15.user.device_auth.ttl_minutes, default
+// 5.
+func DeviceAuthTTL(app *backpack.App) time.Duration {
+	if app != nil && app.Config != nil {
+		if mins := app.Config.Int("golem15.user.device_auth.ttl_minutes"); mins > 0 {
+			return time.Duration(mins) * time.Minute
+		}
+	}
+	return defaultDeviceAuthTTL
+}
+
+// DeviceAuthURL is the auth_url a new device shows as its QR code: the
+// template golem15.user.device_auth.auth_url (default
+// {frontend_url}/device/scan/{token}) with {frontend_url} replaced by
+// FrontendURL (golem15.user.frontend_url, else app.url, no trailing slash)
+// and {token} by the device token.
+func DeviceAuthURL(app *backpack.App, token string) string {
+	tpl := ""
+	if app != nil && app.Config != nil {
+		tpl = strings.TrimSpace(app.Config.String("golem15.user.device_auth.auth_url"))
+	}
+	if tpl == "" {
+		tpl = defaultDeviceAuthURL
+	}
+	return strings.NewReplacer("{frontend_url}", FrontendURL(app), "{token}", token).Replace(tpl)
+}
+
+// DeviceDisplayName is the name a device list shows (PHP's device_name
+// accessor): the stored name, else a name parsed from the user agent
+// (iPhone, iPad, Android Device, Windows PC, Mac, Linux PC), else Unknown
+// Device.
+func DeviceDisplayName(stored *string, userAgent string) string {
+	if stored != nil && *stored != "" {
+		return *stored
+	}
+	switch {
+	case strings.Contains(userAgent, "iPhone"):
+		return "iPhone"
+	case strings.Contains(userAgent, "iPad"):
+		return "iPad"
+	case strings.Contains(userAgent, "Android"):
+		return "Android Device"
+	case strings.Contains(userAgent, "Windows"):
+		return "Windows PC"
+	case strings.Contains(userAgent, "Macintosh"):
+		return "Mac"
+	case strings.Contains(userAgent, "Linux"):
+		return "Linux PC"
+	}
+	return "Unknown Device"
+}
+
+// HandOverDeviceJTI moves a used device session from the jti of a session
+// token to the jti of the token that refreshed it, and stamps its
+// last_activity_at, so revoking the device still reaches the token the
+// device holds now. POST /refresh calls it after a successful refresh;
+// empty values do nothing.
+func HandOverDeviceJTI(ctx context.Context, db *gorm.DB, oldJTI, newJTI string) error {
+	if db == nil || oldJTI == "" || newJTI == "" || oldJTI == newJTI {
+		return nil
+	}
+	return db.WithContext(ctx).Exec(`UPDATE golem15_user_device_auth_sessions
+	SET jwt_jti = ?, last_activity_at = NOW(), updated_at = NOW()
+	WHERE jwt_jti = ? AND status = 'used'`, newJTI, oldJTI).Error
+}
--- a/classes/events.go
+++ b/classes/events.go
@@ -25,6 +25,10 @@ const BackendUnlinkedEventName = "user.BackendUnlinked"
 // AccessRevokedEventName is the festival name of AccessRevokedEvent.
 const AccessRevokedEventName = "user.AccessRevoked"

+// LoginEventName is the festival name of LoginEvent, the PHP plugin's
+// golem15.user.login.
+const LoginEventName = "golem15.user.login"
+
 // GetApiArrayEvent is the fire-and-collect payload other plugins extend.
 type GetApiArrayEvent struct {
 	User *models.User
@@ -111,3 +115,32 @@ type AccessRevokedEvent struct {
 	Reason  string
 	Tx      *gorm.DB
 }
+
+// PasswordChanged reports whether the event comes from a new password the
+// user or an administrator chose: a password reset, the user's own change or
+// an administrator setting one (Reason AccessRevokedPasswordReset,
+// AccessRevokedPasswordChanged or AccessRevokedPasswordSetByAdmin). The
+// bcrypt rehash on login and a new account fire no AccessRevokedEvent. A
+// two-factor plugin listens for these events to revoke the users' trusted
+// devices inside the same transaction.
+func (e *AccessRevokedEvent) PasswordChanged() bool {
+	if e == nil {
+		return false
+	}
+	switch e.Reason {
+	case AccessRevokedPasswordReset, AccessRevokedPasswordChanged, AccessRevokedPasswordSetByAdmin:
+		return true
+	}
+	return false
+}
+
+// LoginEvent fires after a sign-in issued a session token: a password login,
+// a sign-in completed by a second factor, a passkey sign-in or a device
+// hand-over (Source is one of the LoginSource constants). It does not fire
+// on refresh, on /register or for a sign-in a login gate held back. It fires
+// after the token was minted and outside any transaction; a listener error
+// is logged and never fails the sign-in (PHP's golem15.user.login).
+type LoginEvent struct {
+	User   *models.User
+	Source string
+}
--- a/classes/login_gate.go
+++ b/classes/login_gate.go
@@ -0,0 +1,124 @@
+package classes
+
+import (
+	"context"
+	"net/http"
+	"slices"
+	"sync"
+
+	"git.golem15.com/golem15/sm-user-plugin/models"
+)
+
+// Login sources name the first factor a LoginAttempt or a LoginEvent comes
+// from.
+const (
+	// LoginSourcePassword is POST /_user/api/v1/login (email and password).
+	LoginSourcePassword = "password"
+	// LoginSourceSocial is a social sign-in completed by a social-login
+	// plugin.
+	LoginSourceSocial = "social"
+	// LoginSourcePasskey is a passwordless passkey sign-in.
+	LoginSourcePasskey = "passkey"
+	// LoginSourceTwoFactor is a sign-in completed by a second factor after a
+	// gate challenged it.
+	LoginSourceTwoFactor = "two_factor"
+	// LoginSourceDevice is the device authorization hand-over (the first poll
+	// of devices/status after a signed-in user authorized the device).
+	LoginSourceDevice = "device"
+)
+
+// LoginAttempt is a first-factor sign-in that already succeeded: the
+// password (or the social identity) checked out, the throttle was reset and
+// the account may sign in. A LoginGate decides whether a token is issued
+// now.
+type LoginAttempt struct {
+	// User is the account signing in. A deactivated account still has
+	// DeletedAt set: Login restores it only after every gate allowed the
+	// sign-in.
+	User *models.User
+	// Source is one of the LoginSource constants.
+	Source string
+	// Fields is the login body Login already read (a gate must not read the
+	// request body again, it is consumed). It carries keys a gate needs,
+	// such as trusted_device_token. It is nil on a social sign-in. Treat it
+	// as read-only, untrusted input; it holds the password on a password
+	// login.
+	Fields map[string]any
+	// Request is the sign-in request, for the client address and the user
+	// agent.
+	Request *http.Request
+}
+
+// LoginGateResult replaces the token response of a sign-in a gate held
+// back.
+type LoginGateResult struct {
+	// Status is the HTTP status of the answer; 0 means 200. A challenge
+	// answers 200, a refusal (for example a second-factor failure cap)
+	// answers its own status.
+	Status int
+	// Body is the JSON body of the answer, for example
+	// {two_factor_required, challenge_token, available_methods, expires_at}.
+	Body map[string]any
+}
+
+// LoginGate inspects a first-factor sign-in that already succeeded, before
+// any token exists. A two-factor plugin implements one to challenge users
+// who enabled a second factor.
+type LoginGate interface {
+	// CheckLogin returns nil, nil to allow the sign-in. A non-nil result
+	// replaces the token response with its Status and Body, and no token is
+	// issued. An error must fail the sign-in closed: the caller answers the
+	// opaque 500 and issues no token. Error strings must not carry a token,
+	// a code or a password.
+	CheckLogin(ctx context.Context, a LoginAttempt) (*LoginGateResult, error)
+}
+
+// LoginGates is the registry of login gates. The user plugin publishes one
+// in its Register (app.Publish(classes.NewLoginGates())), and another plugin
+// looks it up with app.Lookup[*classes.LoginGates]() and adds its gate in
+// its Boot: every Register runs before every Boot. Password Login consults
+// it after the password, activation and throttle checks and before it
+// restores a deactivated account and mints the token; JWT refresh never
+// consults it. It is safe for concurrent use.
+type LoginGates struct {
+	mu    sync.RWMutex
+	gates []LoginGate
+}
+
+// NewLoginGates returns an empty registry.
+func NewLoginGates() *LoginGates {
+	return &LoginGates{}
+}
+
+// Add appends gate; gates run in the order they were added. A nil gate is
+// ignored.
+func (g *LoginGates) Add(gate LoginGate) {
+	if g == nil || gate == nil {
+		return
+	}
+	g.mu.Lock()
+	g.gates = append(g.gates, gate)
+	g.mu.Unlock()
+}
+
+// Check runs the gates in order and returns the first non-nil result or the
+// first error; gates after it are not called. A nil registry and an empty
+// one return nil, nil, which allows the sign-in.
+func (g *LoginGates) Check(ctx context.Context, a LoginAttempt) (*LoginGateResult, error) {
+	if g == nil {
+		return nil, nil
+	}
+	g.mu.RLock()
+	gates := slices.Clone(g.gates)
+	g.mu.RUnlock()
+	for _, gate := range gates {
+		res, err := gate.CheckLogin(ctx, a)
+		if err != nil {
+			return nil, err
+		}
+		if res != nil {
+			return res, nil
+		}
+	}
+	return nil, nil
+}
--- a/classes/two_factor_admin.go
+++ b/classes/two_factor_admin.go
@@ -0,0 +1,38 @@
+package classes
+
+import (
+	"context"
+
+	"git.golem15.com/golem15/sm-user-plugin/models"
+	"gorm.io/gorm"
+)
+
+// PermissionResetTwoFactor is the backend permission an administrator needs
+// to run the Users screen's "Reset 2FA" record action (reset_two_factor). No
+// role has it by default: only a superuser, or a role granted it
+// explicitly, may remove a user's second factors.
+const PermissionResetTwoFactor = "golem15.users.reset_two_factor"
+
+// TwoFactorAdmin is what a two-factor plugin publishes so the Users screen
+// can offer its "Reset 2FA" record action. The screen looks it up on every
+// request: without a published service the action is never offered, so an
+// application that mounts no two-factor plugin never shows it.
+//
+// Publish it with an explicit type argument,
+//
+//	app.Publish[classes.TwoFactorAdmin](svc)
+//
+// because a bare app.Publish(svc) keys the service on its concrete type and
+// the lookup misses it.
+type TwoFactorAdmin interface {
+	// HasTwoFactor reports whether the user has any second factor (an
+	// enabled method, a WebAuthn credential, recovery codes or a trusted
+	// device) to reset. It only reads, through tx.
+	HasTwoFactor(ctx context.Context, tx *gorm.DB, userID uint) (bool, error)
+	// Reset disables every second-factor method of user, deletes the
+	// WebAuthn credentials and recovery codes, revokes the trusted devices
+	// and fires the plugin's disabled event, all on tx (the record action's
+	// transaction): an error rolls the reset back. The user then signs in
+	// with the password alone until they set up a second factor again.
+	Reset(ctx context.Context, tx *gorm.DB, user *models.User) error
+}
--- a/config/config.yaml
+++ b/config/config.yaml
@@ -39,9 +39,16 @@ privileged_groups:
 # v0.3.0 and later); its secret is turnstile.secret (SUMMER_TURNSTILE__SECRET).
 turnstile: ""
 # The site this plugin's links point to (the account link page,
-# <frontend_url><backend_links.page_path>#code=...). Empty falls back to
-# app.url.
+# <frontend_url><backend_links.page_path>#code=..., and the device
+# authorization page of device_auth.auth_url). Empty falls back to app.url.
 frontend_url: ""
+device_auth:
+  # The page a new device shows as its QR code, where a signed-in user
+  # authorizes it. {frontend_url} is frontend_url (else app.url, no trailing
+  # slash) and {token} the device token.
+  auth_url: "{frontend_url}/device/scan/{token}"
+  # Minutes a device session can be authorized and handed over.
+  ttl_minutes: 5
 backend_links:
  # How long a link request an administrator starts on My account stays
  # usable (a Go duration). The code is one-shot.
--- a/controllers/api_controller.go
+++ b/controllers/api_controller.go
@@ -47,8 +47,11 @@ const invalidLoginBody = "Invalid email or password"
 //
 // It checks in this order: a ban or an active suspension
 // (classes.RejectIfThrottled), the password (bcrypt), the activation, then
-// restores a deactivated (deleted_at) account and sends it the reactivate
-// mail, records the successful attempt and mints the token. With
+// records the successful attempt, consults the login gates
+// (CheckLoginGates: a gate answer replaces the token response, a gate error
+// answers the opaque 500), restores a deactivated (deleted_at) account and
+// sends it the reactivate mail, mints the token and fires
+// classes.LoginEvent. With
 // golem15.user.activation.require_activation on (the default) the correct
 // password of a not-activated account gets the same 401 invalid-login answer
 // as a wrong password and counts as a failed attempt for the throttle; an
@@ -106,13 +109,6 @@ func Login(app *backpack.App) http.HandlerFunc {
 			refuseLogin(ctx, w, r, app, gdb, user, ip)
 			return
 		}
-		if user.DeletedAt.Valid {
-			if err := gdb.WithContext(ctx).Unscoped().Model(user).Update("deleted_at", nil).Error; err != nil {
-				writeOpaque500(w)
-				return
-			}
-			sendTemplateVars(ctx, app, mailName(ctx, user, "golem15.user::mail.reactivate"), user.Email, mailVars(displayName(user), "", ""))
-		}
 		if err := classes.CheckAndRecordLogin(ctx, gdb, user, ip, true); err != nil {
 			if classes.IsLoginRejected(err) {
 				writeInvalidLogin(w, r, app)
@@ -121,15 +117,51 @@ func Login(app *backpack.App) http.HandlerFunc {
 			writeOpaque500(w)
 			return
 		}
+		// The rehash runs before the login gates, so a user who is always
+		// challenged still gets the stronger hash. It is not a password
+		// change: it fires no AccessRevokedEvent (D-07). Unscoped, because a
+		// deactivated account is restored only after the gates.
 		cost := 10
 		if app.Config != nil && app.Config.Int("golem15.user.password.bcrypt_cost") > 0 {
 			cost = app.Config.Int("golem15.user.password.bcrypt_cost")
 		}
 		if bouncer.NeedsRehash(user.Password, cost) {
 			if next, err := bouncer.HashPassword(cost, password); err == nil {
-				_ = gdb.WithContext(ctx).Model(user).Update("password", next).Error
+				_ = gdb.WithContext(ctx).Unscoped().Model(user).Update("password", next).Error
 			}
 		}
+		// Login gates (D-02) run after the password, activation and throttle
+		// checks and before anything that signs the user in. A gate answer
+		// replaces the token response; a gate error fails closed. The
+		// restore of a deactivated account and its reactivate mail come
+		// after the gates (D-18 A10), so the password alone cannot reactivate
+		// an account that a second factor protects.
+		gate, err := CheckLoginGates(ctx, app, classes.LoginAttempt{
+			User:    user,
+			Source:  classes.LoginSourcePassword,
+			Fields:  fields,
+			Request: r,
+		})
+		if err != nil {
+			pluginLog.Error("golem15.user: login gate", "user_id", user.ID, "err", err)
+			writeOpaque500(w)
+			return
+		}
+		if gate != nil {
+			status := gate.Status
+			if status == 0 {
+				status = http.StatusOK
+			}
+			writeJSON(w, status, gate.Body)
+			return
+		}
+		if user.DeletedAt.Valid {
+			if err := gdb.WithContext(ctx).Unscoped().Model(user).Update("deleted_at", nil).Error; err != nil {
+				writeOpaque500(w)
+				return
+			}
+			sendTemplateVars(ctx, app, mailName(ctx, user, "golem15.user::mail.reactivate"), user.Email, mailVars(displayName(user), "", ""))
+		}
 		// A failed last_seen write is logged and never fails the login.
 		if err := classes.TouchLastSeen(ctx, gdb, user.ID); err != nil {
 			pluginLog.Warn("golem15.user: stamp last_seen on login", "user_id", user.ID, "err", err)
@@ -144,6 +176,9 @@ func Login(app *backpack.App) http.HandlerFunc {
 			writeOpaque500(w)
 			return
 		}
+		if err := FireLoginEvent(ctx, app, user, classes.LoginSourcePassword); err != nil {
+			pluginLog.Warn("golem15.user: login event listener", "user_id", user.ID, "err", err)
+		}
 		writeSession(w, app, cc, token, map[string]any{"user": payload})
 	}
 }
@@ -269,10 +304,36 @@ func Refresh(app *backpack.App) http.HandlerFunc {
 		if err := classes.TouchLastSeen(r.Context(), gdb, userID); err != nil {
 			pluginLog.Warn("golem15.user: stamp last_seen on refresh", "user_id", userID, "err", err)
 		}
+		// A device session follows its token through refresh (D-12b), so a
+		// revoke blacklists the token the device holds now. Reading the old
+		// jti unverified is safe: bouncer.Refresh has just verified it. With
+		// golem15.user.jwt.blacklist_grace above 0 two concurrent refreshes of
+		// one token can fork a device's lineage and only one fork is
+		// followed; a password change still ends both (tokens_valid_after).
+		// A failure is logged without any token or jti and never fails the
+		// refresh.
+		if oldJTI := unverifiedJTI(raw); oldJTI != "" {
+			if _, _, _, newJTI, err := bouncer.VerifyClaims(next, secret); err == nil {
+				if err := classes.HandOverDeviceJTI(r.Context(), gdb, oldJTI, newJTI); err != nil {
+					pluginLog.Warn("golem15.user: hand a device session over on refresh", "user_id", userID, "err", err)
+				}
+			}
+		}
 		writeSession(w, app, rotate, next, map[string]any{})
 	}
 }

+// unverifiedJTI returns the jti claim of a token without verifying it, ""
+// when there is none. Only call it on a token that was verified already.
+func unverifiedJTI(raw string) string {
+	claims := jwt.MapClaims{}
+	if _, _, err := jwt.NewParser().ParseUnverified(raw, claims); err != nil {
+		return ""
+	}
+	jti, _ := claims["jti"].(string)
+	return jti
+}
+
 // refreshSubjectRefused reads the subject and iat of a token bouncer.Refresh
 // has already verified and reports whether its user may not slide the
 // session: not found by a scoped load (missing or deactivated), issued
@@ -1036,12 +1097,18 @@ func apiArray(ctx context.Context, app *backpack.App, user *models.User) (map[st
 }

 func mintFor(app *backpack.App, secret string, user *models.User, issuer string) (string, error) {
+	token, _, err := bouncer.Mint(secret, strconv.FormatUint(uint64(user.ID), 10), issuer, sessionTTL(app))
+	return token, err
+}
+
+// sessionTTL is the lifetime of a session JWT: golem15.user.jwt.ttl
+// minutes, default 60.
+func sessionTTL(app *backpack.App) time.Duration {
 	ttl := 60 * time.Minute
 	if app != nil && app.Config != nil && app.Config.Int("golem15.user.jwt.ttl") > 0 {
 		ttl = time.Duration(app.Config.Int("golem15.user.jwt.ttl")) * time.Minute
 	}
-	token, _, err := bouncer.Mint(secret, strconv.FormatUint(uint64(user.ID), 10), issuer, ttl)
-	return token, err
+	return ttl
 }

 // RefreshTTL is the refresh window of a session token:
--- a/controllers/devices.go
+++ b/controllers/devices.go
@@ -0,0 +1,523 @@
+package controllers
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"git.golem15.com/golem15/sm-user-plugin/classes"
+	"git.golem15.com/golem15/sm-user-plugin/models"
+	"git.golem15.com/golem15/summercms/modules/backpack"
+	"git.golem15.com/golem15/summercms/modules/bouncer"
+	"git.golem15.com/golem15/summercms/modules/lagoon"
+	"git.golem15.com/golem15/summercms/modules/surf"
+	"git.golem15.com/golem15/summercms/modules/wire"
+	"github.com/jackc/pgx/v5/pgconn"
+	"gorm.io/gorm"
+)
+
+// deviceTable is the device authorization session table.
+const deviceTable = "golem15_user_device_auth_sessions"
+
+// deviceInsertAttempts bounds the retries of an initiate whose fresh short
+// code (or token) collided with a stored one.
+const deviceInsertAttempts = 5
+
+// deviceCleanupBatch bounds the stale sessions one initiate deletes.
+const deviceCleanupBatch = 500
+
+// writeDeviceUnauthorized is the PHP device controller's 401 body, which
+// differs from the session routes' {"error":true,"message":"Unauthorized"}.
+func writeDeviceUnauthorized(w http.ResponseWriter) {
+	writeJSON(w, http.StatusUnauthorized, map[string]any{"error": "Unauthorized"})
+}
+
+// deviceCaller resolves the signed-in user of a device route that needs one
+// (authorize, list, revoke). It reads and checks the session token as the
+// plugin's jwt guard does (bearer header, then the session cookies; the
+// blacklist and tokens_valid_after apply) and also returns the token's jti.
+// Anything else answers PHP's 401 {"error":"Unauthorized"}.
+func deviceCaller(w http.ResponseWriter, r *http.Request, app *backpack.App, gdb *gorm.DB, secret string) (*models.User, string, bool) {
+	principal, err := sessionGuard(app, secret).Authenticate(r)
+	if err != nil || principal == nil || principal.ID == 0 {
+		writeDeviceUnauthorized(w)
+		return nil, "", false
+	}
+	var user models.User
+	if err := gdb.WithContext(r.Context()).Where("id = ?", principal.ID).Take(&user).Error; err != nil {
+		writeDeviceUnauthorized(w)
+		return nil, "", false
+	}
+	jti := ""
+	if raw := classes.SessionToken(r); raw != "" {
+		if _, _, _, id, err := bouncer.VerifyClaims(raw, secret); err == nil {
+			jti = id
+		}
+	}
+	return &user, jti, true
+}
+
+// deviceClientIP is the client address device rows record: surf.ClientIP
+// with http.trusted_proxies, as /login and /register use.
+func deviceClientIP(app *backpack.App, r *http.Request) string {
+	return surf.ClientIP(r, surf.TrustedProxies(appConfig(app)))
+}
+
+// DeviceInitiate is POST /devices/initiate, called without a session by the
+// device that wants to sign in. It stores a pending session (the SHA-256 of
+// a 64-character token, a short code XXXX-XXXX, expires_at now plus
+// golem15.user.device_auth.ttl_minutes, the device's address, user agent and
+// optional device_name of at most 255 characters) and answers
+// {"success":true,"data":{"token","short_code","auth_url","expires_at"}}.
+// Each call first deletes at most 500 pending or expired sessions that
+// expired more than an hour ago.
+func DeviceInitiate(app *backpack.App) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		gdb, _, ok := sessionDeps(w, app)
+		if !ok {
+			return
+		}
+		fields, err := readFields(r)
+		if err != nil {
+			writeOpaque500(w)
+			return
+		}
+		name := strField(fields, "device_name")
+		if utf8.RuneCountInString(name) > 255 {
+			writeValidation(w, map[string][]string{"device_name": {"The device name may not be greater than 255 characters."}})
+			return
+		}
+		ctx := r.Context()
+		// Stale sessions go in bounded batches, so the unauthenticated route
+		// cannot grow the table without limit (a failure is only logged).
+		if err := gdb.WithContext(ctx).Exec(`DELETE FROM `+deviceTable+` WHERE id IN (
+	SELECT id FROM `+deviceTable+`
+	WHERE status IN ('pending', 'expired') AND expires_at < NOW() - INTERVAL '1 hour'
+	LIMIT ?)`, deviceCleanupBatch).Error; err != nil {
+			pluginLog.Warn("golem15.user: device session cleanup", "err", err)
+		}
+		ip := deviceClientIP(app, r)
+		ua := r.UserAgent()
+		expires := time.Now().Add(classes.DeviceAuthTTL(app)).Truncate(time.Second)
+		var (
+			token string
+			row   models.DeviceAuthSession
+		)
+		for attempt := 0; ; attempt++ {
+			token, err = classes.NewDeviceToken()
+			if err != nil {
+				writeOpaque500(w)
+				return
+			}
+			code, err := classes.NewDeviceShortCode()
+			if err != nil {
+				writeOpaque500(w)
+				return
+			}
+			row = models.DeviceAuthSession{
+				TokenHash: classes.HashAPIToken(token),
+				ShortCode: &code,
+				Status:    models.DeviceStatusPending,
+				ExpiresAt: &expires,
+			}
+			if ip != "" {
+				row.DeviceIP = &ip
+			}
+			if ua != "" {
+				row.DeviceUserAgent = &ua
+			}
+			if name != "" {
+				row.DeviceName = &name
+			}
+			err = gdb.WithContext(ctx).Create(&row).Error
+			if err == nil {
+				break
+			}
+			var pgErr *pgconn.PgError
+			if !errors.As(err, &pgErr) || pgErr.Code != "23505" || attempt+1 >= deviceInsertAttempts {
+				pluginLog.Error("golem15.user: store device session", "err", err)
+				writeOpaque500(w)
+				return
+			}
+		}
+		writeJSON(w, http.StatusOK, map[string]any{
+			"success": true,
+			"data": map[string]any{
+				"token":      token,
+				"short_code": *row.ShortCode,
+				"auth_url":   classes.DeviceAuthURL(app, token),
+				"expires_at": wire.Time{Time: expires},
+			},
+		})
+	}
+}
+
+// DeviceStatus is GET /devices/status/{token}, polled by the waiting
+// device. It answers 404 {"error":"Session not found"} for an unknown token
+// and PHP's flat {"success":true,"status":"expired","message":…} for a
+// pending or confirmed session past expires_at (which it marks expired).
+// The first poll after a signed-in user authorized the session receives a
+// session token: {"success":true,"data":{"status":"confirmed","user_id",
+// "message":"Device authorized - complete login","token","user"}}. One
+// guarded confirmed-to-used UPDATE decides which poll that is, so of
+// concurrent polls exactly one gets the token; the others, and every later
+// poll, answer {"success":true,"data":{"status":"used"}}. Other statuses
+// answer {"success":true,"data":{"status":…}}.
+func DeviceStatus(app *backpack.App) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		gdb, secret, ok := sessionDeps(w, app)
+		if !ok {
+			return
+		}
+		row, found, err := deviceByToken(r, gdb, r.PathValue("token"))
+		if err != nil {
+			writeOpaque500(w)
+			return
+		}
+		if !found {
+			writeJSON(w, http.StatusNotFound, map[string]any{"error": "Session not found"})
+			return
+		}
+		if row.Status == models.DeviceStatusConfirmed && row.UserID != nil && !row.ExpiredAt(time.Now()) {
+			if handOverDevice(w, r, app, gdb, secret, row) {
+				return
+			}
+			// Another poll won the hand-over or the session just expired:
+			// answer what the row says now, never a token.
+			row, found, err = deviceByID(r, gdb, row.ID)
+			if err != nil || !found {
+				writeOpaque500(w)
+				return
+			}
+		}
+		writeDeviceStatus(w, r, gdb, row)
+	}
+}
+
+// deviceByToken loads the session whose token hash matches token.
+func deviceByToken(r *http.Request, gdb *gorm.DB, token string) (models.DeviceAuthSession, bool, error) {
+	var row models.DeviceAuthSession
+	if token == "" {
+		return row, false, nil
+	}
+	res := gdb.WithContext(r.Context()).Where("token = ?", classes.HashAPIToken(token)).Limit(1).Find(&row)
+	return row, res.RowsAffected == 1, res.Error
+}
+
+func deviceByID(r *http.Request, gdb *gorm.DB, id uint) (models.DeviceAuthSession, bool, error) {
+	var row models.DeviceAuthSession
+	res := gdb.WithContext(r.Context()).Where("id = ?", id).Limit(1).Find(&row)
+	return row, res.RowsAffected == 1, res.Error
+}
+
+// writeDeviceStatus answers a status poll that hands over no token. A
+// pending or confirmed session past expires_at is marked expired (used and
+// revoked sessions never are); an expired session answers PHP's flat
+// expired body.
+func writeDeviceStatus(w http.ResponseWriter, r *http.Request, gdb *gorm.DB, row models.DeviceAuthSession) {
+	expire := row.ExpiredAt(time.Now())
+	if expire || row.Status == models.DeviceStatusExpired {
+		if expire {
+			if err := gdb.WithContext(r.Context()).Exec(`UPDATE `+deviceTable+` SET status = 'expired', updated_at = NOW()
+	WHERE id = ? AND status IN ('pending', 'confirmed')`, row.ID).Error; err != nil {
+				writeOpaque500(w)
+				return
+			}
+		}
+		writeJSON(w, http.StatusOK, map[string]any{
+			"success": true,
+			"status":  models.DeviceStatusExpired,
+			"message": "Authorization session has expired",
+		})
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"success": true, "data": map[string]any{"status": row.Status}})
+}
+
+// handOverDevice gives the confirmed session's user a session token for the
+// device (D-12a). It reports false, having written nothing, when another
+// poll already took the session or it expired meanwhile; the token it
+// minted is then dropped unsent.
+func handOverDevice(w http.ResponseWriter, r *http.Request, app *backpack.App, gdb *gorm.DB, secret string, row models.DeviceAuthSession) bool {
+	ctx := r.Context()
+	var user models.User
+	res := gdb.WithContext(ctx).Where("id = ?", *row.UserID).Limit(1).Find(&user)
+	if res.Error != nil {
+		writeOpaque500(w)
+		return true
+	}
+	refused := res.RowsAffected == 0
+	if !refused {
+		banned, _, err := classes.ThrottleStates(classes.ContextWithThrottle(ctx, app), gdb.WithContext(ctx), []uint{user.ID})
+		if err != nil {
+			writeOpaque500(w)
+			return true
+		}
+		refused = banned[user.ID]
+	}
+	if refused {
+		// A deactivated, deleted or banned user signs no device in.
+		if err := gdb.WithContext(ctx).Exec(`UPDATE `+deviceTable+` SET status = 'revoked', updated_at = NOW()
+	WHERE id = ? AND status = 'confirmed'`, row.ID).Error; err != nil {
+			writeOpaque500(w)
+			return true
+		}
+		return false
+	}
+	token, jti, err := mintWithJTI(app, secret, &user, requestURL(r))
+	if err != nil {
+		writeOpaque500(w)
+		return true
+	}
+	payload, err := apiArray(ctx, app, &user)
+	if err != nil {
+		writeOpaque500(w)
+		return true
+	}
+	res = gdb.WithContext(ctx).Exec(`UPDATE `+deviceTable+`
+	SET status = 'used', used_at = NOW(), last_activity_at = NOW(), jwt_jti = ?, updated_at = NOW()
+	WHERE id = ? AND status = 'confirmed' AND expires_at > NOW()`, jti, row.ID)
+	if res.Error != nil {
+		writeOpaque500(w)
+		return true
+	}
+	if res.RowsAffected != 1 {
+		return false
+	}
+	if err := FinishLogin(ctx, app, gdb, &user, deviceClientIP(app, r)); err != nil {
+		pluginLog.Warn("golem15.user: finish device login", "user_id", user.ID, "err", err)
+	}
+	if err := FireLoginEvent(ctx, app, &user, classes.LoginSourceDevice); err != nil {
+		pluginLog.Warn("golem15.user: login event listener", "user_id", user.ID, "err", err)
+	}
+	writeJSON(w, http.StatusOK, map[string]any{
+		"success": true,
+		"data": map[string]any{
+			"status":  models.DeviceStatusConfirmed,
+			"user_id": user.ID,
+			"message": "Device authorized - complete login",
+			"token":   token,
+			"user":    payload,
+		},
+	})
+	return true
+}
+
+// DeviceAuthorize is POST /devices/authorize: a signed-in user (a valid,
+// not blacklisted session token; no second-factor check, D-12c) binds a
+// pending device session to themselves by its short_code (hyphens and
+// spaces optional, any case) or by its token (the QR code). A short_code of
+// other than 8 characters after removing hyphens answers 422 {"error":
+// "Please enter a valid 8-character code"}; an unknown, expired, used,
+// revoked or foreign session answers 400 {"error":"Invalid or expired
+// code"}; success, and repeating it for a session the caller already
+// confirmed, answers {"success":true,"message":"Device authorized
+// successfully"}. Without a session it answers 401 {"error":"Unauthorized"}.
+// The fields are read from the body only, never the query string.
+func DeviceAuthorize(app *backpack.App) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		gdb, secret, ok := sessionDeps(w, app)
+		if !ok {
+			return
+		}
+		user, _, ok := deviceCaller(w, r, app, gdb, secret)
+		if !ok {
+			return
+		}
+		fields, err := readBodyFields(r)
+		if err != nil {
+			writeOpaque500(w)
+			return
+		}
+		invalid := func() {
+			writeJSON(w, http.StatusBadRequest, map[string]any{"error": "Invalid or expired code"})
+		}
+		var (
+			row   models.DeviceAuthSession
+			found bool
+		)
+		if _, has := fields["short_code"]; has {
+			raw := strings.ReplaceAll(strField(fields, "short_code"), "-", "")
+			if len(raw) != 8 {
+				writeJSON(w, http.StatusUnprocessableEntity, map[string]any{"error": "Please enter a valid 8-character code"})
+				return
+			}
+			code, valid := classes.NormalizeDeviceShortCode(raw)
+			if !valid {
+				invalid()
+				return
+			}
+			res := gdb.WithContext(r.Context()).Where("short_code = ?", code).Limit(1).Find(&row)
+			if res.Error != nil {
+				writeOpaque500(w)
+				return
+			}
+			found = res.RowsAffected == 1
+		} else if _, has := fields["token"]; has {
+			row, found, err = deviceByToken(r, gdb, strField(fields, "token"))
+			if err != nil {
+				writeOpaque500(w)
+				return
+			}
+		}
+		if !found {
+			invalid()
+			return
+		}
+		res := gdb.WithContext(r.Context()).Exec(`UPDATE `+deviceTable+`
+	SET status = 'confirmed', user_id = ?, confirmed_at = NOW(), auth_ip = ?, updated_at = NOW()
+	WHERE id = ? AND status = 'pending' AND (user_id IS NULL OR user_id = ?) AND expires_at > NOW()`,
+			user.ID, nullableString(deviceClientIP(app, r)), row.ID, user.ID)
+		if res.Error != nil {
+			writeOpaque500(w)
+			return
+		}
+		if res.RowsAffected != 1 {
+			now, ok, err := deviceByID(r, gdb, row.ID)
+			if err != nil || !ok {
+				writeOpaque500(w)
+				return
+			}
+			again := now.Status == models.DeviceStatusConfirmed && now.UserID != nil && *now.UserID == user.ID && !now.ExpiredAt(time.Now())
+			if !again {
+				if now.ExpiredAt(time.Now()) {
+					_ = gdb.WithContext(r.Context()).Exec(`UPDATE `+deviceTable+` SET status = 'expired', updated_at = NOW()
+	WHERE id = ? AND status IN ('pending', 'confirmed')`, now.ID).Error
+				}
+				invalid()
+				return
+			}
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"success": true, "message": "Device authorized successfully"})
+	}
+}
+
+// nullableString is nil for "", else s.
+func nullableString(s string) any {
+	if s == "" {
+		return nil
+	}
+	return s
+}
+
+// mintWithJTI mints the session JWT as mintFor does and also returns its
+// jti, which device sessions store.
+func mintWithJTI(app *backpack.App, secret string, user *models.User, issuer string) (string, string, error) {
+	return bouncer.Mint(secret, strconv.FormatUint(uint64(user.ID), 10), issuer, sessionTTL(app))
+}
+
+// DeviceIndex is GET /devices: the caller's authorized devices (sessions
+// confirmed or used), most recent activity first, as {"success":true,
+// "devices":[{id, device_name, device_ip, authorized_at, last_activity,
+// is_current}]}. device_name is the stored name or one parsed from the user
+// agent (classes.DeviceDisplayName); is_current is true for the session
+// whose token is the one the request carries. Without a session it answers
+// 401 {"error":"Unauthorized"}.
+func DeviceIndex(app *backpack.App) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		gdb, secret, ok := sessionDeps(w, app)
+		if !ok {
+			return
+		}
+		user, jti, ok := deviceCaller(w, r, app, gdb, secret)
+		if !ok {
+			return
+		}
+		var rows []models.DeviceAuthSession
+		if err := gdb.WithContext(r.Context()).
+			Where("user_id = ? AND status IN ?", user.ID, []string{models.DeviceStatusConfirmed, models.DeviceStatusUsed}).
+			Order("last_activity_at DESC NULLS LAST, id DESC").
+			Find(&rows).Error; err != nil {
+			writeOpaque500(w)
+			return
+		}
+		devices := make([]map[string]any, 0, len(rows))
+		for _, row := range rows {
+			ua := ""
+			if row.DeviceUserAgent != nil {
+				ua = *row.DeviceUserAgent
+			}
+			devices = append(devices, map[string]any{
+				"id":            row.ID,
+				"device_name":   classes.DeviceDisplayName(row.DeviceName, ua),
+				"device_ip":     row.DeviceIP,
+				"authorized_at": wireTimeOrNil(row.ConfirmedAt),
+				"last_activity": wireTimeOrNil(row.LastActivityAt),
+				"is_current":    jti != "" && row.JWTJTI != nil && *row.JWTJTI == jti,
+			})
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"success": true, "devices": wire.Slice(devices)})
+	}
+}
+
+// DeviceDestroy is DELETE /devices/{id}: the caller revokes one of their
+// device sessions. In one transaction the row is marked revoked and the jti
+// of the session token the device holds (followed through refresh) is
+// added to the JWT blacklist for the token's whole refresh window, so the
+// device is signed out at once and cannot refresh. A blacklist failure
+// answers the opaque 500 and leaves the row as it was. Success answers
+// PHP's body with success true and the message Device revoked
+// successfully, also for a row already revoked; a row of another user, or
+// none, answers 404 with the error Device not found; no session answers
+// 401 {"error":"Unauthorized"}.
+func DeviceDestroy(app *backpack.App) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		gdb, secret, ok := sessionDeps(w, app)
+		if !ok {
+			return
+		}
+		user, _, ok := deviceCaller(w, r, app, gdb, secret)
+		if !ok {
+			return
+		}
+		notFound := func() { writeJSON(w, http.StatusNotFound, map[string]any{"error": "Device not found"}) }
+		id, err := strconv.ParseUint(r.PathValue("id"), 10, 64)
+		if err != nil || id == 0 {
+			notFound()
+			return
+		}
+		var row models.DeviceAuthSession
+		res := gdb.WithContext(r.Context()).Where("id = ? AND user_id = ?", id, user.ID).Limit(1).Find(&row)
+		if res.Error != nil {
+			writeOpaque500(w)
+			return
+		}
+		if res.RowsAffected == 0 {
+			notFound()
+			return
+		}
+		err = lagoon.Transaction(r.Context(), gdb, func(ctx context.Context, tx *gorm.DB) error {
+			if err := tx.WithContext(ctx).Exec(`UPDATE `+deviceTable+` SET status = 'revoked', updated_at = NOW()
+	WHERE id = ? AND user_id = ?`, row.ID, user.ID).Error; err != nil {
+				return err
+			}
+			if row.JWTJTI == nil || *row.JWTJTI == "" {
+				return nil
+			}
+			bl, ok := app.Lookup[bouncer.BlacklistStore]()
+			if !ok || bl == nil {
+				return errors.New("golem15.user: no JWT blacklist store is published")
+			}
+			now := time.Now()
+			return bl.Add(ctx, *row.JWTJTI, now.Add(refreshTTL(app)+sessionTTL(app)+time.Minute), now)
+		})
+		if err != nil {
+			pluginLog.Error("golem15.user: revoke device session", "user_id", user.ID, "err", err)
+			writeOpaque500(w)
+			return
+		}
+		writeJSON(w, http.StatusOK, map[string]any{"success": true, "message": "Device revoked successfully"})
+	}
+}
+
+// wireTimeOrNil is t as a +00:00 timestamp, or nil.
+func wireTimeOrNil(t *time.Time) any {
+	if t == nil {
+		return nil
+	}
+	return wire.Time{Time: *t}
+}
--- a/controllers/login_gates.go
+++ b/controllers/login_gates.go
@@ -0,0 +1,26 @@
+package controllers
+
+import (
+	"context"
+
+	"git.golem15.com/golem15/sm-user-plugin/classes"
+	"git.golem15.com/golem15/summercms/modules/backpack"
+)
+
+// CheckLoginGates consults the published *classes.LoginGates for a
+// first-factor sign-in that already succeeded and returns its answer: nil,
+// nil allows the sign-in, a result replaces the token response, and an error
+// must fail the sign-in closed (answer the opaque 500, issue no token). It
+// looks the registry up on every call and allows the sign-in when none is
+// published. Password Login calls it; a social-login plugin calls it before
+// it issues a token.
+func CheckLoginGates(ctx context.Context, app *backpack.App, a classes.LoginAttempt) (*classes.LoginGateResult, error) {
+	if app == nil {
+		return nil, nil
+	}
+	gates, ok := app.Lookup[*classes.LoginGates]()
+	if !ok || gates == nil {
+		return nil, nil
+	}
+	return gates.Check(ctx, a)
+}
--- a/controllers/registration.go
+++ b/controllers/registration.go
@@ -102,8 +102,10 @@ func RegisterUser(ctx context.Context, app *backpack.App, db *gorm.DB, fields ma
 // (a social sign-in). It restores a soft-deleted account and sends the
 // reactivate mail, records ip as last_ip_address, and touches last_seen. It
 // checks no password, throttle, activation or ban and fires no event; the
-// caller does those checks (Go has no login event). A failed last_seen
-// write is logged and does not fail it, as in Login.
+// caller does those checks, consults the login gates (CheckLoginGates)
+// before it, and fires the login event (FireLoginEvent) after it minted the
+// token. A failed last_seen write is logged and does not fail it, as in
+// Login.
 func FinishLogin(ctx context.Context, app *backpack.App, db *gorm.DB, user *models.User, ip string) error {
 	if db == nil {
 		return errors.New("golem15.user: gorm handle is missing")
@@ -179,6 +181,17 @@ func FireDeactivatingEvent(ctx context.Context, app *backpack.App, user *models.
 	return app.Events.Fire(ctx, &classes.DeactivatingEvent{User: user, Tx: tx})
 }

+// FireLoginEvent fires classes.LoginEvent (golem15.user.login) for user
+// with source, one of the classes.LoginSource constants, and returns the
+// listeners' error. Call it after the session token was minted; a caller
+// logs the error and still answers the sign-in.
+func FireLoginEvent(ctx context.Context, app *backpack.App, user *models.User, source string) error {
+	if app == nil || app.Events == nil {
+		return nil
+	}
+	return app.Events.Fire(ctx, &classes.LoginEvent{User: user, Source: source})
+}
+
 // IssueToken mints the session JWT for user exactly as /register and
 // /login do: the plugin's JWT secret, golem15.user.jwt.ttl and the request
 // URL as the issuer.
--- a/controllers/users/config_form.yaml
+++ b/controllers/users/config_form.yaml
@@ -14,7 +14,7 @@ update:
 preview:
    headerPartial: hint

-recordActions: [activate, unban, unsuspend]
+recordActions: [activate, unban, unsuspend, reset_two_factor]

 messages:
    create: golem15.user::lang.users.new_user
--- a/controllers/users_admin_controller.go
+++ b/controllers/users_admin_controller.go
@@ -719,8 +719,15 @@ func (c usersAdminController) throttleState(ctx context.Context, userID uint) (b
 }

 // AdminRecordActions are the PHP preview handlers onActivate, onUnban and
-// onUnsuspendUser. Each is offered only while it applies; the checks only
-// read. There is no impersonate action and no guest action.
+// onUnsuspendUser, plus reset_two_factor. Each is offered only while it
+// applies; the checks only read. There is no impersonate action and no
+// guest action.
+//
+// reset_two_factor ("Reset 2FA") needs classes.PermissionResetTwoFactor and
+// asks for a danger confirmation. It is offered only when a two-factor
+// plugin published a classes.TwoFactorAdmin (looked up per request) and the
+// user has a second factor; Run hands the record to that service's Reset in
+// the action's transaction.
 func (c usersAdminController) AdminRecordActions() []pact.AdminRecordAction {
 	asUser := func(record any) (*models.User, error) {
 		user, ok := record.(*models.User)
@@ -785,9 +792,55 @@ func (c usersAdminController) AdminRecordActions() []pact.AdminRecordAction {
 			func(ctx context.Context, tx *gorm.DB, user *models.User) error {
 				return classes.UnsuspendUser(ctx, tx, user.ID)
 			}),
+		c.resetTwoFactorAction(action),
 	}
 }

+// resetTwoFactorAction builds the reset_two_factor record action with the
+// shared action builder, behind classes.PermissionResetTwoFactor and marked
+// as dangerous.
+func (c usersAdminController) resetTwoFactorAction(action func(name, label, confirm, success string,
+	applies func(ctx context.Context, user *models.User) (bool, error),
+	run func(ctx context.Context, tx *gorm.DB, user *models.User) error,
+) pact.AdminRecordAction) pact.AdminRecordAction {
+	reset := action("reset_two_factor", "reset_two_factor", "reset_two_factor_confirm", "reset_two_factor_success",
+		func(ctx context.Context, user *models.User) (bool, error) {
+			svc, ok := c.twoFactorAdmin()
+			if !ok {
+				return false, nil
+			}
+			db := requestDB(ctx, c.db)
+			if db == nil {
+				return false, errors.New("users admin: gorm handle is missing")
+			}
+			return svc.HasTwoFactor(ctx, db, user.ID)
+		},
+		func(ctx context.Context, tx *gorm.DB, user *models.User) error {
+			svc, ok := c.twoFactorAdmin()
+			if !ok {
+				return errors.New("users admin: no two-factor plugin publishes classes.TwoFactorAdmin")
+			}
+			return svc.Reset(ctx, tx, user)
+		})
+	reset.Permissions = []string{classes.PermissionResetTwoFactor}
+	reset.Danger = true
+	return reset
+}
+
+// twoFactorAdmin looks up the classes.TwoFactorAdmin a two-factor plugin
+// published, on every call, so a plugin that boots later is still found.
+func (c usersAdminController) twoFactorAdmin() (classes.TwoFactorAdmin, bool) {
+	app := c.application()
+	if app == nil {
+		return nil, false
+	}
+	svc, ok := app.Lookup[classes.TwoFactorAdmin]()
+	if !ok || svc == nil {
+		return nil, false
+	}
+	return svc, true
+}
+
 // usersHintView is the view model of controllers/users/_hint.htm, the status
 // callout above the preview: the callout kind (danger or warning) and the
 // phrase keys of its title and text. It is empty when no state applies, and
--- a/device_flow_smoke_test.go
+++ b/device_flow_smoke_test.go
@@ -0,0 +1,320 @@
+package user
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"git.golem15.com/golem15/sm-user-plugin/classes"
+	"git.golem15.com/golem15/sm-user-plugin/controllers"
+	"git.golem15.com/golem15/sm-user-plugin/models"
+	"git.golem15.com/golem15/summercms/modules/backpack"
+	"git.golem15.com/golem15/summercms/modules/bouncer"
+	"gorm.io/gorm"
+)
+
+var deviceShortCodeRE = regexp.MustCompile(`^[2-9A-HJKMNP-Z]{4}-[2-9A-HJKMNP-Z]{4}$`)
+
+// TestDeviceCodesSmoke pins the device token, the short code, its
+// normalisation and the auth_url template. No database.
+func TestDeviceCodesSmoke(t *testing.T) {
+	seen := map[string]bool{}
+	for range 1000 {
+		tok, err := classes.NewDeviceToken()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(tok) != 64 || strings.Trim(tok, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_") != "" {
+			t.Fatalf("token %q is not 64 base64url characters", tok)
+		}
+		if seen[tok] {
+			t.Fatalf("token %q repeated", tok)
+		}
+		seen[tok] = true
+		code, err := classes.NewDeviceShortCode()
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !deviceShortCodeRE.MatchString(code) {
+			t.Fatalf("short code %q", code)
+		}
+	}
+
+	for in, want := range map[string]string{
+		"abcd-efgh":     "ABCD-EFGH",
+		"ABCDEFGH":      "ABCD-EFGH",
+		" ab cd ef gh ": "ABCD-EFGH",
+		"2345-6789":     "2345-6789",
+	} {
+		if got, ok := classes.NormalizeDeviceShortCode(in); !ok || got != want {
+			t.Fatalf("normalize %q = %q %v, want %q", in, got, ok, want)
+		}
+	}
+	for _, in := range []string{"ABCDEFG", "ABCDEFGHJ", "ABCDEFGO", "ABCDEFGI", "ABCDEFGL", "ABCDEFG0", "ABCDEFG1", ""} {
+		if got, ok := classes.NormalizeDeviceShortCode(in); ok {
+			t.Fatalf("normalize %q accepted as %q", in, got)
+		}
+	}
+
+	app := backpack.New(sessionConfig(t))
+	if got := classes.DeviceAuthURL(app, "tok"); got != "/device/scan/tok" {
+		t.Fatalf("auth_url without urls = %q", got)
+	}
+	if err := app.Config.Set("app.url", "https://api.example.test/"); err != nil {
+		t.Fatal(err)
+	}
+	if got := classes.DeviceAuthURL(app, "tok"); got != "https://api.example.test/device/scan/tok" {
+		t.Fatalf("auth_url from app.url = %q", got)
+	}
+	if err := app.Config.Set("golem15.user.frontend_url", "https://www.example.test/"); err != nil {
+		t.Fatal(err)
+	}
+	if got := classes.DeviceAuthURL(app, "tok"); got != "https://www.example.test/device/scan/tok" {
+		t.Fatalf("auth_url from frontend_url = %q", got)
+	}
+	if err := app.Config.Set("golem15.user.device_auth.auth_url", "{frontend_url}/link?device={token}"); err != nil {
+		t.Fatal(err)
+	}
+	if got := classes.DeviceAuthURL(app, "tok"); got != "https://www.example.test/link?device=tok" {
+		t.Fatalf("auth_url from a custom template = %q", got)
+	}
+	if got := classes.DeviceAuthTTL(app); got != 5*time.Minute {
+		t.Fatalf("default ttl = %s", got)
+	}
+
+	tv := "Living room TV"
+	for _, c := range []struct {
+		stored *string
+		ua     string
+		want   string
+	}{
+		{&tv, "Mozilla/5.0 (iPhone)", tv},
+		{nil, "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0)", "iPhone"},
+		{nil, "Mozilla/5.0 (iPad; CPU OS 17_0)", "iPad"},
+		{nil, "Mozilla/5.0 (Linux; Android 14)", "Android Device"},
+		{nil, "Mozilla/5.0 (Windows NT 10.0)", "Windows PC"},
+		{nil, "Mozilla/5.0 (Macintosh; Intel Mac OS X 14_0)", "Mac"},
+		{nil, "Mozilla/5.0 (X11; Linux x86_64)", "Linux PC"},
+		{nil, "curl/8.0", "Unknown Device"},
+	} {
+		if got := classes.DeviceDisplayName(c.stored, c.ua); got != c.want {
+			t.Fatalf("display name of %q = %q, want %q", c.ua, got, c.want)
+		}
+	}
+}
+
+// deviceCall runs one device handler with an optional bearer token and JSON
+// body; pathToken fills {token} or {id}.
+func deviceCall(t *testing.T, h http.HandlerFunc, method, path, bearerToken, body string, pathValues map[string]string) *httptest.ResponseRecorder {
+	t.Helper()
+	var req *http.Request
+	if body != "" {
+		req = httptest.NewRequest(method, path, strings.NewReader(body))
+		req.Header.Set("Content-Type", "application/json")
+	} else {
+		req = httptest.NewRequest(method, path, nil)
+	}
+	req.Host = "example.com"
+	req.Header.Set("User-Agent", "Mozilla/5.0 (X11; Linux x86_64) SmokeTV")
+	if bearerToken != "" {
+		req.Header.Set("Authorization", "Bearer "+bearerToken)
+	}
+	for k, v := range pathValues {
+		req.SetPathValue(k, v)
+	}
+	rec := httptest.NewRecorder()
+	h(rec, req)
+	return rec
+}
+
+type deviceInitiated struct {
+	Token     string `json:"token"`
+	ShortCode string `json:"short_code"`
+	AuthURL   string `json:"auth_url"`
+	ExpiresAt string `json:"expires_at"`
+}
+
+func initiateDevice(t *testing.T, app *backpack.App, name string) deviceInitiated {
+	t.Helper()
+	body := `{}`
+	if name != "" {
+		body = `{"device_name":"` + name + `"}`
+	}
+	rec := deviceCall(t, controllers.DeviceInitiate(app), http.MethodPost, "/_user/api/v1/devices/initiate", "", body, nil)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("initiate = %d %s", rec.Code, rec.Body.String())
+	}
+	var out struct {
+		Success bool            `json:"success"`
+		Data    deviceInitiated `json:"data"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil || !out.Success {
+		t.Fatalf("initiate body %s: %v", rec.Body.String(), err)
+	}
+	return out.Data
+}
+
+func deviceStatus(t *testing.T, app *backpack.App, token string) (int, map[string]any) {
+	t.Helper()
+	rec := deviceCall(t, controllers.DeviceStatus(app), http.MethodGet, "/_user/api/v1/devices/status/"+token, "", "", map[string]string{"token": token})
+	var body map[string]any
+	_ = json.Unmarshal(rec.Body.Bytes(), &body)
+	return rec.Code, body
+}
+
+func authorizeDevice(t *testing.T, app *backpack.App, bearerToken, body string) *httptest.ResponseRecorder {
+	t.Helper()
+	return deviceCall(t, controllers.DeviceAuthorize(app), http.MethodPost, "/_user/api/v1/devices/authorize", bearerToken, body, nil)
+}
+
+func deviceRow(t *testing.T, gdb *gorm.DB, token string) models.DeviceAuthSession {
+	t.Helper()
+	var row models.DeviceAuthSession
+	if err := gdb.Where("token = ?", classes.HashAPIToken(token)).Take(&row).Error; err != nil {
+		t.Fatal(err)
+	}
+	return row
+}
+
+func statusData(body map[string]any) map[string]any {
+	data, _ := body["data"].(map[string]any)
+	return data
+}
+
+// TestDeviceFlowSmoke drives initiate, authorize and the one-time hand-over
+// on Postgres.
+func TestDeviceFlowSmoke(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Postgres (testcontainers)")
+	}
+	app, gdb := sessionApp(t, "0s")
+	email := "device-owner-" + strconv.FormatInt(time.Now().UnixNano(), 10) + "@example.test"
+	session := loginToken(t, app, gdb, email)
+	var owner models.User
+	if err := gdb.Where("email = ?", email).Take(&owner).Error; err != nil {
+		t.Fatal(err)
+	}
+
+	dev := initiateDevice(t, app, "Living room TV")
+	if len(dev.Token) != 64 || !deviceShortCodeRE.MatchString(dev.ShortCode) || !strings.Contains(dev.AuthURL, dev.Token) || !strings.HasSuffix(dev.ExpiresAt, "+00:00") {
+		t.Fatalf("initiate data = %+v", dev)
+	}
+	row := deviceRow(t, gdb, dev.Token)
+	if row.TokenHash != classes.HashAPIToken(dev.Token) || row.Status != models.DeviceStatusPending || row.UserID != nil ||
+		row.DeviceName == nil || *row.DeviceName != "Living room TV" || row.DeviceUserAgent == nil {
+		t.Fatalf("stored row = %+v", row)
+	}
+	if code, body := deviceStatus(t, app, dev.Token); code != http.StatusOK || body["success"] != true || statusData(body)["status"] != "pending" {
+		t.Fatalf("pending status = %d %v", code, body)
+	}
+	if code, body := deviceStatus(t, app, strings.Repeat("z", 64)); code != http.StatusNotFound || body["error"] != "Session not found" {
+		t.Fatalf("unknown status = %d %v", code, body)
+	}
+
+	// Authorize needs a session, answering PHP's 401 body.
+	if rec := authorizeDevice(t, app, "", `{"short_code":"`+dev.ShortCode+`"}`); rec.Code != http.StatusUnauthorized || rec.Body.String() != `{"error":"Unauthorized"}` {
+		t.Fatalf("authorize without a session = %d %s", rec.Code, rec.Body.String())
+	}
+	if rec := authorizeDevice(t, app, session, `{"short_code":"ABC"}`); rec.Code != http.StatusUnprocessableEntity || rec.Body.String() != `{"error":"Please enter a valid 8-character code"}` {
+		t.Fatalf("short code of 3 = %d %s", rec.Code, rec.Body.String())
+	}
+	lower := strings.ToLower(dev.ShortCode)
+	if rec := authorizeDevice(t, app, session, `{"short_code":"`+lower+`"}`); rec.Code != http.StatusOK || rec.Body.String() != `{"message":"Device authorized successfully","success":true}` {
+		t.Fatalf("authorize = %d %s", rec.Code, rec.Body.String())
+	}
+	if rec := authorizeDevice(t, app, session, `{"short_code":"`+lower+`"}`); rec.Code != http.StatusOK {
+		t.Fatalf("authorizing again for the same user = %d %s", rec.Code, rec.Body.String())
+	}
+
+	// The first poll after confirmation receives the token, once.
+	code, body := deviceStatus(t, app, dev.Token)
+	data := statusData(body)
+	if code != http.StatusOK || data["status"] != "confirmed" || data["message"] != "Device authorized - complete login" || data["user_id"] != float64(owner.ID) {
+		t.Fatalf("hand-over = %d %v", code, body)
+	}
+	jwtToken, _ := data["token"].(string)
+	sub, _, _, jti, err := bouncer.VerifyClaims(jwtToken, sessionSecret)
+	if err != nil || sub != strconv.FormatUint(uint64(owner.ID), 10) {
+		t.Fatalf("device token sub=%q err=%v", sub, err)
+	}
+	if user, _ := data["user"].(map[string]any); user["email"] != email {
+		t.Fatalf("hand-over user = %v", data["user"])
+	}
+	row = deviceRow(t, gdb, dev.Token)
+	if row.Status != models.DeviceStatusUsed || row.JWTJTI == nil || *row.JWTJTI != jti || row.UsedAt == nil {
+		t.Fatalf("row after hand-over = %+v", row)
+	}
+	if _, body := deviceStatus(t, app, dev.Token); statusData(body)["status"] != "used" || statusData(body)["token"] != nil {
+		t.Fatalf("second poll = %v", body)
+	}
+	// The used session is past nothing: even past expires_at it stays used.
+	if err := gdb.Model(&models.DeviceAuthSession{}).Where("id = ?", row.ID).Update("expires_at", time.Now().Add(-time.Hour)).Error; err != nil {
+		t.Fatal(err)
+	}
+	if _, body := deviceStatus(t, app, dev.Token); statusData(body)["status"] != "used" {
+		t.Fatalf("used session past expires_at = %v", body)
+	}
+	// A used session cannot be authorized again.
+	if rec := authorizeDevice(t, app, session, `{"token":"`+dev.Token+`"}`); rec.Code != http.StatusBadRequest || rec.Body.String() != `{"error":"Invalid or expired code"}` {
+		t.Fatalf("authorize a used session = %d %s", rec.Code, rec.Body.String())
+	}
+
+	// Ten concurrent polls of a confirmed session yield exactly one token.
+	race := initiateDevice(t, app, "")
+	if rec := authorizeDevice(t, app, session, `{"token":"`+race.Token+`"}`); rec.Code != http.StatusOK {
+		t.Fatalf("authorize by token = %d %s", rec.Code, rec.Body.String())
+	}
+	var (
+		wg     sync.WaitGroup
+		mu     sync.Mutex
+		tokens int
+		used   int
+	)
+	for range 10 {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			_, body := deviceStatus(t, app, race.Token)
+			d := statusData(body)
+			mu.Lock()
+			defer mu.Unlock()
+			if tok, _ := d["token"].(string); tok != "" {
+				tokens++
+			} else if d["status"] == "used" {
+				used++
+			}
+		}()
+	}
+	wg.Wait()
+	if tokens != 1 || used != 9 {
+		t.Fatalf("concurrent polls: %d tokens, %d used", tokens, used)
+	}
+
+	// A pending session past expires_at answers PHP's flat expired body.
+	stale := initiateDevice(t, app, "")
+	if err := gdb.Model(&models.DeviceAuthSession{}).Where("token = ?", classes.HashAPIToken(stale.Token)).Update("expires_at", time.Now().Add(-time.Minute)).Error; err != nil {
+		t.Fatal(err)
+	}
+	if rec := authorizeDevice(t, app, session, `{"short_code":"`+stale.ShortCode+`"}`); rec.Code != http.StatusBadRequest {
+		t.Fatalf("authorize an expired session = %d %s", rec.Code, rec.Body.String())
+	}
+	rec := deviceCall(t, controllers.DeviceStatus(app), http.MethodGet, "/_user/api/v1/devices/status/"+stale.Token, "", "", map[string]string{"token": stale.Token})
+	if rec.Body.String() != `{"message":"Authorization session has expired","status":"expired","success":true}` {
+		t.Fatalf("expired status = %d %s", rec.Code, rec.Body.String())
+	}
+	if row := deviceRow(t, gdb, stale.Token); row.Status != models.DeviceStatusExpired {
+		t.Fatalf("expired row status = %s", row.Status)
+	}
+
+	// device_name is bounded.
+	long := strings.Repeat("n", 256)
+	if rec := deviceCall(t, controllers.DeviceInitiate(app), http.MethodPost, "/_user/api/v1/devices/initiate", "", `{"device_name":"`+long+`"}`, nil); rec.Code != http.StatusUnprocessableEntity {
+		t.Fatalf("device_name of 256 = %d %s", rec.Code, rec.Body.String())
+	}
+}
--- a/device_revoke_smoke_test.go
+++ b/device_revoke_smoke_test.go
@@ -0,0 +1,183 @@
+package user
+
+import (
+	"encoding/json"
+	"net/http"
+	"strconv"
+	"testing"
+	"time"
+
+	"git.golem15.com/golem15/sm-user-plugin/models"
+	"git.golem15.com/golem15/summercms/modules/bouncer"
+)
+
+// envDevice signs a device in through the assembled routes: initiate,
+// authorize by session, first poll. It returns the device's session token,
+// its jti and the session row id.
+func envDevice(t *testing.T, env *adminEnv, session, name string) (string, string, uint) {
+	t.Helper()
+	rec := env.call(t, http.MethodPost, "/_user/api/v1/devices/initiate", "", map[string]string{"device_name": name})
+	if rec.Code != http.StatusOK {
+		t.Fatalf("initiate = %d %s", rec.Code, rec.Body.String())
+	}
+	var started struct {
+		Data deviceInitiated `json:"data"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &started); err != nil {
+		t.Fatal(err)
+	}
+	env.expect(t, http.StatusOK, http.MethodPost, "/_user/api/v1/devices/authorize", session, map[string]string{"token": started.Data.Token})
+	rec = env.expect(t, http.StatusOK, http.MethodGet, "/_user/api/v1/devices/status/"+started.Data.Token, "", nil)
+	var polled struct {
+		Data struct {
+			Token string `json:"token"`
+		} `json:"data"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &polled); err != nil || polled.Data.Token == "" {
+		t.Fatalf("hand-over %s: %v", rec.Body.String(), err)
+	}
+	_, _, _, jti, err := bouncer.VerifyClaims(polled.Data.Token, sessionSecret)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var row models.DeviceAuthSession
+	if err := env.gdb.Where("jwt_jti = ?", jti).Take(&row).Error; err != nil {
+		t.Fatal(err)
+	}
+	return polled.Data.Token, jti, row.ID
+}
+
+type deviceListBody struct {
+	Success bool `json:"success"`
+	Devices []struct {
+		ID           uint    `json:"id"`
+		DeviceName   string  `json:"device_name"`
+		DeviceIP     *string `json:"device_ip"`
+		AuthorizedAt *string `json:"authorized_at"`
+		LastActivity *string `json:"last_activity"`
+		IsCurrent    bool    `json:"is_current"`
+	} `json:"devices"`
+}
+
+func envDevices(t *testing.T, env *adminEnv, token string) deviceListBody {
+	t.Helper()
+	rec := env.expect(t, http.StatusOK, http.MethodGet, "/_user/api/v1/devices", token, nil)
+	var body deviceListBody
+	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+		t.Fatal(err)
+	}
+	return body
+}
+
+// TestDeviceRevokeSmoke lists and revokes device sessions through the
+// assembled routes, including a device that refreshed its token first.
+func TestDeviceRevokeSmoke(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Postgres")
+	}
+	env := newAdminEnv(t)
+	owner := env.seedUser(t, "dev-owner", nil)
+	other := env.seedUser(t, "dev-other", nil)
+	status, session := env.userLogin(t, owner.Email, "correct-horse")
+	if status != http.StatusOK {
+		t.Fatalf("owner login = %d", status)
+	}
+	otherStatus, otherSession := env.userLogin(t, other.Email, "correct-horse")
+	if otherStatus != http.StatusOK {
+		t.Fatalf("other login = %d", otherStatus)
+	}
+
+	tvToken, _, tvID := envDevice(t, env, session, "Living room TV")
+	// A second used session with no name and an older activity, a pending
+	// session of the owner and a device of another user.
+	hourAgo := time.Now().Add(-time.Hour)
+	ua := "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0)"
+	oldJTI := "dev-old-" + strconv.FormatInt(time.Now().UnixNano(), 10)
+	ownerID := owner.ID
+	phone := models.DeviceAuthSession{TokenHash: "a" + strconv.FormatInt(time.Now().UnixNano(), 10), UserID: &ownerID, Status: models.DeviceStatusUsed,
+		ExpiresAt: &hourAgo, DeviceUserAgent: &ua, ConfirmedAt: &hourAgo, LastActivityAt: &hourAgo, JWTJTI: &oldJTI}
+	pendingRow := models.DeviceAuthSession{TokenHash: "b" + strconv.FormatInt(time.Now().UnixNano(), 10), UserID: &ownerID, Status: models.DeviceStatusPending, ExpiresAt: &hourAgo}
+	if err := env.gdb.Create(&phone).Error; err != nil {
+		t.Fatal(err)
+	}
+	if err := env.gdb.Create(&pendingRow).Error; err != nil {
+		t.Fatal(err)
+	}
+	_, _, foreignID := envDevice(t, env, otherSession, "Other TV")
+
+	t.Run("list", func(t *testing.T) {
+		if rec := env.call(t, http.MethodGet, "/_user/api/v1/devices", "", nil); rec.Code != http.StatusUnauthorized || rec.Body.String() != `{"error":"Unauthorized"}` {
+			t.Fatalf("list without a session = %d %s", rec.Code, rec.Body.String())
+		}
+		list := envDevices(t, env, tvToken)
+		if !list.Success || len(list.Devices) != 2 {
+			t.Fatalf("list = %+v", list)
+		}
+		first, second := list.Devices[0], list.Devices[1]
+		if first.ID != tvID || first.DeviceName != "Living room TV" || !first.IsCurrent || first.AuthorizedAt == nil || first.LastActivity == nil {
+			t.Fatalf("first device = %+v", first)
+		}
+		if second.ID != phone.ID || second.DeviceName != "iPhone" || second.IsCurrent {
+			t.Fatalf("second device = %+v", second)
+		}
+		for _, d := range envDevices(t, env, session).Devices {
+			if d.IsCurrent {
+				t.Fatalf("device %d is current for the owner's own session", d.ID)
+			}
+		}
+	})
+
+	t.Run("revoke", func(t *testing.T) {
+		env.expect(t, http.StatusOK, http.MethodGet, "/_user/api/v1/fetch", tvToken, nil)
+		rec := env.expect(t, http.StatusOK, http.MethodDelete, "/_user/api/v1/devices/"+strconv.FormatUint(uint64(tvID), 10), session, nil)
+		if rec.Body.String() != `{"message":"Device revoked successfully","success":true}` {
+			t.Fatalf("revoke body = %s", rec.Body.String())
+		}
+		env.expect(t, http.StatusUnauthorized, http.MethodGet, "/_user/api/v1/fetch", tvToken, nil)
+		env.expect(t, http.StatusOK, http.MethodDelete, "/_user/api/v1/devices/"+strconv.FormatUint(uint64(tvID), 10), session, nil)
+		rec = env.expect(t, http.StatusNotFound, http.MethodDelete, "/_user/api/v1/devices/"+strconv.FormatUint(uint64(foreignID), 10), session, nil)
+		if rec.Body.String() != `{"error":"Device not found"}` {
+			t.Fatalf("foreign revoke body = %s", rec.Body.String())
+		}
+		// The id constraint keeps a non-numeric id away from the handler,
+		// which would answer 401 without a session.
+		if rec := env.call(t, http.MethodDelete, "/_user/api/v1/devices/abc", "", nil); rec.Code != http.StatusNotFound && rec.Code != http.StatusMethodNotAllowed {
+			t.Fatalf("DELETE /devices/abc = %d %s", rec.Code, rec.Body.String())
+		}
+		var row models.DeviceAuthSession
+		if err := env.gdb.Where("id = ?", tvID).Take(&row).Error; err != nil || row.Status != models.DeviceStatusRevoked {
+			t.Fatalf("revoked row = %+v %v", row, err)
+		}
+		for _, d := range envDevices(t, env, session).Devices {
+			if d.ID == tvID {
+				t.Fatal("a revoked device is still listed")
+			}
+		}
+	})
+
+	t.Run("revoke_after_refresh", func(t *testing.T) {
+		deskToken, deskJTI, deskID := envDevice(t, env, session, "Desktop")
+		rec := env.expect(t, http.StatusOK, http.MethodPost, "/_user/api/v1/refresh", deskToken, nil)
+		var refreshed struct {
+			Token string `json:"token"`
+		}
+		if err := json.Unmarshal(rec.Body.Bytes(), &refreshed); err != nil || refreshed.Token == "" {
+			t.Fatalf("refresh %s: %v", rec.Body.String(), err)
+		}
+		_, _, _, newJTI, err := bouncer.VerifyClaims(refreshed.Token, sessionSecret)
+		if err != nil || newJTI == deskJTI {
+			t.Fatalf("refreshed jti %q err %v", newJTI, err)
+		}
+		var row models.DeviceAuthSession
+		if err := env.gdb.Where("id = ?", deskID).Take(&row).Error; err != nil || row.JWTJTI == nil || *row.JWTJTI != newJTI {
+			t.Fatalf("row after refresh = %+v %v, want jti %s", row, err, newJTI)
+		}
+		env.expect(t, http.StatusOK, http.MethodGet, "/_user/api/v1/fetch", refreshed.Token, nil)
+		env.expect(t, http.StatusOK, http.MethodDelete, "/_user/api/v1/devices/"+strconv.FormatUint(uint64(deskID), 10), session, nil)
+		env.expect(t, http.StatusUnauthorized, http.MethodGet, "/_user/api/v1/fetch", deskToken, nil)
+		env.expect(t, http.StatusUnauthorized, http.MethodGet, "/_user/api/v1/fetch", refreshed.Token, nil)
+		env.expect(t, http.StatusUnauthorized, http.MethodPost, "/_user/api/v1/refresh", refreshed.Token, nil)
+		// The owner's own session is untouched.
+		env.expect(t, http.StatusOK, http.MethodGet, "/_user/api/v1/fetch", session, nil)
+	})
+}
--- a/lang/en/lang.yaml
+++ b/lang/en/lang.yaml
@@ -9,6 +9,7 @@ plugin:
  impersonate_user: Impersonate Users
  manage_privileged_groups: Manage privileged group membership
  manage_backend_links: Link frontend accounts to administrators
+  reset_two_factor: Reset two-factor authentication of users
 users:
  menu_label: Users
  new_user: New User
@@ -52,6 +53,9 @@ users:
  unsuspend_user: Unsuspend user
  unsuspend_confirm: Unsuspend this user?
  unsuspend_success: User has been unsuspended.
+  reset_two_factor: Reset 2FA
+  reset_two_factor_confirm: Remove every second factor of this user? Their authenticator apps, security keys, recovery codes and trusted devices stop working, and they sign in with the password alone until they set up two-factor authentication again.
+  reset_two_factor_success: Two-factor authentication of the user has been reset.
  privileged_member_forbidden: This user belongs to a privileged group. You do not have permission to change their email or password. Nothing was saved.
  privileged_member_delete_forbidden: Users who belong to a privileged group cannot be deleted without the permission to manage privileged groups. Nothing was deleted.
  privileged_group_forbidden: You do not have permission to change membership of privileged groups. Nothing was saved.
--- a/lang/pl/lang.yaml
+++ b/lang/pl/lang.yaml
@@ -9,6 +9,7 @@ plugin:
  impersonate_user: Wcielaj się w użytkowników
  manage_privileged_groups: Zarządzaj członkostwem w grupach uprzywilejowanych
  manage_backend_links: Łącz konta na stronie z administratorami
+  reset_two_factor: Resetowanie uwierzytelniania dwuskładnikowego użytkowników
 users:
  menu_label: Użytkownicy
  new_user: Nowy użytkownik
@@ -52,6 +53,9 @@ users:
  unsuspend_user: Odblokuj użytkownika
  unsuspend_confirm: Odblokować tego użytkownika?
  unsuspend_success: Udało się odblokować użytkownika.
+  reset_two_factor: Resetuj 2FA
+  reset_two_factor_confirm: Usunąć wszystkie drugie składniki tego użytkownika? Jego aplikacje uwierzytelniające, klucze bezpieczeństwa, kody odzyskiwania i zaufane urządzenia przestaną działać, a do czasu ponownego włączenia uwierzytelniania dwuskładnikowego będzie logować się samym hasłem.
+  reset_two_factor_success: Uwierzytelnianie dwuskładnikowe użytkownika zostało zresetowane.
  privileged_member_forbidden: Ten użytkownik należy do grupy uprzywilejowanej. Nie masz uprawnień do zmiany jego adresu e-mail ani hasła. Nic nie zostało zapisane.
  privileged_member_delete_forbidden: Użytkowników należących do grupy uprzywilejowanej nie można usunąć bez uprawnienia do zarządzania grupami uprzywilejowanymi. Nic nie zostało usunięte.
  privileged_group_forbidden: Nie masz uprawnień do zmiany członkostwa w grupach uprzywilejowanych. Nic nie zostało zapisane.
--- a/login_gate_smoke_test.go
+++ b/login_gate_smoke_test.go
@@ -0,0 +1,273 @@
+package user
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"reflect"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"git.golem15.com/golem15/sm-user-plugin/classes"
+	"git.golem15.com/golem15/sm-user-plugin/controllers"
+	"git.golem15.com/golem15/sm-user-plugin/models"
+	"git.golem15.com/golem15/summercms/modules/backpack"
+	"git.golem15.com/golem15/summercms/modules/postcard"
+)
+
+// gateFunc adapts a function to classes.LoginGate.
+type gateFunc func(context.Context, classes.LoginAttempt) (*classes.LoginGateResult, error)
+
+func (f gateFunc) CheckLogin(ctx context.Context, a classes.LoginAttempt) (*classes.LoginGateResult, error) {
+	return f(ctx, a)
+}
+
+// TestLoginGatesSmoke pins the registry: nil and empty allow, the first
+// non-nil result or error wins and stops the chain.
+func TestLoginGatesSmoke(t *testing.T) {
+	ctx := context.Background()
+	var nilGates *classes.LoginGates
+	if res, err := nilGates.Check(ctx, classes.LoginAttempt{}); res != nil || err != nil {
+		t.Fatalf("nil registry = %v, %v", res, err)
+	}
+	empty := classes.NewLoginGates()
+	if res, err := empty.Check(ctx, classes.LoginAttempt{}); res != nil || err != nil {
+		t.Fatalf("empty registry = %v, %v", res, err)
+	}
+
+	want := &classes.LoginGateResult{Body: map[string]any{"two_factor_required": true}}
+	calls := 0
+	g := classes.NewLoginGates()
+	g.Add(gateFunc(func(context.Context, classes.LoginAttempt) (*classes.LoginGateResult, error) {
+		calls++
+		return nil, nil
+	}))
+	g.Add(gateFunc(func(context.Context, classes.LoginAttempt) (*classes.LoginGateResult, error) {
+		calls++
+		return want, nil
+	}))
+	g.Add(gateFunc(func(context.Context, classes.LoginAttempt) (*classes.LoginGateResult, error) {
+		calls++
+		return nil, nil
+	}))
+	res, err := g.Check(ctx, classes.LoginAttempt{})
+	if err != nil || res != want {
+		t.Fatalf("A(nil) then B(result) = %v, %v", res, err)
+	}
+	if calls != 2 {
+		t.Fatalf("gates called %d times, want 2 (the chain stops at the result)", calls)
+	}
+
+	boom := errors.New("gate failed")
+	later := 0
+	e := classes.NewLoginGates()
+	e.Add(gateFunc(func(context.Context, classes.LoginAttempt) (*classes.LoginGateResult, error) { return nil, boom }))
+	e.Add(gateFunc(func(context.Context, classes.LoginAttempt) (*classes.LoginGateResult, error) {
+		later++
+		return nil, nil
+	}))
+	if res, err := e.Check(ctx, classes.LoginAttempt{}); res != nil || !errors.Is(err, boom) {
+		t.Fatalf("erroring gate = %v, %v", res, err)
+	}
+	if later != 0 {
+		t.Fatal("a gate after the erroring one was called")
+	}
+}
+
+// loginEvents records every classes.LoginEvent fired on app.
+type loginEvents struct {
+	mu  sync.Mutex
+	got []classes.LoginEvent
+}
+
+func listenLoginEvents(app *backpack.App, owner string) *loginEvents {
+	rec := &loginEvents{}
+	app.Events.Listen[*classes.LoginEvent](owner, func(_ context.Context, e *classes.LoginEvent) error {
+		rec.mu.Lock()
+		rec.got = append(rec.got, *e)
+		rec.mu.Unlock()
+		return nil
+	})
+	return rec
+}
+
+func (l *loginEvents) count() int {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	return len(l.got)
+}
+
+// gateApp is sessionApp with a published login-gate registry (bootPlugin
+// runs Boot only, so the test publishes what Register would).
+func gateApp(t *testing.T) (*backpack.App, *classes.LoginGates) {
+	t.Helper()
+	app, _ := sessionApp(t, "0s")
+	gates := classes.NewLoginGates()
+	if err := app.Publish(gates); err != nil {
+		t.Fatal(err)
+	}
+	return app, gates
+}
+
+func decodeBody(t *testing.T, raw []byte) map[string]any {
+	t.Helper()
+	var body map[string]any
+	if err := json.Unmarshal(raw, &body); err != nil {
+		t.Fatalf("decode %s: %v", raw, err)
+	}
+	return body
+}
+
+// TestLoginGateSmoke drives POST /login through a registered gate.
+func TestLoginGateSmoke(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Postgres (testcontainers)")
+	}
+	_, gdb := sessionApp(t, "0s")
+
+	t.Run("no_gate", func(t *testing.T) {
+		app, _ := gateApp(t)
+		events := listenLoginEvents(app, "test.login-gate.no-gate")
+		user := insertUser(t, gdb, "gate-none@example.test", "correct-horse")
+		rec := postJSON(t, controllers.Login(app), "/_user/api/v1/login", `{"email":"gate-none@example.test","password":"correct-horse"}`)
+		if rec.Code != http.StatusOK {
+			t.Fatalf("status %d body %s", rec.Code, rec.Body.String())
+		}
+		body := decodeBody(t, rec.Body.Bytes())
+		if tok, _ := body["token"].(string); tok == "" {
+			t.Fatalf("no token: %s", rec.Body.String())
+		}
+		if _, ok := body["user"].(map[string]any); !ok {
+			t.Fatalf("no user: %s", rec.Body.String())
+		}
+		if events.count() != 1 {
+			t.Fatalf("login events = %d, want 1", events.count())
+		}
+		if e := events.got[0]; e.Source != classes.LoginSourcePassword || e.User == nil || e.User.ID != user.ID {
+			t.Fatalf("event = %+v", e)
+		}
+	})
+
+	challengeBody := map[string]any{
+		"two_factor_required": true,
+		"challenge_token":     strings.Repeat("x", 64),
+		"available_methods":   []any{"totp"},
+		"expires_at":          "2026-10-21T12:00:00+00:00",
+	}
+
+	t.Run("challenge", func(t *testing.T) {
+		app, gates := gateApp(t)
+		events := listenLoginEvents(app, "test.login-gate.challenge")
+		var seen classes.LoginAttempt
+		gates.Add(gateFunc(func(_ context.Context, a classes.LoginAttempt) (*classes.LoginGateResult, error) {
+			seen = a
+			return &classes.LoginGateResult{Status: http.StatusOK, Body: challengeBody}, nil
+		}))
+		insertUser(t, gdb, "gate-challenge@example.test", "correct-horse")
+		rec := postJSON(t, controllers.Login(app), "/_user/api/v1/login",
+			`{"email":"gate-challenge@example.test","password":"correct-horse","trusted_device_token":"td-123"}`)
+		if rec.Code != http.StatusOK {
+			t.Fatalf("status %d body %s", rec.Code, rec.Body.String())
+		}
+		body := decodeBody(t, rec.Body.Bytes())
+		if !reflect.DeepEqual(body, challengeBody) {
+			t.Fatalf("body = %#v", body)
+		}
+		if _, ok := body["token"]; ok {
+			t.Fatal("a challenged login answered a token")
+		}
+		if seen.Source != classes.LoginSourcePassword || seen.User == nil || seen.Request == nil {
+			t.Fatalf("attempt = %+v", seen)
+		}
+		if seen.Fields["trusted_device_token"] != "td-123" {
+			t.Fatalf("fields = %#v", seen.Fields)
+		}
+		if events.count() != 0 {
+			t.Fatalf("a challenged login fired %d login events", events.count())
+		}
+	})
+
+	t.Run("refusal", func(t *testing.T) {
+		app, gates := gateApp(t)
+		gates.Add(gateFunc(func(context.Context, classes.LoginAttempt) (*classes.LoginGateResult, error) {
+			return &classes.LoginGateResult{Status: http.StatusUnauthorized, Body: map[string]any{"error": "Invalid or expired challenge."}}, nil
+		}))
+		insertUser(t, gdb, "gate-refusal@example.test", "correct-horse")
+		rec := postJSON(t, controllers.Login(app), "/_user/api/v1/login", `{"email":"gate-refusal@example.test","password":"correct-horse"}`)
+		if rec.Code != http.StatusUnauthorized || rec.Body.String() != `{"error":"Invalid or expired challenge."}` {
+			t.Fatalf("refusal = %d %s", rec.Code, rec.Body.String())
+		}
+	})
+
+	t.Run("gate_error", func(t *testing.T) {
+		app, gates := gateApp(t)
+		events := listenLoginEvents(app, "test.login-gate.error")
+		gates.Add(gateFunc(func(context.Context, classes.LoginAttempt) (*classes.LoginGateResult, error) {
+			return nil, errors.New("challenge store down")
+		}))
+		insertUser(t, gdb, "gate-error@example.test", "correct-horse")
+		rec := postJSON(t, controllers.Login(app), "/_user/api/v1/login", `{"email":"gate-error@example.test","password":"correct-horse"}`)
+		if rec.Code != http.StatusInternalServerError {
+			t.Fatalf("gate error = %d %s", rec.Code, rec.Body.String())
+		}
+		if strings.Contains(rec.Body.String(), `"token"`) {
+			t.Fatalf("gate error answered a token: %s", rec.Body.String())
+		}
+		if events.count() != 0 {
+			t.Fatal("a failed gate fired a login event")
+		}
+	})
+
+	t.Run("soft_deleted_stays", func(t *testing.T) {
+		app, gates := gateApp(t)
+		gates.Add(gateFunc(func(context.Context, classes.LoginAttempt) (*classes.LoginGateResult, error) {
+			return &classes.LoginGateResult{Body: challengeBody}, nil
+		}))
+		mail := &captureMail{}
+		if err := app.Publish[postcard.Mailer](mail); err != nil {
+			t.Fatal(err)
+		}
+		user := insertUser(t, gdb, "gate-soft@example.test", "correct-horse")
+		if err := gdb.Model(user).Update("deleted_at", time.Now()).Error; err != nil {
+			t.Fatal(err)
+		}
+		rec := postJSON(t, controllers.Login(app), "/_user/api/v1/login", `{"email":"gate-soft@example.test","password":"correct-horse"}`)
+		if rec.Code != http.StatusOK || decodeBody(t, rec.Body.Bytes())["two_factor_required"] != true {
+			t.Fatalf("challenge = %d %s", rec.Code, rec.Body.String())
+		}
+		var still models.User
+		if err := gdb.Unscoped().First(&still, user.ID).Error; err != nil {
+			t.Fatal(err)
+		}
+		if !still.DeletedAt.Valid {
+			t.Fatal("a challenged login restored the deactivated account")
+		}
+		if len(mail.got) != 0 {
+			t.Fatalf("a challenged login sent %v", mail.got)
+		}
+
+		// Without a gate the same login restores the account, as before.
+		plain, _ := gateApp(t)
+		plainMail := &captureMail{}
+		if err := plain.Publish[postcard.Mailer](plainMail); err != nil {
+			t.Fatal(err)
+		}
+		rec = postJSON(t, controllers.Login(plain), "/_user/api/v1/login", `{"email":"gate-soft@example.test","password":"correct-horse"}`)
+		if rec.Code != http.StatusOK {
+			t.Fatalf("restore = %d %s", rec.Code, rec.Body.String())
+		}
+		var restored models.User
+		if err := gdb.Unscoped().First(&restored, user.ID).Error; err != nil {
+			t.Fatal(err)
+		}
+		if restored.DeletedAt.Valid {
+			t.Fatal("login without a gate did not restore the account")
+		}
+		if len(plainMail.got) != 1 || !strings.HasPrefix(plainMail.got[0], "golem15.user::mail.reactivate") {
+			t.Fatalf("reactivate mails = %v", plainMail.got)
+		}
+	})
+}
--- a/models/device_auth_session.go
+++ b/models/device_auth_session.go
@@ -0,0 +1,66 @@
+package models
+
+import "time"
+
+// Device authorization session statuses, PHP's DeviceAuthSession constants.
+// pending becomes confirmed when a signed-in user authorizes the device,
+// confirmed becomes used on the device's first poll (which receives the
+// session token), used becomes revoked when the user revokes the device,
+// and pending or confirmed become expired once expires_at passes. used and
+// revoked never become expired.
+const (
+	DeviceStatusPending   = "pending"
+	DeviceStatusConfirmed = "confirmed"
+	DeviceStatusUsed      = "used"
+	DeviceStatusExpired   = "expired"
+	DeviceStatusRevoked   = "revoked"
+)
+
+// DeviceAuthSession is one QR or short-code device authorization
+// (golem15_user_device_auth_sessions). TokenHash is the SHA-256 hex of the
+// device token (column token, PHP's name); the token itself is never
+// stored. JWTJTI is the jti of the session token the device received,
+// followed through refresh.
+type DeviceAuthSession struct {
+	ID              uint       `gorm:"column:id;primaryKey"`
+	TokenHash       string     `gorm:"column:token" json:"-"`
+	ShortCode       *string    `gorm:"column:short_code" json:"-"`
+	UserID          *uint      `gorm:"column:user_id"`
+	Status          string     `gorm:"column:status"`
+	ExpiresAt       *time.Time `gorm:"column:expires_at"`
+	DeviceIP        *string    `gorm:"column:device_ip"`
+	DeviceUserAgent *string    `gorm:"column:device_user_agent"`
+	DeviceName      *string    `gorm:"column:device_name"`
+	AuthIP          *string    `gorm:"column:auth_ip"`
+	ConfirmedAt     *time.Time `gorm:"column:confirmed_at"`
+	UsedAt          *time.Time `gorm:"column:used_at"`
+	SessionID       *string    `gorm:"column:session_id"`
+	LastActivityAt  *time.Time `gorm:"column:last_activity_at"`
+	JWTJTI          *string    `gorm:"column:jwt_jti" json:"-"`
+	CreatedAt       time.Time  `gorm:"column:created_at"`
+	UpdatedAt       time.Time  `gorm:"column:updated_at"`
+}
+
+func (DeviceAuthSession) TableName() string { return "golem15_user_device_auth_sessions" }
+
+func (DeviceAuthSession) Fillable() []string {
+	return []string{
+		"token", "short_code", "user_id", "status", "expires_at", "device_ip",
+		"device_user_agent", "device_name", "auth_ip", "confirmed_at", "used_at",
+		"session_id", "last_activity_at", "jwt_jti",
+	}
+}
+
+func (DeviceAuthSession) Hidden() []string { return []string{"token", "short_code", "jwt_jti"} }
+
+// ExpiredAt reports whether a pending or confirmed session is past
+// expires_at at now. A used, revoked or expired session, and one without
+// expires_at, is never newly expired.
+func (s DeviceAuthSession) ExpiredAt(now time.Time) bool {
+	if s.Status != DeviceStatusPending && s.Status != DeviceStatusConfirmed {
+		return false
+	}
+	return s.ExpiresAt != nil && !s.ExpiresAt.After(now)
+}
+
+func init() { Register(DeviceAuthSession{}) }
--- a/password_changed_smoke_test.go
+++ b/password_changed_smoke_test.go
@@ -0,0 +1,153 @@
+package user
+
+import (
+	"context"
+	"errors"
+	"net/http"
+	"strconv"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"git.golem15.com/golem15/sm-user-plugin/classes"
+	"git.golem15.com/golem15/sm-user-plugin/models"
+	"git.golem15.com/golem15/summercms/modules/bouncer"
+)
+
+// passwordProbe records the AccessRevokedEvents of an app (the D-07
+// password-change hook) and can make the listener fail.
+type passwordProbe struct {
+	mu   sync.Mutex
+	seen []classes.AccessRevokedEvent
+	fail atomic.Bool
+}
+
+func (p *passwordProbe) take() []classes.AccessRevokedEvent {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	out := p.seen
+	p.seen = nil
+	return out
+}
+
+// onePasswordChange asserts exactly one event for id with reason, fired in
+// a transaction and reporting PasswordChanged.
+func onePasswordChange(t *testing.T, probe *passwordProbe, id uint, reason string) {
+	t.Helper()
+	seen := probe.take()
+	if len(seen) != 1 {
+		t.Fatalf("%s fired %d events, want 1: %+v", reason, len(seen), seen)
+	}
+	ev := seen[0]
+	if ev.Reason != reason || len(ev.UserIDs) != 1 || ev.UserIDs[0] != id || ev.Tx == nil || !ev.PasswordChanged() {
+		t.Fatalf("%s event = %+v (PasswordChanged %v)", reason, ev, ev.PasswordChanged())
+	}
+}
+
+// TestPasswordChangedEventSmoke pins the D-07 hook a two-factor plugin
+// listens to: a password reset, the user's own change and an administrator
+// setting a password each fire one AccessRevokedEvent that reports
+// PasswordChanged, inside the write's transaction; the bcrypt rehash on
+// login fires none; a failing listener rolls the change back. The event
+// itself predates this test (TestAccessRevocation pins its other fields).
+func TestPasswordChangedEventSmoke(t *testing.T) {
+	for reason, want := range map[string]bool{
+		classes.AccessRevokedPasswordReset:      true,
+		classes.AccessRevokedPasswordChanged:    true,
+		classes.AccessRevokedPasswordSetByAdmin: true,
+		classes.AccessRevokedBan:                false,
+		"":                                      false,
+	} {
+		if got := (&classes.AccessRevokedEvent{Reason: reason}).PasswordChanged(); got != want {
+			t.Fatalf("PasswordChanged(%q) = %v, want %v", reason, got, want)
+		}
+	}
+	var nilEvent *classes.AccessRevokedEvent
+	if nilEvent.PasswordChanged() {
+		t.Fatal("a nil event reports a password change")
+	}
+	if testing.Short() {
+		t.Skip("Postgres")
+	}
+
+	env := newAdminEnv(t)
+	probe := &passwordProbe{}
+	env.app.Events.Listen("test.password_changed", func(_ context.Context, ev *classes.AccessRevokedEvent) error {
+		if probe.fail.Load() {
+			return errors.New("listener refused")
+		}
+		probe.mu.Lock()
+		probe.seen = append(probe.seen, *ev)
+		probe.mu.Unlock()
+		return nil
+	})
+	admin := env.superAdmin(t)
+	ctx := context.Background()
+	session := func(user *models.User) string {
+		return craftToken(t, strconv.FormatUint(uint64(user.ID), 10), "pc-"+strconv.FormatInt(time.Now().UnixNano(), 10), time.Now().Add(-time.Minute), time.Now().Add(time.Hour))
+	}
+
+	t.Run("reset", func(t *testing.T) {
+		user := env.seedUser(t, "pc-reset", nil)
+		code, err := classes.IssueResetCode(ctx, env.gdb, user)
+		if err != nil {
+			t.Fatal(err)
+		}
+		probe.take()
+		packed := strconv.FormatUint(uint64(user.ID), 10) + "!" + code
+		env.expect(t, http.StatusOK, http.MethodPost, "/_user/api/v1/reset-password", "", map[string]string{"code": packed, "password": "pc-new-password", "password_confirmation": "pc-new-password"})
+		onePasswordChange(t, probe, user.ID, classes.AccessRevokedPasswordReset)
+	})
+
+	t.Run("change", func(t *testing.T) {
+		user := env.seedUser(t, "pc-change", func(u *models.User) { u.HasSelfSetPassword = true })
+		probe.take()
+		env.expect(t, http.StatusOK, http.MethodPost, "/_user/api/v1/change-password", session(user), map[string]string{"current_password": "correct-horse", "password": "pc-changed-password", "password_confirmation": "pc-changed-password"})
+		onePasswordChange(t, probe, user.ID, classes.AccessRevokedPasswordChanged)
+	})
+
+	t.Run("admin_set", func(t *testing.T) {
+		user := env.seedUser(t, "pc-admin", nil)
+		probe.take()
+		const set = "pc-admin-password"
+		env.expect(t, http.StatusOK, http.MethodPut, userPath(user.ID, ""), admin, map[string]any{"name": user.Name, "email": user.Email, "password": set, "password_confirmation": set})
+		onePasswordChange(t, probe, user.ID, classes.AccessRevokedPasswordSetByAdmin)
+		env.expect(t, http.StatusOK, http.MethodPut, userPath(user.ID, ""), admin, map[string]any{"name": user.Name, "email": user.Email})
+		if seen := probe.take(); len(seen) != 0 {
+			t.Fatalf("an update without a password fired %+v", seen)
+		}
+	})
+
+	t.Run("rehash_fires_none", func(t *testing.T) {
+		user := env.seedUser(t, "pc-rehash", nil)
+		if err := env.app.Config.Set("golem15.user.password.bcrypt_cost", 11); err != nil {
+			t.Fatal(err)
+		}
+		t.Cleanup(func() { _ = env.app.Config.Set("golem15.user.password.bcrypt_cost", 10) })
+		probe.take()
+		if status, _ := env.userLogin(t, user.Email, "correct-horse"); status != http.StatusOK {
+			t.Fatalf("login = %d", status)
+		}
+		stored := env.reload(t, user.ID).Password
+		if stored == user.Password || bouncer.NeedsRehash(stored, 11) {
+			t.Fatal("the login did not rehash the password at the higher cost")
+		}
+		if seen := probe.take(); len(seen) != 0 {
+			t.Fatalf("the rehash fired %+v", seen)
+		}
+	})
+
+	t.Run("listener_error_rolls_back", func(t *testing.T) {
+		user := env.seedUser(t, "pc-rollback", func(u *models.User) { u.HasSelfSetPassword = true })
+		probe.fail.Store(true)
+		rec := env.call(t, http.MethodPost, "/_user/api/v1/change-password", session(user), map[string]string{"current_password": "correct-horse", "password": "pc-never-set", "password_confirmation": "pc-never-set"})
+		probe.fail.Store(false)
+		if rec.Code != http.StatusInternalServerError {
+			t.Fatalf("change with a failing listener = %d %s", rec.Code, rec.Body.String())
+		}
+		if stored := env.reload(t, user.ID).Password; stored != user.Password {
+			t.Fatal("the stored hash changed although the listener failed")
+		}
+	})
+}
--- a/password_routes_test.go
+++ b/password_routes_test.go
@@ -97,9 +97,11 @@ func TestPasswordPublicRoutes(t *testing.T) {
 	}
 	// 18 routes up to v0.1.9, plus GET /backend-link/{code}, POST
 	// /backend-link/show and POST /backend-link/confirm (the account link),
-	// GET /token/me and GET /tokens/scopes.
-	if len(base) != 23 {
-		t.Fatalf("unset: %d routes, want 23", len(base))
+	// GET /token/me and GET /tokens/scopes, plus POST /devices/initiate,
+	// GET /devices/status/{token}, POST /devices/authorize, GET /devices and
+	// DELETE /devices/{id} (device authorization).
+	if len(base) != 28 {
+		t.Fatalf("unset: %d routes, want 28", len(base))
 	}
 	seen := 0
 	for _, route := range base {
@@ -111,8 +113,8 @@ func TestPasswordPublicRoutes(t *testing.T) {
 		t.Fatalf("unset: found %d of the password routes, want %d", seen, len(passwordRouteKeys))
 	}
 	off := withoutPasswordRoutes(base)
-	if len(off) != 20 {
-		t.Fatalf("base without the password routes has %d routes, want 20", len(off))
+	if len(off) != 25 {
+		t.Fatalf("base without the password routes has %d routes, want 25", len(off))
 	}

 	for _, c := range []struct {
--- a/plugin.go
+++ b/plugin.go
@@ -60,9 +60,14 @@ type Plugin struct {
 func (p *Plugin) ID() string         { return "golem15.user" }
 func (p *Plugin) Requires() []string { return nil }

+// Register publishes the login-gate registry (*classes.LoginGates), so a
+// plugin that requires this one can add its gate in its Boot.
 func (p *Plugin) Register(app *backpack.App) error {
 	p.app = app
-	return nil
+	if gates, ok := app.Lookup[*classes.LoginGates](); ok && gates != nil {
+		return nil
+	}
+	return app.Publish(classes.NewLoginGates())
 }

 func (p *Plugin) Boot(app *backpack.App) error {
--- a/reset_two_factor_smoke_test.go
+++ b/reset_two_factor_smoke_test.go
@@ -0,0 +1,117 @@
+package user
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"slices"
+	"sync"
+	"testing"
+
+	"git.golem15.com/golem15/sm-user-plugin/classes"
+	"git.golem15.com/golem15/sm-user-plugin/models"
+	"gorm.io/gorm"
+)
+
+const permResetTwoFactor = "golem15.users.reset_two_factor"
+
+// fakeTwoFactorAdmin stands in for a two-factor plugin's service.
+type fakeTwoFactorAdmin struct {
+	mu     sync.Mutex
+	has    bool
+	resets []uint
+	txs    []*gorm.DB
+}
+
+func (f *fakeTwoFactorAdmin) HasTwoFactor(_ context.Context, tx *gorm.DB, _ uint) (bool, error) {
+	if tx == nil {
+		return false, nil
+	}
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return f.has, nil
+}
+
+func (f *fakeTwoFactorAdmin) Reset(_ context.Context, tx *gorm.DB, user *models.User) error {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.resets = append(f.resets, user.ID)
+	f.txs = append(f.txs, tx)
+	f.has = false
+	return nil
+}
+
+// recordAction returns the offered record action named name from the show
+// response of user id, or nil.
+func (e *adminEnv) recordAction(t *testing.T, token string, id uint, name string) map[string]any {
+	t.Helper()
+	rec := e.expect(t, http.StatusOK, http.MethodGet, userPath(id, ""), token, nil)
+	var meta struct {
+		Actions []map[string]any `json:"actions"`
+	}
+	if err := json.Unmarshal(adminDecode(t, rec).Meta, &meta); err != nil {
+		t.Fatal(err)
+	}
+	for _, action := range meta.Actions {
+		if action["name"] == name {
+			return action
+		}
+	}
+	return nil
+}
+
+// TestResetTwoFactorSlotSmoke pins the D-15 slot: reset_two_factor is
+// offered only when a classes.TwoFactorAdmin is published and the user has
+// a second factor, only to an administrator holding
+// golem15.users.reset_two_factor, with the danger confirmation, and running
+// it calls Reset once inside the action's transaction.
+func TestResetTwoFactorSlotSmoke(t *testing.T) {
+	if testing.Short() {
+		t.Skip("Postgres")
+	}
+	env := newAdminEnv(t)
+	token := env.admin(t, permAccessUsers, permResetTwoFactor)
+	plain := env.admin(t, permAccessUsers)
+	user := env.seedUser(t, "r2fa", nil)
+	actionPath := userPath(user.ID, "/actions/reset_two_factor")
+
+	// No two-factor plugin: never offered, never runs.
+	if slices.Contains(env.offered(t, token, user.ID), "reset_two_factor") {
+		t.Fatal("reset_two_factor offered without a published TwoFactorAdmin")
+	}
+	if rec := env.call(t, http.MethodPost, actionPath, token, map[string]any{}); rec.Code == http.StatusOK {
+		t.Fatalf("reset_two_factor ran without a TwoFactorAdmin: %s", rec.Body.String())
+	}
+
+	svc := &fakeTwoFactorAdmin{has: true}
+	if err := env.app.Publish[classes.TwoFactorAdmin](svc); err != nil {
+		t.Fatal(err)
+	}
+
+	action := env.recordAction(t, token, user.ID, "reset_two_factor")
+	if action == nil {
+		t.Fatalf("reset_two_factor not offered: %v", env.offered(t, token, user.ID))
+	}
+	if action["danger"] != true || action["label"] != "Reset 2FA" {
+		t.Fatalf("offered action = %v", action)
+	}
+
+	// An administrator with only access_users neither sees nor runs it.
+	if slices.Contains(env.offered(t, plain, user.ID), "reset_two_factor") {
+		t.Fatal("reset_two_factor offered without its permission")
+	}
+	env.expect(t, http.StatusForbidden, http.MethodPost, actionPath, plain, map[string]any{})
+	if len(svc.resets) != 0 {
+		t.Fatal("a refused administrator reached Reset")
+	}
+
+	env.expect(t, http.StatusOK, http.MethodPost, actionPath, token, map[string]any{})
+	if len(svc.resets) != 1 || svc.resets[0] != user.ID || svc.txs[0] == nil {
+		t.Fatalf("Reset calls = %v (tx %v)", svc.resets, svc.txs)
+	}
+
+	// Nothing left to reset: no longer offered.
+	if slices.Contains(env.offered(t, token, user.ID), "reset_two_factor") {
+		t.Fatal("reset_two_factor offered for a user without a second factor")
+	}
+}
--- a/routes.go
+++ b/routes.go
@@ -48,6 +48,14 @@ func (p *Plugin) Routes(r pact.Router) error {
 		g.Post("/backend-link/show", controllers.BackendLinkShowPost(p.app))
 		g.Post("/backend-link/confirm", controllers.BackendLinkConfirm(p.app), "jwt.auth")
 		g.Get("/token/me", controllers.TokenMe(p.app), "user.api_token", "user.scope:read")
+		// Device authorization (QR and short code). The routes authenticate
+		// inside the handlers, as PHP's controller does.
+		g.Post("/devices/initiate", controllers.DeviceInitiate(p.app))
+		g.Get("/devices/status/{token}", controllers.DeviceStatus(p.app))
+		g.Post("/devices/authorize", controllers.DeviceAuthorize(p.app))
+		g.Get("/devices", controllers.DeviceIndex(p.app))
+		g.Delete("/devices/{id}", controllers.DeviceDestroy(p.app))
+		g.Where("id", "[0-9]+")
 	})
 	return nil
 }
--- a/updates/202610260001_create_device_auth_sessions.go
+++ b/updates/202610260001_create_device_auth_sessions.go
@@ -0,0 +1,50 @@
+package updates
+
+import (
+	"github.com/go-gormigrate/gormigrate/v2"
+	"gorm.io/gorm"
+)
+
+// deviceAuthSessionMigrations create golem15_user_device_auth_sessions, the
+// QR and short-code device authorization sessions, with the PHP plugin's
+// table and column names (the v2.1.0 to v2.7.1 migrations: short_code, a
+// nullable user_id and expires_at). The token column holds the SHA-256 hex
+// of the 64-character device token, never the token itself; jwt_jti is
+// added: the jti of the session token the device received, so a revoke can
+// blacklist it. session_id is kept for a Winter import and stays NULL.
+var deviceAuthSessionMigrations = []*gormigrate.Migration{
+	{
+		ID: "202610260001_create_device_auth_sessions",
+		Migrate: func(tx *gorm.DB) error {
+			return tx.Exec(`CREATE TABLE golem15_user_device_auth_sessions (
+	id BIGSERIAL PRIMARY KEY,
+	token VARCHAR(64) NOT NULL UNIQUE,
+	short_code VARCHAR(9) NULL UNIQUE,
+	user_id INTEGER NULL REFERENCES users(id) ON DELETE CASCADE,
+	status VARCHAR(16) NOT NULL DEFAULT 'pending'
+		CHECK (status IN ('pending', 'confirmed', 'used', 'expired', 'revoked')),
+	expires_at TIMESTAMPTZ NULL,
+	device_ip VARCHAR(255) NULL,
+	device_user_agent TEXT NULL,
+	device_name VARCHAR(255) NULL,
+	auth_ip VARCHAR(255) NULL,
+	confirmed_at TIMESTAMPTZ NULL,
+	used_at TIMESTAMPTZ NULL,
+	session_id VARCHAR(255) NULL,
+	last_activity_at TIMESTAMPTZ NULL,
+	jwt_jti VARCHAR(64) NULL,
+	created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+	updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+CREATE INDEX golem15_user_device_auth_sessions_user_id_index ON golem15_user_device_auth_sessions (user_id);
+CREATE INDEX golem15_user_device_auth_sessions_status_index ON golem15_user_device_auth_sessions (status);
+CREATE INDEX golem15_user_device_auth_sessions_expires_at_index ON golem15_user_device_auth_sessions (expires_at);
+CREATE INDEX golem15_user_device_auth_sessions_jwt_jti_index ON golem15_user_device_auth_sessions (jwt_jti)`).Error
+		},
+		Rollback: func(tx *gorm.DB) error {
+			return tx.Exec("DROP TABLE IF EXISTS golem15_user_device_auth_sessions").Error
+		},
+	},
+}
+
+func init() { Register(deviceAuthSessionMigrations...) }
--- a/updates/organisations_test.go
+++ b/updates/organisations_test.go
@@ -53,6 +53,7 @@ func TestCreateOrganisationsMigration(t *testing.T) {
 		"202610160002_add_handle_to_users",
 		"202610210001_add_users_email_verified_at",
 		"202610220001_create_golem15_user_backend_links",
+		"202610260001_create_device_auth_sessions",
 	}
 	if len(ids) != len(want) {
 		t.Fatalf("history = %v", ids)
@@ -63,9 +64,10 @@ func TestCreateOrganisationsMigration(t *testing.T) {
 		}
 	}

-	// Backend links, email proof, handle, OAuth identities, the three admin migrations, API tokens, user groups,
-	// jwt blacklist, throttle, extend-users, then organisations.
-	for range 13 {
+	// Device auth sessions (golem15_user_device_auth_sessions), backend links, email proof, handle, OAuth
+	// identities, the three admin migrations, API tokens, user groups, jwt blacklist, throttle, extend-users,
+	// then organisations.
+	for range 14 {
 		if err := m.RollbackLast(); err != nil {
 			t.Fatal(err)
 		}
--- a/updates/user_groups_test.go
+++ b/updates/user_groups_test.go
@@ -54,8 +54,9 @@ func TestUserGroupsMigration(t *testing.T) {
 		t.Fatalf("users_groups primary key = %q", pk)
 	}

-	// Backend links, email verified at, handle, OAuth identities, frontend permissions, last seen, API tokens, user permissions, then user groups.
-	for range 9 {
+	// Device auth sessions (golem15_user_device_auth_sessions), backend links, email verified at, handle, OAuth
+	// identities, frontend permissions, last seen, API tokens, user permissions, then user groups.
+	for range 10 {
 		if err := m.RollbackLast(); err != nil {
 			t.Fatal(err)
 		}
--- a/updates/user_session_test.go
+++ b/updates/user_session_test.go
@@ -47,9 +47,9 @@ func TestExtendUsersMigration(t *testing.T) {
 	if !row.HasSelfSetPassword || row.IsActivated || row.MarketingConsent || row.IsOnboarded {
 		t.Fatalf("defaults = %+v", row)
 	}
-	// Backend links, email verified at, handle, OAuth identities, the three admin migrations, API tokens, user groups,
-	// jwt blacklist, throttle, then extend-users.
-	for range 12 {
+	// Device auth sessions (golem15_user_device_auth_sessions), backend links, email verified at, handle, OAuth
+	// identities, the three admin migrations, API tokens, user groups, jwt blacklist, throttle, then extend-users.
+	for range 13 {
 		if err := m.RollbackLast(); err != nil {
 			t.Fatal(err)
 		}
@@ -88,8 +88,9 @@ func TestCreateUserThrottleMigration(t *testing.T) {
 			t.Fatalf("missing column %s", col)
 		}
 	}
-	// Backend links, email verified at, handle, OAuth identities, the three admin migrations, API tokens, user groups, jwt blacklist, then throttle.
-	for range 11 {
+	// Device auth sessions (golem15_user_device_auth_sessions), backend links, email verified at, handle, OAuth
+	// identities, the three admin migrations, API tokens, user groups, jwt blacklist, then throttle.
+	for range 12 {
 		if err := m.RollbackLast(); err != nil {
 			t.Fatal(err)
 		}
@@ -120,8 +121,9 @@ func TestCreateJwtBlacklistMigration(t *testing.T) {
 			t.Fatalf("missing column %s", col)
 		}
 	}
-	// Backend links, email verified at, handle, OAuth identities, the three admin migrations, API tokens, user groups, then jwt blacklist.
-	for range 10 {
+	// Device auth sessions (golem15_user_device_auth_sessions), backend links, email verified at, handle, OAuth
+	// identities, the three admin migrations, API tokens, user groups, then jwt blacklist.
+	for range 11 {
 		if err := m.RollbackLast(); err != nil {
 			t.Fatal(err)
 		}
Author	SHA1	Message	Date
Jakub Zych	3b22134292	feat: device list and revoke with the jti followed through refresh GET /devices lists the caller's confirmed and used device sessions (PHP's fields, device_name from the stored name or the user agent, is_current for the session the request's token belongs to). DELETE /devices/{id} marks the session revoked and blacklists the device token's jti for its whole refresh window in one transaction. POST /refresh hands a used session's jwt_jti over to the refreshed token (classes.HandOverDeviceJTI), so a device that refreshed before the revoke is signed out too.	2026-10-26 10:19:25 +01:00
Jakub Zych	4e3e5b05b5	feat: device authorization by QR or short code PHP's device flow on golem15_user_device_auth_sessions (PHP's columns, the token stored as its SHA-256, plus jwt_jti): POST /devices/initiate answers a 64-character token, an XXXX-XXXX short code, the configurable auth_url (golem15.user.device_auth.auth_url) and the expiry; a signed-in user authorizes it with POST /devices/authorize (short_code or token, one guarded pending-to-confirmed UPDATE); the device's first poll of GET /devices/status/{token} after that receives a session JWT through one guarded confirmed-to-used UPDATE, so exactly one poll gets it. Used and revoked sessions never turn into expired; each initiate deletes a bounded batch of stale sessions.	2026-10-26 10:14:48 +01:00
Jakub Zych	3d4c8d2160	style: gofmt the login gate smoke test	2026-10-26 10:08:57 +01:00
Jakub Zych	7900f47ba6	feat: password-change hook and the reset-2FA admin slot The D-07 password-change hook is the existing AccessRevokedEvent, fired inside the write's transaction by a reset, the user's own change and an administrator's password; (*AccessRevokedEvent).PasswordChanged reports those three reasons, and the login rehash fires nothing. The Users screen declares the record action reset_two_factor (danger) behind the new permission golem15.users.reset_two_factor, which no role has by default. It is offered only when a two-factor plugin publishes a classes.TwoFactorAdmin and the user has a second factor; Run calls the service's Reset in the action's transaction.	2026-10-26 10:03:59 +01:00
Jakub Zych	8501f3475a	feat: login gates and the login event Register publishes a *classes.LoginGates registry. POST /login consults it through controllers.CheckLoginGates after the password, activation and throttle checks and the bcrypt rehash, and before the restore of a deactivated account, last_seen and the mint: a gate result replaces the token response, a gate error answers the opaque 500. The restore and its reactivate mail now run after the gates, so a password alone cannot reactivate an account a second factor protects. Without a gate /login answers as before; refresh never consults the gates. classes.LoginEvent (golem15.user.login) fires after every password login that minted a token; controllers.FireLoginEvent lets other plugins fire it.	2026-10-26 09:55:48 +01:00