feat(backend): appareils appairés persistants, révocables et code éphémère (#77 B1-B4)

L'appairage ne survivait pas au redémarrage et son code, permanent, était
imprimé sur la sortie standard. Un appareil appairé devient une entité
persistante, nommée et révocable, derrière un code désormais éphémère.

- B1 : port DeviceSessionStore et adapter FsDeviceSessionStore, entités de
  domaine (PairedDevice, DeviceId, SessionTokenHash, DeviceName). Les tokens
  sont hachés en SHA-256 et comparés en temps constant (subtle) : le store
  ne peut pas rejouer une session qu'il a servie. Cookie Max-Age 400 j à
  renouvellement glissant, lastSeenAtMs throttlé.
- B2 : code éphémère en mémoire, TTL 10 min et usage unique, toute
  génération invalidant la précédente. POST /api/pairing-code authentifiée,
  flag --new-code. Le code est retiré du boot et l'eprintln! qui l'imprimait
  est supprimé.
- B3 : endpoints devices (list/rename/revoke/revoke-all/logout), event
  DeviceRevoked et ActiveConnectionRegistry par device_id, fermant sans
  délai les WebSockets d'un appareil révoqué.
- B4 : port PairAttemptLimiter et adapter mémoire, rate-limit par origine et
  global sur horloge injectée, donc testable sans attente réelle.

La normalisation du code passe côté serveur : elle absorbe la dette #76, que
la seule normalisation frontend de #75 ne faisait que masquer.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

crates/domain/src/ports.rs

@@ -34,6 +34,7 @@ use crate::agent_tool_policy::AgentToolPolicy;
 use crate::background_task::{
     BackgroundTask, BackgroundTaskKind, BackgroundTaskResult, BackgroundTaskWakePolicy,
 };
+use crate::device::{AuthenticatedDevice, DeviceId, PairedDevice};
 use crate::events::DomainEvent;
 use crate::ids::{
     AgentId, LocalModelServerId, NodeId, ProjectId, ScheduleId, SessionId, SprintId, TaskId,
@@ -1688,6 +1689,45 @@ pub trait EmbedderPromptStore: Send + Sync {
     ) -> Result<(), StoreError>;
 }
 
+/// Persists paired devices and their session-token hashes.
+#[async_trait]
+pub trait DeviceSessionStore: Send + Sync {
+    /// Loads all paired devices. A missing store is represented as an empty list.
+    async fn load_devices(&self) -> Result<Vec<PairedDevice>, StoreError>;
+
+    /// Replaces the persisted device list atomically enough for the filesystem
+    /// adapter's single-process use case.
+    async fn save_devices(&self, devices: &[PairedDevice]) -> Result<(), StoreError>;
+
+    /// Removes one device by id.
+    async fn remove_device(&self, device_id: DeviceId) -> Result<bool, StoreError> {
+        let mut devices = self.load_devices().await?;
+        let before = devices.len();
+        devices.retain(|device| device.device_id != device_id);
+        if devices.len() != before {
+            self.save_devices(&devices).await?;
+            return Ok(true);
+        }
+        Ok(false)
+    }
+
+    /// Authenticates a session token against persisted token hashes.
+    async fn authenticate_token(
+        &self,
+        token_bytes: &[u8],
+    ) -> Result<Option<AuthenticatedDevice>, StoreError> {
+        for device in self.load_devices().await? {
+            if device.session_token_hash.verify_token_bytes(token_bytes) {
+                return Ok(Some(AuthenticatedDevice {
+                    device_id: device.device_id,
+                    token_hash: device.session_token_hash,
+                }));
+            }
+        }
+        Ok(None)
+    }
+}
+
 /// Reads/writes agent `.md` contexts and the project manifest, within a project.
 #[async_trait]
 pub trait AgentContextStore: Send + Sync {