@@ -1133,10 +1133,10 @@ async fn accepted_relay(
         }
     }
     match (accepted.len(), transient) {
-        (1, _) => Ok(accepted.pop()),
-        // Nothing usable, but a check that might pass on retry: report it
-        // rather than fall back to a relay this person is not paired for.
-        (0, Some(e)) => Err(e),
+        // A desktop whose check failed may accept a relay of its own: report
+        // it rather than pick, or fall back to, a relay it might contradict.
+        (0 | 1, Some(e)) => Err(e),
+        (1, None) => Ok(accepted.pop()),
         _ => Ok(None),
     }
 }
@@ -2489,14 +2489,16 @@ pub(crate) mod tests {
             .unwrap_err();
         assert_eq!(crate::error::exit_code(&err), 2, "{err:?}");
 
-        // A usable relay wins over a transient failure elsewhere.
+        // A still-throttled desktop might add a second relay, so one
+        // accepted relay elsewhere does not settle the choice.
         let (throttled, _) = provider(
             |_, _| serde_json::json!({"result": "", "error": "rate_limited", "retry_after": 1}),
         )
         .await;
         let store = MemoryStore::with(&[("a", "ta", &[RELAY]), ("b", "tb", &[RELAY])]);
         let ads = vec![("a".into(), good), ("b".into(), throttled)];
-        assert!(accepted_relay(&store, ads).await.unwrap().is_some());
+        let err = accepted_relay(&store, ads).await.unwrap_err();
+        assert_eq!(crate::error::exit_code(&err), 2, "{err:?}");
     }
 
     /// With no usable relay, a retryable failure is reported over an
 
@@ -2748,6 +2748,38 @@ mod tests {
         Cli::command().debug_assert();
     }
 
+    /// Relay selection asks only what a command needs: an explicit key never
+    /// asks for a pairing, unpairing asks nothing, pairing asks for no other
+    /// pairing, and an agent's inherited relay comes first. `None` for
+    /// `inherited` means it must not be asked; the paired lookup never is.
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn relay_selection_asks_only_what_a_command_needs() {
+        use clap::Parser;
+        const INHERITED: &str = "wss://inherited.example/";
+        const DEFAULT: &str = "http://localhost:3000";
+        let cases = [
+            ("users get", true, Some(None), DEFAULT),
+            ("auth desktop unpair", false, None, DEFAULT),
+            ("auth desktop pair", false, Some(None), DEFAULT),
+            ("users get", false, Some(Some(INHERITED)), INHERITED),
+        ];
+        for (args, explicit_key, inherited, want) in cases {
+            let argv = std::iter::once("buzz").chain(args.split(' '));
+            let cli = Cli::try_parse_from(argv).unwrap();
+            let inherited = async move {
+                Ok(inherited
+                    .unwrap_or_else(|| panic!("`{args}` asked for an inherited relay"))
+                    .map(str::to_owned))
+            };
+            let paired = async { panic!("`{args}` asked for a paired relay") };
+            let relay = default_relay_with(&cli.command, explicit_key, inherited, paired)
+                .await
+                .unwrap();
+            assert_eq!(relay, want, "`{args}`");
+        }
+    }
+
     #[test]
     fn messages_send_from_thread_conflicts_with_reply_and_broadcast() {
         let base = [
Original file line number	Diff line number	Diff line change
`@@ -1133,10 +1133,10 @@ async fn accepted_relay(`
`1133`	`1133`	`}`
`1134`	`1134`	`}`
`1135`	`1135`	`match (accepted.len(), transient) {`
`1136`		`- (1, _) => Ok(accepted.pop()),`
`1137`		`- // Nothing usable, but a check that might pass on retry: report it`
`1138`		`- // rather than fall back to a relay this person is not paired for.`
`1139`		`- (0, Some(e)) => Err(e),`
	`1136`	`+ // A desktop whose check failed may accept a relay of its own: report`
	`1137`	`+ // it rather than pick, or fall back to, a relay it might contradict.`
	`1138`	`+ (0 \| 1, Some(e)) => Err(e),`
	`1139`	`+ (1, None) => Ok(accepted.pop()),`
`1140`	`1140`	`_ => Ok(None),`
`1141`	`1141`	`}`
`1142`	`1142`	`}`
`@@ -2489,14 +2489,16 @@ pub(crate) mod tests {`
`2489`	`2489`	`.unwrap_err();`
`2490`	`2490`	`assert_eq!(crate::error::exit_code(&err), 2, "{err:?}");`
`2491`	`2491`
`2492`		`- // A usable relay wins over a transient failure elsewhere.`
	`2492`	`+ // A still-throttled desktop might add a second relay, so one`
	`2493`	`+ // accepted relay elsewhere does not settle the choice.`
`2493`	`2494`	`let (throttled, _) = provider(`
`2494`	`2495`	`\|_, _\| serde_json::json!({"result": "", "error": "rate_limited", "retry_after": 1}),`
`2495`	`2496`	`)`
`2496`	`2497`	`.await;`
`2497`	`2498`	`let store = MemoryStore::with(&[("a", "ta", &[RELAY]), ("b", "tb", &[RELAY])]);`
`2498`	`2499`	`let ads = vec![("a".into(), good), ("b".into(), throttled)];`
`2499`		`- assert!(accepted_relay(&store, ads).await.unwrap().is_some());`
	`2500`	`+ let err = accepted_relay(&store, ads).await.unwrap_err();`
	`2501`	`+ assert_eq!(crate::error::exit_code(&err), 2, "{err:?}");`
`2500`	`2502`	`}`
`2501`	`2503`
`2502`	`2504`	`/// With no usable relay, a retryable failure is reported over an`