Stop choosing a model, and keep an imported session up to date

**Why the model became fable.** `spawn_session` fell back to the
provider's first listed model when none was given. That list is a shortcut
for the spawn screen, written in whatever order somebody typed it, and its
first entry is `fable` -- so every session spawned without a model, which
is every import, silently became a fable session. It looked like a default
and was an artefact of list order. Absent now means absent: no `--model`
flag, and the CLI uses whatever the person configured for themselves.

**Model and permission mode are now visible and changeable** from the
session, as buttons that read as their current value rather than labels
beside one. The mode was spawn-only; the CLI turns out to accept
`control_request{subtype:set_permission_mode}` and echo the mode back,
probed against 2.1.237 the same way the rest of the protocol record was.
Both default to `auto` -- on a phone every ask is a round trip to a
question card, which is how "allow Bash?" became the most-answered
question in the app.

The mode is reported by the API so the picker shows what the session is
actually set to, and it is kept in the live session beside the model for
the reason the model already was: `meta` is the shape a session was
*launched* with, so reporting from it shows the value a change replaced.

**And an imported session keeps itself level with its source file**, so
work done at a terminal arrives without a button. `--resume` appends to
the same transcript rather than forking -- measured, not assumed -- so the
only hard question is which new lines came from here.

Answered by counting the events this session has recorded. Status is the
obvious signal and is wrong, which cost a round trip to find: a turn that
starts and finishes between two polls reads as idle at both, so its output
is replayed on top of itself. It showed up on screen as `donedone`, and
only because the reply was one word -- with a longer answer it would have
looked like the model repeating itself.

Verified against both halves: text appended to the source file the way a
terminal writes it appears within one interval, and a message sent through
the app appears exactly once, before and after a turn.

server/src/session/import.rs

@@ -348,3 +348,75 @@ pub async fn delete(transport: &Transport, id: &str) -> Result<()> {
         .with_context(|| format!("deleting {}", chosen.path))?;
     Ok(())
 }
+
+/// How often an imported session checks whether its source file grew.
+///
+/// A poll rather than a watch, because the file may be on another machine
+/// and there is no portable way to be told. Ten seconds is chosen against
+/// the cost of an ssh round trip rather than against how fast a person
+/// types: nothing here is waiting on it, and the events arrive on the same
+/// stream as everything else once they do.
+pub const SYNC_INTERVAL: std::time::Duration = std::time::Duration::from_secs(10);
+
+/// Where an imported session came from, and how much of it has been shown.
+///
+/// Kept beside the session rather than in its config, because it is a
+/// position in someone else's file rather than anything the person chose,
+/// and it changes constantly.
+#[derive(Debug, Clone, Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Cursor {
+    /// Server-side only, and resolved once at import. Nothing accepts a
+    /// path from the phone; this is the path *we* found.
+    pub path: String,
+    /// Lines of that file already accounted for -- whether replayed into
+    /// the transcript or skipped because this session wrote them itself.
+    pub lines: usize,
+}
+
+const CURSOR_FILE: &str = "import.json";
+
+pub fn read_cursor(session_dir: &std::path::Path) -> Option<Cursor> {
+    let text = std::fs::read_to_string(session_dir.join(CURSOR_FILE)).ok()?;
+    serde_json::from_str(&text).ok()
+}
+
+pub fn write_cursor(session_dir: &std::path::Path, cursor: &Cursor) {
+    let path = session_dir.join(CURSOR_FILE);
+    match serde_json::to_string(cursor) {
+        Ok(text) => {
+            if let Err(err) = std::fs::write(&path, text) {
+                tracing::error!(
+                    "couldn't persist the import cursor to {}: {err}",
+                    path.display()
+                );
+            }
+        }
+        Err(err) => tracing::error!("couldn't serialize the import cursor: {err}"),
+    }
+}
+
+/// How many lines the source file has now.
+pub async fn line_count(transport: &Transport, path: &str) -> Result<usize> {
+    let launch = Launch::new("wc", vec!["-l".to_string(), path.to_string()], None);
+    let out = transport.capture(&launch).await?;
+    out.split_whitespace()
+        .next()
+        .and_then(|n| n.parse().ok())
+        .with_context(|| format!("couldn't read a line count out of {out:?}"))
+}
+
+/// Events from the lines after `after`, which is a 0-based count of lines
+/// already accounted for.
+pub async fn replay_after(transport: &Transport, path: &str, after: usize) -> Result<Vec<Event>> {
+    let launch = Launch::new(
+        "tail",
+        vec![format!("-n+{}", after + 1), path.to_string()],
+        None,
+    );
+    let text = transport
+        .capture(&launch)
+        .await
+        .with_context(|| format!("reading {path} from line {}", after + 1))?;
+    Ok(events_from(&text))
+}