crates/tsql/src/config/schema.rs (1)

131-132: LGTM!

The configurable timeout with a sensible 500ms default is well-designed. The u64 type is appropriate for millisecond durations.

Consider adding bounds validation in the future if users report issues with extreme timeout values (e.g., <50ms causing hint flicker or >5000ms feeling unresponsive).

Also applies to: 154-154

crates/tsql/src/config/keymap.rs (2)

101-107: Avoid long-term drift between config::Action::Goto* and ui::KeySequenceAction::* (same conceptual actions).
Right now the PR introduces two parallel “goto action” enums. Consider converging on a single source of truth (e.g., KeySequenceAction -> Action conversion, or reuse Action directly) to prevent future mismatches in behavior/descriptions.

Also applies to: 178-182, 285-290

---

934-956: Add coverage for the new goto_* FromStr branches.
The test_action_from_str test doesn’t exercise the new variants, so regressions in config parsing could slip in.

@@
     fn test_action_from_str() {
@@
         // Test case insensitivity
         assert_eq!("MOVE_UP".parse::<Action>().unwrap(), Action::MoveUp);
         assert_eq!("Move_Up".parse::<Action>().unwrap(), Action::MoveUp);
+
+        // Goto sequences
+        assert_eq!("goto_first".parse::<Action>().unwrap(), Action::GotoFirst);
+        assert_eq!("goto_editor".parse::<Action>().unwrap(), Action::GotoEditor);
+        assert_eq!(
+            "goto_connections".parse::<Action>().unwrap(),
+            Action::GotoConnections
+        );
+        assert_eq!("goto_tables".parse::<Action>().unwrap(), Action::GotoTables);
+        assert_eq!("goto_results".parse::<Action>().unwrap(), Action::GotoResults);
     }

crates/tsql/src/ui/key_hint_popup.rs (1)

31-38: Keep hint copy aligned with actual actions (and consider reusing Action::description()).
Right now the popup shows abbreviated strings (“tables”, “first row”) while config descriptions are richer (“tables/schema sidebar”, “first row/document start”). Reusing the existing description source (or at least aligning wording) will reduce UI drift.

Also applies to: 114-127

crates/tsql/src/app/app.rs (1)

1361-1368: Either mark hint_shown (or remove it) to keep KeySequenceHandler state coherent.
KeySequenceHandler has hint_shown, but the app never calls mark_hint_shown(), and should_show_hint() doesn’t consult it—so the flag is currently dead state.

@@
                 if self.key_sequence.should_show_hint() {
                     if let Some(pending_key) = self.key_sequence.pending() {
                         let hint_popup = KeyHintPopup::new(pending_key);
                         hint_popup.render(frame, size);
+                        self.key_sequence.mark_hint_shown();
                     }
                 }

crates/tsql/src/ui/key_sequence.rs (2)

88-109: Make hint_shown meaningful (or delete it) by gating should_show_hint().
Right now hint_shown doesn’t affect anything, so it’s confusing state. If you keep it, should_show_hint() should likely return false once hint_shown is true.

@@
     pub fn should_show_hint(&self) -> bool {
-        if let (Some(_), Some(since)) = (self.pending, self.pending_since) {
-            since.elapsed() >= Duration::from_millis(self.timeout_ms)
+        if self.hint_shown {
+            return false;
+        }
+        if let (Some(_), Some(since)) = (self.pending, self.pending_since) {
+            since.elapsed() >= Duration::from_millis(self.timeout_ms)
         } else {
             false
         }
     }

Also applies to: 101-109

---

173-178: Fix is_waiting() doc (or implement timeout-based auto-cancel) + reduce sleep-test flakiness.

• The is_waiting() comment says it considers timeout, but it doesn’t.
• test_should_show_hint_after_timeout using sleep(20ms) can be flaky; bump the margin.

@@
-    /// Check if there's a pending key and timeout hasn't been reached.
-    /// Useful for deciding whether to wait for more input.
+    /// Returns true if there is a pending key sequence.
     pub fn is_waiting(&self) -> bool {
         self.pending.is_some()
     }
@@
     fn test_should_show_hint_after_timeout() {
         let mut handler = KeySequenceHandler::new(10); // 10ms timeout for quick test
@@
-        sleep(Duration::from_millis(20));
+        sleep(Duration::from_millis(50));
         assert!(handler.should_show_hint());
     }

Also applies to: 286-295

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Disabled knowledge base sources:

• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

crates/tsql/src/app/app.rs (1)

1582-1630: Clearing legacy pending_key during sequences
Already addressed in this diff and previously called out.

crates/tsql/src/ui/key_sequence.rs (3)

116-136: Deduplicate state reset logic (cancel() vs complete()).
cancel() and complete() do the same thing; it’s easy for them to drift later.

 pub fn cancel(&mut self) {
-    self.pending = None;
-    self.pending_since = None;
-    self.hint_shown = false;
+    self.complete();
 }

---

137-147: Guard against starting a “first key” while already waiting (API footgun).
Right now process_first_key() will reset the timer/state even if a sequence is already pending; App currently guards this, but the handler API itself doesn’t. Consider making it a no-op (or cancel+restart) when self.pending.is_some().

---

291-300: Timeout test may be flaky under load.
The sleep(50ms) vs timeout=10ms is probably fine, but CI jitter can still bite. Consider increasing the margin (e.g., timeout 50ms + sleep 200ms) to reduce flakes.

crates/tsql/src/app/app.rs (4)

1361-1378: Compute hint visibility once per tick to avoid “marked shown but not rendered” edge cases.
Because should_show_hint() is time-based and called multiple times per loop, it can flip between calls. Recommend computing once before draw() and reusing the value in both places.

-            terminal.draw(|frame| {
+            let show_key_hint = self.key_sequence.should_show_hint();
+            let pending_key = self.key_sequence.pending();
+
+            terminal.draw(|frame| {
                 let size = frame.area();
                 ...
-                if self.key_sequence.should_show_hint() {
-                    if let Some(pending_key) = self.key_sequence.pending() {
+                if show_key_hint {
+                    if let Some(pending_key) = pending_key {
                         let hint_popup = KeyHintPopup::new(pending_key);
                         hint_popup.render(frame, size);
                     }
                 }
                 ...
             })?;

---

1375-1378: Tie mark_hint_shown() to the same computed “rendered” condition.
This pairs with the change above.

-            if self.key_sequence.should_show_hint() && !self.key_sequence.is_hint_shown() {
+            if show_key_hint && !self.key_sequence.is_hint_shown() {
                 self.key_sequence.mark_hint_shown();
             }

---

1582-1630: Clarify/lock in intended behavior for “invalid second key” (fallthrough vs consume).
Currently KeySequenceResult::Cancelled cancels and then lets the second key fall through to normal handling. That can be great (users don’t “lose” the key), but it also means g becomes a hard prefix that always eats the first key even if the user mistypes. Worth confirming this UX is intentional.

(Also: the else if key.code == KeyCode::Esc branch inside this block appears redundant because Esc is handled earlier in on_key().)

---

1732-1734: Dead check in grid ToggleSidebar branch (focus can’t be Sidebar here).
This branch is under Focus::Grid, so matches!(self.focus, Focus::Sidebar(_)) is always false.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Disabled knowledge base sources:

• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.