feat(command): add MTP/M2P midpoint-between-two-points modifier

Add MTP (Midpoint Between Two Points) as a keyword that can be typed
during any point-picking command (e.g. LINE) to suspend the current
command, prompt for two points, and return the midpoint to the parent.

- New Mid2PointCommand registered under both "MTP" and "M2P" aliases
- ReturnPoint CmdResult variant feeds the resolved midpoint back to
  the suspended parent command
- MTP/M2P typed during a point step suspends the active command and
  starts the midpoint modifier; Escape restores the parent command
- Preview wires show a rubber-band line with a triangle marker at
  the midpoint
- Character-by-character typing is routed correctly even with dynamic
  input active (digits no longer leak into dyn fields)
- Three automation tests cover the full workflow, ESC restoration, and
  dynamic-input character routing

src/app/automation.rs

@@ -1513,4 +1513,101 @@ mod tests {
         // Finish
         let _ = app.update(Message::CommandOptionPick(String::new()));
     }
+
+    #[test]
+    fn test_mtp_in_line_command() {
+        use crate::app::Message;
+        let mut app = OpenCADStudio::new_for_test();
+        app.automation_op(r#"{"op":"new"}"#);
+        {
+            app.tabs[0].scene.selection.borrow_mut().vp_size = (1920.0, 1080.0);
+            app.tabs[0].scene.sync_tiles_from_panes(1920.0, 1080.0);
+        }
+
+        // Start LINE
+        let _ = app.update(Message::CommandInput("LINE".to_string()));
+        let _ = app.update(Message::CommandSubmit);
+        assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("LINE"));
+
+        // Type M2P
+        let _ = app.update(Message::CommandInput("M2P".to_string()));
+        let _ = app.update(Message::CommandSubmit);
+        assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("MTP"));
+        assert!(app.tabs[0].suspended_cmd.is_some());
+        assert_eq!(app.tabs[0].suspended_cmd.as_ref().map(|c| c.name()), Some("LINE"));
+
+        // Point 1: 0,0
+        let _ = app.update(Message::CommandInput("0,0".to_string()));
+        let _ = app.update(Message::CommandSubmit);
+        assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("MTP"));
+
+        // Point 2: 10,20
+        let _ = app.update(Message::CommandInput("10,20".to_string()));
+        let _ = app.update(Message::CommandSubmit);
+
+        // MTP should have finished and restored LINE, with midpoint (5, 10, 0)
+        assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("LINE"));
+        assert!(app.tabs[0].suspended_cmd.is_none());
+        assert_eq!(app.last_point, Some(glam::DVec3::new(5.0, 10.0, 0.0)));
+
+        // Cancel LINE
+        let _ = app.update(Message::CommandEscape);
+        assert!(app.tabs[0].active_cmd.is_none());
+    }
+
+    #[test]
+    fn test_mtp_escape_restores_parent() {
+        use crate::app::Message;
+        let mut app = OpenCADStudio::new_for_test();
+        app.automation_op(r#"{"op":"new"}"#);
+
+        // Start LINE
+        let _ = app.update(Message::CommandInput("LINE".to_string()));
+        let _ = app.update(Message::CommandSubmit);
+        assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("LINE"));
+
+        // Type MTP
+        let _ = app.update(Message::CommandInput("MTP".to_string()));
+        let _ = app.update(Message::CommandSubmit);
+        assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("MTP"));
+
+        // Escape during MTP
+        let _ = app.update(Message::CommandEscape);
+        // Parent LINE must be restored, not cancelled!
+        assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("LINE"));
+        assert!(app.tabs[0].suspended_cmd.is_none());
+
+        // Escape again cancels LINE
+        let _ = app.update(Message::CommandEscape);
+        assert!(app.tabs[0].active_cmd.is_none());
+    }
+
+    #[test]
+    fn test_mtp_typing_routing_with_dyn_input() {
+        use crate::app::Message;
+        let mut app = OpenCADStudio::new_for_test();
+        app.automation_op(r#"{"op":"new"}"#);
+        app.dyn_input = true;
+
+        // Start LINE
+        let _ = app.update(Message::CommandInput("LINE".to_string()));
+        let _ = app.update(Message::CommandSubmit);
+        assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("LINE"));
+
+        // Simulate typing 'm', '2', 'p' character by character
+        let _ = app.update(Message::CommandAppendChar("m".to_string()));
+        assert_eq!(app.command_line.input, "M");
+
+        // The digit '2' must stay in command_line.input instead of routing to dyn fields!
+        let _ = app.update(Message::CommandAppendChar("2".to_string()));
+        assert_eq!(app.command_line.input, "M2");
+
+        let _ = app.update(Message::CommandAppendChar("p".to_string()));
+        assert_eq!(app.command_line.input, "M2P");
+
+        // Submit triggers MTP
+        let _ = app.update(Message::CommandSubmit);
+        assert_eq!(app.tabs[0].active_cmd.as_ref().map(|c| c.name()), Some("MTP"));
+    }
 }
+

src/app/command_driver.rs

@@ -671,6 +671,29 @@ impl OpenCADStudio {
             }
             return Task::none();
         }
+        let is_mtp = token.trim_start_matches('_').eq_ignore_ascii_case("MTP")
+            || token.trim_start_matches('_').eq_ignore_ascii_case("M2P");
+        if is_mtp {
+            let is_point_step = !self.tabs[i]
+                .active_cmd
+                .as_ref()
+                .map(|c| c.input_kind().wants_text())
+                .unwrap_or(true)
+                || self.tabs[i]
+                    .active_cmd
+                    .as_ref()
+                    .map(|c| c.point_step_accepts_keywords())
+                    .unwrap_or(false);
+            let not_entity_pick = !self.tabs[i]
+                .active_cmd
+                .as_ref()
+                .map(|c| c.needs_entity_pick())
+                .unwrap_or(false);
+            if is_point_step && not_entity_pick {
+                self.start_mtp_modifier(i);
+                return Task::none();
+            }
+        }
         if let Some((coord, kind)) = super::helpers::parse_coord(token) {
             // Match the GUI command line: typed coordinates are in the active
             // UCS (relative offsets are rotated by the UCS axes), so a multi-
@@ -712,7 +735,22 @@ impl OpenCADStudio {
     /// pick-first selector relaunching MOVE on the picked set works this way).
     /// Pure-selection commands (SELECTALL, QSELECT, …) run without an active
     /// command, so `was_active` is false and their selection is preserved.
-    pub(super) fn apply_cmd_result(&mut self, result: CmdResult) -> Task<Message> {
+    pub(super) fn apply_cmd_result(&mut self, mut result: CmdResult) -> Task<Message> {
+        let i = self.active_tab;
+        if let CmdResult::ReturnPoint(pt) = result {
+            self.tabs[i].scene.clear_preview_wire();
+            if let Some(mut suspended) = self.tabs[i].suspended_cmd.take() {
+                self.last_point = Some(pt);
+                let next_res = suspended.on_point(pt);
+                self.tabs[i].active_cmd = Some(suspended);
+                result = next_res;
+            } else {
+                self.tabs[i].active_cmd = None;
+                self.tabs[i].snap_result = None;
+                self.restore_pre_cmd_tangent();
+                return Task::none();
+            }
+        }
         let settings = self.tabs[self.active_tab]
             .active_cmd
             .as_ref()
@@ -877,6 +915,18 @@ impl OpenCADStudio {
         TableCellEditStart::Started
     }
 
+    pub(in crate::app) fn start_mtp_modifier(&mut self, i: usize) {
+        let parent = self.tabs[i].active_cmd.take();
+        self.tabs[i].suspended_cmd = parent;
+        self.tabs[i].scene.clear_preview_wire();
+        let cmd = crate::command::Mid2PointCommand::new();
+        let prompt = crate::command::CadCommand::prompt(&cmd);
+        self.tabs[i].active_cmd = Some(Box::new(cmd));
+        self.command_line.push_info(&prompt);
+        self.command_line.set_step_options(Vec::new());
+        self.refresh_active_cmd_preview(i);
+    }
+
     fn apply_cmd_result_inner(&mut self, result: CmdResult) -> Task<Message> {
         let i = self.active_tab;
         let preserve_commit_layer = self.tabs[i]
@@ -2439,14 +2489,30 @@ impl OpenCADStudio {
             cancel @ (CmdResult::Cancel | CmdResult::CancelForSpaceChange) => {
                 let space_changed = matches!(cancel, CmdResult::CancelForSpaceChange);
                 self.tabs[i].scene.clear_preview_wire();
-                self.tabs[i].active_cmd = None;
-                self.tabs[i].snap_result = None;
-                self.restore_pre_cmd_tangent();
-                self.command_line.push_info(crate::t!(if space_changed {
-                    "Command cancelled because the active drawing space changed."
+                if !space_changed && self.tabs[i].suspended_cmd.is_some() {
+                    self.tabs[i].active_cmd = self.tabs[i].suspended_cmd.take();
+                    let prompt = self.tabs[i].active_cmd.as_ref().map(|c| c.prompt());
+                    if let Some(p) = prompt {
+                        self.command_line.push_info(&p);
+                    }
+                    let opts = self.tabs[i]
+                        .active_cmd
+                        .as_ref()
+                        .map(|c| c.options())
+                        .unwrap_or_default();
+                    self.command_line.set_step_options(opts);
+                    self.refresh_active_cmd_preview(i);
                 } else {
-                    "Command cancelled."
-                }).as_ref());
+                    self.tabs[i].suspended_cmd = None;
+                    self.tabs[i].active_cmd = None;
+                    self.tabs[i].snap_result = None;
+                    self.restore_pre_cmd_tangent();
+                    self.command_line.push_info(crate::t!(if space_changed {
+                        "Command cancelled because the active drawing space changed."
+                    } else {
+                        "Command cancelled."
+                    }).as_ref());
+                }
             }
             CmdResult::SelectByPath {
                 path,
@@ -4751,6 +4817,12 @@ impl OpenCADStudio {
                 self.tabs[i].scene.clear_preview_wire();
                 self.restore_pre_cmd_tangent();
             }
+            CmdResult::ReturnPoint(_) => {
+                self.tabs[i].active_cmd = None;
+                self.tabs[i].snap_result = None;
+                self.tabs[i].scene.clear_preview_wire();
+                self.restore_pre_cmd_tangent();
+            }
         }
         // When no command is running the ribbon tool button still has to
         // visually deactivate. Keyboard focus is assigned below to whichever

src/app/update/command.rs

@@ -191,7 +191,11 @@ pub(super) fn on_tab_close(&mut self, idx: usize) -> Task<Message> {
                             c.is_ascii_digit()
                                 || matches!(c, '.' | '-' | '+' | '*' | '/' | '^' | '%' | '(' | ')')
                         });
-                    if dyn_field_char && self.dyn_input && !self.tabs[i].dyn_fields.is_empty() {
+                    if dyn_field_char
+                        && self.command_line.input.is_empty()
+                        && self.dyn_input
+                        && !self.tabs[i].dyn_fields.is_empty()
+                    {
                         let a = self.tabs[i]
                             .dyn_active
                             .min(self.tabs[i].dyn_fields.len() - 1);
@@ -634,6 +638,30 @@ pub(super) fn on_tab_close(&mut self, idx: usize) -> Task<Message> {
                         .map(|c| c.is_free_text_step())
                         .unwrap_or(false);
                     let raw = self.command_line.input.trim().to_string();
+                    let is_mtp = raw.trim_start_matches('_').eq_ignore_ascii_case("MTP")
+                        || raw.trim_start_matches('_').eq_ignore_ascii_case("M2P");
+                    if is_mtp {
+                        let is_point_step = !self.tabs[i]
+                            .active_cmd
+                            .as_ref()
+                            .map(|c| c.input_kind().wants_text())
+                            .unwrap_or(true)
+                            || self.tabs[i]
+                                .active_cmd
+                                .as_ref()
+                                .map(|c| c.point_step_accepts_keywords())
+                                .unwrap_or(false);
+                        let not_entity_pick = !self.tabs[i]
+                            .active_cmd
+                            .as_ref()
+                            .map(|c| c.needs_entity_pick())
+                            .unwrap_or(false);
+                        if is_point_step && not_entity_pick {
+                            self.command_line.input.clear();
+                            self.start_mtp_modifier(i);
+                            return self.focus_cmd_input();
+                        }
+                    }
                     let text = if free_text {
                         raw
                     } else {