sigit-code 1.7.6__tar.gz → 1.7.7__tar.gz

{sigit_code-1.7.6 → sigit_code-1.7.7}/Cargo.lock

@@ -5945,7 +5945,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sigit"
-version = "1.7.6"
+version = "1.7.7"
 dependencies = [
  "agent-client-protocol",
  "anyhow",
@@ -5976,7 +5976,7 @@ dependencies = [
 
 [[package]]
 name = "sigit-agent"
-version = "1.7.6"
+version = "1.7.7"
 dependencies = [
  "agent-client-protocol",
  "anyhow",

{sigit_code-1.7.6 → sigit_code-1.7.7}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["crates/cli", "crates/sigit-*"]
 
 [workspace.package]
-version = "1.7.6"
+version = "1.7.7"
 edition = "2024"
 license = "Apache-2.0"
 repository = "https://github.com/getsigit/sigit"
@@ -16,7 +16,7 @@ authors = ["Seto Elkahfi <seto@sigit.si>", "paydii <193906237+paydii@users.norep
 # crates.io, so this resolves from the registry rather than the onde-ed checkout next door.
 ed-acp = { version = "1.3.0", default-features = false }
 ed-acp-testkit = "1.3.0"
-sigit-agent = { version = "1.7.6", default-features = false, path = "crates/sigit-agent" }
+sigit-agent = { version = "1.7.7", default-features = false, path = "crates/sigit-agent" }
 
 # ACP protocol SDK
 agent-client-protocol = { version = "2.2", features = ["unstable_session_fork"] }

{sigit_code-1.7.6 → sigit_code-1.7.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sigit-code
-Version: 1.7.6
+Version: 1.7.7
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{sigit_code-1.7.6 → sigit_code-1.7.7}/crates/cli/src/account.rs

@@ -129,14 +129,32 @@ pub async fn end_session() -> String {
     }
 }
 
-/// One-line description of the current session, verifying the token if reachable.
-pub async fn status_line() -> String {
+/// What the stored session amounts to right now.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum SessionState {
+    /// No credentials are stored.
+    SignedOut,
+    /// The server accepted the token.
+    Valid { email: String },
+    /// The server rejected the token (HTTP status).
+    Expired { status: u16 },
+    /// Credentials are stored but the server could not be reached in time.
+    Offline { email: String },
+}
+
+/// Look up the stored session and verify its token, giving up on the network
+/// after `timeout`.
+pub async fn check_session(timeout: std::time::Duration) -> SessionState {
     let Some(creds) = credentials::load() else {
-        return "Not signed in. Use `/login` to use siGit Code Cloud.".to_string();
+        return SessionState::SignedOut;
     };
 
     let url = format!("{}/api/v1/user", api_base().trim_end_matches('/'));
-    match reqwest::Client::new()
+    let client = reqwest::Client::builder()
+        .timeout(timeout)
+        .build()
+        .unwrap_or_default();
+    match client
         .get(&url)
         .bearer_auth(&creds.access_token)
         .send()
@@ -150,14 +168,28 @@ pub async fn status_line() -> String {
                 .and_then(|me| me.email)
                 .or(creds.email)
                 .unwrap_or_else(|| "(unknown)".to_string());
-            format!("Signed in to siGit Code Cloud as {email}.")
+            SessionState::Valid { email }
+        }
+        Ok(response) => SessionState::Expired {
+            status: response.status().as_u16(),
+        },
+        Err(_) => SessionState::Offline {
+            email: creds.email.unwrap_or_else(|| "(unknown)".to_string()),
+        },
+    }
+}
+
+/// One-line description of the current session, verifying the token if reachable.
+pub async fn status_line() -> String {
+    match check_session(std::time::Duration::from_secs(10)).await {
+        SessionState::SignedOut => {
+            "Not signed in. Use `/login` to use siGit Code Cloud.".to_string()
+        }
+        SessionState::Valid { email } => format!("Signed in to siGit Code Cloud as {email}."),
+        SessionState::Expired { status } => {
+            format!("Session may be expired (HTTP {status}). Use `/login` again.")
         }
-        Ok(response) => format!(
-            "Session may be expired (HTTP {}). Use `/login` again.",
-            response.status().as_u16()
-        ),
-        Err(_) => {
-            let email = creds.email.unwrap_or_else(|| "(unknown)".to_string());
+        SessionState::Offline { email } => {
             format!("Signed in as {email} (could not reach siGit Code Cloud to verify).")
         }
     }

{sigit_code-1.7.6 → sigit_code-1.7.7}/crates/cli/src/chat.rs

@@ -520,6 +520,7 @@ mod tui {
     use onde::inference::{ChatEngine, SamplingConfig};
 
     use super::{RepoItem, Tab};
+    use crate::account::SessionState;
     use crate::backend::{
         InferenceBackend, LocalBackend, OpenAiBackend, TokenChunk, ToolResult, ToolSpec,
     };
@@ -528,6 +529,10 @@ mod tui {
     };
     use crate::program_status::{Reporter, Status};
     use crate::session_store::SessionEntry;
+    use crate::splash::{self, Phase, Splash, Wordmark};
+    use crate::startup::{
+        self, Check, Checks, Report, account_check, models_check, tools_check, workspace_check,
+    };
     use ratatui::{
         Frame,
         layout::{Constraint, Layout, Position},
@@ -545,8 +550,6 @@ mod tui {
         User,
         Assistant,
         System,
-        /// rainbow-colored banner art
-        Banner,
         /// a collapsible tool-call entry (`text` holds the title line)
         Tool,
     }
@@ -596,16 +599,6 @@ mod tui {
             }
         }
 
-        fn banner(text: impl Into<String>) -> Self {
-            Self {
-                role: Role::Banner,
-                text: text.into(),
-                think_block: None,
-                tool_detail: None,
-                tool_result: None,
-            }
-        }
-
         fn tool_call(title: impl Into<String>, detail: impl Into<String>) -> Self {
             Self {
                 role: Role::Tool,
@@ -771,6 +764,13 @@ mod tui {
         load_error: Option<String>,
         load_start: Instant,
         load_model_name: String,
+        /// The backend is up. The splash still decides when the loading view ends.
+        load_ready: bool,
+        /// The launch splash and the checks it waits on.
+        splash: Splash,
+        checks: Checks,
+        /// What the account check found, for the welcome message.
+        session: Option<SessionState>,
 
         // ── Model picker state ────────────────────────────────────────────────
         show_model_picker: bool,
@@ -832,21 +832,6 @@ mod tui {
         repo_rx: Option<mpsc::UnboundedReceiver<RepoUpdate>>,
     }
 
-    const BANNER_ART: &str = "\
-77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777
-77777777322222222222222222222222222222223777389969902208431358831999699051111177777777777777
-1111111125555555555555555555555511113222311159    5002         088    3081771691111111111111
-1111111111111111111111111111131136841   1482853332007    05    9043332891    400811111111111
-1111111111111111111111111111111201        109    304    40     00    79      100041111111111
-333333255555555555555555555552392   102   503    90    7000000005    903    0000023333333333
-333333245454545454545454545433381    7600000    302    61    780    109    20009533333333333
-3333333333333333333333333333333402      7001    08    761    202    902    90003333333333333
-2222255555555555555555555555250899901    49    304    403    08    108    300042222222222222
-2222222222222222222222222222269   106    03    901    06    505    402    000052222222222222
-2222255555555555555555555555299        708    1002          80     00      90852222222222222
-55555555555555555555555555555560953258000866660000051140866908666600008966900065555555555555
-88888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888";
-
     const THINKING_FRAMES: &[&str] = &["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
     fn rich_text_spans(text: &str, base_style: Style, bold_style: Style) -> Vec<Span<'static>> {
@@ -870,21 +855,10 @@ mod tui {
             backend: Arc<dyn InferenceBackend>,
             program_status: Reporter,
         ) -> Self {
-            let is_remote = backend.is_remote();
-            let items = build_model_picker_items();
-            let tool_calling = items
-                .iter()
-                .find(|m| m.display_name == load_model_name)
-                .map(|m| m.tool_calling)
-                .unwrap_or(true);
-            // For a remote provider the passed-in name is authoritative; the
-            // persisted local selection must not override it (or the title would
-            // show an on-device model while requests go to the cloud).
-            let current_model_name = if is_remote {
-                load_model_name.clone()
-            } else {
-                crate::setup::load_selected_model_name().unwrap_or_else(|| load_model_name.clone())
-            };
+            // The model scan, the saved selection and the repo lookup used to run
+            // here, before the first frame. They run behind the splash now and
+            // land in `apply_startup`; until then the picker is empty and the
+            // passed-in name stands.
             Self {
                 messages: Vec::new(),
                 input: String::new(),
@@ -911,11 +885,15 @@ mod tui {
                 load_error: None,
                 load_start: Instant::now(),
                 load_model_name: load_model_name.clone(),
+                load_ready: false,
+                splash: Splash::new(std::time::Instant::now()),
+                checks: Checks::new(),
+                session: None,
                 show_model_picker: false,
                 model_picker_index: 0,
-                model_picker_items: items,
-                current_model_name,
-                tool_calling,
+                model_picker_items: Vec::new(),
+                current_model_name: load_model_name.clone(),
+                tool_calling: true,
                 context_tokens_used: None,
                 show_thinking: false,
                 tools_expanded: false,
@@ -927,7 +905,7 @@ mod tui {
                 history_notice: None,
                 cloud_lines: None,
                 cloud_rx: None,
-                repo: detect_sigit_repo(),
+                repo: None,
                 repo_section: RepoSection::Issues,
                 repo_issues: RepoData::NotFetched,
                 repo_prs: RepoData::NotFetched,
@@ -1108,16 +1086,54 @@ mod tui {
             self.download_progress = Some((downloaded, expected));
         }
 
-        /// switch to chat phase and show the welcome banner
+        /// Take one startup check's answer.
+        fn apply_startup(&mut self, report: Report) {
+            match report {
+                Report::Account(state) => {
+                    self.checks.account = account_check(&state);
+                    self.session = Some(state);
+                }
+                Report::Models { items, selected } => {
+                    self.tool_calling = items
+                        .iter()
+                        .find(|m| m.display_name == self.load_model_name)
+                        .map(|m| m.tool_calling)
+                        .unwrap_or(true);
+                    // For a remote provider the passed-in name is authoritative; the
+                    // persisted local selection must not override it (or the title
+                    // would show an on-device model while requests go to the cloud).
+                    if !self.backend.is_remote()
+                        && let Some(name) = selected
+                    {
+                        self.current_model_name = name;
+                    }
+                    self.checks.models = models_check(&items);
+                    self.model_picker_items = items;
+                }
+                Report::Tools(overview) => {
+                    self.checks.tools = tools_check(overview.as_ref());
+                }
+                Report::Workspace(repo) => {
+                    self.checks.workspace = workspace_check(repo.as_deref());
+                    self.repo = repo;
+                }
+            }
+        }
+
+        /// switch to chat phase and show the welcome notes
         fn finish_loading(&mut self) {
             self.is_loading = false;
-            for line in BANNER_ART.lines() {
-                self.messages.push(ChatMessage::banner(line));
-            }
-            self.messages.push(ChatMessage::system(""));
             self.messages.push(ChatMessage::system(
                 "In this world, nothing can be said to be certain, except death and taxes. ~ Pak Sigit",
             ));
+            for (label, check) in self.checks.rows() {
+                match check {
+                    Check::Ok(d) | Check::Note(d) | Check::Warn(d) => self
+                        .messages
+                        .push(ChatMessage::system(format!("{label}: {d}"))),
+                    Check::Pending => {}
+                }
+            }
             if self.backend.is_remote() {
                 self.messages.push(ChatMessage::system(format!(
                     "Current model: {}",
@@ -1131,6 +1147,11 @@ mod tui {
                     self.current_model_name
                 )));
             }
+            if matches!(self.session, Some(SessionState::Expired { .. })) {
+                self.messages.push(ChatMessage::system(
+                    "Your siGit Code Cloud session has expired. Use /login to sign in again.",
+                ));
+            }
             self.messages
                 .push(ChatMessage::system("Type /help for commands."));
         }
@@ -1555,21 +1576,6 @@ mod tui {
 
     // ── Repo tab (issues / pull requests via the official MCP server) ─────────
 
-    /// `owner/name` when the current directory's `origin` remote lives on the
-    /// sigit.si host (per `SIGIT_API_URL`). Runs `git remote get-url origin`
-    /// once at startup; any failure (no git, no repo, no origin) → `None`.
-    fn detect_sigit_repo() -> Option<String> {
-        let output = std::process::Command::new("git")
-            .args(["remote", "get-url", "origin"])
-            .output()
-            .ok()?;
-        if !output.status.success() {
-            return None;
-        }
-        let url = String::from_utf8_lossy(&output.stdout);
-        super::parse_repo_remote(url.trim(), &super::sigit_host())
-    }
-
     /// Fetch both Repo-tab lists on spawned tasks feeding `repo_rx` — the same
     /// spawned-fetch pattern as the Cloud tab, so the render loop never blocks
     /// on the network. Replacing the channel drops any in-flight fetch's
@@ -2125,6 +2131,11 @@ mod tui {
     fn render(frame: &mut Frame, app: &mut App) {
         let area = frame.area();
 
+        if app.is_loading && app.load_error.is_none() {
+            render_splash(frame, app, area);
+            return;
+        }
+
         if app.is_loading {
             let zones = Layout::vertical([
                 Constraint::Length(1),
@@ -2247,9 +2258,58 @@ mod tui {
         }
     }
 
+    /// The launch splash: the wordmark with a caption under it. The startup
+    /// checks still gate it, and their results land in the chat's info lines.
+    /// Too small a terminal gets the caption without the art.
+    fn render_splash(frame: &mut Frame, app: &App, area: ratatui::layout::Rect) {
+        let now = std::time::Instant::now();
+        let reduced = app.splash.reduced();
+        let tc = app.splash.truecolor;
+        let t = if reduced {
+            Duration::from_secs(2)
+        } else {
+            app.splash.elapsed(now)
+        };
+        let ms = t.as_millis() as f32;
+        let exit = app.splash.exit_progress(now);
+        let vis = 1.0 - exit;
+
+        // the wordmark, a gap, the caption
+        let art = app
+            .splash
+            .banner
+            .size(area.width)
+            .filter(|(_, h)| area.height >= h + 2);
+        let art_h = art.map_or(0, |(_, h)| h + 1);
+        let total = art_h + 1;
+        let top = area.y + area.height.saturating_sub(total) / 2;
+        let rect = |y: u16, h: u16| ratatui::layout::Rect::new(area.x, y, area.width, h);
+
+        if let Some((_, h)) = art {
+            frame.render_widget(
+                Wordmark {
+                    banner: &app.splash.banner,
+                    t,
+                    exit,
+                    still: reduced,
+                    truecolor: tc,
+                },
+                rect(top, h),
+            );
+        }
+
+        let caption_y = top + art_h;
+        let caption = Paragraph::new(Line::from(Span::styled(
+            "siGit Code & Deploy",
+            Style::default().fg(splash::fade(splash::MUTED, vis * (ms / 300.0).min(1.0), tc)),
+        )))
+        .alignment(ratatui::layout::Alignment::Center);
+        frame.render_widget(caption, rect(caption_y, 1));
+    }
+
     fn render_loading_title(frame: &mut Frame, app: &App, area: ratatui::layout::Rect) {
         const SPINNER: &[&str] = &["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"];
-        let spin = SPINNER[(app.load_tick as usize) % SPINNER.len()];
+        let spin = SPINNER[(app.load_tick as usize / 3) % SPINNER.len()];
         let label = format!(" siGit {} loading {}… ", spin, app.load_model_name);
         let line = Line::from(Span::styled(
             label,
@@ -2443,22 +2503,6 @@ mod tui {
                     lines.push(Line::from(Span::styled(format!("  {entry_line}"), dim)));
                 }
             }
-            Role::Banner => {
-                let palette = [
-                    Color::Red,
-                    Color::Yellow,
-                    Color::Green,
-                    Color::Cyan,
-                    Color::Blue,
-                    Color::Magenta,
-                ];
-                let mut spans = Vec::new();
-                for (i, ch) in msg.text.chars().enumerate() {
-                    let color = palette[i % palette.len()];
-                    spans.push(Span::styled(ch.to_string(), Style::default().fg(color)));
-                }
-                lines.push(Line::from(spans));
-            }
             Role::System => {
                 for text_line in msg.text.split('\n') {
                     let trimmed = text_line.trim();
@@ -3528,15 +3572,16 @@ mod tui {
     {
         let mut app = App::new(load_model_name, backend, program_status);
         let mut event_stream = EventStream::new();
+        let mut startup_rx = startup::spawn();
 
-        // 10 fps is plenty for spinners
-        let mut ticker = interval(Duration::from_millis(100));
+        // ~30 fps while the splash plays; the loading phase is the only user
+        let mut ticker = interval(Duration::from_millis(33));
 
         loop {
             // ── Poll the loader channel (non-blocking) ────────────────────────
             if app.is_loading {
                 match load_rx.try_recv() {
-                    Ok(Ok(())) => app.finish_loading(),
+                    Ok(Ok(())) => app.load_ready = true,
                     Ok(Err(e)) => app.set_load_error(e),
                     Err(std_mpsc::TryRecvError::Empty) => {}
                     Err(std_mpsc::TryRecvError::Disconnected) => {
@@ -3545,6 +3590,24 @@ mod tui {
                 }
             }
 
+            // Startup checks report as they finish, and keep reporting after a
+            // skip: the picker and the Repo tab fill in behind the chat.
+            while let Ok(report) = startup_rx.try_recv() {
+                app.apply_startup(report);
+            }
+            // The splash leaves once the backend is up and every check has
+            // reported (and never before its minimum), or on a key press.
+            if app.is_loading
+                && app.load_ready
+                && app.load_error.is_none()
+                && app
+                    .splash
+                    .update(std::time::Instant::now(), app.checks.all_done())
+                    == Phase::Done
+            {
+                app.finish_loading();
+            }
+
             // redraw every iteration
             terminal.draw(|frame| render(frame, &mut app))?;
 
@@ -3637,7 +3700,7 @@ mod tui {
             tokio::select! {
                 biased;
 
-                // ── Spinner tick (loading phase only) ─────────────────────────
+                // ── Splash / spinner tick (loading phase only) ────────────────
                 _ = ticker.tick(), if app.is_loading => {
                     app.tick();
                 }
@@ -3800,6 +3863,9 @@ mod tui {
                                         || key.code == KeyCode::Char('d'))
                                 {
                                     app.quit = true;
+                                } else {
+                                    // any other key skips the splash
+                                    app.splash.skip();
                                 }
                             }
                             continue;

{sigit_code-1.7.6 → sigit_code-1.7.7}/crates/cli/src/headless.rs

@@ -30,7 +30,7 @@ use crate::{permissions, provider, session_store, settings, tools};
 pub const USAGE: &str = "Usage: sigit run \"<prompt>\" [--cwd <dir>] [--add-dir <dir>]... \
                          [--output text|jsonl] [--quiet] [--resume <session-id>] \
                          [--allow-tool <name>]... [--deny-tool <name>]... \
-                         [--max-tool-rounds <n>]\n       \
+                         [--max-tool-rounds <n>] [--model <tier>]\n       \
                          sigit -p \"<prompt>\" [same options]";
 
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
@@ -67,6 +67,9 @@ pub struct HeadlessConfig {
     /// asked for its final message. `--max-tool-rounds`, else
     /// `SIGIT_MAX_TOOL_ROUNDS`, else the built-in cap.
     pub max_tool_rounds: usize,
+    /// siGit Code Cloud tier named by `--model`. When set it wins over the
+    /// provider override and the local-inference setting.
+    pub cloud_tier: Option<&'static str>,
 }
 
 /// Upper bound for `--max-tool-rounds` / `SIGIT_MAX_TOOL_ROUNDS`.
@@ -147,6 +150,7 @@ pub fn parse_args(args: &[String]) -> Result<Option<HeadlessConfig>, String> {
     let mut allow_tools: Vec<String> = Vec::new();
     let mut deny_tools: Vec<String> = Vec::new();
     let mut max_tool_rounds: Option<usize> = None;
+    let mut cloud_tier: Option<&'static str> = None;
 
     let mut iter = args.iter().skip(usize::from(run_command));
     while let Some(arg) = iter.next() {
@@ -211,6 +215,21 @@ pub fn parse_args(args: &[String]) -> Result<Option<HeadlessConfig>, String> {
                     .ok_or_else(|| "--max-tool-rounds requires a number".to_string())?;
                 max_tool_rounds = Some(parse_tool_rounds(value, "--max-tool-rounds")?);
             }
+            "--model" => {
+                let value = iter
+                    .next()
+                    .ok_or_else(|| "--model requires a cloud tier".to_string())?;
+                if cloud_tier.is_some() {
+                    return Err("--model was given more than once".to_string());
+                }
+                let tier = provider::cloud_tier_named(value).ok_or_else(|| {
+                    format!(
+                        "unknown cloud tier: {value} (expected one of: {})",
+                        provider::CLOUD_TIERS.join(", ")
+                    )
+                })?;
+                cloud_tier = Some(tier);
+            }
             // A mistyped flag must not become the prompt. A prompt that
             // really starts with '-' can still go through -p.
             other if other.starts_with('-') => return Err(format!("unknown argument: {other}")),
@@ -258,6 +277,7 @@ pub fn parse_args(args: &[String]) -> Result<Option<HeadlessConfig>, String> {
         allow_tools,
         deny_tools,
         max_tool_rounds,
+        cloud_tier,
     }))
 }
 
@@ -312,22 +332,32 @@ pub async fn run(config: HeadlessConfig) -> i32 {
     // first, else the signed-in cloud tier when local inference is off (what
     // `apply_startup_inference_mode` does at every ACP session entry). There is
     // never an implicit on-device load — a fresh process has no model in memory
-    // and headless mode must not silently download gigabytes.
-    let provider_cfg = provider::active_provider().or_else(|| {
-        if settings::local_inference_enabled() {
-            None
-        } else {
-            provider::cloud_tier_provider(provider::DEFAULT_CLOUD_TIER)
-        }
-    });
+    // and headless mode must not silently download gigabytes. `--model` is the
+    // exception to that order: a tier named on the command line wins over the
+    // override and the setting, the way a flag wins over the environment.
+    let provider_cfg = match config.cloud_tier {
+        Some(tier) => provider::cloud_tier_provider(tier),
+        None => provider::active_provider().or_else(|| {
+            if settings::local_inference_enabled() {
+                None
+            } else {
+                provider::cloud_tier_provider(provider::DEFAULT_CLOUD_TIER)
+            }
+        }),
+    };
     let Some(cfg) = provider_cfg else {
-        emit_error(
-            &config,
-            "headless mode needs a remote inference provider — running on-device would require \
-             loading (and possibly downloading) a local model, which headless mode never does \
-             implicitly. Set OPENAI_BASE_URL and OPENAI_API_KEY (or configure providers.toml), \
-             or sign in with `sigit login` and turn local inference off.",
-        );
+        let message = match config.cloud_tier {
+            Some(tier) => format!(
+                "--model {tier} needs a siGit Code Cloud session. Sign in with `sigit login`."
+            ),
+            None => "headless mode needs a remote inference provider — running on-device would \
+                     require loading (and possibly downloading) a local model, which headless \
+                     mode never does implicitly. Set OPENAI_BASE_URL and OPENAI_API_KEY (or \
+                     configure providers.toml), or sign in with `sigit login` and turn local \
+                     inference off."
+                .to_string(),
+        };
+        emit_error(&config, &message);
         return 1;
     };
 
@@ -814,6 +844,32 @@ mod tests {
         assert!(resolve_max_tool_rounds(None, Some("0")).is_err());
     }
 
+    #[test]
+    fn model_flag_names_a_cloud_tier() {
+        let config = parse_args(&args(&["run", "go"])).unwrap().unwrap();
+        assert_eq!(config.cloud_tier, None);
+        let config = parse_args(&args(&["run", "go", "--model", "prism"]))
+            .unwrap()
+            .unwrap();
+        assert_eq!(config.cloud_tier, Some("prism"));
+        // The wire id works too, so a model id copied from logs is accepted.
+        let config = parse_args(&args(&["-p", "go", "--model", "onde-zenith"]))
+            .unwrap()
+            .unwrap();
+        assert_eq!(config.cloud_tier, Some("zenith"));
+    }
+
+    #[test]
+    fn model_flag_rejects_unknown_and_repeated_tiers() {
+        let error = parse_args(&args(&["run", "go", "--model", "gpt-4o"])).unwrap_err();
+        assert!(error.starts_with("unknown cloud tier: gpt-4o"), "{error}");
+        assert!(error.contains("prism"), "{error}");
+        assert_eq!(
+            parse_args(&args(&["run", "go", "--model", "apex", "--model", "flare"])),
+            Err("--model was given more than once".to_string())
+        );
+    }
+
     #[test]
     fn wrap_up_prompt_names_the_cap_only_when_it_was_reached() {
         let capped = wrap_up_prompt(true, 24);
@@ -877,6 +933,7 @@ mod tests {
         assert!(parse_args(&args(&["-p", "x", "--deny-tool"])).is_err());
         assert!(parse_args(&args(&["run", "x", "--output"])).is_err());
         assert!(parse_args(&args(&["run", "x", "--resume"])).is_err());
+        assert!(parse_args(&args(&["run", "x", "--model"])).is_err());
     }
 
     #[test]

{sigit_code-1.7.6 → sigit_code-1.7.7}/crates/cli/src/main.rs

@@ -51,6 +51,10 @@ mod session_store;
 mod settings;
 mod setup;
 mod skills;
+#[cfg(unix)]
+mod splash;
+#[cfg(unix)]
+mod startup;
 mod subagents;
 mod tools;
 mod workspace;
@@ -6922,9 +6926,9 @@ async fn main() -> anyhow::Result<()> {
             let (tty, cleanup_tty) = redirect_output_to_log()?;
             init_logging(true);
             setup::setup_shared_model_cache();
-            // Best-effort: discover MCP servers (incl. the official one) before
-            // the first turn so their tools are offered to the model.
-            mcp::init().await;
+            // MCP discovery (incl. the official server) runs behind the launch
+            // splash (`startup.rs`), so a slow server never leaves the terminal
+            // blank before the first frame.
             run_interactive(tty, cleanup_tty).await
         }
         #[cfg(not(unix))]