diff --git a/deploy/server/setup.sh b/deploy/server/setup.sh
index e33c443..5231fa2 100755
--- a/deploy/server/setup.sh
+++ b/deploy/server/setup.sh
@@ -16,7 +16,7 @@ if [ -t 1 ]; then
 else
   B=""; D=""; A=""; G=""; Y=""; R=""; N=""
 fi
-STEPS=("檢查" "網址" "帳號" "金鑰" "啟動")
+STEPS=("檢查" "網址" "帳號" "啟動")
 AT=0
 
 header() {
@@ -36,7 +36,7 @@ card_open() { printf '  %s╭─%s %s%s%s\n  %s│%s\n' "$D" "$N" "$B" "$1" "$N"
 line() { printf '  %s│%s  %s\n' "$D" "$N" "$*"; }
 note() { printf '  %s│%s  %s%s%s\n' "$D" "$N" "$D" "$*" "$N"; }
 ok() { printf '  %s│%s  %s✓%s %s\n' "$D" "$N" "$G" "$N" "$*"; }
-warn() { printf '  %s│%s  %s!%s %s\n' "$D" "$N" "$Y" "$N" "$*"; }
+warn() { WARNED=1; printf '  %s│%s  %s!%s %s\n' "$D" "$N" "$Y" "$N" "$*"; }
 bad() { printf '  %s│%s  %s✗ %s%s\n' "$D" "$N" "$R" "$*" "$N"; }
 card_close() { printf '  %s│%s\n  %s╰────────────────────────────────────────────────%s\n' "$D" "$N" "$D" "$N"; [ -n "${1:-}" ] && printf '   %s%s%s\n' "$D" "$1" "$N"; }
 
@@ -110,7 +110,7 @@ die() { card_close; printf '\n'; exit 1; }
 
 # ---------- 0. this server ----------
 AT=0; header; card_open "檢查這台伺服器"
-FAIL=0
+FAIL=0; WARNED=0
 if command -v docker >/dev/null; then ok "Docker 已安裝"; else bad "沒有 Docker：curl -fsSL https://get.docker.com | sh"; FAIL=1; fi
 if docker compose version >/dev/null 2>&1; then ok "docker compose 可以用"; elif [ $FAIL = 0 ]; then bad "沒有 docker compose（Docker 太舊？請更新 Docker）"; FAIL=1; fi
 if [ $FAIL = 0 ] && ! docker info >/dev/null 2>&1; then bad "沒有權限使用 Docker：sudo usermod -aG docker \$USER，登出再登入"; FAIL=1; fi
@@ -123,7 +123,8 @@ mem=$(awk '/MemTotal/ {print int($2/1024/1024+0.5)}' /proc/meminfo 2>/dev/null |
 disk=$(df -Pk . 2>/dev/null | awk 'NR==2 {print int($4/1024/1024)}')
 [ "${disk:-0}" -ge 10 ] && ok "硬碟還有 ${disk} GB" || warn "硬碟只剩 ${disk:-?} GB（建議 10 GB 以上）"
 if [ $FAIL = 1 ] && [ $DRY = 0 ]; then note ""; note "修好上面的問題後再執行一次 ./setup.sh"; die; fi
-card_close; pause
+# All fine: go on by itself.
+if [ $WARNED = 1 ]; then card_close; pause; else card_close; sleep 1; fi
 
 # Keep the current settings?
 if [ -f .env ] && [ -f Caddyfile ]; then
@@ -134,7 +135,7 @@ if [ -f .env ] && [ -f Caddyfile ]; then
     "重新設定|網址、帳號或金鑰要改"
   if [ "$KEEP" = 0 ]; then
     DOMAIN=${ANYBOT_RELAY_PUBLIC_URL#https://}; USERNAME=$ANYBOT_USER; INVITE=${ANYBOT_RELAY_INVITE:-}; BRAIN=${ANYBOT_HOST_NAME:-}
-    AT=4; SKIP=1
+    AT=3; SKIP=1
   fi
 fi
 
@@ -177,41 +178,12 @@ if [ "${SKIP:-0}" != 1 ]; then
     if [ "${#PW1}" -lt 8 ]; then MSG=$(bad "密碼至少 8 個字"); continue; fi
     if [ "$PW1" != "$PW2" ]; then MSG=$(bad "兩次密碼不一樣"); continue; fi
     case "$PW1" in *"'"*) MSG=$(bad "密碼裡不能有單引號 '"); continue ;; esac
-    ask BRAIN "大腦名字" "${BRAIN:-雲端大腦}"
-    [ -z "$BRAIN" ] && BRAIN="雲端大腦"
+    BRAIN="雲端大腦"
     break
   done
-  choose OTHERS "別人可以在這台註冊帳號嗎？" \
-    "只有我|最安全" \
-    "給邀請碼的人可以|家人或同事拿邀請碼註冊，各自有自己的帳號和 Bot"
-  INVITE=""
-  [ "$OTHERS" = 1 ] && INVITE=$(LC_ALL=C tr -dc 'a-z0-9' </dev/urandom | head -c 10)
-
-  # ---------- 3. keys ----------
-  AT=3
-  choose KEYS "AI 模型的金鑰" \
-    "之後在 App 裡設定|在手機或電腦的 AnyBot › 設定 › 模型 填，金鑰只存在大腦上" \
-    "現在輸入|xAI、Anthropic、OpenAI、Gemini，有哪個填哪個" \
-    "從我電腦的備份接手|帳號已經存在、電腦做過「備份到帳號」時：Bot、聊天、排程和金鑰一起搬過來"
-  XAI=""; ANT=""; OAI=""; GEM=""; RESTORE=""
-  if [ "$KEYS" = 1 ]; then
-    header; card_open "AI 模型的金鑰（沒有的直接按 Enter 跳過）"; line ""
-    ask XAI "xAI" "" secret; ask ANT "Anthropic" "" secret; ask OAI "OpenAI" "" secret; ask GEM "Gemini" "" secret
-    card_close
-  elif [ "$KEYS" = 2 ]; then RESTORE=1; fi
-
-  # ---------- confirm ----------
-  AT=4
-  header; card_open "確認一下"
-  line "${D}網址      ${N}${B}https://$DOMAIN${N}"
-  line "${D}帳號      ${N}${B}$USERNAME${N}"
-  line "${D}大腦      ${N}${B}$BRAIN${N}"
-  line "${D}註冊      ${N}${B}$([ -n "$INVITE" ] && echo "邀請碼 $INVITE" || echo "只有我")${N}"
-  line "${D}金鑰      ${N}${B}$(case $KEYS in 0) echo "之後在 App 裡設定" ;; 1) n=0; for k in "$XAI" "$ANT" "$OAI" "$GEM"; do [ -n "$k" ] && n=$((n + 1)); done; echo "$n 個" ;; 2) echo "從電腦的備份接手" ;; esac)${N}"
-  line ""
-  note "設定會寫進 $(pwd)/.env（只有你看得到）和 Caddyfile。"
-  card_close "Enter 開始   Ctrl+C 取消"
-  IFS= read -r _
+  # Only this account (others can be let in later: ANYBOT_RELAY_INVITE in .env). AI keys are set
+  # in the app (設定 › 模型); they stay on the brain.
+  INVITE=""; XAI=""; ANT=""; OAI=""; GEM=""; RESTORE=""
 
   q() { printf "%s='%s'\n" "$1" "$2"; }
   umask 077
@@ -234,7 +206,7 @@ if [ "${SKIP:-0}" != 1 ]; then
 fi
 
 # ---------- 4. start ----------
-AT=4; header; card_open "啟動"
+AT=3; header; card_open "啟動"
 ok "寫好設定（.env、Caddyfile）"
 if [ $DRY = 1 ]; then
   warn "試跑（--dry-run）：沒有啟動。要啟動：docker compose up -d --build"
@@ -274,8 +246,8 @@ printf '\n'
 card_open "$([ -n "$joined" ] && echo "完成了" || echo "差一點")"
 line "${B}手機${N}      打開 ${A}https://$DOMAIN${N}，用 ${B}$USERNAME${N} 登入，可以「加入主畫面」"
 line "${B}電腦${N}      AnyBot › 設定 › 手機與帳號 登入，在「大腦」選「$BRAIN」"
-line "${B}Linux 手腳${N} anybot setup（選「手腳」，再選「$BRAIN」）"
-[ -n "${INVITE:-}" ] && line "${B}邀請碼${N}    $INVITE（給要註冊的人）"
+line "${B}AI 金鑰${N}   手機或電腦的 AnyBot › 設定 › 模型（只存在大腦上）"
+line "${B}加一台電腦${N} 手機 AnyBot 右上 ⋯ › 加一台電腦，把那一行貼到那台的終端機"
 line ""
 note "看紀錄   docker compose logs -f anybot"
 note "更新     ./setup.sh（選「用現有設定」）"
diff --git a/mobile/index.html b/mobile/index.html
index 00f5580..07f1df3 100644
--- a/mobile/index.html
+++ b/mobile/index.html
@@ -132,6 +132,11 @@ header .sub{font-size:12px;color:var(--text3);font-weight:400}
 .sheet button{display:block;width:100%;text-align:left;padding:14px 16px;border-radius:12px;font-size:16px}
 .sheet button:active{background:var(--raise)}
 .sheet .no{color:var(--danger)}
+.pair{padding:18px 16px calc(env(safe-area-inset-bottom) + 12px)}
+.pair-t{font-size:18px;font-weight:600;margin:2px 4px 6px}
+.pair-code{font:600 34px/1.2 ui-monospace,Menlo,monospace;letter-spacing:6px;text-align:center;margin:16px 0 10px}
+.pair-line{display:block;font:13px/1.5 ui-monospace,Menlo,monospace;background:var(--raise);border-radius:10px;padding:10px 12px;word-break:break-all;margin-bottom:12px;user-select:all}
+.sheet .pair-copy,.pair .btn.main{text-align:center;padding:13px}
 .sheet .note{color:var(--text3);font-size:12.5px;padding:4px 16px 8px}
 .toast{position:fixed;left:50%;bottom:calc(env(safe-area-inset-bottom) + 90px);transform:translateX(-50%);background:var(--text);color:var(--bg);padding:9px 16px;border-radius:12px;font-size:14px;opacity:0;transition:opacity .2s;pointer-events:none;max-width:88vw;text-align:center}
 .toast.on{opacity:.95}
@@ -217,11 +222,22 @@ header .sub{font-size:12px;color:var(--text3);font-weight:400}
 <div class="sheet-bg" id="sheet"><div class="sheet">
   <button id="m-notify">開啟通知</button>
   <div class="note" id="m-note">Bot 需要你允許、或在你不在時做完事，手機會跳通知。</div>
+  <button id="m-pair" style="display:none">加一台電腦（Linux、伺服器）</button>
   <button id="m-host" style="display:none">切換到別台 AnyBot</button>
   <button class="no" id="m-out">登出這支手機</button>
   <button id="m-cancel">取消</button>
 </div></div>
 
+<div class="sheet-bg" id="pair"><div class="sheet pair">
+  <div class="pair-t">加一台電腦</div>
+  <div class="note">在那台電腦的終端機貼上這一行執行，它就會變成「<b id="pair-for"></b>」的手腳，開機自動執行。不用帳號密碼。</div>
+  <div class="pair-code" id="pair-code">······</div>
+  <code class="pair-line" id="pair-line"></code>
+  <button class="btn main" id="pair-copy">複製這一行</button>
+  <div class="note" id="pair-left"></div>
+  <button id="pair-close">關閉</button>
+</div></div>
+
 <script>
 "use strict";
 // Lucide icons (ISC licence), the same set as the app.
@@ -526,11 +542,38 @@ $("typein").addEventListener("keydown", (e) => { if (e.key === "Enter" && !e.isC
 $("k-right").onclick = () => { S.right = !S.right; $("k-right").textContent = "右鍵：" + (S.right ? "開" : "關"); };
 $("k-wake").onclick = () => { toast("正在叫醒 Bot 的電腦…"); input2({kind: "wake"}); };
 // ---------- menu, notifications ----------
-$("b-more").onclick = () => { $("m-host").style.display = S.relay ? "" : "none"; notifyLabel(); $("sheet").classList.add("on"); };
+$("b-more").onclick = () => { $("m-host").style.display = S.relay ? "" : "none"; $("m-pair").style.display = S.relay ? "" : "none"; notifyLabel(); $("sheet").classList.add("on"); };
 $("sheet").onclick = (e) => { if (e.target.id === "sheet") $("sheet").classList.remove("on"); };
 $("m-cancel").onclick = () => $("sheet").classList.remove("on");
 $("m-out").onclick = () => { $("sheet").classList.remove("on"); if (confirm("要登出這支手機嗎？")) signOut(); };
 $("m-host").onclick = () => { $("sheet").classList.remove("on"); S.host = ""; localStorage.removeItem("anybot.host"); S.version = 0; pickHost(); };
+// 加一台電腦: a code for a new computer (ten minutes, once), as hands for this AnyBot.
+$("m-pair").onclick = async () => {
+  $("sheet").classList.remove("on");
+  $("pair-for").textContent = $("host-name").textContent || "這台 AnyBot";
+  $("pair-code").textContent = "······"; $("pair-line").textContent = "正在產生…"; $("pair-left").textContent = "";
+  $("pair").classList.add("on");
+  try {
+    const v = await api("relay/pair", {json: {for: S.host}});
+    const line = `anybot setup ${location.origin} ${v.code}`;
+    $("pair-code").textContent = v.code.slice(0, 3) + " " + v.code.slice(3);
+    $("pair-line").textContent = line;
+    const end = Date.now() + (v.expires_in || 600) * 1000;
+    clearInterval(S.pairTimer);
+    S.pairTimer = setInterval(() => {
+      const left = Math.max(0, Math.round((end - Date.now()) / 1000));
+      $("pair-left").textContent = left ? `還有 ${Math.floor(left / 60)} 分 ${String(left % 60).padStart(2, "0")} 秒，只能用一次` : "過期了，關掉再按一次「加一台電腦」";
+      if (!left) clearInterval(S.pairTimer);
+    }, 1000);
+  } catch (e) { $("pair-line").textContent = "沒有拿到配對碼：" + e.message; }
+};
+$("pair-copy").onclick = async () => {
+  const line = $("pair-line").textContent;
+  if (!line.startsWith("anybot")) return;
+  try { await navigator.clipboard.writeText(line); toast("已複製"); } catch (_) { toast("請長按上面那一行複製"); }
+};
+$("pair-close").onclick = () => { clearInterval(S.pairTimer); $("pair").classList.remove("on"); };
+$("pair").onclick = (e) => { if (e.target.id === "pair") $("pair-close").click(); };
 const pushOK = () => S.relay && "serviceWorker" in navigator && "PushManager" in window && "Notification" in window;
 async function notifyLabel() {
   const b = $("m-notify"), n = $("m-note");
diff --git a/relay/src/main.rs b/relay/src/main.rs
index 4d44cb7..0de710f 100644
--- a/relay/src/main.rs
+++ b/relay/src/main.rs
@@ -36,6 +36,8 @@ const ICON: &str = r##"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 96 9
 const HOST_POLL_SECS: u64 = 25;
 /// How long a phone's request waits for the AnyBot to answer (its own long-poll is 20 s).
 const FORWARD_SECS: u64 = 35;
+/// How long a 配對碼 lasts.
+const PAIR_SECS: u64 = 600;
 /// How long a request may wait to be picked up before the host counts as gone.
 const PICKUP_SECS: u64 = 8;
 /// The lasting connection: a ping this often, and given up after this long without a word.
@@ -188,8 +190,11 @@ struct Relay {
     /// AnyBots connected the lasting way (WebSocket), and which requests went over which.
     sockets: Mutex<HashMap<String, Sock>>,
     flights: Mutex<HashMap<String, (String, u64)>>,
-    /// The brain each AnyBot shows (when it is a screen of another).
+    /// The brain each AnyBot shows (when it is a screen of another), and which lend their hands.
     uses: Mutex<HashMap<String, String>>,
+    hands: Mutex<std::collections::HashSet<String>>,
+    /// 配對碼: code → (account, the AnyBot it is for, when made). Ten minutes, once.
+    pairs: Mutex<HashMap<String, (String, String, Instant)>>,
     /// When each host last asked (in memory; saved now and then).
     seen: Mutex<HashMap<String, Instant>>,
     fails: Mutex<HashMap<String, (u32, Instant)>>,
@@ -216,6 +221,8 @@ impl Relay {
             sockets: Mutex::new(HashMap::new()),
             flights: Mutex::new(HashMap::new()),
             uses: Mutex::new(HashMap::new()),
+            hands: Mutex::new(std::collections::HashSet::new()),
+            pairs: Mutex::new(HashMap::new()),
             seen: Mutex::new(HashMap::new()),
             fails: Mutex::new(HashMap::new()),
             invite: std::env::var("ANYBOT_RELAY_INVITE").unwrap_or_default(),
@@ -451,6 +458,11 @@ impl Relay {
                 });
             }
             "hello" => {
+                if head["hands"].as_bool().unwrap_or(false) {
+                    self.hands.lock().unwrap().insert(h.id.clone());
+                } else {
+                    self.hands.lock().unwrap().remove(&h.id);
+                }
                 let brain = s("brain");
                 let mut u = self.uses.lock().unwrap();
                 if brain.is_empty() {
@@ -548,19 +560,47 @@ impl Relay {
             ("POST", ["relay", "hosts"]) => {
                 let Some(user) = self.session(&req) else { return Resp::error(401, "請先登入") };
                 let name: String = req.json()["name"].as_str().unwrap_or("AnyBot").chars().take(60).collect();
-                let token = httpd::random_hex(32);
-                let h = Host { id: httpd::random_hex(8), name: name.clone(), user: user.clone(), token_hash: httpd::sha256_hex(&token), created: now(), last_seen: 0, members: vec![] };
-                let mut d = self.data.lock().unwrap();
-                // Signing the same computer in again replaces its old key (keeping who it's shared with).
-                let mut h = h;
-                if let Some(old) = d.hosts.iter().find(|x| x.user == user && x.name == name) {
-                    h.members = old.members.clone();
-                }
-                d.hosts.retain(|x| !(x.user == user && x.name == name));
-                d.hosts.push(h.clone());
-                self.save(&d);
+                let (h, token) = self.add_host(&user, &name);
                 Resp::json(&json!({"id": h.id, "token": token}))
             }
+            // 加一台電腦: a signed-in phone or AnyBot asks for a code; the new computer gives it back.
+            ("POST", ["relay", "pair"]) => {
+                let Some(user) = self.session(&req).or_else(|| self.host(&req).map(|h| h.user)) else { return Resp::error(401, "請先登入") };
+                let want = req.json()["for"].as_str().unwrap_or("").to_string();
+                let for_host = if self.data.lock().unwrap().hosts.iter().any(|h| h.id == want && h.user == user) { want } else { String::new() };
+                let mut pairs = self.pairs.lock().unwrap();
+                pairs.retain(|_, p| p.2.elapsed().as_secs() < PAIR_SECS);
+                let code = loop {
+                    let n = u32::from_str_radix(&httpd::random_hex(4), 16).unwrap_or(0) % 1_000_000;
+                    let c = format!("{n:06}");
+                    if !pairs.contains_key(&c) {
+                        break c;
+                    }
+                };
+                pairs.insert(code.clone(), (user, for_host, Instant::now()));
+                Resp::json(&json!({"code": code, "expires_in": PAIR_SECS}))
+            }
+            ("POST", ["relay", "pair", "claim"]) => {
+                let key = format!("pair:{}", req.peer);
+                if self.too_many_fails(&key) {
+                    return Resp::error(429, "配對碼錯太多次，請 5 分鐘後再試");
+                }
+                let v = req.json();
+                let code: String = v["code"].as_str().unwrap_or("").chars().filter(|c| c.is_ascii_digit()).collect();
+                let got = {
+                    let mut pairs = self.pairs.lock().unwrap();
+                    pairs.retain(|_, p| p.2.elapsed().as_secs() < PAIR_SECS);
+                    pairs.remove(&code)
+                };
+                let Some((user, for_host, _)) = got else {
+                    self.failed(&key);
+                    return Resp::error(404, "配對碼不對，或已經過期（10 分鐘內有效，只能用一次）");
+                };
+                let name: String = v["name"].as_str().unwrap_or("AnyBot").chars().take(60).collect();
+                let (h, token) = self.add_host(&user, &name);
+                let for_name = self.data.lock().unwrap().hosts.iter().find(|x| x.id == for_host).map(|x| x.name.clone()).unwrap_or_default();
+                Resp::json(&json!({"id": h.id, "token": token, "user": user, "for": for_host, "for_name": for_name}))
+            }
             ("POST", ["relay", "hosts", id, "remove"]) => {
                 let Some(user) = self.session(&req) else { return Resp::error(401, "請先登入") };
                 let mut d = self.data.lock().unwrap();
@@ -735,9 +775,24 @@ impl Relay {
         }
     }
 
+    /// Register an AnyBot of `user`. The same name again replaces its old key (keeping who it's
+    /// shared with).
+    fn add_host(&self, user: &str, name: &str) -> (Host, String) {
+        let token = httpd::random_hex(32);
+        let mut h = Host { id: httpd::random_hex(8), name: name.to_string(), user: user.to_string(), token_hash: httpd::sha256_hex(&token), created: now(), last_seen: 0, members: vec![] };
+        let mut d = self.data.lock().unwrap();
+        if let Some(old) = d.hosts.iter().find(|x| x.user == user && x.name == name) {
+            h.members = old.members.clone();
+        }
+        d.hosts.retain(|x| !(x.user == user && x.name == name));
+        d.hosts.push(h.clone());
+        self.save(&d);
+        (h, token)
+    }
+
     fn host_json(&self, h: &Host) -> Value {
         let online = self.online(&h.id);
-        json!({"id": h.id, "name": h.name, "online": online, "uses": self.uses.lock().unwrap().get(&h.id).cloned().unwrap_or_default(), "last_seen_text": if online { "在線上".to_string() } else if h.last_seen > 0 { chrono::DateTime::from_timestamp(h.last_seen, 0).map(|t| t.format("%m/%d %H:%M UTC").to_string()).unwrap_or_default() } else { "從未連線".into() }})
+        json!({"id": h.id, "name": h.name, "online": online, "uses": self.uses.lock().unwrap().get(&h.id).cloned().unwrap_or_default(), "hands": self.hands.lock().unwrap().contains(&h.id), "last_seen_text": if online { "在線上".to_string() } else if h.last_seen > 0 { chrono::DateTime::from_timestamp(h.last_seen, 0).map(|t| t.format("%m/%d %H:%M UTC").to_string()).unwrap_or_default() } else { "從未連線".into() }})
     }
 
     fn signup(&self, req: &Req) -> Resp {
@@ -979,4 +1034,41 @@ mod tests {
         assert_eq!(post(port, "/relay/host/sites/Bad_Name", &ht, json!({})).0, 400);
         let _ = std::fs::remove_dir_all(&dir);
     }
+
+    #[test]
+    fn a_pairing_code_adds_a_computer_once() {
+        let dir = std::env::temp_dir().join(format!("anybot-relay-pair-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        let relay = Arc::new(Relay::load(dir.clone()));
+        let l = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
+        let port = l.local_addr().unwrap().port();
+        let r = relay.clone();
+        std::thread::spawn(move || httpd::serve(l, Arc::new(move |req| r.handle(req)), Arc::new(|| true)));
+        post(port, "/relay/signup", "", json!({"user": "amy", "password": "12345678"}));
+        let (_, v) = post(port, "/relay/login", "", json!({"user": "amy", "password": "12345678", "device": "phone"}));
+        let session = v["token"].as_str().unwrap().to_string();
+        let (_, brain) = post(port, "/relay/hosts", &session, json!({"name": "雲端大腦"}));
+        // Asked from the phone, for the brain.
+        let (st, p) = post(port, "/relay/pair", &session, json!({"for": brain["id"]}));
+        assert_eq!(st, 200);
+        let code = p["code"].as_str().unwrap().to_string();
+        assert_eq!(code.len(), 6);
+        // Without signing in: no code.
+        assert_eq!(post(port, "/relay/pair", "", json!({})).0, 401);
+        let (st, h) = post(port, "/relay/pair/claim", "", json!({"code": format!("{} {}", &code[..3], &code[3..]), "name": "書房電腦"}));
+        assert_eq!(st, 200, "{h}");
+        assert_eq!(h["user"], "amy");
+        assert_eq!(h["for_name"], "雲端大腦");
+        // The new computer's key works.
+        let (st, peers) = get(port, "/relay/host/peers", h["token"].as_str().unwrap());
+        assert_eq!(st, 200);
+        assert!(String::from_utf8_lossy(&peers).contains("雲端大腦"));
+        // Once only; a wrong code is refused, and guessing is stopped.
+        assert_eq!(post(port, "/relay/pair/claim", "", json!({"code": code, "name": "x"})).0, 404);
+        for _ in 0..10 {
+            post(port, "/relay/pair/claim", "", json!({"code": "000000", "name": "x"}));
+        }
+        assert_eq!(post(port, "/relay/pair/claim", "", json!({"code": "000000", "name": "x"})).0, 429);
+        let _ = std::fs::remove_dir_all(&dir);
+    }
 }
diff --git a/src/app/mirror_ui.rs b/src/app/mirror_ui.rs
index d4c4dd4..b0644a4 100644
--- a/src/app/mirror_ui.rs
+++ b/src/app/mirror_ui.rs
@@ -389,6 +389,8 @@ pub struct Mirror {
     down_since: Option<Instant>,
     /// Files from the brain being fetched (by local path).
     fetching: std::collections::HashSet<String>,
+    /// 加一台電腦: the line to run on the new computer (or why there is none), and when it was made.
+    pub(super) pair: Arc<Mutex<(String, bool, Option<Instant>)>>,
 }
 
 /// Where a screen keeps its copy of a file the brain has.
@@ -726,7 +728,7 @@ impl App {
         *self.mir.status.lock().unwrap() = "正在連到大腦…".into();
         self.mirror_worker();
         self.mirror_outbox();
-        crate::tunnel::hello(&self.state.remote.brain_id);
+        crate::tunnel::hello(&self.state.remote.brain_id, self.state.remote.device_link);
     }
 
     /// Back to this computer's own bots.
@@ -758,7 +760,7 @@ impl App {
         }
         self.state.save();
         self.dirty = false;
-        crate::tunnel::hello("");
+        crate::tunnel::hello("", self.state.remote.device_link);
     }
 
     fn keep_local_fields(&mut self, from: &State) {
diff --git a/src/app/remote_ui.rs b/src/app/remote_ui.rs
index 08dc09e..1ebcb8b 100644
--- a/src/app/remote_ui.rs
+++ b/src/app/remote_ui.rs
@@ -145,6 +145,62 @@ impl App {
         }
     }
 
+    /// 加一台電腦: one line to run on the new computer (a Linux box, a server); it joins as hands for
+    /// the brain, with no password and nothing to answer.
+    fn pair_section(&mut self, ui: &mut egui::Ui) {
+        let p = self.pal;
+        ui.add_space(6.0);
+        ui.separator();
+        ui.horizontal(|ui| {
+            ui.label(RichText::new(t("加一台電腦")).size(13.5).strong());
+            help_mark(ui, "讓另一台電腦（例如沒有螢幕的 Linux）也當大腦的手腳：在那台的終端機貼上這一行就好，不用帳號密碼、不用回答問題。它會設成開機自動執行，只讓這個大腦使用。", p);
+            ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
+                if ui.add(secondary_button("產生配對碼")).clicked() {
+                    let (s, slot) = (self.state.remote.clone(), self.mir.pair.clone());
+                    let for_host = if self.mir.on { s.brain_id.clone() } else { s.host_id.clone() };
+                    *slot.lock().unwrap() = (t("正在產生…"), false, None);
+                    std::thread::spawn(move || {
+                        *slot.lock().unwrap() = match crate::remote::pair_code(&s, &for_host) {
+                            Ok(code) => (format!("anybot setup {} {code}", s.relay_url), true, Some(Instant::now())),
+                            Err(e) => (e, false, None),
+                        };
+                    });
+                }
+            });
+        });
+        let (line, ok, at) = self.mir.pair.lock().unwrap().clone();
+        if line.is_empty() {
+            return;
+        }
+        let left = at.map(|t| 600u64.saturating_sub(t.elapsed().as_secs())).unwrap_or(0);
+        if ok && left == 0 {
+            hint(ui, "配對碼過期了，再按一次「產生配對碼」。", p);
+            return;
+        }
+        if !ok {
+            let c = if line.ends_with('…') { p.text2 } else { p.danger };
+            ui.label(RichText::new(line).size(12.5).color(c));
+            return;
+        }
+        Frame::new().fill(p.hover).corner_radius(8).inner_margin(Margin::symmetric(10, 8)).show(ui, |ui| {
+            ui.horizontal(|ui| {
+                ui.add(egui::Label::new(RichText::new(&line).monospace().size(13.0)).selectable(true).wrap());
+                ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
+                    if ui.add(secondary_button("複製")).clicked() {
+                        ui.ctx().copy_text(line.clone());
+                        self.notice = Some(t("已複製，貼到那台電腦的終端機執行"));
+                    }
+                });
+            });
+        });
+        ui.label(RichText::new(format!("{}（還有 {} 分 {:02} 秒，只能用一次）", t("在那台電腦的終端機貼上執行"), left / 60, left % 60)).size(12.0).color(p.text3));
+        // Just made: bring it into view.
+        if at.map(|t| t.elapsed().as_millis() < 800).unwrap_or(false) {
+            ui.scroll_to_cursor(Some(Align::Max));
+        }
+        ui.ctx().request_repaint_after(std::time::Duration::from_secs(1));
+    }
+
     fn remote_signature(&self) -> u64 {
         let mut h = std::collections::hash_map::DefaultHasher::new();
         self.state.remote.host_name.hash(&mut h);
@@ -441,9 +497,9 @@ impl App {
                 } else {
                     ui.label(RichText::new(t("這台就是大腦：Bot 在這台電腦上思考和工作。")).size(13.0).color(p.text2));
                     let me = s.host_id.clone();
-                    let peers: Vec<(String, String, bool)> = self.rm.peers.lock().unwrap().iter().filter(|(id, _, _)| !id.is_empty() && *id != me).cloned().collect();
+                    let peers: Vec<(String, String, bool)> = self.rm.peers.lock().unwrap().iter().filter(|(id, _, _)| !id.is_empty() && *id != me && !remote::is_hands(id)).cloned().collect();
                     if peers.is_empty() {
-                        hint(ui, "帳號裡還沒有其他 AnyBot。在伺服器上啟動 anybot --serve 並登入同一個帳號，它就會出現在這裡。", p);
+                        hint(ui, "帳號裡還沒有別台可以當大腦的 AnyBot。", p);
                     }
                     for (id, name, online) in peers {
                         ui.horizontal(|ui| {
@@ -461,6 +517,7 @@ impl App {
                         });
                     }
                 }
+                self.pair_section(ui);
             });
         }
 
diff --git a/src/remote.rs b/src/remote.rs
index a40e20a..1a4ac4a 100644
--- a/src/remote.rs
+++ b/src/remote.rs
@@ -1090,6 +1090,32 @@ pub fn set_member(s: &Settings, user: &str, role: &str) -> Result<(), String> {
 }
 
 /// The other AnyBots signed in to this account (for 裝置連結).
+/// 加一台電腦: a code (ten minutes, once) another computer uses to join this account, as hands for
+/// `for_host` (empty = any AnyBot of the account).
+pub fn pair_code(s: &Settings, for_host: &str) -> Result<String, String> {
+    let v = relay_post(&format!("{}/relay/pair", s.relay_url), &s.host_token, &json!({"for": for_host}))?;
+    v["code"].as_str().map(String::from).ok_or("帳號伺服器沒有給配對碼".into())
+}
+
+/// Join the account with a 配對碼 (no password). Gives the settings to keep.
+pub fn pair_claim(base_settings: &Settings, url: &str, code: &str) -> Result<Settings, String> {
+    let url = check_server(url)?;
+    let v = relay_post(&format!("{url}/relay/pair/claim"), "", &json!({"code": code, "name": base_settings.host_name}))?;
+    let mut s = base_settings.clone();
+    s.relay_url = url;
+    s.relay_user = v["user"].as_str().unwrap_or("").to_string();
+    s.host_id = v["id"].as_str().unwrap_or("").to_string();
+    s.host_token = v["token"].as_str().unwrap_or("").to_string();
+    // No password here, so no key for backups (hands keep nothing to back up).
+    s.backup_key.clear();
+    s.hands_for = v["for"].as_str().unwrap_or("").to_string();
+    s.hands_for_name = v["for_name"].as_str().unwrap_or("").to_string();
+    if s.host_id.is_empty() || s.host_token.is_empty() {
+        return Err("帳號伺服器沒有給這台電腦的金鑰".into());
+    }
+    Ok(s)
+}
+
 /// The account's AnyBots as the account server sees them (for choosing a brain).
 pub fn peers(s: &Settings) -> Result<Vec<Value>, String> {
     let mut r = agent(15).get(&format!("{}/relay/host/peers", s.relay_url)).header("Authorization", &format!("Bearer {}", s.host_token)).call().map_err(|e| format!("連不到帳號伺服器：{}", why_unreachable(&e)))?;
@@ -1120,12 +1146,23 @@ pub fn check_server(url: &str) -> Result<String, String> {
     Ok(u)
 }
 
+/// AnyBots of the account that lend their hands (not offered as a brain).
+pub fn is_hands(id: &str) -> bool {
+    hands_ids().lock().unwrap().contains(id)
+}
+
+fn hands_ids() -> &'static Mutex<std::collections::HashSet<String>> {
+    static H: OnceLock<Mutex<std::collections::HashSet<String>>> = OnceLock::new();
+    H.get_or_init(Mutex::default)
+}
+
 pub fn devices_online(s: &Settings) -> Vec<(String, String, bool)> {
     if s.relay_url.is_empty() {
         return vec![];
     }
     let Ok(mut r) = agent(10).get(&format!("{}/relay/host/peers", s.relay_url)).header("Authorization", &format!("Bearer {}", s.host_token)).call() else { return vec![] };
     let v: Value = serde_json::from_str(&r.body_mut().read_to_string().unwrap_or_default()).unwrap_or(Value::Null);
+    *hands_ids().lock().unwrap() = v["hosts"].as_array().into_iter().flatten().filter(|h| h["hands"].as_bool() == Some(true) || !h["uses"].as_str().unwrap_or("").is_empty()).filter_map(|h| h["id"].as_str().map(String::from)).collect();
     v["hosts"].as_array().map(|a| a.iter().map(|h| (h["id"].as_str().unwrap_or("").to_string(), h["name"].as_str().unwrap_or("").to_string(), h["online"].as_bool().unwrap_or(false))).collect()).unwrap_or_default()
 }
 
diff --git a/src/setup.rs b/src/setup.rs
index 4dac0f4..2236a19 100644
--- a/src/setup.rs
+++ b/src/setup.rs
@@ -1,13 +1,16 @@
-// `anybot setup`: a guided setup in the terminal, for computers set up over SSH or without a
-// window (a server, a Linux box). Five short steps: what this computer is (大腦 or 手腳), its
-// name, the account server, the account, and — for hands — which brain may use it, picked from
-// the account's AnyBots as they are right now. Then it saves the settings, makes AnyBot start with
-// the computer (systemd), and waits until the account server and the brain see it.
+// `anybot setup`: join this computer to your AnyBot, as hands for your brain (or as a brain), from
+// a terminal (over SSH, or on a computer without a window). As little to answer as possible:
 //
-// Without a terminal (a script), the same can be given as flags:
-//   anybot setup --role hands --name 書房電腦 --server https://anybot.example.com --user me
-//                --brain 雲端大腦 [--create] [--invite 碼] [--no-service]
-// with the password in ANYBOT_ACCOUNT_PASSWORD (or on stdin with --password-stdin).
+//   anybot setup https://anybot.example.com 482913   the line 「加一台電腦」 shows on the phone or in
+//                                                    the app: nothing to answer at all
+//   anybot setup                                     one screen: the address and the code (or the
+//                                                    account and password instead)
+//   anybot setup --brain …                           this computer is a brain, not hands
+//
+// Then it saves the settings, makes AnyBot start with the computer (systemd; a virtual screen when
+// there is none), and waits until the account server and the brain see it. For scripts:
+//   anybot setup --server URL --user NAME [--brain-name 雲端大腦] [--no-service]
+// with the password in ANYBOT_ACCOUNT_PASSWORD.
 
 use crate::model::State;
 use crate::remote::{self, Settings};
@@ -35,12 +38,8 @@ enum Role {
 
 #[derive(Clone, Copy, PartialEq, Debug)]
 enum Step {
-    Role,
-    Name,
-    Server,
-    Account,
+    Form,
     Brain,
-    Confirm,
     Install,
     Done,
 }
@@ -63,9 +62,8 @@ enum Mark {
 }
 
 enum Msg {
-    Server(Result<String, String>),
-    Joined(Result<Settings, String>),
-    Peers(Result<Vec<Peer>, String>),
+    /// Joined the account; with a code, the brain it was made for.
+    Joined(Result<(Settings, Option<Peer>, Vec<Peer>), String>),
     Progress(usize, Mark, String),
     Finished(Vec<String>),
 }
@@ -76,7 +74,6 @@ struct Env {
     linux: bool,
     display: String,
     systemd: bool,
-    xvfb: bool,
 }
 
 impl Env {
@@ -95,33 +92,11 @@ impl Env {
                     !out.trim().is_empty() && !out.contains("offline")
                 })
                 .unwrap_or(false);
-        Env { linux, display, systemd, xvfb: which("xvfb-run") }
+        Env { linux, display, systemd }
     }
     fn has_display(&self) -> bool {
         !self.display.is_empty()
     }
-    fn summary(&self) -> String {
-        let os = if self.linux {
-            "Linux"
-        } else if cfg!(target_os = "macos") {
-            "macOS"
-        } else {
-            "Windows"
-        };
-        let screen = if self.has_display() {
-            "有螢幕"
-        } else if self.xvfb {
-            "沒有螢幕（會開一個虛擬螢幕）"
-        } else {
-            "沒有螢幕"
-        };
-        let service = if self.systemd { "會設成開機自動執行" } else { "沒有 systemd（要自己啟動）" };
-        format!("這台：{os} · {screen} · {service}")
-    }
-}
-
-fn which(cmd: &str) -> bool {
-    std::env::var_os("PATH").map(|p| std::env::split_paths(&p).any(|d| d.join(cmd).is_file())).unwrap_or(false)
 }
 
 // ---------- drawing ----------
@@ -219,17 +194,16 @@ struct Wiz {
     env: Env,
     step: Step,
     role: Role,
-    sel: usize,
-    name: String,
+    /// Sign in with the account and password instead of a code.
+    password: bool,
     url: String,
+    code: String,
     user: String,
     pass: String,
-    invite: String,
-    create: bool,
     focus: usize,
-    server: String,
     joined: Option<Settings>,
     peers: Vec<Peer>,
+    sel: usize,
     brain: Option<Peer>,
     busy: Option<String>,
     rx: Option<Receiver<Msg>>,
@@ -241,29 +215,26 @@ struct Wiz {
     ok: bool,
     quit: bool,
     service: bool,
-    saved: Settings,
+    name: Option<String>,
 }
 
 impl Wiz {
-    fn new() -> Wiz {
-        let st = State::load();
-        let saved = st.remote.clone();
+    fn new(role: Role) -> Wiz {
+        let saved = State::load().remote;
         let (tx, rx) = channel();
         let env = Env::detect();
         Wiz {
-            role: if saved.device_link || !env.has_display() { Role::Hands } else { Role::Brain },
-            sel: if saved.device_link || !env.has_display() { 0 } else { 1 },
-            step: Step::Role,
-            name: if saved.host_name.is_empty() { remote::default_host_name() } else { saved.host_name.clone() },
+            role,
+            password: false,
+            step: Step::Form,
             url: saved.relay_url.clone(),
+            code: String::new(),
             user: saved.relay_user.clone(),
             pass: String::new(),
-            invite: String::new(),
-            create: false,
-            focus: if saved.relay_user.is_empty() { 0 } else { 1 },
-            server: String::new(),
+            focus: if saved.relay_url.is_empty() { 0 } else { 1 },
             joined: None,
             peers: vec![],
+            sel: 0,
             brain: None,
             busy: None,
             rx: Some(rx),
@@ -275,42 +246,32 @@ impl Wiz {
             ok: false,
             quit: false,
             service: env.systemd,
-            saved,
             env,
+            name: None,
         }
     }
 
-    fn crumbs(&self) -> Vec<&'static str> {
-        let role = if self.step == Step::Role { if self.sel == 0 { Role::Hands } else { Role::Brain } } else { self.role };
-        match role {
-            Role::Hands => vec!["角色", "名字", "帳號", "大腦", "完成"],
-            Role::Brain => vec!["角色", "名字", "帳號", "完成"],
+    /// The rows of the form: text fields, then the switch to the other way of signing in.
+    fn rows(&self) -> usize {
+        if self.password {
+            4
+        } else {
+            3
         }
     }
 
-    fn crumb_at(&self) -> usize {
-        let last = self.crumbs().len() - 1;
+    fn title(&self) -> (String, String) {
         match self.step {
-            Step::Role => 0,
-            Step::Name => 1,
-            Step::Server | Step::Account => 2,
-            Step::Brain => 3,
-            Step::Confirm | Step::Install | Step::Done => last,
-        }
-    }
-
-    // ----- what each step shows -----
-
-    fn title(&self) -> (&'static str, String) {
-        match self.step {
-            Step::Role => ("這台電腦要做什麼？", "之後隨時可以再執行 anybot setup 改。".into()),
-            Step::Name => ("這台電腦叫什麼？", "手機、大腦和其他電腦上看到的名字。".into()),
-            Step::Server => ("帳號伺服器在哪裡？", "就是手機登入 AnyBot 的那個網址，例如 https://anybot.example.com".into()),
-            Step::Account => ("登入帳號", "和手機、大腦用同一個帳號。密碼只用來登入，不會存在這台電腦上。".into()),
-            Step::Brain => ("要當哪個大腦的手腳？", "只有選的大腦能使用這台電腦；它的 Bot 每個動作仍照大腦的規則先問你。".into()),
-            Step::Confirm => ("確認一下", "按 Enter 開始設定。".into()),
-            Step::Install => (if self.ok { "設定好了" } else { "正在設定…" }, String::new()),
-            Step::Done => (if self.ok { "設定好了" } else { "沒有完成" }, String::new()),
+            Step::Form => (
+                match self.role {
+                    Role::Hands => "把這台電腦接到你的 AnyBot".into(),
+                    Role::Brain => "把這台設成大腦".into(),
+                },
+                if self.password { "用手機登入 AnyBot 的那個網址和帳號。".into() } else { "在手機或電腦的 AnyBot 按「加一台電腦」，會看到網址和配對碼。".into() },
+            ),
+            Step::Brain => ("要給哪個大腦用？".into(), "帳號裡有好幾台，選一台：只有它能用這台電腦。".into()),
+            Step::Install => ("正在設定…".into(), String::new()),
+            Step::Done => (if self.ok { "好了".into() } else { "沒有完成".into() }, String::new()),
         }
     }
 
@@ -334,40 +295,20 @@ impl Wiz {
     fn body(&self, w: usize) -> Vec<Line> {
         let mut b: Vec<Line> = vec![];
         match self.step {
-            Step::Role => {
-                let opts = [
-                    ("手腳", "讓大腦的 Bot 使用這台電腦：看畫面、點擊打字、檔案和指令、這台的瀏覽器。"),
-                    ("大腦", "這台保存所有 Bot、聊天、記憶和排程，一直開著；其他電腦和手機都連到它。"),
-                ];
-                for (i, (name, desc)) in opts.iter().enumerate() {
-                    let on = self.sel == i;
-                    b.push(vec![if on { colored("❯ ", ACC) } else { plain("  ") }, sp(if on { "● " } else { "○ " }, Some(if on { ACC } else { DIM }), false), sp(*name, if on { Some(ACC) } else { None }, true)]);
-                    b.extend(para(desc, 6, w, dim));
-                    b.push(vec![]);
-                }
-                b.push(vec![dim(self.env.summary())]);
-            }
-            Step::Name => b.push(self.field("名字", &self.name, true, false, "")),
-            Step::Server => b.push(self.field("網址", &self.url, true, false, "https://…")),
-            Step::Account => {
-                let reuse = self.can_reuse();
-                b.push(self.field("帳號", &self.user, self.focus == 0, false, "帳號名稱"));
-                b.push(self.field("密碼", &self.pass, self.focus == 1, true, if reuse { "已登入過，留空直接沿用" } else { "" }));
-                b.push(vec![
-                    if self.focus == 2 { colored("❯ ", ACC) } else { plain("  ") },
-                    sp(if self.create { "■ " } else { "□ " }, Some(if self.focus == 2 { ACC } else { DIM }), false),
-                    sp("這是新帳號（第一次用這台伺服器）", if self.focus == 2 { Some(ACC) } else { None }, false),
-                    dim(if self.focus == 2 { "  空白鍵切換" } else { "" }),
-                ]);
-                if self.create {
-                    b.push(self.field("邀請碼", &self.invite, self.focus == 3, false, "伺服器管理員給的（第一個帳號不用）"));
+            Step::Form => {
+                b.push(self.field("網址", &self.url, self.focus == 0, false, "https://…"));
+                if self.password {
+                    b.push(self.field("帳號", &self.user, self.focus == 1, false, ""));
+                    b.push(self.field("密碼", &self.pass, self.focus == 2, true, ""));
+                } else {
+                    b.push(self.field("配對碼", &self.code, self.focus == 1, false, "6 位數字"));
                 }
+                b.push(vec![]);
+                let on = self.focus == self.rows() - 1;
+                let other = if self.password { "改用配對碼 ›" } else { "沒有配對碼？用帳號密碼登入 ›" };
+                b.push(vec![if on { colored("❯ ", ACC) } else { plain("  ") }, sp(other, Some(if on { ACC } else { DIM }), false)]);
             }
             Step::Brain => {
-                if self.peers.is_empty() && self.busy.is_none() {
-                    b.extend(para("帳號裡還沒有其他 AnyBot。先把大腦裝好（伺服器上執行 deploy/server/setup.sh，或在一台電腦上開 AnyBot 登入帳號），再按 r 重新整理。", 0, w, plain));
-                    b.push(vec![]);
-                }
                 for (i, p) in self.peers.iter().enumerate() {
                     let on = self.sel == i;
                     let status = if p.online { colored("在線上", GOOD) } else { dim(format!("離線（{}）", p.last)) };
@@ -375,67 +316,8 @@ impl Wiz {
                     let pad = 28usize.saturating_sub(name.width());
                     b.push(vec![if on { colored("❯ ", ACC) } else { plain("  ") }, sp(if p.online { "● " } else { "○ " }, Some(if p.online { GOOD } else { DIM }), false), sp(name, if on { Some(ACC) } else { None }, true), plain(" ".repeat(pad)), status]);
                 }
-                let i = self.peers.len();
-                let on = self.sel == i;
-                if !self.peers.is_empty() {
-                    b.push(vec![]);
-                }
-                b.push(vec![if on { colored("❯ ", ACC) } else { plain("  ") }, sp("○ ", Some(DIM), false), sp("不指定", if on { Some(ACC) } else { None }, true)]);
-                b.extend(para("帳號裡任何一台 AnyBot 都能使用這台電腦。", 6, w, dim));
-            }
-            Step::Confirm => {
-                let row = |k: &str, v: String| vec![dim(format!("{k}{}", " ".repeat(14usize.saturating_sub(k.width())))), strong(v)];
-                b.push(row("這台是", match self.role { Role::Hands => "手腳".into(), Role::Brain => "大腦".into() }));
-                b.push(row("名字", self.name.clone()));
-                b.push(row("帳號伺服器", self.server.clone()));
-                b.push(row("帳號", self.user.clone()));
-                if self.role == Role::Hands {
-                    b.push(row("給哪個大腦用", self.brain.as_ref().map(|p| p.name.clone()).unwrap_or_else(|| "不指定（帳號裡任何一台）".into())));
-                    let screen = if self.env.has_display() {
-                        "用這台的螢幕".to_string()
-                    } else if self.env.xvfb {
-                        "開一個 1440×900 的虛擬螢幕".to_string()
-                    } else {
-                        "沒有螢幕：只能用檔案和指令".to_string()
-                    };
-                    b.push(row("螢幕", screen));
-                }
-                b.push(row("開機自動執行", if self.service { "會（systemd 使用者服務 anybot）".into() } else if self.env.linux { "不會（這台沒有 systemd）".into() } else { "不會（請開 AnyBot App）".into() }));
-                if self.role == Role::Hands && !self.env.has_display() && !self.env.xvfb && self.env.linux {
-                    b.push(vec![]);
-                    b.extend(para("想讓 Bot 看這台的畫面、操作程式：先執行 ./deploy/linux/hands.sh --deps 裝好虛擬螢幕，再回來。", 0, w, |s| colored(s, WARN)));
-                }
-            }
-            Step::Install | Step::Done => {
-                for (label, mark, note) in &self.progress {
-                    let icon = match mark {
-                        Mark::Wait => dim("·"),
-                        Mark::Run => colored(SPIN[self.spin % SPIN.len()], ACC),
-                        Mark::Ok => colored("✓", GOOD),
-                        Mark::Warn => colored("!", WARN),
-                        Mark::Fail => colored("✗", BAD),
-                    };
-                    b.push(vec![icon, plain(" "), sp(label.clone(), if *mark == Mark::Wait { Some(DIM) } else { None }, *mark == Mark::Run)]);
-                    if !note.is_empty() {
-                        let c = match mark {
-                            Mark::Fail => BAD,
-                            Mark::Warn => WARN,
-                            _ => DIM,
-                        };
-                        b.extend(para(note, 2, w, if c == BAD { |s| colored(s, BAD) } else if c == WARN { |s| colored(s, WARN) } else { dim }));
-                    }
-                }
-                if !self.tips.is_empty() {
-                    b.push(vec![]);
-                    for t in &self.tips {
-                        if let Some((k, v)) = t.split_once('\t') {
-                            b.push(vec![dim(format!("{k}{}", " ".repeat(10usize.saturating_sub(k.width())))), colored(v.to_string(), ACC)]);
-                        } else {
-                            b.extend(para(t, 0, w, plain));
-                        }
-                    }
-                }
             }
+            Step::Install | Step::Done => b.extend(progress_lines(&self.progress, &self.tips, self.spin, w)),
         }
         if let Some(what) = &self.busy {
             b.push(vec![]);
@@ -443,107 +325,32 @@ impl Wiz {
         }
         if !self.error.is_empty() {
             b.push(vec![]);
-            for l in wrap(&self.error, w.saturating_sub(2)) {
-                b.push(vec![colored(if b.last().map(|x| x.is_empty()).unwrap_or(true) { "✗ " } else { "  " }, BAD), colored(l, BAD)]);
+            for (i, l) in wrap(&self.error, w.saturating_sub(2)).into_iter().enumerate() {
+                b.push(vec![colored(if i == 0 { "✗ " } else { "  " }, BAD), colored(l, BAD)]);
             }
         }
         b
     }
 
     fn keys(&self) -> &'static str {
-        if self.busy.is_some() {
+        if self.busy.is_some() || self.step == Step::Install {
             return "Ctrl+C 離開";
         }
         match self.step {
-            Step::Brain => "↑↓ 選擇   Enter 確定   r 重新整理   Esc 上一步",
-            Step::Role => "↑↓ 選擇   Enter 下一步   Esc 離開",
-            Step::Account => "↑↓ 換欄位   Enter 登入   Esc 上一步",
-            Step::Confirm => "Enter 開始設定   Esc 上一步",
-            Step::Install => "Ctrl+C 離開",
-            Step::Done => "Enter 離開",
-            _ => "Enter 下一步   Esc 上一步",
+            Step::Form => "Enter 連線   ↑↓ 換欄位   Esc 離開",
+            Step::Brain => "↑↓ 選擇   Enter 確定",
+            _ => "Enter 離開",
         }
     }
 
     fn render(&self, out: &mut impl Write) -> std::io::Result<()> {
         let (cols, rows) = terminal::size().unwrap_or((80, 24));
-        let cols = cols as usize;
-        let w = cols.saturating_sub(4).clamp(36, 78);
-        let inner = w - 4;
-        let mut lines: Vec<Line> = vec![vec![]];
-        // Header: the name, and where we are.
-        let mut head = vec![plain("  "), colored("◆ ", ACC), strong("AnyBot 設定")];
-        let at = self.crumb_at();
-        let mut crumbs: Line = vec![plain("  ")];
-        for (i, c) in self.crumbs().iter().enumerate() {
-            if i > 0 {
-                crumbs.push(dim(" ─ "));
-            }
-            let done = i < at || (self.step == Step::Done && self.ok);
-            crumbs.push(if done {
-                colored(format!("✓ {c}"), GOOD)
-            } else if i == at {
-                sp(format!("{} {c}", i + 1), Some(ACC), true)
-            } else {
-                dim(format!("{} {c}", i + 1))
-            });
-        }
-        if width(&head) + width(&crumbs) + 4 <= w + 2 {
-            let gap = (w + 2).saturating_sub(width(&head) + width(&crumbs));
-            head.push(plain(" ".repeat(gap)));
-            head.extend(crumbs.into_iter().skip(1));
-            lines.push(head);
-        } else {
-            lines.push(head);
-            lines.push(crumbs);
-        }
-        lines.push(vec![]);
-        // The card.
         let (title, sub) = self.title();
-        let mut card: Vec<Line> = vec![vec![], vec![strong(title)]];
-        if !sub.is_empty() {
-            card.extend(para(&sub, 0, inner, dim));
-        }
-        card.push(vec![]);
-        card.extend(self.body(inner));
-        card.push(vec![]);
-        let edge = |l: &str, r: &str| vec![plain("  "), dim(format!("{l}{}{r}", "─".repeat(w - 2)))];
-        lines.push(edge("╭", "╮"));
-        for l in card {
-            let l = clip(l, inner);
-            let pad = inner.saturating_sub(width(&l));
-            let mut row = vec![plain("  "), dim("│ ")];
-            row.extend(l);
-            row.push(plain(" ".repeat(pad)));
-            row.push(dim(" │"));
-            lines.push(row);
-        }
-        lines.push(edge("╰", "╯"));
-        lines.push(vec![plain("   "), dim(self.keys())]);
-
-        queue!(out, terminal::BeginSynchronizedUpdate, terminal::Clear(terminal::ClearType::All))?;
-        for (y, l) in lines.into_iter().enumerate().take(rows as usize) {
-            queue!(out, cursor::MoveTo(0, y as u16))?;
-            for (s, st) in clip(l, cols) {
-                if let Some(c) = st.fg {
-                    queue!(out, SetForegroundColor(c))?;
-                }
-                if st.bold {
-                    queue!(out, SetAttribute(Attribute::Bold))?;
-                }
-                queue!(out, Print(s), SetAttribute(Attribute::Reset), ResetColor)?;
-            }
-        }
-        queue!(out, terminal::EndSynchronizedUpdate)?;
-        out.flush()
+        let lines = card_page(cols as usize, &title, &sub, |w| self.body(w), self.keys());
+        draw(out, lines, cols as usize, rows as usize)
     }
 
-    // ----- moving through the steps -----
-
-    fn can_reuse(&self) -> bool {
-        let s = &self.saved;
-        !s.host_token.is_empty() && s.relay_url == self.server && s.relay_user == self.user.trim() && s.host_name == self.name.trim()
-    }
+    // ----- moving along -----
 
     fn start(&mut self, what: &str, job: impl FnOnce() -> Msg + Send + 'static) {
         self.error.clear();
@@ -554,53 +361,55 @@ impl Wiz {
         });
     }
 
-    fn load_peers(&mut self) {
-        let Some(s) = self.joined.clone() else { return };
-        self.start("正在找帳號裡的大腦…", move || Msg::Peers(list_brains(&s)));
+    fn submit(&mut self) {
+        let base = base_settings(self.name.clone());
+        let url = self.url.clone();
+        if self.password {
+            let (user, pass) = (self.user.trim().to_string(), self.pass.clone());
+            if user.is_empty() || pass.is_empty() {
+                self.error = "請輸入帳號和密碼".into();
+                return;
+            }
+            self.start("正在登入…", move || Msg::Joined(join_with_password(&base, &url, &user, &pass)));
+        } else {
+            let code: String = self.code.chars().filter(|c| c.is_ascii_digit()).collect();
+            if code.len() != 6 {
+                self.error = "配對碼是 6 位數字".into();
+                self.focus = 1;
+                return;
+            }
+            self.start("正在連線…", move || Msg::Joined(remote::pair_claim(&base, &url, &code).map(|s| (s.clone(), brain_of(&s), vec![]))));
+        }
+    }
+
+    fn install(&mut self) {
+        self.step = Step::Install;
+        let plan = Plan { role: self.role, settings: self.joined.clone().unwrap_or_default(), brain: self.brain.clone(), env: self.env.clone(), service: self.service };
+        self.progress = plan.steps().into_iter().map(|s| (s, Mark::Wait, String::new())).collect();
+        let tx = self.tx.clone();
+        std::thread::spawn(move || plan.run(&tx));
     }
 
     fn on_msg(&mut self, m: Msg) {
         match m {
-            Msg::Server(r) => {
-                self.busy = None;
-                match r {
-                    Ok(u) => {
-                        self.server = u.clone();
-                        self.url = u;
-                        self.focus = if self.user.is_empty() { 0 } else { 1 };
-                        self.step = Step::Account;
-                    }
-                    Err(e) => self.error = e,
-                }
-            }
             Msg::Joined(r) => {
                 self.busy = None;
                 match r {
-                    Ok(s) => {
+                    Ok((s, brain, choices)) => {
                         self.joined = Some(s);
                         self.pass.clear();
-                        match self.role {
-                            Role::Hands => {
-                                self.step = Step::Brain;
-                                self.load_peers();
-                            }
-                            Role::Brain => self.step = Step::Confirm,
+                        if self.role == Role::Hands && brain.is_none() && choices.len() > 1 {
+                            self.sel = choices.iter().position(|p| p.online).unwrap_or(0);
+                            self.peers = choices;
+                            self.step = Step::Brain;
+                        } else {
+                            self.brain = brain;
+                            self.install();
                         }
                     }
                     Err(e) => self.error = e,
                 }
             }
-            Msg::Peers(r) => {
-                self.busy = None;
-                match r {
-                    Ok(p) => {
-                        let want = if self.saved.hands_for.is_empty() { None } else { p.iter().position(|x| x.id == self.saved.hands_for) };
-                        self.sel = want.or_else(|| p.iter().position(|x| x.online)).unwrap_or(0);
-                        self.peers = p;
-                    }
-                    Err(e) => self.error = e,
-                }
-            }
             Msg::Progress(i, mark, note) => {
                 if let Some(p) = self.progress.get_mut(i) {
                     p.1 = mark;
@@ -615,89 +424,6 @@ impl Wiz {
         }
     }
 
-    fn back(&mut self) {
-        self.error.clear();
-        self.step = match self.step {
-            Step::Role => {
-                self.quit = true;
-                Step::Role
-            }
-            Step::Name => Step::Role,
-            Step::Server => Step::Name,
-            Step::Account => Step::Server,
-            Step::Brain => Step::Account,
-            Step::Confirm if self.role == Role::Hands => Step::Brain,
-            Step::Confirm => Step::Account,
-            s => s,
-        };
-        if self.step == Step::Role {
-            self.sel = if self.role == Role::Hands { 0 } else { 1 };
-        }
-    }
-
-    fn enter(&mut self) {
-        self.error.clear();
-        match self.step {
-            Step::Role => {
-                self.role = if self.sel == 0 { Role::Hands } else { Role::Brain };
-                self.step = Step::Name;
-            }
-            Step::Name => {
-                let n = self.name.trim().to_string();
-                if n.is_empty() || n.chars().count() > 60 {
-                    self.error = "名字要 1 到 60 個字".into();
-                    return;
-                }
-                self.name = n;
-                self.step = Step::Server;
-            }
-            Step::Server => {
-                let u = self.url.clone();
-                self.start("正在找帳號伺服器…", move || Msg::Server(remote::check_server(&u)));
-            }
-            Step::Account => {
-                // Enter on the name goes to the password first.
-                if self.focus == 0 && self.pass.is_empty() && !self.can_reuse() {
-                    self.focus = 1;
-                    return;
-                }
-                let user = self.user.trim().to_string();
-                if user.is_empty() {
-                    self.error = "請輸入帳號".into();
-                    self.focus = 0;
-                    return;
-                }
-                if self.pass.is_empty() {
-                    if self.can_reuse() {
-                        self.joined = Some(self.saved.clone());
-                        self.on_msg(Msg::Joined(Ok(self.saved.clone())));
-                        return;
-                    }
-                    self.error = "請輸入密碼".into();
-                    self.focus = 1;
-                    return;
-                }
-                let mut base = self.saved.clone();
-                base.host_name = self.name.clone();
-                let (url, pass, create, invite) = (self.server.clone(), self.pass.clone(), self.create, self.invite.trim().to_string());
-                self.start(if create { "正在建立帳號…" } else { "正在登入…" }, move || Msg::Joined(remote::relay_join(&base, &url, &user, &pass, create, &invite)));
-            }
-            Step::Brain => {
-                self.brain = self.peers.get(self.sel).cloned();
-                self.step = Step::Confirm;
-            }
-            Step::Confirm => {
-                self.step = Step::Install;
-                let plan = Plan { role: self.role, settings: self.joined.clone().unwrap_or_default(), brain: self.brain.clone(), env: self.env.clone(), service: self.service };
-                self.progress = plan.steps().into_iter().map(|s| (s, Mark::Wait, String::new())).collect();
-                let tx = self.tx.clone();
-                std::thread::spawn(move || plan.run(&tx));
-            }
-            Step::Install => {}
-            Step::Done => self.quit = true,
-        }
-    }
-
     fn key(&mut self, code: KeyCode, mods: KeyModifiers) {
         if mods.contains(KeyModifiers::CONTROL) && matches!(code, KeyCode::Char('c') | KeyCode::Char('d')) {
             self.quit = true;
@@ -706,48 +432,44 @@ impl Wiz {
         if self.busy.is_some() || self.step == Step::Install {
             return;
         }
-        let rows = match self.step {
-            Step::Role => 2,
-            Step::Brain => self.peers.len() + 1,
-            Step::Account => {
-                if self.create {
-                    4
-                } else {
-                    3
-                }
+        if self.step == Step::Done {
+            if matches!(code, KeyCode::Enter | KeyCode::Esc | KeyCode::Char('q')) {
+                self.quit = true;
             }
-            _ => 0,
-        };
+            return;
+        }
+        if self.step == Step::Brain {
+            let n = self.peers.len().max(1);
+            match code {
+                KeyCode::Up => self.sel = (self.sel + n - 1) % n,
+                KeyCode::Down => self.sel = (self.sel + 1) % n,
+                KeyCode::Enter => {
+                    self.brain = self.peers.get(self.sel).cloned();
+                    self.install();
+                }
+                _ => {}
+            }
+            return;
+        }
+        let rows = self.rows();
         match code {
-            KeyCode::Esc => self.back(),
-            KeyCode::Enter => self.enter(),
-            KeyCode::Up | KeyCode::BackTab if rows > 0 => {
-                if self.step == Step::Account {
-                    self.focus = (self.focus + rows - 1) % rows;
-                } else {
-                    self.sel = (self.sel + rows - 1) % rows;
-                }
+            KeyCode::Esc => self.quit = true,
+            KeyCode::Up | KeyCode::BackTab => self.focus = (self.focus + rows - 1) % rows,
+            KeyCode::Down | KeyCode::Tab => self.focus = (self.focus + 1) % rows,
+            KeyCode::Enter if self.focus == rows - 1 => {
+                // The switch between a code and the password.
+                self.password = !self.password;
+                self.error.clear();
+                self.focus = 1;
             }
-            KeyCode::Down | KeyCode::Tab if rows > 0 => {
-                if self.step == Step::Account {
-                    self.focus = (self.focus + 1) % rows;
-                } else {
-                    self.sel = (self.sel + 1) % rows;
-                }
-            }
-            KeyCode::Char('r') if self.step == Step::Brain => self.load_peers(),
-            KeyCode::Char(' ') if self.step == Step::Account && self.focus == 2 => {
-                self.create = !self.create;
-                if !self.create && self.focus > 2 {
-                    self.focus = 2;
-                }
-            }
-            KeyCode::Char(c) if !mods.contains(KeyModifiers::CONTROL) => self.type_text(&c.to_string()),
+            KeyCode::Enter if self.focus + 2 < rows && !self.field_done() => self.focus += 1,
+            KeyCode::Enter => self.submit(),
             KeyCode::Char('u') if mods.contains(KeyModifiers::CONTROL) => {
                 if let Some(f) = self.text_field() {
                     f.clear();
                 }
             }
+            KeyCode::Char(c) if !mods.contains(KeyModifiers::CONTROL) => self.type_text(&c.to_string()),
             KeyCode::Backspace => {
                 if let Some(f) = self.text_field() {
                     f.pop();
@@ -757,31 +479,143 @@ impl Wiz {
         }
     }
 
+    /// Every text field is filled (Enter connects from anywhere then).
+    fn field_done(&self) -> bool {
+        !self.url.trim().is_empty() && if self.password { !self.user.trim().is_empty() && !self.pass.is_empty() } else { !self.code.trim().is_empty() }
+    }
+
     fn text_field(&mut self) -> Option<&mut String> {
-        match (self.step, self.focus) {
-            (Step::Name, _) => Some(&mut self.name),
-            (Step::Server, _) => Some(&mut self.url),
-            (Step::Account, 0) => Some(&mut self.user),
-            (Step::Account, 1) => Some(&mut self.pass),
-            (Step::Account, 3) => Some(&mut self.invite),
+        match (self.password, self.focus) {
+            (_, 0) => Some(&mut self.url),
+            (false, 1) => Some(&mut self.code),
+            (true, 1) => Some(&mut self.user),
+            (true, 2) => Some(&mut self.pass),
             _ => None,
         }
     }
 
     fn type_text(&mut self, s: &str) {
         let s: String = s.chars().filter(|c| !c.is_control()).collect();
+        // A pasted 「anybot setup 網址 配對碼」 line fills both.
+        let words: Vec<&str> = s.split_whitespace().filter(|w| *w != "anybot" && *w != "setup").collect();
+        if words.len() == 2 && words[1].chars().all(|c| c.is_ascii_digit()) && !self.password {
+            self.url = words[0].to_string();
+            self.code = words[1].to_string();
+            self.focus = 1;
+            return;
+        }
         if let Some(f) = self.text_field() {
             f.push_str(&s);
         }
     }
 }
 
+/// The brain a pairing code was made for.
+fn brain_of(s: &Settings) -> Option<Peer> {
+    (!s.hands_for.is_empty()).then(|| Peer { id: s.hands_for.clone(), name: s.hands_for_name.clone(), online: true, last: String::new() })
+}
+
+/// Sign in with the password; the brain is picked when there is only one to pick.
+fn join_with_password(base: &Settings, url: &str, user: &str, pass: &str) -> Result<(Settings, Option<Peer>, Vec<Peer>), String> {
+    let url = remote::check_server(url)?;
+    let s = remote::relay_join(base, &url, user, pass, false, "")?;
+    let list = list_brains(&s).unwrap_or_default();
+    let online: Vec<&Peer> = list.iter().filter(|p| p.online).collect();
+    let brain = if list.len() == 1 { list.first().cloned() } else if online.len() == 1 { Some(online[0].clone()) } else { None };
+    Ok((s, brain, list))
+}
+
+/// A page: the name on top, one card, the keys below.
+fn card_page(cols: usize, title: &str, sub: &str, body: impl Fn(usize) -> Vec<Line>, keys: &str) -> Vec<Line> {
+    let w = cols.saturating_sub(4).clamp(36, 78);
+    let inner = w - 4;
+    let mut lines: Vec<Line> = vec![vec![], vec![plain("  "), colored("◆ ", ACC), strong("AnyBot")], vec![]];
+    let mut card: Vec<Line> = vec![vec![], vec![strong(title)]];
+    if !sub.is_empty() {
+        card.extend(para(sub, 0, inner, dim));
+    }
+    card.push(vec![]);
+    card.extend(body(inner));
+    card.push(vec![]);
+    let edge = |l: &str, r: &str| vec![plain("  "), dim(format!("{l}{}{r}", "─".repeat(w - 2)))];
+    lines.push(edge("╭", "╮"));
+    for l in card {
+        let l = clip(l, inner);
+        let pad = inner.saturating_sub(width(&l));
+        let mut row = vec![plain("  "), dim("│ ")];
+        row.extend(l);
+        row.push(plain(" ".repeat(pad)));
+        row.push(dim(" │"));
+        lines.push(row);
+    }
+    lines.push(edge("╰", "╯"));
+    lines.push(vec![plain("   "), dim(keys)]);
+    lines
+}
+
+fn draw(out: &mut impl Write, lines: Vec<Line>, cols: usize, rows: usize) -> std::io::Result<()> {
+    queue!(out, terminal::BeginSynchronizedUpdate, terminal::Clear(terminal::ClearType::All))?;
+    for (y, l) in lines.into_iter().enumerate().take(rows) {
+        queue!(out, cursor::MoveTo(0, y as u16))?;
+        print_line(out, l, cols)?;
+    }
+    queue!(out, terminal::EndSynchronizedUpdate)?;
+    out.flush()
+}
+
+fn print_line(out: &mut impl Write, l: Line, cols: usize) -> std::io::Result<()> {
+    for (s, st) in clip(l, cols) {
+        if let Some(c) = st.fg {
+            queue!(out, SetForegroundColor(c))?;
+        }
+        if st.bold {
+            queue!(out, SetAttribute(Attribute::Bold))?;
+        }
+        queue!(out, Print(s), SetAttribute(Attribute::Reset), ResetColor)?;
+    }
+    Ok(())
+}
+
+/// The steps with their marks, then the tips.
+fn progress_lines(progress: &[(String, Mark, String)], tips: &[String], spin: usize, w: usize) -> Vec<Line> {
+    let mut b: Vec<Line> = vec![];
+    for (label, mark, note) in progress {
+        let icon = match mark {
+            Mark::Wait => dim("·"),
+            Mark::Run => colored(SPIN[spin % SPIN.len()], ACC),
+            Mark::Ok => colored("✓", GOOD),
+            Mark::Warn => colored("!", WARN),
+            Mark::Fail => colored("✗", BAD),
+        };
+        b.push(vec![icon, plain(" "), sp(label.clone(), if *mark == Mark::Wait { Some(DIM) } else { None }, *mark == Mark::Run)]);
+        if !note.is_empty() {
+            let f: fn(String) -> Span = match mark {
+                Mark::Fail => |s| colored(s, BAD),
+                Mark::Warn => |s| colored(s, WARN),
+                _ => dim,
+            };
+            b.extend(para(note, 2, w, f));
+        }
+    }
+    if !tips.is_empty() {
+        b.push(vec![]);
+        for t in tips {
+            if let Some((k, v)) = t.split_once('\t') {
+                b.push(vec![dim(format!("{k}{}", " ".repeat(10usize.saturating_sub(k.width())))), colored(v.to_string(), ACC)]);
+            } else {
+                b.extend(para(t, 0, w, plain));
+            }
+        }
+    }
+    b
+}
+
 /// The account's AnyBots that can be a brain (not this one, not one showing another's bots).
 fn list_brains(s: &Settings) -> Result<Vec<Peer>, String> {
     let all = remote::peers(s)?;
     let mut v: Vec<Peer> = all
         .iter()
-        .filter(|h| h["id"].as_str() != Some(s.host_id.as_str()) && h["uses"].as_str().unwrap_or("").is_empty())
+        .filter(|h| h["id"].as_str() != Some(s.host_id.as_str()) && h["uses"].as_str().unwrap_or("").is_empty() && h["hands"].as_bool() != Some(true))
         .map(|h| Peer {
             id: h["id"].as_str().unwrap_or("").into(),
             name: h["name"].as_str().unwrap_or("").into(),
@@ -848,7 +682,7 @@ impl Plan {
         }
         st.remote = r.clone();
         st.save();
-        say(0, Mark::Ok, &format!("存在 {}", State::path().display()));
+        say(0, Mark::Ok, "");
 
         // 2. Start with the computer.
         say(1, Mark::Run, "");
@@ -1001,28 +835,54 @@ fn lingering() -> bool {
 
 // ---------- entry ----------
 
+/// Flags that take a value (so the value isn't read as the address or the code).
+const VALUED: [&str; 4] = ["--server", "--user", "--name", "--brain-name"];
+
 pub fn run(args: &[String]) -> i32 {
     let flag = |k: &str| args.iter().position(|a| a == k).and_then(|i| args.get(i + 1)).cloned();
     if args.iter().any(|a| a == "-h" || a == "--help") {
-        println!("anybot setup：把這台設成大腦，或大腦的手腳。\n\n在終端機裡直接執行會一步一步問你。給程式用：\n  anybot setup --role hands|brain --name 名字 --server 網址 --user 帳號 [--brain 大腦名字|any]\n               [--create] [--invite 碼] [--no-service] [--password-stdin]\n  密碼放在 ANYBOT_ACCOUNT_PASSWORD，或加 --password-stdin 從標準輸入讀。");
+        println!("anybot setup：把這台電腦接到你的 AnyBot。\n\n  anybot setup 網址 配對碼     （手機或電腦的 AnyBot 按「加一台電腦」會給你這一行）\n  anybot setup                 一個畫面：填網址和配對碼（或帳號密碼）\n  加 --brain                   這台當大腦，不當手腳\n  加 --no-service              不設開機自動執行\n\n給程式用：anybot setup --server 網址 --user 帳號 [--brain-name 大腦名字]，密碼放在 ANYBOT_ACCOUNT_PASSWORD。");
         return 0;
     }
-    if flag("--role").is_some() || !std::io::stdin().is_terminal() || !std::io::stdout().is_terminal() {
-        return run_plain(args);
+    let role = if args.iter().any(|a| a == "--brain") { Role::Brain } else { Role::Hands };
+    let mut pos = vec![];
+    let mut skip = false;
+    for a in args {
+        if skip {
+            skip = false;
+        } else if VALUED.contains(&a.as_str()) {
+            skip = true;
+        } else if !a.starts_with("--") {
+            pos.push(a.clone());
+        }
     }
-    let mut w = Wiz::new();
-    if args.iter().any(|a| a == "--no-service") {
-        w.service = false;
+    let service = !args.iter().any(|a| a == "--no-service");
+    let name = flag("--name");
+    if flag("--server").is_some() || flag("--user").is_some() {
+        return run_script(role, &flag("--server").unwrap_or_default(), &flag("--user").unwrap_or_default(), flag("--brain-name"), name, service);
     }
+    if pos.len() >= 2 {
+        return run_code(role, &pos[0], &pos[1], name, service);
+    }
+    let name_for_screen = name.clone();
+    if !std::io::stdin().is_terminal() || !std::io::stdout().is_terminal() {
+        eprintln!("✗ 請用：anybot setup 網址 配對碼（在手機或電腦的 AnyBot 按「加一台電腦」）");
+        return 1;
+    }
+    run_screen(role, service, name_for_screen)
+}
+
+/// The one-screen form, then the progress.
+fn run_screen(role: Role, service: bool, name: Option<String>) -> i32 {
+    let mut w = Wiz::new(role);
+    w.name = name;
+    w.service = service && w.env.systemd;
     let mut out = std::io::stdout();
     if terminal::enable_raw_mode().is_err() {
-        return run_plain(args);
+        eprintln!("✗ 這個終端機不能用互動畫面。請用：anybot setup 網址 配對碼");
+        return 1;
     }
     let _ = execute!(out, terminal::EnterAlternateScreen, cursor::Hide, event::EnableBracketedPaste);
-    let restore = |out: &mut std::io::Stdout| {
-        let _ = execute!(out, event::DisableBracketedPaste, cursor::Show, terminal::LeaveAlternateScreen);
-        let _ = terminal::disable_raw_mode();
-    };
     let rx = w.rx.take().expect("channel");
     let mut dirty = true;
     while !w.quit {
@@ -1049,106 +909,188 @@ pub fn run(args: &[String]) -> i32 {
             dirty = true;
         }
     }
-    restore(&mut out);
-    // Leave a short note behind in the terminal.
-    if w.step == Step::Done {
-        let (mark, c) = if w.ok { ("✓", GOOD) } else { ("✗", BAD) };
-        let _ = execute!(out, SetForegroundColor(c), Print(format!("{mark} ")), ResetColor);
-        println!(
-            "{}",
-            match (w.ok, w.role) {
-                (true, Role::Hands) => format!("「{}」現在是{}的手腳。", w.name, w.brain.as_ref().map(|b| format!("大腦「{}」", b.name)).unwrap_or_else(|| "帳號裡大腦".into())),
-                (true, Role::Brain) => format!("「{}」現在是大腦。", w.name),
-                (false, _) => "設定沒有完成，再執行一次 anybot setup 看看。".into(),
-            }
-        );
-        for (label, mark, note) in &w.progress {
-            if matches!(mark, Mark::Fail | Mark::Warn) {
-                println!("  {label}：{note}");
-            }
-        }
+    let _ = execute!(out, event::DisableBracketedPaste, cursor::Show, terminal::LeaveAlternateScreen);
+    let _ = terminal::disable_raw_mode();
+    if w.step != Step::Done {
+        println!("沒有改任何設定。");
+        return 1;
+    }
+    // What happened stays in the terminal.
+    let mut lines = vec![vec![], vec![plain("  "), colored("◆ ", ACC), strong("AnyBot")], vec![]];
+    lines.extend(progress_lines(&w.progress, &w.tips, 0, 72).into_iter().map(|l| [vec![plain("  ")], l].concat()));
+    for l in lines {
+        let _ = print_line(&mut out, l, 200);
+        println!();
+    }
+    if w.ok {
         0
     } else {
-        println!("沒有改任何設定。");
         1
     }
 }
 
-/// No terminal (or --role given): the same, from flags, printed line by line.
-fn run_plain(args: &[String]) -> i32 {
-    let flag = |k: &str| args.iter().position(|a| a == k).and_then(|i| args.get(i + 1)).cloned();
-    let fail = |m: &str| {
-        eprintln!("✗ {m}");
-        1
-    };
-    let role = match flag("--role").as_deref() {
-        Some("hands") | Some("手腳") => Role::Hands,
-        Some("brain") | Some("大腦") => Role::Brain,
-        _ => return fail("請用 --role hands 或 --role brain（在終端機直接執行 anybot setup 會一步一步問）"),
-    };
-    let saved = State::load().remote;
-    let name = flag("--name").unwrap_or_else(|| if saved.host_name.is_empty() { remote::default_host_name() } else { saved.host_name.clone() });
-    let Some(server) = flag("--server").or_else(|| (!saved.relay_url.is_empty()).then(|| saved.relay_url.clone())) else { return fail("請用 --server 給帳號伺服器的網址") };
-    let server = match remote::check_server(&server) {
-        Ok(u) => u,
-        Err(e) => return fail(&e),
-    };
-    println!("✓ 帳號伺服器 {server}");
-    let user = flag("--user").unwrap_or_else(|| saved.relay_user.clone());
-    let mut pass = std::env::var("ANYBOT_ACCOUNT_PASSWORD").unwrap_or_default();
-    if args.iter().any(|a| a == "--password-stdin") {
-        let mut s = String::new();
-        let _ = std::io::stdin().read_line(&mut s);
-        pass = s.trim_end_matches(['\n', '\r']).to_string();
-    }
-    let joined = if pass.is_empty() && !saved.host_token.is_empty() && saved.relay_url == server && saved.relay_user == user && saved.host_name == name {
-        saved.clone()
+/// Print a line now (colors only in a terminal).
+fn say(l: Line) {
+    let mut out = std::io::stdout();
+    if out.is_terminal() {
+        let _ = print_line(&mut out, l, 400);
     } else {
-        if user.is_empty() || pass.is_empty() {
-            return fail("請給 --user，密碼放在 ANYBOT_ACCOUNT_PASSWORD（或用 --password-stdin）");
+        print!("{}", l.into_iter().map(|(s, _)| s).collect::<String>());
+    }
+    println!();
+}
+
+/// Shows a spinner on this line while `job` runs (in a terminal).
+fn waiting<T: Send + 'static>(what: &str, job: impl FnOnce() -> T + Send + 'static) -> T {
+    let (tx, rx) = channel();
+    std::thread::spawn(move || {
+        let _ = tx.send(job());
+    });
+    let tty = std::io::stdout().is_terminal();
+    let mut n = 0;
+    loop {
+        if let Ok(v) = rx.recv_timeout(Duration::from_millis(100)) {
+            if tty {
+                print!("\r\x1b[K");
+                let _ = std::io::stdout().flush();
+            }
+            return v;
         }
-        let mut base = saved.clone();
-        base.host_name = name.clone();
-        match remote::relay_join(&base, &server, &user, &pass, args.iter().any(|a| a == "--create"), &flag("--invite").unwrap_or_default()) {
-            Ok(s) => s,
-            Err(e) => return fail(&e),
+        if tty {
+            let mut out = std::io::stdout();
+            print!("\r\x1b[K  ");
+            let _ = print_line(&mut out, vec![colored(SPIN[n % SPIN.len()], ACC), plain(" "), colored(what.to_string(), ACC)], 200);
+            let _ = out.flush();
+        }
+        n += 1;
+    }
+}
+
+fn header() {
+    say(vec![]);
+    say(vec![plain("  "), colored("◆ ", ACC), strong("AnyBot")]);
+    say(vec![]);
+}
+
+fn base_settings(name: Option<String>) -> Settings {
+    let mut base = State::load().remote;
+    if let Some(n) = name.filter(|n| !n.trim().is_empty()) {
+        base.host_name = n.trim().chars().take(60).collect();
+    }
+    if base.host_name.is_empty() {
+        base.host_name = remote::default_host_name();
+    }
+    base
+}
+
+/// `anybot setup 網址 配對碼`: nothing to answer.
+fn run_code(role: Role, url: &str, code: &str, name: Option<String>, service: bool) -> i32 {
+    header();
+    let base = base_settings(name);
+    let (url, code) = (url.to_string(), code.chars().filter(|c| c.is_ascii_digit()).collect::<String>());
+    let r = waiting("正在連線…", move || remote::pair_claim(&base, &url, &code));
+    let s = match r {
+        Ok(s) => s,
+        Err(e) => {
+            say(vec![plain("  "), colored("✗ ", BAD), colored(e, BAD)]);
+            say(vec![plain("    "), dim("在手機或電腦的 AnyBot 按「加一台電腦」拿新的一行再試。")]);
+            return 1;
         }
     };
-    println!("✓ 已登入帳號 {user}（這台叫「{name}」）");
-    let mut brain = None;
-    if role == Role::Hands {
-        match flag("--brain").as_deref() {
-            None | Some("any") | Some("") => {}
-            Some(want) => match list_brains(&joined) {
-                Ok(list) => match list.into_iter().find(|p| p.name == want) {
-                    Some(p) => brain = Some(p),
-                    None => return fail(&format!("帳號裡沒有叫「{want}」的 AnyBot")),
-                },
-                Err(e) => return fail(&e),
-            },
+    say(vec![plain("  "), colored("✓ ", GOOD), plain(format!("加入帳號 {}（這台叫「{}」）", s.relay_user, s.host_name))]);
+    let brain = brain_of(&s);
+    finish(role, s, brain, service)
+}
+
+/// Scripts: the account and password.
+fn run_script(role: Role, server: &str, user: &str, brain_name: Option<String>, name: Option<String>, service: bool) -> i32 {
+    header();
+    let pass = std::env::var("ANYBOT_ACCOUNT_PASSWORD").unwrap_or_default();
+    if server.is_empty() || user.is_empty() || pass.is_empty() {
+        say(vec![plain("  "), colored("✗ 請給 --server 和 --user，密碼放在 ANYBOT_ACCOUNT_PASSWORD", BAD)]);
+        return 1;
+    }
+    let base = base_settings(name);
+    let (server, user2) = (server.to_string(), user.to_string());
+    let (s, mut brain, list) = match waiting("正在登入…", move || join_with_password(&base, &server, &user2, &pass)) {
+        Ok(v) => v,
+        Err(e) => {
+            say(vec![plain("  "), colored("✗ ", BAD), colored(e, BAD)]);
+            return 1;
+        }
+    };
+    say(vec![plain("  "), colored("✓ ", GOOD), plain(format!("登入帳號 {user}（這台叫「{}」）", s.host_name))]);
+    if let Some(want) = brain_name {
+        match list.into_iter().find(|p| p.name == want) {
+            Some(p) => brain = Some(p),
+            None => {
+                say(vec![plain("  "), colored(format!("✗ 帳號裡沒有叫「{want}」的 AnyBot"), BAD)]);
+                return 1;
+            }
         }
     }
+    finish(role, s, brain, service)
+}
+
+/// Save, start with the computer, check; printed line by line.
+fn finish(role: Role, s: Settings, brain: Option<Peer>, service: bool) -> i32 {
     let env = Env::detect();
-    let plan = Plan { role, settings: joined, brain, service: env.systemd && !args.iter().any(|a| a == "--no-service"), env };
+    let plan = Plan { role, settings: s, brain, service: service && env.systemd, env };
     let steps = plan.steps();
     let (tx, rx) = channel();
     std::thread::spawn(move || plan.run(&tx));
     let mut failed = false;
-    for m in rx {
+    let mut current = String::new();
+    loop {
+        let m = if std::io::stdout().is_terminal() && !current.is_empty() {
+            let what = current.clone();
+            let rx2 = &rx;
+            // Spin until the next message.
+            let mut n = 0;
+            loop {
+                match rx2.recv_timeout(Duration::from_millis(100)) {
+                    Ok(m) => {
+                        print!("\r\x1b[K");
+                        break Some(m);
+                    }
+                    Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {
+                        let mut out = std::io::stdout();
+                        print!("\r\x1b[K  ");
+                        let _ = print_line(&mut out, vec![colored(SPIN[n % SPIN.len()], ACC), plain(" "), plain(what.clone())], 200);
+                        let _ = out.flush();
+                        n += 1;
+                    }
+                    Err(_) => break None,
+                }
+            }
+        } else {
+            rx.recv().ok()
+        };
+        let Some(m) = m else { break };
         match m {
-            Msg::Progress(i, mark, note) if mark != Mark::Run && mark != Mark::Wait => {
-                let icon = match mark {
-                    Mark::Ok => "✓",
-                    Mark::Warn => "!",
-                    _ => "✗",
-                };
+            Msg::Progress(i, Mark::Run, _) => current = steps.get(i).cloned().unwrap_or_default(),
+            Msg::Progress(i, mark, note) if mark != Mark::Wait => {
+                current.clear();
                 failed |= mark == Mark::Fail;
-                println!("{icon} {}{}", steps.get(i).cloned().unwrap_or_default(), if note.is_empty() { String::new() } else { format!("：{note}") });
+                let (icon, c) = match mark {
+                    Mark::Ok => ("✓ ", GOOD),
+                    Mark::Warn => ("! ", WARN),
+                    _ => ("✗ ", BAD),
+                };
+                say(vec![plain("  "), colored(icon, c), plain(steps.get(i).cloned().unwrap_or_default())]);
+                if !note.is_empty() {
+                    say(vec![plain("    "), if mark == Mark::Ok { dim(note) } else { colored(note, c) }]);
+                }
             }
             Msg::Finished(tips) => {
-                for t in tips.iter().filter(|t| !t.is_empty()) {
-                    println!("  {}", t.replace('\t', "  "));
+                say(vec![]);
+                for t in tips {
+                    match t.split_once('\t') {
+                        Some((k, v)) => say(vec![plain("  "), dim(format!("{k}{}", " ".repeat(10usize.saturating_sub(k.width())))), colored(v.to_string(), ACC)]),
+                        None => say(vec![plain("  "), plain(t)]),
+                    }
                 }
+                say(vec![]);
                 break;
             }
             _ => {}
@@ -1178,7 +1120,7 @@ mod tests {
 
     #[test]
     fn launcher_makes_a_screen_when_there_is_none() {
-        let env = Env { linux: true, display: String::new(), systemd: true, xvfb: true };
+        let env = Env { linux: true, display: String::new(), systemd: true };
         let s = launcher_script(Role::Hands, std::path::Path::new("/home/a b/anybot"), &env);
         assert!(s.contains("xvfb-run") && s.contains("'/home/a b/anybot'") && s.ends_with("exec '/home/a b/anybot' --serve\n"));
         let brain = launcher_script(Role::Brain, std::path::Path::new("/x/anybot"), &env);
@@ -1186,14 +1128,27 @@ mod tests {
     }
 
     #[test]
-    fn every_step_fits_a_narrow_terminal() {
-        let mut w = Wiz::new();
+    fn every_screen_fits_a_narrow_terminal() {
+        let mut w = Wiz::new(Role::Hands);
         w.peers = vec![Peer { id: "1".into(), name: "很長很長很長很長很長很長很長很長的大腦名字".into(), online: true, last: String::new() }];
-        for step in [Step::Role, Step::Name, Step::Server, Step::Account, Step::Brain, Step::Confirm, Step::Done] {
+        w.error = "配對碼不對，或已經過期（10 分鐘內有效，只能用一次）".into();
+        for step in [Step::Form, Step::Brain, Step::Install, Step::Done] {
             w.step = step;
-            for l in w.body(40) {
-                assert!(width(&clip(l, 40)) <= 40);
+            for pw in [false, true] {
+                w.password = pw;
+                for l in w.body(40) {
+                    assert!(width(&clip(l, 40)) <= 40);
+                }
             }
         }
     }
+
+    #[test]
+    fn a_pasted_line_fills_the_form() {
+        let mut w = Wiz::new(Role::Hands);
+        w.focus = 0;
+        w.url.clear();
+        w.type_text("anybot setup https://anybot.example.com 482913");
+        assert_eq!((w.url.as_str(), w.code.as_str()), ("https://anybot.example.com", "482913"));
+    }
 }
diff --git a/src/tunnel.rs b/src/tunnel.rs
index bfe7f09..a2b2310 100644
--- a/src/tunnel.rs
+++ b/src/tunnel.rs
@@ -230,7 +230,8 @@ fn keep(mut ws: WebSocket<Stream>, serial: u64, alive: &dyn Fn() -> bool) {
     let (tx, rx) = channel::<Vec<u8>>();
     let calls: Calls = Arc::default();
     *link().lock().unwrap() = Some(Link { tx: tx.clone(), calls: calls.clone(), serial });
-    let _ = tx.send(wire::pack(&json!({"t": "hello", "brain": crate::remote::hub().settings().brain_id}), &[]));
+    let s = crate::remote::hub().settings();
+    let _ = tx.send(wire::pack(&json!({"t": "hello", "brain": s.brain_id, "hands": s.device_link}), &[]));
     let (mut heard, mut pinged) = (Instant::now(), Instant::now());
     'live: while alive() {
         match ws.read() {
@@ -309,9 +310,9 @@ fn on_frame(head: Value, body: Vec<u8>, tx: &Sender<Vec<u8>>, calls: &Calls) {
 }
 
 /// Tell the account server which brain this AnyBot shows (so the phone can go there).
-pub fn hello(brain: &str) {
+pub fn hello(brain: &str, hands: bool) {
     if let Some(l) = link().lock().unwrap().as_ref() {
-        let _ = l.tx.send(wire::pack(&json!({"t": "hello", "brain": brain}), &[]));
+        let _ = l.tx.send(wire::pack(&json!({"t": "hello", "brain": brain, "hands": hands}), &[]));
     }
 }