Merge branch 'main' into dependabot/cargo/lru-0.18.3

Author: Hmbown

crates/tui/src/plugins/marketplace/document.rs

@@ -208,20 +208,17 @@ mod tests {
         assert!(!valid_marketplace_name("a".repeat(65).as_str()));
     }
 
+    #[cfg(unix)]
     #[test]
     fn load_refuses_symlink_documents() {
         let dir = tempfile::tempdir().unwrap();
         let real = dir.path().join("real.json");
         std::fs::write(&real, "{}").unwrap();
         let link = dir.path().join("link.json");
-        #[cfg(unix)]
         std::os::unix::fs::symlink(&real, &link).unwrap();
-        #[cfg(not(unix))]
-        let link = real.clone();
 
         let error = load_catalog_document("test", dir.path(), link.to_str().unwrap())
             .expect_err("symlink document must be refused");
-        #[cfg(unix)]
         assert!(error.contains("symlink"), "{error}");
     }
 

crates/tui/src/runtime_api/tests.rs

@@ -11191,6 +11191,7 @@ async fn marketplace_catalog_lifecycle_over_http_lists_installs_and_removes() ->
     Ok(())
 }
 
+#[cfg(unix)]
 #[tokio::test]
 async fn marketplace_add_rejects_symlink_documents_over_http() -> Result<()> {
     let tmp = tempfile::tempdir()?;
@@ -11203,10 +11204,7 @@ async fn marketplace_add_rejects_symlink_documents_over_http() -> Result<()> {
     let real = catalog_dir.join("real.json");
     fs::write(&real, r#"{"plugins":[]}"#)?;
     let link = catalog_dir.join("link.json");
-    #[cfg(unix)]
     std::os::unix::fs::symlink(&real, &link)?;
-    #[cfg(not(unix))]
-    let link = real;
 
     let Some((addr, handle)) = spawn_plugin_api_server(root, workspace).await? else {
         return Ok(());
@@ -11221,10 +11219,7 @@ async fn marketplace_add_rejects_symlink_documents_over_http() -> Result<()> {
         }))
         .send()
         .await?;
-    #[cfg(unix)]
     assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
-    #[cfg(not(unix))]
-    assert!(resp.status().is_success());
 
     handle.abort();
     Ok(())

crates/tui/src/runtime_threads/tests.rs

@@ -3719,24 +3719,30 @@ async fn wait_for_terminal_turn(
                 | RuntimeTurnStatus::Interrupted
                 | RuntimeTurnStatus::Canceled
         );
-        if terminal {
+        let timed_out = Instant::now() >= deadline;
+        if terminal || timed_out {
             let receipt_is_durable =
                 manager
                     .events_since(&turn.thread_id, None)?
                     .iter()
                     .any(|event| {
                         event.event == "turn.completed" && event.turn_id.as_deref() == Some(turn_id)
                     });
-            let claim_is_clear = manager
+            let active_claim_present = manager
                 .active_turn_flags(&turn.thread_id, turn_id)
                 .await
-                .is_none();
-            if receipt_is_durable && claim_is_clear {
+                .is_some();
+            if terminal && receipt_is_durable && !active_claim_present {
                 return Ok(turn);
             }
-        }
-        if Instant::now() >= deadline {
-            bail!("Timed out waiting for turn {turn_id}");
+            if timed_out {
+                bail!(
+                    "Timed out waiting for turn {turn_id}: status={:?}, \
+                     completion_receipt_present={receipt_is_durable}, \
+                     active_claim_present={active_claim_present}",
+                    turn.status
+                );
+            }
         }
         sleep(Duration::from_millis(20)).await;
     }
@@ -5420,7 +5426,8 @@ async fn monitor_separates_lifecycle_start_from_billing_dispatch_and_child_usage
         })
         .await?;
 
-    let completed = wait_for_terminal_turn(&manager, &turn.id, Duration::from_secs(2)).await?;
+    let completed =
+        wait_for_terminal_turn(&manager, &turn.id, TURN_SETTLEMENT_DEADLOCK_TIMEOUT).await?;
     assert_eq!(completed.effective_provider.as_deref(), Some("stepfun"));
     assert_eq!(
         completed.effective_provider_id.as_deref(),

crates/tui/src/tui/app/init.rs

@@ -722,7 +722,7 @@ impl App {
                 selected_attachment_index: None,
                 slash_menu_selected: 0,
                 slash_menu_hidden: false,
-                    mention_menu_selected: 0,
+                mention_menu_selected: 0,
                 mention_menu_hidden: false,
                 mention_completion_cache: None,
                 mention_discovery: crate::tui::mention_completion::MentionDiscovery::default(),

crates/tui/src/tui/mouse_ui.rs

@@ -337,9 +337,6 @@ fn handle_plugin_cta_mouse(app: &mut App, mouse: MouseEvent) -> Option<Vec<ViewE
     Some(Vec::new())
 }
 
-/// Handle mouse events within the composer area.
-/// Returns true if the event was consumed.
-
 /// Slash-autocomplete rows painted inside the composer. Click selects
 /// (second click on the same row applies, matching the command palette);
 /// wheel moves the highlight. Returns true when the event was consumed so
@@ -349,12 +346,13 @@ fn handle_slash_autocomplete_mouse(app: &mut App, mouse: MouseEvent) -> bool {
     if hitboxes.is_empty() {
         return false;
     }
-    let over_row = hitboxes.iter().find_map(|(idx, rect)| {
-        mouse_hits_rect(mouse, Some(*rect)).then_some(*idx)
-    });
+    let over_row = hitboxes
+        .iter()
+        .find_map(|(idx, rect)| mouse_hits_rect(mouse, Some(*rect)).then_some(*idx));
     let over_menu = over_row.is_some()
         || hitboxes.iter().any(|(_, rect)| {
-            mouse.row >= rect.y && mouse.row < rect.y.saturating_add(rect.height)
+            mouse.row >= rect.y
+                && mouse.row < rect.y.saturating_add(rect.height)
                 && mouse.column >= rect.x
                 && mouse.column < rect.x.saturating_add(rect.width)
         });
@@ -405,6 +403,8 @@ fn handle_slash_autocomplete_mouse(app: &mut App, mouse: MouseEvent) -> bool {
     }
 }
 
+/// Handle mouse events within the composer area.
+/// Returns true if the event was consumed.
 pub(crate) fn handle_composer_mouse(app: &mut App, mouse: MouseEvent) -> bool {
     // Use outer area for hit-testing (includes border).
     let Some(area) = app.viewport.last_composer_area else {
@@ -1973,8 +1973,6 @@ mod tests {
         crate::tui::hover_layer::clear_pointer();
     }
 
-
-
     #[test]
     fn slash_autocomplete_click_selects_and_second_click_applies() {
         let mut app = create_test_app();
@@ -1986,18 +1984,22 @@ mod tests {
         app.slash_menu_selected = 0;
         // Simulate two painted rows from ComposerWidget.
         app.viewport.last_composer_area = Some(Rect::new(0, 18, 80, 6));
-        *app.viewport.last_slash_menu_hitboxes.borrow_mut() = vec![
-            (0, Rect::new(1, 20, 78, 1)),
-            (1, Rect::new(1, 21, 78, 1)),
-        ];
+        *app.viewport.last_slash_menu_hitboxes.borrow_mut() =
+            vec![(0, Rect::new(1, 20, 78, 1)), (1, Rect::new(1, 21, 78, 1))];
 
         assert!(
             handle_composer_mouse(&mut app, left_click(5, 21)),
             "slash row click must be consumed by the composer"
         );
-        assert_eq!(app.slash_menu_selected, 1, "click on another row highlights it");
+        assert_eq!(
+            app.slash_menu_selected, 1,
+            "click on another row highlights it"
+        );
         let before = app.input.clone();
-        assert_eq!(before, "/he", "select-only click must not rewrite the composer");
+        assert_eq!(
+            before, "/he",
+            "select-only click must not rewrite the composer"
+        );
 
         assert!(handle_composer_mouse(&mut app, left_click(5, 21)));
         assert_ne!(app.input, before, "click on the highlighted row applies it");
@@ -2018,10 +2020,8 @@ mod tests {
         app.slash_menu_hidden = false;
         app.slash_menu_selected = 0;
         app.viewport.last_composer_area = Some(Rect::new(0, 18, 80, 6));
-        *app.viewport.last_slash_menu_hitboxes.borrow_mut() = vec![
-            (0, Rect::new(1, 20, 78, 1)),
-            (1, Rect::new(1, 21, 78, 1)),
-        ];
+        *app.viewport.last_slash_menu_hitboxes.borrow_mut() =
+            vec![(0, Rect::new(1, 20, 78, 1)), (1, Rect::new(1, 21, 78, 1))];
         let entries = crate::tui::slash_menu::visible_slash_menu_entries(&app, 128);
         assert!(entries.len() >= 2, "prefix must offer multiple entries");
 
@@ -2048,7 +2048,6 @@ mod tests {
         assert_eq!(app.slash_menu_selected, 0);
     }
 
-
     #[test]
     fn send_click_matches_the_keyboard_submit_and_focus_never_leaves_the_composer() {
         let mut app = create_test_app();

crates/tui/src/tui/ui/tests.rs

@@ -4927,7 +4927,10 @@ fn paste_burst_does_not_leak_into_composer_while_a_modal_owns_keys() {
         &mut app,
         now + crate::tui::paste_burst::PasteBurst::recommended_flush_delay(),
     );
-    assert!(!flushed, "modal-owned keys must not flush into the composer");
+    assert!(
+        !flushed,
+        "modal-owned keys must not flush into the composer"
+    );
     assert!(
         app.input.is_empty() || app.input == "/",
         "composer must not gain leaked burst text under a modal: {:?}",

crates/tui/src/tui/widgets/mod.rs

@@ -1359,7 +1359,11 @@ impl Renderable for ComposerWidget<'_> {
     fn render(&self, area: Rect, buf: &mut Buffer) {
         // Slash rows are re-recorded below; clear first so a closed or
         // resized menu cannot keep stale hitboxes from the prior frame.
-        self.app.viewport.last_slash_menu_hitboxes.borrow_mut().clear();
+        self.app
+            .viewport
+            .last_slash_menu_hitboxes
+            .borrow_mut()
+            .clear();
         let background = Style::default().bg(self.app.ui_theme.composer_bg);
         let has_panel = self.has_panel(area);
         let inner_area = self.inner_area(area);
@@ -1826,10 +1830,7 @@ impl Renderable for ComposerWidget<'_> {
                         .viewport
                         .last_slash_menu_hitboxes
                         .borrow_mut()
-                        .push((
-                            idx,
-                            Rect::new(inner_area.x, row_y, inner_area.width, 1),
-                        ));
+                        .push((idx, Rect::new(inner_area.x, row_y, inner_area.width, 1)));
                 }
 
                 if name_was_truncated || description_was_truncated {

crates/tui/tests/cucumber/active_composer_pointer_pty.rs

@@ -341,9 +341,13 @@ fn assert_startup_contract(frame: &Frame, rows: u16, cols: u16, size: &str) {
 
 fn assert_live_shell_contract(frame: &Frame, cols: u16, size: &str) {
     let text = frame.text();
+    // The bottom metrics row owns the model; repository state belongs to
+    // the launch header and git view. This sealed offline session uses the
+    // default model, which must remain visible even at 40 columns.
+    let metrics = frame.row(frame.rows().saturating_sub(1));
     assert!(
-        text.contains("no git"),
-        "{size}: live shell misses the info line\n{}",
+        metrics.contains("deepseek-v4-pro"),
+        "{size}: live shell misses the model in the metrics line\n{}",
         frame.debug_dump()
     );
     // The shell advertises one help route per surface: the info line's

crates/tui/tests/cucumber/plugin_e2e_acceptance.rs

@@ -693,19 +693,22 @@ fn review_confirmation_in_text(text: &str) -> Option<String> {
     // The confirmation is `/plugin trust demo <64-hex>.<64-hex>` (129 chars).
     // Transcript cards wrap well before that, so a single rendered line no
     // longer holds the token. Join trimmed lines and recover the two digests.
+    // The transcript may also retain an earlier partial command, so scan every
+    // marker instead of rejecting after the first malformed candidate.
     let joined: String = text.lines().map(str::trim).collect();
     let marker = "/plugin trust demo ";
-    let start = joined.find(marker)?;
-    let token: String = joined[start + marker.len()..]
-        .chars()
-        .take_while(|ch| ch.is_ascii_hexdigit() || *ch == '.')
-        .collect();
-    let (content, capability) = token.split_once('.')?;
-    (content.len() == 64
-        && capability.len() == 64
-        && content.chars().all(|ch| ch.is_ascii_hexdigit())
-        && capability.chars().all(|ch| ch.is_ascii_hexdigit()))
-    .then(|| format!("{marker}{content}.{capability}"))
+    joined.match_indices(marker).find_map(|(start, _)| {
+        let token: String = joined[start + marker.len()..]
+            .chars()
+            .take_while(|ch| ch.is_ascii_hexdigit() || *ch == '.')
+            .collect();
+        let (content, capability) = token.split_once('.')?;
+        (content.len() == 64
+            && capability.len() == 64
+            && content.chars().all(|ch| ch.is_ascii_hexdigit())
+            && capability.chars().all(|ch| ch.is_ascii_hexdigit()))
+        .then(|| format!("{marker}{content}.{capability}"))
+    })
 }
 
 #[cfg(all(unix, feature = "long-running-tests"))]
@@ -970,11 +973,11 @@ async fn plugin_toml_binary_lifecycle_skill_and_stdio_mcp_acceptance() {
 
 #[cfg(all(unix, feature = "long-running-tests"))]
 #[test]
-fn review_confirmation_survives_transcript_wrap() {
+fn review_confirmation_skips_partial_candidates_and_survives_transcript_wrap() {
     let content = "a".repeat(64);
     let capability = "b".repeat(64);
     let wrapped = format!(
-        "  /plugin trust demo {head}\n  {mid}\n  {tail}\n",
+        "/plugin trust demo partial\n  /plugin trust demo {head}\n  {mid}\n  {tail}\n",
         head = &format!("{content}.{capability}")[..40],
         mid = &format!("{content}.{capability}")[40..90],
         tail = &format!("{content}.{capability}")[90..],