fix: make WorkerId the standalone primary identity

crates/tui/src/console/mod.rs

@@ -25,9 +25,7 @@ use tokio::sync::mpsc;
 
 use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};
 use client::transport::Socket;
-use client::{
-    BackendRuntimeTarget, Client, StandaloneSessionResumeIntent, connect_backend_runtime,
-};
+use client::{BackendRuntimeTarget, Client, StandaloneWorkerResumeIntent, connect_backend_runtime};
 
 use crate::app::{ActionbarNoticeLevel, ActionbarNoticeSource, App};
 use crate::composer_keys::{ComposerEditAction, composer_edit_action};
@@ -193,18 +191,18 @@ pub(crate) async fn run_standalone(
 }
 
 pub(crate) async fn run_standalone_restore(
-    intent: StandaloneSessionResumeIntent,
+    intent: StandaloneWorkerResumeIntent,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    let session_id = intent.session_id.parse().map_err(|error| {
+    let worker_id = intent.worker_id.parse().map_err(|error| {
         io::Error::new(
             io::ErrorKind::InvalidInput,
-            format!("Invalid standalone session ID: {error}"),
+            format!("Invalid standalone Worker ID: {error}"),
         )
     })?;
-    let host = StandaloneHost::restore(intent.state_dir, session_id)
+    let host = StandaloneHost::restore(intent.state_dir, worker_id)
         .await
         .map_err(|error| io::Error::other(format!("Standalone restore failed: {error}")))?;
-    let worker_label = format!("standalone-{}", session_id.short());
+    let worker_label = host.record().worker_name.clone();
     let history_root = host.record().cwd.canonical_path.clone();
     run_standalone_host(host, worker_label, history_root).await
 }

crates/tui/src/lib.rs

@@ -46,8 +46,8 @@ pub enum LaunchMode {
         worker_name: Option<String>,
         profile: Option<String>,
     },
-    /// Restore one client-owned standalone session. The current cwd is the default scope;
-    /// `include_all` opts into all standalone sessions under the same client data root.
+    /// Restore one client-owned standalone Worker. The current cwd is the default scope;
+    /// `include_all` opts into all standalone Workers under the same client data root.
     StandaloneResume { include_all: bool },
     /// List Backend Workers and attach to the selected Worker.
     Workers {

crates/tui/src/standalone_picker.rs

@@ -1,7 +1,7 @@
 use std::io;
 use std::time::Duration;
 
-use client::{StandaloneSessionListIntent, StandaloneSessionResumeIntent, Target};
+use client::{StandaloneWorkerListIntent, StandaloneWorkerResumeIntent, Target};
 use crossterm::event::{self, Event as TermEvent, KeyCode, KeyEventKind, KeyModifiers};
 use ratatui::Terminal;
 use ratatui::backend::CrosstermBackend;
@@ -9,7 +9,7 @@ use ratatui::layout::{Constraint, Layout};
 use ratatui::prelude::{Color, Line, Modifier, Span, Style};
 use ratatui::widgets::Paragraph;
 use ratatui::{TerminalOptions, Viewport};
-use standalone::{StandaloneListScope, StandaloneSessionRecord, StandaloneSessionStore};
+use standalone::{StandaloneListScope, StandaloneWorkerRecord, StandaloneWorkerStore};
 use thiserror::Error;
 
 const LIMIT: usize = 100;
@@ -17,28 +17,28 @@ const LIMIT: usize = 100;
 pub(crate) fn pick(
     target: &dyn Target,
     include_all: bool,
-) -> Result<Option<StandaloneSessionResumeIntent>, StandalonePickerError> {
+) -> Result<Option<StandaloneWorkerResumeIntent>, StandalonePickerError> {
     let intent = target
-        .standalone_session_list(include_all)
+        .standalone_worker_list(include_all)
         .map_err(StandalonePickerError::Target)?;
     let records = load_records(&intent)?;
     if records.is_empty() {
-        return Err(StandalonePickerError::NoSessions { include_all });
+        return Err(StandalonePickerError::NoWorkers { include_all });
     }
     let selected = run_picker(records)?;
     selected
         .map(|record| {
             target
-                .standalone_session_resume(record.session_id.to_string())
+                .standalone_worker_resume(record.worker_id.to_string())
                 .map_err(StandalonePickerError::Target)
         })
         .transpose()
 }
 
 fn load_records(
-    intent: &StandaloneSessionListIntent,
-) -> Result<Vec<StandaloneSessionRecord>, StandalonePickerError> {
-    let store = StandaloneSessionStore::open(&intent.state_dir)
+    intent: &StandaloneWorkerListIntent,
+) -> Result<Vec<StandaloneWorkerRecord>, StandalonePickerError> {
+    let store = StandaloneWorkerStore::open(&intent.state_dir)
         .map_err(StandalonePickerError::StateStore)?;
     store
         .list(
@@ -54,8 +54,8 @@ fn load_records(
 }
 
 fn run_picker(
-    records: Vec<StandaloneSessionRecord>,
-) -> Result<Option<StandaloneSessionRecord>, StandalonePickerError> {
+    records: Vec<StandaloneWorkerRecord>,
+) -> Result<Option<StandaloneWorkerRecord>, StandalonePickerError> {
     let height = u16::try_from(records.len().saturating_add(3).min(20)).unwrap_or(20);
     let mut terminal = Terminal::with_options(
         CrosstermBackend::new(io::stdout()),
@@ -94,14 +94,14 @@ fn run_picker(
     }
 }
 
-fn draw(frame: &mut ratatui::Frame<'_>, records: &[StandaloneSessionRecord], selected: usize) {
+fn draw(frame: &mut ratatui::Frame<'_>, records: &[StandaloneWorkerRecord], selected: usize) {
     let mut constraints = vec![Constraint::Length(1)];
     constraints.extend(records.iter().map(|_| Constraint::Length(1)));
     constraints.push(Constraint::Length(1));
     let rows = Layout::vertical(constraints).split(frame.area());
     frame.render_widget(
         Paragraph::new(Line::from(Span::styled(
-            "resume standalone session",
+            "resume standalone Worker",
             Style::default().add_modifier(Modifier::BOLD),
         ))),
         rows[0],
@@ -120,7 +120,10 @@ fn draw(frame: &mut ratatui::Frame<'_>, records: &[StandaloneSessionRecord], sel
         frame.render_widget(
             Paragraph::new(Line::from(vec![
                 Span::raw(marker),
-                Span::styled(record.session_id.short(), style),
+                Span::styled(
+                    format!("{} ({})", record.worker_name, record.worker_id.short()),
+                    style,
+                ),
                 Span::raw(format!(
                     "  [{:?}]  updated:{}  {}",
                     record.status, record.updated_at_unix_ms, cwd
@@ -139,13 +142,13 @@ fn draw(frame: &mut ratatui::Frame<'_>, records: &[StandaloneSessionRecord], sel
 pub(crate) enum StandalonePickerError {
     #[error("standalone target error: {0}")]
     Target(#[source] client::TargetError),
-    #[error("standalone session state is unavailable: {0}")]
+    #[error("standalone Worker state is unavailable: {0}")]
     StateStore(#[source] standalone::StandaloneStoreError),
     #[error(
-        "no standalone sessions found for this cwd; use `yoi --local --resume --all` to include all cwd identities"
+        "no standalone Workers found for this cwd; use `yoi --local --resume --all` to include all cwd identities"
     )]
-    NoSessions { include_all: bool },
-    #[error("standalone session picker I/O failed: {0}")]
+    NoWorkers { include_all: bool },
+    #[error("standalone Worker picker I/O failed: {0}")]
     Io(#[source] io::Error),
 }