Read a timeout in units, share one usage answer, and let a tilde mean home

The composer's settings row is outlined bubbles opening round menus, and
the message box is a TextFieldValue so anything put into it without being
typed -- a draft, a share, a slash command -- leaves the cursor at the end.

A tap that puts a text selection away no longer also collapses the card the
text was drawn in: every open and close on the session screen goes through
one guard that spends such a press on the selection.

The usage bar and the usage dialog were two polls of one measurement and
disagreed for up to a minute at a time; they are one feed now, and the
countdown rounds up to the minute in the one place both read.

A working directory typed as ~/repos/ai-app was four literal characters on
the local transport and as an argument on both, so the existence check
refused every home-relative path. It is checked by entering the directory
now, expanded for a local spawn the way the remote shell expands it, and
stored short so the phone draws what somebody would write.

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

server/src/setups.rs

@@ -160,6 +160,32 @@ pub fn tidy(value: &str) -> Option<String> {
     })
 }
 
+/// The inverse of [`tidy`]'s expansion: an absolute path under this
+/// machine's home, written back as `~/…`.
+///
+/// So that a working directory reads on a phone the way it is written by
+/// hand. `/home/bob/repos/ai-app-2` is most of a line on that screen and
+/// almost all of it is the part nobody is reading.
+///
+/// Applied only to paths on **this** machine. `$HOME` here says nothing
+/// about the home directory of a machine reached over ssh, so a remote
+/// path is stored exactly as it was typed -- where a `~` somebody wrote
+/// stays a `~`, and the remote shell is what expands it
+/// (`ssh::quote_path`).
+pub fn shorten_home(path: &str) -> String {
+    let Some(home) = std::env::home_dir() else {
+        return path.to_string();
+    };
+    let home = home.to_string_lossy();
+    // The separator has to be part of the match, or `/home/bobby` would be
+    // read as a path inside `/home/bob`.
+    match path.strip_prefix(home.as_ref()) {
+        Some("") => "~".to_string(),
+        Some(rest) if rest.starts_with('/') => format!("~{rest}"),
+        _ => path.to_string(),
+    }
+}
+
 /// Runs a launch to completion and returns its stdout.
 impl Transport {
     pub async fn capture(&self, launch: &Launch) -> Result<String> {
@@ -182,3 +208,29 @@ impl Transport {
         Ok(String::from_utf8_lossy(&output.stdout).into_owned())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// The two halves of a home-relative path, which have to be inverses:
+    /// what is stored is what the phone draws, and what the phone sends
+    /// back is what a process is started in.
+    #[test]
+    fn a_home_path_shortens_and_expands_back() {
+        let Some(home) = std::env::home_dir() else {
+            return;
+        };
+        let full = home.join("repos/ai-app-2");
+        let full = full.to_string_lossy();
+        assert_eq!(shorten_home(&full), "~/repos/ai-app-2");
+        assert_eq!(shorten_home(&home.to_string_lossy()), "~");
+        assert_eq!(tidy("~/repos/ai-app-2").as_deref(), Some(full.as_ref()));
+
+        // Not a prefix match on the characters: a sibling directory whose
+        // name merely starts with the home directory's is not inside it.
+        let sibling = format!("{}-backup/notes", home.to_string_lossy());
+        assert_eq!(shorten_home(&sibling), sibling);
+        assert_eq!(shorten_home("/etc/hosts"), "/etc/hosts");
+    }
+}