feat(settings): session timeout is configurable from the UI

auth.session-policy.get/set plus a card under Account. Presented as two
plain questions rather than the token mechanism underneath, because the
distinction that matters to an operator is which control actually ends a
session: the dashboard polls constantly, so an idle timeout alone never
fires on an open tab — the absolute cap is what guarantees it.

Values are clamped server-side and the stored result is echoed back, so
the bounds are discoverable instead of an error. Presets rather than a free
number field: a box accepting '5' invites locking yourself out. A short
idle choice warns that it is the payments-industry posture.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

core/archipelago/src/api/rpc/dispatcher.rs

@@ -472,6 +472,8 @@ impl RpcHandler {
             "system.disk-cleanup" => self.handle_system_disk_cleanup().await,
             "system.reboot" => self.handle_system_reboot(params).await,
             "system.factory-reset" => self.handle_system_factory_reset(params).await,
+            "auth.session-policy.get" => self.handle_session_policy_get().await,
+            "auth.session-policy.set" => self.handle_session_policy_set(params).await,
             "system.settings.get" => self.handle_system_settings_get(params).await,
             "system.settings.set" => self.handle_system_settings_set(params).await,
             "system.kiosk-display.get" => self.handle_system_kiosk_display_get().await,

core/archipelago/src/api/rpc/system/handlers.rs

@@ -1011,6 +1011,59 @@ impl RpcHandler {
         }
     }
 
+    /// auth.session-policy.get — how long a login lasts on this node.
+    pub(in crate::api::rpc) async fn handle_session_policy_get(&self) -> Result<serde_json::Value> {
+        let policy = crate::settings::session_policy::load(&self.config.data_dir).await;
+        Ok(serde_json::json!({
+            "idle_timeout_secs": policy.idle_timeout_secs,
+            "absolute_timeout_secs": policy.absolute_timeout_secs,
+            "reauth_for_funds": policy.reauth_for_funds,
+        }))
+    }
+
+    /// auth.session-policy.set — change it.
+    ///
+    /// Values are clamped rather than rejected: the caller learns what was
+    /// actually stored from the reply, which is friendlier than an error and
+    /// makes the bounds discoverable. Fields are individually optional so the
+    /// UI can change one control without having to send the others back.
+    pub(in crate::api::rpc) async fn handle_session_policy_set(
+        &self,
+        params: Option<serde_json::Value>,
+    ) -> Result<serde_json::Value> {
+        let params = params.unwrap_or(serde_json::json!({}));
+        let current = crate::settings::session_policy::load(&self.config.data_dir).await;
+        let policy = crate::settings::session_policy::SessionPolicy {
+            idle_timeout_secs: params
+                .get("idle_timeout_secs")
+                .and_then(|v| v.as_u64())
+                .unwrap_or(current.idle_timeout_secs),
+            absolute_timeout_secs: match params.get("absolute_timeout_secs") {
+                // Explicit null means "no absolute cap", which is different
+                // from the field being absent (leave it as it is).
+                Some(serde_json::Value::Null) => None,
+                Some(v) => v.as_u64().or(current.absolute_timeout_secs),
+                None => current.absolute_timeout_secs,
+            },
+            reauth_for_funds: params
+                .get("reauth_for_funds")
+                .and_then(|v| v.as_bool())
+                .unwrap_or(current.reauth_for_funds),
+        };
+        let saved = crate::settings::session_policy::save(&self.config.data_dir, policy).await?;
+        tracing::info!(
+            idle = saved.idle_timeout_secs,
+            absolute = ?saved.absolute_timeout_secs,
+            reauth_for_funds = saved.reauth_for_funds,
+            "session policy updated"
+        );
+        Ok(serde_json::json!({
+            "idle_timeout_secs": saved.idle_timeout_secs,
+            "absolute_timeout_secs": saved.absolute_timeout_secs,
+            "reauth_for_funds": saved.reauth_for_funds,
+        }))
+    }
+
     /// system.settings.set — Write a settings value
     pub(in crate::api::rpc) async fn handle_system_settings_set(
         &self,