From c13cc7cc5c8ac8d972d6e0eaf42bb238f814386b Mon Sep 17 00:00:00 2001
From: Kenneth Yang <kjy5@uw.edu>
Date: Mon, 29 Dec 2025 13:41:42 -0800
Subject: [PATCH 01/12] WIP drew trajectory

---
 .../AutomationInspectorViewModel.cs           | 534 ++++++++++++++++--
 1 file changed, 499 insertions(+), 35 deletions(-)

diff --git a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
index 7f5cbf09..d3e95a1a 100644
--- a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
+++ b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
@@ -1,9 +1,14 @@
+using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Globalization;
 using System.Linq;
 using BrainAtlas;
+using EphysLink;
+using KS.Diagnostics;
 using Models;
 using Models.Scene;
+using Pinpoint.Probes;
 using Services;
 using Unity.AppUI.MVVM;
 using Unity.AppUI.Redux;
@@ -85,6 +90,50 @@ public partial class AutomationInspectorViewModel
 
         #endregion
 
+        #region Trajectory and Visualization Fields
+
+        /// <summary>
+        ///     Trajectory broken into 3 stages (for 3 axes of movement).
+        /// </summary>
+        /// <remarks>Execution order: DV, AP, ML. Defaults to negative infinity when there is no trajectory.</remarks>
+        private (Vector3 first, Vector3 second, Vector3 third) _trajectoryCoordinates = (
+            Vector3.negativeInfinity,
+            Vector3.negativeInfinity,
+            Vector3.negativeInfinity
+        );
+
+        /// <summary>
+        ///     Record the depth at the entry coordinate.
+        /// </summary>
+        /// <remarks>Used during insertion to calculate the actual distance needed to retract back to the entry coordinate.</remarks>
+        private float _entryCoordinateDepth;
+
+        /// <summary>
+        ///     Trajectory line GameObjects.
+        /// </summary>
+        private (GameObject ap, GameObject ml, GameObject dv) _trajectoryLineGameObjects;
+
+        /// <summary>
+        ///     Trajectory line renderers.
+        /// </summary>
+        private (LineRenderer ap, LineRenderer ml, LineRenderer dv) _trajectoryLineRenderers;
+
+        // Axes colors
+        private static readonly Color AP_COLOR = new(1, 0.3215686f, 0.3215686f); // Red
+        private static readonly Color ML_COLOR = new(0.2039216f, 0.6745098f, 0.8784314f); // Blue
+        private static readonly Color DV_COLOR = new(1, 0.854902f, 0.4745098f); // Yellow
+
+        // Trajectory line properties
+        private const float LINE_WIDTH = 0.1f;
+        private const int NUM_SEGMENTS = 2;
+
+        // Safety margin
+        private const float IDEAL_ENTRY_COORDINATE_TO_DURA_DISTANCE = 3.5f;
+
+        // Movement speed
+        private const float AUTOMATIC_MOVEMENT_SPEED = 0.5f; // mm/s
+        #endregion
+
         public AutomationInspectorViewModel(
             StoreService storeService,
             EphysLinkService ephysLinkService
@@ -161,10 +210,13 @@ private void OnSceneStateChanged(SceneState state)
             var selectedTargetInsertionProbeState = state.Probes.FirstOrDefault(probeState =>
                 probeState.Name == state.ActiveManipulatorState.TargetInsertionProbeName
             );
-            TargetInsertionProbeIndex = (selectedTargetInsertionProbeState == null
-                || !TargetInsertionProbeStates.Contains(selectedTargetInsertionProbeState))
-                ? -1
-                : TargetInsertionProbeStates.IndexOf(selectedTargetInsertionProbeState);
+            TargetInsertionProbeIndex =
+                (
+                    selectedTargetInsertionProbeState == null
+                    || !TargetInsertionProbeStates.Contains(selectedTargetInsertionProbeState)
+                )
+                    ? -1
+                    : TargetInsertionProbeStates.IndexOf(selectedTargetInsertionProbeState);
 
             // Update dura offset.
             DuraOffset = state.ActiveManipulatorState.DuraOffset;
@@ -202,6 +254,9 @@ private void OnShuttingDown()
         {
             App.shuttingDown -= OnShuttingDown;
             _sceneStateSubscription.Dispose();
+
+            // Clean up trajectory lines
+            RemoveTrajectoryLines();
         }
 
         #region Commands
@@ -232,17 +287,36 @@ private void SelectTargetInsertionProbe(int index)
                 ResetTargetInsertionProbeSelection();
                 return;
             }
-            
-            // Set the selected target insertion probe name in the store.
-            var selectedTargetInsertionProbeState = TargetInsertionProbeStates.ElementAt(
-                index
+
+            // Get the selected target insertion probe
+            var selectedTargetInsertionProbeState = TargetInsertionProbeStates.ElementAt(index);
+
+            // Get the probe manager for the selected target
+            var targetProbeManager = ProbeManager.Instances.FirstOrDefault(manager =>
+                manager.name == selectedTargetInsertionProbeState.Name
             );
+
+            if (targetProbeManager == null)
+            {
+                Debug.LogError(
+                    $"Target probe manager not found: {selectedTargetInsertionProbeState.Name}"
+                );
+                return;
+            }
+
+            // Set the selected target insertion probe name in the store
             _storeService.Store.Dispatch(
                 SceneActions.SET_TARGET_INSERTION_PROBE_NAME,
                 (ActiveManipulatorId, selectedTargetInsertionProbeState.Name)
             );
 
-            // TODO: Call ComputeEntryCoordinateTrajectory once it has been converted.
+            // Compute and visualize trajectory with the target probe manager
+            var entryCoordinate = ComputeTargetEntryCoordinateTrajectory(targetProbeManager);
+
+            if (float.IsNegativeInfinity(entryCoordinate.x))
+            {
+                Debug.LogWarning("Failed to compute trajectory for selected target probe");
+            }
         }
 
         [ICommand]
@@ -253,44 +327,189 @@ private void ResetTargetInsertionProbeSelection()
                 SceneActions.SET_TARGET_INSERTION_PROBE_NAME,
                 (ActiveManipulatorId, string.Empty)
             );
+
+            // Remove trajectory visualization
+            RemoveTrajectoryLines();
         }
 
         [ICommand]
-        private void DriveToTargetEntryCoordinate()
+        private async void DriveToTargetEntryCoordinate()
         {
-            ProbeService
-                .DriveActiveProbeToTargetEntryCoordinate()
-                .ContinueWith(task =>
+            // Validate trajectory exists
+            if (float.IsNegativeInfinity(_trajectoryCoordinates.first.x))
+            {
+                Debug.LogError($"No trajectory planned for manipulator {ActiveManipulatorId}");
+                return;
+            }
+
+            // Convert coordinates to manipulator positions
+            var dvPosition = ConvertInsertionAPMLDVToManipulatorPosition(
+                _trajectoryCoordinates.first
+            );
+            var apPosition = ConvertInsertionAPMLDVToManipulatorPosition(
+                _trajectoryCoordinates.second
+            );
+            var mlPosition = ConvertInsertionAPMLDVToManipulatorPosition(
+                _trajectoryCoordinates.third
+            );
+
+            // Check if conversion failed
+            if (dvPosition == null || apPosition == null || mlPosition == null)
+            {
+                HandleDriveFailed(
+                    "Failed to convert trajectory coordinates to manipulator positions"
+                );
+                return;
+            }
+
+            // Set state to driving
+            _storeService.Store.Dispatch(
+                SceneActions.SET_AUTOMATION_PROGRESS_STATE,
+                (ActiveManipulatorId, AutomationProgressState.DrivingToTargetEntryCoordinate)
+            );
+
+            // Log that movement is starting
+            OutputLog.Log(
+                new[]
                 {
-                    // Do not proceed if the drive failed.
-                    if (!task.Result)
-                        return;
+                    "Automation",
+                    DateTime.Now.ToString(CultureInfo.InvariantCulture),
+                    "DriveToTargetEntryCoordinate",
+                    ActiveManipulatorId,
+                    "Start",
+                }
+            );
 
-                    // Complete the drive state if successful.
-                    _storeService.Store.Dispatch(
-                        SceneActions.COMPLETE_AUTOMATION_INTERMEDIATE_PROGRESS,
-                        ActiveManipulatorId
-                    );
-                });
+            // Stage 1: DV movement
+            var dvResponse = await _ephysLinkService.SetPosition(
+                new SetPositionRequest(
+                    ActiveManipulatorId,
+                    dvPosition.Value,
+                    AUTOMATIC_MOVEMENT_SPEED
+                )
+            );
+
+            if (EphysLinkService.HasError(dvResponse.Error))
+            {
+                HandleDriveFailed("Failed to move to DV position");
+                return;
+            }
+
+            // Stage 2: AP movement
+            var apResponse = await _ephysLinkService.SetPosition(
+                new SetPositionRequest(
+                    ActiveManipulatorId,
+                    apPosition.Value,
+                    AUTOMATIC_MOVEMENT_SPEED
+                )
+            );
+
+            if (EphysLinkService.HasError(apResponse.Error))
+            {
+                HandleDriveFailed("Failed to move to AP position");
+                return;
+            }
+
+            // Stage 3: ML movement
+            var mlResponse = await _ephysLinkService.SetPosition(
+                new SetPositionRequest(
+                    ActiveManipulatorId,
+                    mlPosition.Value,
+                    AUTOMATIC_MOVEMENT_SPEED
+                )
+            );
+
+            if (EphysLinkService.HasError(mlResponse.Error))
+            {
+                HandleDriveFailed("Failed to move to ML position");
+                return;
+            }
+
+            // Record entry coordinate depth
+            var finalPositionResponse = await _ephysLinkService.GetPosition(ActiveManipulatorId);
+            if (EphysLinkService.HasError(finalPositionResponse.Error))
+            {
+                HandleDriveFailed("Failed to get final position at entry coordinate");
+                return;
+            }
+
+            _entryCoordinateDepth = finalPositionResponse.Position.w;
+
+            // Remove visualization lines
+            RemoveTrajectoryLines();
+
+            // Complete the drive state
+            _storeService.Store.Dispatch(
+                SceneActions.COMPLETE_AUTOMATION_INTERMEDIATE_PROGRESS,
+                ActiveManipulatorId
+            );
+
+            // Log completion
+            OutputLog.Log(
+                new[]
+                {
+                    "Automation",
+                    DateTime.Now.ToString(CultureInfo.InvariantCulture),
+                    "DriveToTargetEntryCoordinate",
+                    ActiveManipulatorId,
+                    "Finish",
+                }
+            );
+        }
+
+        private void HandleDriveFailed(string errorMessage)
+        {
+            Debug.LogError(errorMessage);
+            OutputLog.Log(
+                new[]
+                {
+                    "Automation",
+                    DateTime.Now.ToString(CultureInfo.InvariantCulture),
+                    "DriveToTargetEntryCoordinate",
+                    ActiveManipulatorId,
+                    $"Failed: {errorMessage}",
+                }
+            );
+
+            // Revert state to calibrated
+            _storeService.Store.Dispatch(
+                SceneActions.CANCEL_AUTOMATION_INTERMEDIATE_PROGRESS,
+                ActiveManipulatorId
+            );
         }
 
         [ICommand]
-        private void StopDriveToTargetEntryCoordinate()
+        private async void StopDriveToTargetEntryCoordinate()
         {
-            ProbeService
-                .StopActiveProbeDriveToTargetEntryCoordinate()
-                .ContinueWith(task =>
+            // Log stop request
+            OutputLog.Log(
+                new[]
                 {
-                    // Do not proceed if the drive failed.
-                    if (!task.Result)
-                        return;
+                    "Automation",
+                    DateTime.Now.ToString(CultureInfo.InvariantCulture),
+                    "DriveToTargetEntryCoordinate",
+                    ActiveManipulatorId,
+                    "Stopped",
+                }
+            );
 
-                    // Reset back to calibrated state.
-                    _storeService.Store.Dispatch(
-                        SceneActions.SET_AUTOMATION_PROGRESS_STATE,
-                        (ActiveManipulatorId, AutomationProgressState.IsCalibrated)
-                    );
-                });
+            // Send stop command to manipulator
+            var stopResponse = await _ephysLinkService.Stop(ActiveManipulatorId);
+
+            // Check for errors
+            if (EphysLinkService.HasError(stopResponse))
+            {
+                Debug.LogError($"Failed to stop drive: {stopResponse}");
+                return;
+            }
+
+            // Cancel intermediate progress (revert to IsCalibrated state)
+            _storeService.Store.Dispatch(
+                SceneActions.CANCEL_AUTOMATION_INTERMEDIATE_PROGRESS,
+                ActiveManipulatorId
+            );
+
+            // Note: Do NOT remove trajectory lines on stop - user may want to restart
         }
 
         [ICommand]
@@ -372,5 +591,250 @@ private void StopInsertionDrive()
         }
 
         #endregion
+
+        #region Trajectory Computation and Visualization
+
+        /// <summary>
+        ///     Compute the entry coordinate and trajectory for the target insertion. Also, create and update the trajectory visualization lines.
+        /// </summary>
+        /// <param name="targetProbeManager">The probe manager of the target insertion probe.</param>
+        /// <returns>
+        ///     The computed entry coordinate in AP, ML, DV coordinates. Vector3.negativeInfinity if target is unset or computation fails.
+        /// </returns>
+        private Vector3 ComputeTargetEntryCoordinateTrajectory(ProbeManager targetProbeManager)
+        {
+            // Validate target probe manager
+            if (targetProbeManager == null)
+            {
+                Debug.LogError("Target probe manager is null");
+                RemoveTrajectoryLines();
+                return Vector3.negativeInfinity;
+            }
+
+            // Check if BrainAtlasManager is ready
+            if (
+                BrainAtlasManager.Instance == null
+                || BrainAtlasManager.ActiveReferenceAtlas == null
+            )
+            {
+                Debug.LogWarning("BrainAtlasManager not ready for trajectory computation");
+                RemoveTrajectoryLines();
+                return Vector3.negativeInfinity;
+            }
+
+            // Compute entry coordinate in world space
+            var surfaceCoordinateWorldT = targetProbeManager.GetSurfaceCoordinateWorldT();
+            var tipForwardWorldU = targetProbeManager
+                .ProbeController.GetTipWorldU()
+                .tipForwardWorldU;
+
+            var entryCoordinateWorld =
+                surfaceCoordinateWorldT
+                - tipForwardWorldU * IDEAL_ENTRY_COORDINATE_TO_DURA_DISTANCE;
+
+            // Convert to AP/ML/DV coordinates
+            var entryCoordinateAtlasU = BrainAtlasManager.ActiveReferenceAtlas.World2Atlas(
+                entryCoordinateWorld
+            );
+            var entryCoordinateAPMLDV = BrainAtlasManager.ActiveAtlasTransform.U2T(
+                entryCoordinateAtlasU
+            );
+
+            // Get current manipulator coordinate.
+            var currentState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
+            var visualizationProbeName = currentState.ActiveManipulatorState.VisualizationProbeName;
+            var currentCoordinate = currentState
+                .Probes.FirstOrDefault(state => state.Name == visualizationProbeName)!
+                .APMLDV;
+
+            // Create 3-stage trajectory
+            // Stage 1: DV movement (change depth only)
+            _trajectoryCoordinates.first = new Vector3(
+                currentCoordinate.x,
+                currentCoordinate.y,
+                entryCoordinateAPMLDV.z
+            );
+
+            // Stage 2: AP movement (change AP only)
+            _trajectoryCoordinates.second = new Vector3(
+                entryCoordinateAPMLDV.x,
+                currentCoordinate.y,
+                entryCoordinateAPMLDV.z
+            );
+
+            // Stage 3: ML movement (final position)
+            _trajectoryCoordinates.third = entryCoordinateAPMLDV;
+
+            // Create and update trajectory lines
+            CreateTrajectoryLines();
+            UpdateTrajectoryLines();
+
+            // Return final entry coordinate
+            return _trajectoryCoordinates.third;
+        }
+
+        /// <summary>
+        ///     Create the trajectory line game objects and line renderers (if needed).
+        /// </summary>
+        private void CreateTrajectoryLines()
+        {
+            // Exit if they already exist
+            if (_trajectoryLineGameObjects.ap != null)
+                return;
+
+            // Create the trajectory line game objects
+            _trajectoryLineGameObjects = (
+                new GameObject("APTrajectoryLine") { layer = 5 },
+                new GameObject("MLTrajectoryLine") { layer = 5 },
+                new GameObject("DVTrajectoryLine") { layer = 5 }
+            );
+
+            // Create the line renderers
+            _trajectoryLineRenderers = (
+                _trajectoryLineGameObjects.ap.AddComponent<LineRenderer>(),
+                _trajectoryLineGameObjects.ml.AddComponent<LineRenderer>(),
+                _trajectoryLineGameObjects.dv.AddComponent<LineRenderer>()
+            );
+
+            // Apply materials
+            var defaultSpriteShader = Shader.Find("Sprites/Default");
+            _trajectoryLineRenderers.ap.material = new Material(defaultSpriteShader)
+            {
+                color = AP_COLOR,
+            };
+            _trajectoryLineRenderers.ml.material = new Material(defaultSpriteShader)
+            {
+                color = ML_COLOR,
+            };
+            _trajectoryLineRenderers.dv.material = new Material(defaultSpriteShader)
+            {
+                color = DV_COLOR,
+            };
+
+            // Set line widths
+            _trajectoryLineRenderers.ap.startWidth = _trajectoryLineRenderers.ap.endWidth =
+                LINE_WIDTH;
+            _trajectoryLineRenderers.ml.startWidth = _trajectoryLineRenderers.ml.endWidth =
+                LINE_WIDTH;
+            _trajectoryLineRenderers.dv.startWidth = _trajectoryLineRenderers.dv.endWidth =
+                LINE_WIDTH;
+
+            // Set segment counts
+            _trajectoryLineRenderers.ap.positionCount = NUM_SEGMENTS;
+            _trajectoryLineRenderers.ml.positionCount = NUM_SEGMENTS;
+            _trajectoryLineRenderers.dv.positionCount = NUM_SEGMENTS;
+        }
+
+        /// <summary>
+        ///     Update the trajectory line positions.
+        /// </summary>
+        private void UpdateTrajectoryLines()
+        {
+            if (
+                BrainAtlasManager.Instance == null
+                || BrainAtlasManager.ActiveReferenceAtlas == null
+            )
+                return;
+
+            // Get active probe manager for current tip position
+            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
+            var activeProbeManager = ProbeManager.Instances.FirstOrDefault(manager =>
+                manager.name == sceneState.ActiveManipulatorState.VisualizationProbeName
+            );
+
+            if (activeProbeManager == null)
+                return;
+
+            // DV line: From current probe tip to first coordinate
+            _trajectoryLineRenderers.dv.SetPosition(
+                0,
+                activeProbeManager.ProbeController.ProbeTipT.position
+            );
+            _trajectoryLineRenderers.dv.SetPosition(
+                1,
+                BrainAtlasManager.ActiveReferenceAtlas.Atlas2World(
+                    BrainAtlasManager.ActiveAtlasTransform.T2U_Vector(_trajectoryCoordinates.first)
+                )
+            );
+
+            // AP line: From first to second coordinate
+            _trajectoryLineRenderers.ap.SetPosition(
+                0,
+                BrainAtlasManager.ActiveReferenceAtlas.Atlas2World(
+                    BrainAtlasManager.ActiveAtlasTransform.T2U_Vector(_trajectoryCoordinates.first)
+                )
+            );
+            _trajectoryLineRenderers.ap.SetPosition(
+                1,
+                BrainAtlasManager.ActiveReferenceAtlas.Atlas2World(
+                    BrainAtlasManager.ActiveAtlasTransform.T2U_Vector(_trajectoryCoordinates.second)
+                )
+            );
+
+            // ML line: From second to third coordinate
+            _trajectoryLineRenderers.ml.SetPosition(
+                0,
+                BrainAtlasManager.ActiveReferenceAtlas.Atlas2World(
+                    BrainAtlasManager.ActiveAtlasTransform.T2U_Vector(_trajectoryCoordinates.second)
+                )
+            );
+            _trajectoryLineRenderers.ml.SetPosition(
+                1,
+                BrainAtlasManager.ActiveReferenceAtlas.Atlas2World(
+                    BrainAtlasManager.ActiveAtlasTransform.T2U_Vector(_trajectoryCoordinates.third)
+                )
+            );
+        }
+
+        /// <summary>
+        ///     Destroy the trajectory line game objects and line renderers. Also reset the references.
+        /// </summary>
+        private void RemoveTrajectoryLines()
+        {
+            // Destroy the objects
+            if (_trajectoryLineGameObjects.ap != null)
+                UnityEngine.Object.Destroy(_trajectoryLineGameObjects.ap);
+            if (_trajectoryLineGameObjects.ml != null)
+                UnityEngine.Object.Destroy(_trajectoryLineGameObjects.ml);
+            if (_trajectoryLineGameObjects.dv != null)
+                UnityEngine.Object.Destroy(_trajectoryLineGameObjects.dv);
+
+            // Reset the references
+            _trajectoryLineGameObjects = (null, null, null);
+            _trajectoryLineRenderers = (null, null, null);
+
+            // Reset trajectory coordinates
+            _trajectoryCoordinates = (
+                Vector3.negativeInfinity,
+                Vector3.negativeInfinity,
+                Vector3.negativeInfinity
+            );
+        }
+
+        /// <summary>
+        ///     Convert insertion AP, ML, DV coordinates to manipulator translation stage position.
+        /// </summary>
+        /// <param name="insertionAPMLDV">AP, ML, DV coordinates from an insertion.</param>
+        /// <returns>Computed manipulator translation stage positions to match this coordinate, or null if conversion fails.</returns>
+        private Vector4? ConvertInsertionAPMLDVToManipulatorPosition(Vector3 insertionAPMLDV)
+        {
+            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
+            var activeProbeManager = ProbeManager.Instances.FirstOrDefault(manager =>
+                manager.name == sceneState.ActiveManipulatorState.VisualizationProbeName
+            );
+
+            if (activeProbeManager == null || !activeProbeManager.IsEphysLinkControlled)
+            {
+                Debug.LogError("Active probe manager not found or not EphysLink controlled");
+                return null;
+            }
+
+            // Use the ManipulatorBehaviorController's conversion method
+            return activeProbeManager.ManipulatorBehaviorController.ConvertInsertionAPMLDVToManipulatorPosition(
+                insertionAPMLDV
+            );
+        }
+
+        #endregion
     }
 }

From 49e7ef7b879d32b19d39427e24f43dadb39424fb Mon Sep 17 00:00:00 2001
From: Kenneth Yang <kjy5@uw.edu>
Date: Mon, 29 Dec 2025 15:10:27 -0800
Subject: [PATCH 02/12] Drive to target insertion

---
 .../AutomationInspectorViewModel.cs           | 55 ++++++++++++++++---
 .../UI/Views/AutomationInspectorView.cs       |  7 +++
 2 files changed, 55 insertions(+), 7 deletions(-)

diff --git a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
index d3e95a1a..fb14c61d 100644
--- a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
+++ b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
@@ -4,10 +4,12 @@
 using System.Globalization;
 using System.Linq;
 using BrainAtlas;
+using BrainAtlas.CoordinateSystems;
 using EphysLink;
 using KS.Diagnostics;
 using Models;
 using Models.Scene;
+using Pinpoint.CoordinateSystems;
 using Pinpoint.Probes;
 using Services;
 using Unity.AppUI.MVVM;
@@ -819,20 +821,59 @@ private void RemoveTrajectoryLines()
         private Vector4? ConvertInsertionAPMLDVToManipulatorPosition(Vector3 insertionAPMLDV)
         {
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
-            var activeProbeManager = ProbeManager.Instances.FirstOrDefault(manager =>
-                manager.name == sceneState.ActiveManipulatorState.VisualizationProbeName
+            var activeManipulatorState = sceneState.ActiveManipulatorState;
+
+            // Validate we have the necessary data
+            if (BrainAtlasManager.ActiveReferenceAtlas == null)
+            {
+                Debug.LogError("BrainAtlasManager.ActiveReferenceAtlas is null");
+                return null;
+            }
+
+            if (sceneState.ManipulatorCoordinateSpace == null)
+            {
+                Debug.LogError("ManipulatorCoordinateSpace is null");
+                return null;
+            }
+
+            // Convert AP/ML/DV to world coordinate
+            var convertToWorld = BrainAtlasManager.ActiveReferenceAtlas.Atlas2World_Vector(
+                BrainAtlasManager.ActiveAtlasTransform.T2U_Vector(insertionAPMLDV)
             );
 
-            if (activeProbeManager == null || !activeProbeManager.IsEphysLinkControlled)
+            // Create coordinate transform based on manipulator configuration
+            var numAxes = sceneState.NumberOfAxesOnManipulator;
+            var isRightHanded = activeManipulatorState.Handedness == ManipulatorHandedness.Right;
+            var yaw = activeManipulatorState.Angles.x;
+            var pitch = activeManipulatorState.Angles.y;
+
+            CoordinateTransform coordinateTransform = numAxes switch
+            {
+                4 => isRightHanded
+                    ? new FourAxisRightHandedManipulatorTransform(yaw)
+                    : new FourAxisLeftHandedManipulatorTransform(yaw),
+                3 => new ThreeAxisLeftHandedTransform(yaw, pitch),
+                _ => null,
+            };
+
+            if (coordinateTransform == null)
             {
-                Debug.LogError("Active probe manager not found or not EphysLink controlled");
+                Debug.LogError($"Unsupported number of axes: {numAxes}");
                 return null;
             }
 
-            // Use the ManipulatorBehaviorController's conversion method
-            return activeProbeManager.ManipulatorBehaviorController.ConvertInsertionAPMLDVToManipulatorPosition(
-                insertionAPMLDV
+            // Convert to manipulator space
+            var posInManipulatorSpace = sceneState.ManipulatorCoordinateSpace.World2Space(
+                convertToWorld
             );
+            Vector4 posInManipulatorTransform = coordinateTransform.U2T(posInManipulatorSpace);
+
+            // Apply brain surface offset (DuraOffset)
+            var duraOffset = activeManipulatorState.DuraOffset;
+            posInManipulatorTransform.w -= float.IsNaN(duraOffset) ? 0 : duraOffset;
+
+            // Apply coordinate offsets and return result
+            return posInManipulatorTransform + activeManipulatorState.ReferenceCoordinateOffset;
         }
 
         #endregion
diff --git a/Assets/Scripts/UI/Views/AutomationInspectorView.cs b/Assets/Scripts/UI/Views/AutomationInspectorView.cs
index 9cca5824..c9fafd36 100644
--- a/Assets/Scripts/UI/Views/AutomationInspectorView.cs
+++ b/Assets/Scripts/UI/Views/AutomationInspectorView.cs
@@ -116,9 +116,16 @@ public AutomationInspectorView(AutomationInspectorViewModel automationInspectorV
             var targetEntryDriveButton = root.Q<Button>(
                 "automation-inspector__target-entry--drive-button"
             );
+            targetEntryDriveButton.clickable.clicked += _automationInspectorViewModel
+                .DriveToTargetEntryCoordinateCommand
+                .Execute;
+
             var targetEntryStopButton = root.Q<Button>(
                 "automation-inspector__target-entry--stop-button"
             );
+            targetEntryStopButton.clickable.clicked += _automationInspectorViewModel
+                .StopDriveToTargetEntryCoordinateCommand
+                .Execute;
 
             // Dura offset controls.
             var duraOffsetResetButton = root.Q<IconButton>(

From 74e7d446e85dab6008c4bef90ce5f10ff86832cc Mon Sep 17 00:00:00 2001
From: Kenneth Yang <kjy5@uw.edu>
Date: Mon, 29 Dec 2025 16:39:51 -0800
Subject: [PATCH 03/12] fixed update delay

---
 Assets/Scripts/Services/EphysLinkService.cs | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/Assets/Scripts/Services/EphysLinkService.cs b/Assets/Scripts/Services/EphysLinkService.cs
index 9967080d..37592ca5 100644
--- a/Assets/Scripts/Services/EphysLinkService.cs
+++ b/Assets/Scripts/Services/EphysLinkService.cs
@@ -704,16 +704,6 @@ var manipulatorState in sceneState.Manipulators.Where(state =>
                     referenceCoordinateAdjustedWorldPosition
                 );
 
-                // Cancel update if the manipulator's position did not change by a lot.
-                var probeState = sceneState.Probes.FirstOrDefault(state =>
-                    state.Name == manipulatorState.VisualizationProbeName
-                );
-                if (
-                    probeState == null
-                    || Vector3.SqrMagnitude(transformedAPMLDV - probeState.APMLDV) < 0.0001f
-                )
-                    continue;
-
                 // Get the current forward vector of the probe.
                 var forwardT = BrainAtlasManager.ActiveAtlasTransform.U2T_Vector(
                     BrainAtlasManager.ActiveReferenceAtlas.World2Atlas_Vector(

From 41eace73ace8373a99ac6b7805c8cfbee228a535 Mon Sep 17 00:00:00 2001
From: Kenneth Yang <kjy5@uw.edu>
Date: Mon, 29 Dec 2025 18:11:50 -0800
Subject: [PATCH 04/12] Reset dura

---
 .../Probes/Controllers/CartesianProbeController.cs         | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Assets/Scripts/Pinpoint/Probes/Controllers/CartesianProbeController.cs b/Assets/Scripts/Pinpoint/Probes/Controllers/CartesianProbeController.cs
index dcd7e8dd..d14b61fb 100644
--- a/Assets/Scripts/Pinpoint/Probes/Controllers/CartesianProbeController.cs
+++ b/Assets/Scripts/Pinpoint/Probes/Controllers/CartesianProbeController.cs
@@ -942,6 +942,13 @@ private void UpdateVisualizationProbePosition()
         transform.RotateAround(_probeTipT.position, transform.right, VisualizationLocalAngles.y);
         transform.RotateAround(_probeTipT.position, transform.forward, -VisualizationLocalAngles.z);
 
+        // Apply brain surface depth offset (persistent offset from manipulator position).
+        // This offset is set by EphysLinkService and should not be reset.
+        if (VisualizationLocalDepth != 0f)
+        {
+            transform.position += transform.forward * VisualizationLocalDepth;
+        }
+
         // Update tip coords.
         SetTipWorldU();
 

From fcb3fb769fed673ab99299607e22f4c219d9b528 Mon Sep 17 00:00:00 2001
From: Kenneth Yang <kjy5@uw.edu>
Date: Mon, 29 Dec 2025 21:34:05 -0800
Subject: [PATCH 05/12] Set default drive past distance

---
 Assets/Scripts/Models/Scene/ManipulatorState.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Assets/Scripts/Models/Scene/ManipulatorState.cs b/Assets/Scripts/Models/Scene/ManipulatorState.cs
index f4a076e7..5bb4ac4e 100644
--- a/Assets/Scripts/Models/Scene/ManipulatorState.cs
+++ b/Assets/Scripts/Models/Scene/ManipulatorState.cs
@@ -67,7 +67,7 @@ public record ManipulatorState
         /// <summary>
         /// Drive past target distance (µm).
         /// </summary>
-        public int DrivePastDistance;
+        public int DrivePastDistance = 50;
 
         #endregion
 

From 433f1b03e335fa39e0130809068ebe7690c96570 Mon Sep 17 00:00:00 2001
From: Kenneth Yang <kjy5@uw.edu>
Date: Mon, 29 Dec 2025 23:27:38 -0800
Subject: [PATCH 06/12] WIP insertion code somehow broke targetting code

---
 .../AutomationInspectorViewModel.cs           | 600 +++++++++++++++++-
 .../UI/Views/AutomationInspectorView.cs       |  15 +
 2 files changed, 595 insertions(+), 20 deletions(-)

diff --git a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
index fb14c61d..0a34978a 100644
--- a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
+++ b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
@@ -3,6 +3,7 @@
 using System.ComponentModel;
 using System.Globalization;
 using System.Linq;
+using System.Threading;
 using BrainAtlas;
 using BrainAtlas.CoordinateSystems;
 using EphysLink;
@@ -136,6 +137,35 @@ public partial class AutomationInspectorViewModel
         private const float AUTOMATIC_MOVEMENT_SPEED = 0.5f; // mm/s
         #endregion
 
+        #region Insertion Constants
+
+        /// <summary>
+        ///     Distance from target to start slowing down probe (mm).
+        /// </summary>
+        private const float NEAR_TARGET_DISTANCE = 1f;
+
+        /// <summary>
+        ///     Slowdown factor for the probe when it is near the target.
+        /// </summary>
+        private const float NEAR_TARGET_SPEED_MULTIPLIER = 2f / 3f;
+
+        /// <summary>
+        ///     Extra speed multiplier for the probe when it is exiting.
+        /// </summary>
+        private const int EXIT_DRIVE_SPEED_MULTIPLIER = 6;
+
+        /// <summary>
+        ///     Extra safety margin for the Dura to outside (mm).
+        /// </summary>
+        private const float DURA_MARGIN_DISTANCE = 0.2f;
+
+        /// <summary>
+        ///     Cancellation token source for stopping ongoing insertion/exit operations.
+        /// </summary>
+        private CancellationTokenSource _insertionDriveCts;
+
+        #endregion
+
         public AutomationInspectorViewModel(
             StoreService storeService,
             EphysLinkService ephysLinkService
@@ -559,37 +589,370 @@ private void SetCustomInsertionSpeed(int customSpeed)
         }
 
         [ICommand]
-        private void InsertionDrive()
+        private async void InsertionDrive()
         {
-            // State is updated externally by the ProbeService.
-            // _probeService.InsertionDriveActiveProbe();
-        }
+            // Validate state is insertable.
+            if (!IsInsertable(AutomationProgressState))
+            {
+                Debug.LogError(
+                    $"Cannot drive: not in insertable state. Current state: {AutomationProgressState}"
+                );
+                return;
+            }
 
-        [ICommand]
-        private void InsertionExit()
-        {
-            // State is updated externally by the ProbeService.
-            // _ = _probeService.InsertionExitActiveProbe();
+            // Get scene state and target probe manager.
+            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
+            var manipulatorState = sceneState.ActiveManipulatorState;
+
+            var targetProbeManager = ProbeManager.Instances.FirstOrDefault(m =>
+                m.name == manipulatorState.TargetInsertionProbeName
+            );
+            if (targetProbeManager == null)
+            {
+                Debug.LogError(
+                    $"Target probe manager not found: {manipulatorState.TargetInsertionProbeName}"
+                );
+                return;
+            }
+
+            // Convert speed from µm/s to mm/s.
+            var baseSpeed = CustomInsertionSpeed / 1000f;
+            var drivePastDistance = DrivePastDistance / 1000f;
+
+            // Set up cancellation token.
+            _insertionDriveCts = new CancellationTokenSource();
+
+            // Store initial ETA for progress calculation.
+            _originalETA = ComputeEtaSeconds(targetProbeManager, baseSpeed, drivePastDistance);
+
+            try
+            {
+                while (AutomationProgressState != AutomationProgressState.AtTarget)
+                {
+                    // Check for cancellation.
+                    _insertionDriveCts.Token.ThrowIfCancellationRequested();
+
+                    // Get target depth.
+                    var targetDepth = GetTargetDepth(targetProbeManager);
+
+                    // Set state to next driving state.
+                    _storeService.Store.Dispatch(
+                        SceneActions.SET_AUTOMATION_PROGRESS_STATE_TO_NEXT_DRIVING,
+                        ActiveManipulatorId
+                    );
+
+                    // Log set to driving state.
+                    LogDriveToTargetInsertion(targetDepth, baseSpeed, drivePastDistance);
+
+                    // Update ETA.
+                    Eta = ComputeEtaSeconds(targetProbeManager, baseSpeed, drivePastDistance);
+                    DriveProgressPercentage =
+                        _originalETA > 0 ? 1f - (float)Eta / _originalETA : 0f;
+
+                    // Handle driving state.
+                    switch (AutomationProgressState)
+                    {
+                        case AutomationProgressState.DrivingToNearTarget:
+                            // Drive to near target if not already there.
+                            if (
+                                GetCurrentDistanceToTarget(targetProbeManager)
+                                > NEAR_TARGET_DISTANCE
+                            )
+                            {
+                                var driveToNearTargetResponse = await _ephysLinkService.SetDepth(
+                                    new SetDepthRequest(
+                                        ActiveManipulatorId,
+                                        targetDepth - NEAR_TARGET_DISTANCE,
+                                        baseSpeed
+                                    )
+                                );
+
+                                if (EphysLinkService.HasError(driveToNearTargetResponse.Error))
+                                {
+                                    Debug.LogError(
+                                        $"Failed to drive to near target: {driveToNearTargetResponse.Error}"
+                                    );
+                                    return;
+                                }
+                            }
+                            break;
+
+                        case AutomationProgressState.DrivingToPastTarget:
+                            // Drive past target at reduced speed.
+                            var driveToPastTargetResponse = await _ephysLinkService.SetDepth(
+                                new SetDepthRequest(
+                                    ActiveManipulatorId,
+                                    targetDepth + drivePastDistance,
+                                    baseSpeed * NEAR_TARGET_SPEED_MULTIPLIER
+                                )
+                            );
+
+                            if (EphysLinkService.HasError(driveToPastTargetResponse.Error))
+                            {
+                                Debug.LogError(
+                                    $"Failed to drive past target: {driveToPastTargetResponse.Error}"
+                                );
+                                return;
+                            }
+                            break;
+
+                        case AutomationProgressState.ReturningToTarget:
+                            // Return to target at reduced speed.
+                            var returnToTargetResponse = await _ephysLinkService.SetDepth(
+                                new SetDepthRequest(
+                                    ActiveManipulatorId,
+                                    targetDepth,
+                                    baseSpeed * NEAR_TARGET_SPEED_MULTIPLIER
+                                )
+                            );
+
+                            if (EphysLinkService.HasError(returnToTargetResponse.Error))
+                            {
+                                Debug.LogError(
+                                    $"Failed to return to target: {returnToTargetResponse.Error}"
+                                );
+                                return;
+                            }
+                            break;
+                    }
+
+                    // Complete this phase.
+                    _storeService.Store.Dispatch(
+                        SceneActions.COMPLETE_AUTOMATION_INTERMEDIATE_PROGRESS,
+                        ActiveManipulatorId
+                    );
+
+                    // Log the event.
+                    LogDriveToTargetInsertion(targetDepth, baseSpeed, drivePastDistance);
+                }
+
+                // Drive complete - reset ETA and progress.
+                Eta = 0;
+                DriveProgressPercentage = 1f;
+            }
+            catch (OperationCanceledException)
+            {
+                // Stopped by user - state already handled by StopInsertionDrive.
+            }
+            finally
+            {
+                _insertionDriveCts?.Dispose();
+                _insertionDriveCts = null;
+            }
         }
 
         [ICommand]
-        private void StopInsertionDrive()
+        private async void InsertionExit()
         {
-            // State is updated externally by the ProbeService.
-            ProbeService
-                .StopInsertionDriveActiveProbe()
-                .ContinueWith(task =>
+            // Validate state is exitable.
+            if (!IsExitable(AutomationProgressState))
+            {
+                Debug.LogError(
+                    $"Cannot exit: not in exitable state. Current state: {AutomationProgressState}"
+                );
+                return;
+            }
+
+            // Get scene state and target probe manager.
+            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
+            var manipulatorState = sceneState.ActiveManipulatorState;
+
+            var targetProbeManager = ProbeManager.Instances.FirstOrDefault(m =>
+                m.name == manipulatorState.TargetInsertionProbeName
+            );
+            if (targetProbeManager == null)
+            {
+                Debug.LogError(
+                    $"Target probe manager not found: {manipulatorState.TargetInsertionProbeName}"
+                );
+                return;
+            }
+
+            // Convert speed from µm/s to mm/s.
+            var baseSpeed = CustomInsertionSpeed / 1000f;
+            var drivePastDistance = DrivePastDistance / 1000f;
+
+            // Set up cancellation token.
+            _insertionDriveCts = new CancellationTokenSource();
+
+            // Store initial ETA for progress calculation.
+            _originalETA = ComputeEtaSeconds(targetProbeManager, baseSpeed, drivePastDistance);
+
+            try
+            {
+                while (AutomationProgressState != AutomationProgressState.AtTargetEntryCoordinate)
                 {
-                    // Do not proceed if the stop failed.
-                    if (!task.Result)
-                        return;
+                    // Check for cancellation.
+                    _insertionDriveCts.Token.ThrowIfCancellationRequested();
+
+                    // Get dura depth for exit calculations.
+                    var currentManipulatorState = _storeService
+                        .Store.GetState<SceneState>(SliceNames.SCENE_SLICE)
+                        .ActiveManipulatorState;
+                    var duraDepth = currentManipulatorState.DuraDepth;
 
-                    // If the stop was successful, cancel the intermediate progress state.
+                    // Set state to next exiting state.
                     _storeService.Store.Dispatch(
-                        SceneActions.CANCEL_AUTOMATION_INTERMEDIATE_PROGRESS,
+                        SceneActions.SET_AUTOMATION_PROGRESS_STATE_TO_NEXT_EXITING,
                         ActiveManipulatorId
                     );
-                });
+
+                    // Log set to exiting state.
+                    LogDriveToTargetInsertion(duraDepth, baseSpeed);
+
+                    // Update ETA.
+                    Eta = ComputeEtaSeconds(targetProbeManager, baseSpeed, drivePastDistance);
+                    DriveProgressPercentage =
+                        _originalETA > 0 ? 1f - (float)Eta / _originalETA : 0f;
+
+                    // Handle exiting state.
+                    switch (AutomationProgressState)
+                    {
+                        case AutomationProgressState.ExitingToDura:
+                            // Exit back up to the Dura.
+                            var exitToDuraResponse = await _ephysLinkService.SetDepth(
+                                new SetDepthRequest(
+                                    ActiveManipulatorId,
+                                    duraDepth,
+                                    baseSpeed * EXIT_DRIVE_SPEED_MULTIPLIER
+                                )
+                            );
+
+                            if (EphysLinkService.HasError(exitToDuraResponse.Error))
+                            {
+                                Debug.LogError(
+                                    $"Failed to exit to dura: {exitToDuraResponse.Error}"
+                                );
+                                return;
+                            }
+                            break;
+
+                        case AutomationProgressState.ExitingToMargin:
+                            // Reset dura offset.
+                            _storeService.Store.Dispatch(
+                                SceneActions.RESET_DURA_OFFSET,
+                                ActiveManipulatorId
+                            );
+
+                            // Exit to the safe margin above the Dura.
+                            var exitToMarginResponse = await _ephysLinkService.SetDepth(
+                                new SetDepthRequest(
+                                    ActiveManipulatorId,
+                                    duraDepth - DURA_MARGIN_DISTANCE,
+                                    baseSpeed * EXIT_DRIVE_SPEED_MULTIPLIER
+                                )
+                            );
+
+                            if (EphysLinkService.HasError(exitToMarginResponse.Error))
+                            {
+                                Debug.LogError(
+                                    $"Failed to exit to margin: {exitToMarginResponse.Error}"
+                                );
+                                return;
+                            }
+                            break;
+
+                        case AutomationProgressState.ExitingToTargetEntryCoordinate:
+                            // Drive to the target entry coordinate.
+                            var entryPosition = ConvertInsertionAPMLDVToManipulatorPosition(
+                                _trajectoryCoordinates.third
+                            );
+                            if (entryPosition == null)
+                            {
+                                Debug.LogError(
+                                    "Failed to convert entry coordinate to manipulator position"
+                                );
+                                return;
+                            }
+
+                            var exitToEntryCoordinateResponse = await _ephysLinkService.SetPosition(
+                                new SetPositionRequest(
+                                    ActiveManipulatorId,
+                                    entryPosition.Value,
+                                    AUTOMATIC_MOVEMENT_SPEED
+                                )
+                            );
+
+                            if (EphysLinkService.HasError(exitToEntryCoordinateResponse.Error))
+                            {
+                                Debug.LogError(
+                                    $"Failed to exit to entry coordinate: {exitToEntryCoordinateResponse.Error}"
+                                );
+                                return;
+                            }
+                            break;
+                    }
+
+                    // Complete this phase.
+                    _storeService.Store.Dispatch(
+                        SceneActions.COMPLETE_AUTOMATION_INTERMEDIATE_PROGRESS,
+                        ActiveManipulatorId
+                    );
+
+                    // Log the event.
+                    LogDriveToTargetInsertion(duraDepth, baseSpeed);
+                }
+
+                // Exit complete - reset ETA and progress.
+                Eta = 0;
+                DriveProgressPercentage = 1f;
+            }
+            catch (OperationCanceledException)
+            {
+                // Stopped by user - state already handled by StopInsertionDrive.
+            }
+            finally
+            {
+                _insertionDriveCts?.Dispose();
+                _insertionDriveCts = null;
+            }
+        }
+
+        [ICommand]
+        private async void StopInsertionDrive()
+        {
+            // Cancel ongoing drive operation.
+            _insertionDriveCts?.Cancel();
+
+            // Send stop command to manipulator.
+            var stopResponse = await _ephysLinkService.Stop(ActiveManipulatorId);
+
+            if (EphysLinkService.HasError(stopResponse))
+            {
+                Debug.LogError($"Failed to stop: {stopResponse}");
+                return;
+            }
+
+            // Log stop event.
+            OutputLog.Log(
+                new[]
+                {
+                    "Automation",
+                    DateTime.Now.ToString(CultureInfo.InvariantCulture),
+                    "Drive",
+                    ActiveManipulatorId,
+                    "Stop",
+                }
+            );
+
+            // Cancel intermediate progress (revert state).
+            _storeService.Store.Dispatch(
+                SceneActions.CANCEL_AUTOMATION_INTERMEDIATE_PROGRESS,
+                ActiveManipulatorId
+            );
+
+            // Reset ETA and progress.
+            Eta = 0;
+            DriveProgressPercentage = 0f;
+        }
+
+        [ICommand]
+        private void SetDrivePastDistance(int distance)
+        {
+            _storeService.Store.Dispatch(
+                SceneActions.SET_DRIVE_PAST_DISTANCE,
+                (ActiveManipulatorId, distance)
+            );
         }
 
         #endregion
@@ -877,5 +1240,202 @@ private void RemoveTrajectoryLines()
         }
 
         #endregion
+
+        #region Insertion Helper Methods
+
+        /// <summary>
+        ///     Check if the current state allows starting or resuming insertion drive.
+        /// </summary>
+        private static bool IsInsertable(AutomationProgressState state)
+        {
+            return state
+                is AutomationProgressState.AtDuraInsert
+                    or AutomationProgressState.AtNearTargetInsert
+                    or AutomationProgressState.AtPastTarget
+                    or AutomationProgressState.AtTarget;
+        }
+
+        /// <summary>
+        ///     Check if the current state allows starting or resuming exit.
+        /// </summary>
+        private static bool IsExitable(AutomationProgressState state)
+        {
+            return state
+                is AutomationProgressState.AtDuraInsert
+                    or AutomationProgressState.AtNearTargetInsert
+                    or AutomationProgressState.AtPastTarget
+                    or AutomationProgressState.AtTarget
+                    or AutomationProgressState.AtDuraExit
+                    or AutomationProgressState.AtExitMargin;
+        }
+
+        /// <summary>
+        ///     Compute the target coordinate adjusted for the probe's actual position.
+        /// </summary>
+        /// <param name="targetInsertionProbeManager">Target probe manager.</param>
+        /// <returns>APMLDV coordinates of where the probe should actually go.</returns>
+        private Vector3 GetOffsetAdjustedTargetCoordinate(ProbeManager targetInsertionProbeManager)
+        {
+            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
+            var visualizationProbeName = sceneState.ActiveManipulatorState.VisualizationProbeName;
+            var visualizationProbeManager = ProbeManager.Instances.FirstOrDefault(m =>
+                m.name == visualizationProbeName
+            );
+
+            if (visualizationProbeManager == null)
+                return Vector3.negativeInfinity;
+
+            // Extract target insertion.
+            var targetInsertion = targetInsertionProbeManager.ProbeController.Insertion;
+
+            var targetWorldT = targetInsertion.PositionWorldT();
+            var relativePositionWorldT =
+                visualizationProbeManager.ProbeController.Insertion.PositionWorldT() - targetWorldT;
+            var probeTipTForward = visualizationProbeManager.ProbeController.ProbeTipT.forward;
+            var offsetAdjustedRelativeTargetPositionWorldT = Vector3.ProjectOnPlane(
+                relativePositionWorldT,
+                probeTipTForward
+            );
+            var offsetAdjustedTargetCoordinateWorldT =
+                targetWorldT + offsetAdjustedRelativeTargetPositionWorldT;
+
+            // Convert worldT to AtlasT then switch axes to get APMLDV.
+            var offsetAdjustedTargetCoordinateAtlasT =
+                BrainAtlasManager.ActiveReferenceAtlas.World2Atlas(
+                    offsetAdjustedTargetCoordinateWorldT
+                );
+            return BrainAtlasManager.ActiveAtlasTransform.U2T_Vector(
+                offsetAdjustedTargetCoordinateAtlasT
+            );
+        }
+
+        /// <summary>
+        ///     Compute the absolute distance from the target insertion to the Dura.
+        /// </summary>
+        /// <param name="targetInsertionProbeManager">Target to compute distance to.</param>
+        /// <returns>Distance in mm to the target from the Dura.</returns>
+        private float GetTargetDistanceToDura(ProbeManager targetInsertionProbeManager)
+        {
+            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
+            var duraCoordinate = sceneState.ActiveManipulatorState.DuraCoordinate;
+            return Vector3.Distance(
+                GetOffsetAdjustedTargetCoordinate(targetInsertionProbeManager),
+                new Vector3(duraCoordinate.x, duraCoordinate.y, duraCoordinate.z)
+            );
+        }
+
+        /// <summary>
+        ///     Compute the current distance to the target insertion.
+        /// </summary>
+        /// <param name="targetInsertionProbeManager">Target probe manager.</param>
+        /// <returns>Distance in mm to the target from the probe.</returns>
+        private float GetCurrentDistanceToTarget(ProbeManager targetInsertionProbeManager)
+        {
+            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
+            var visualizationProbeName = sceneState.ActiveManipulatorState.VisualizationProbeName;
+            var visualizationProbeState = sceneState.Probes.FirstOrDefault(p =>
+                p.Name == visualizationProbeName
+            );
+
+            if (visualizationProbeState == null)
+                return float.NaN;
+
+            return Vector3.Distance(
+                visualizationProbeState.APMLDV,
+                GetOffsetAdjustedTargetCoordinate(targetInsertionProbeManager)
+            );
+        }
+
+        /// <summary>
+        ///     Compute the target depth for the probe to drive to.
+        /// </summary>
+        /// <param name="targetInsertionProbeManager">Target to drive (insert) to.</param>
+        /// <returns>The depth the manipulator needs to drive to reach the target insertion.</returns>
+        private float GetTargetDepth(ProbeManager targetInsertionProbeManager)
+        {
+            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
+            var duraDepth = sceneState.ActiveManipulatorState.DuraDepth;
+            return duraDepth + GetTargetDistanceToDura(targetInsertionProbeManager);
+        }
+
+        /// <summary>
+        ///     Compute the ETA in seconds for a probe to reach a target insertion (or exit).
+        /// </summary>
+        /// <param name="targetInsertionProbeManager">Target to calculate ETA to.</param>
+        /// <param name="baseSpeed">Base driving speed in mm/s.</param>
+        /// <param name="drivePastDistance">Distance to drive past target in mm.</param>
+        /// <returns>ETA in seconds for reaching a target or exiting.</returns>
+        private int ComputeEtaSeconds(
+            ProbeManager targetInsertionProbeManager,
+            float baseSpeed,
+            float drivePastDistance
+        )
+        {
+            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
+            var manipulatorState = sceneState.ActiveManipulatorState;
+
+            var distanceToTarget = GetCurrentDistanceToTarget(targetInsertionProbeManager);
+            var targetDistanceToDura = GetTargetDistanceToDura(targetInsertionProbeManager);
+            var actualExitMarginToDuraDistance = manipulatorState.DuraDepth - _entryCoordinateDepth;
+
+            var secondsToDestination = AutomationProgressState switch
+            {
+                AutomationProgressState.DrivingToNearTarget => Mathf.Max(
+                    0,
+                    distanceToTarget - NEAR_TARGET_DISTANCE
+                ) / baseSpeed
+                    + (NEAR_TARGET_DISTANCE + 2 * drivePastDistance)
+                        / (baseSpeed * NEAR_TARGET_SPEED_MULTIPLIER),
+                AutomationProgressState.DrivingToPastTarget => (
+                    distanceToTarget + 2 * drivePastDistance
+                ) / (baseSpeed * NEAR_TARGET_SPEED_MULTIPLIER),
+                AutomationProgressState.ReturningToTarget => distanceToTarget
+                    / (baseSpeed * NEAR_TARGET_SPEED_MULTIPLIER),
+                AutomationProgressState.ExitingToDura => (targetDistanceToDura - distanceToTarget)
+                    / (baseSpeed * EXIT_DRIVE_SPEED_MULTIPLIER)
+                    + DURA_MARGIN_DISTANCE / (baseSpeed * EXIT_DRIVE_SPEED_MULTIPLIER)
+                    + actualExitMarginToDuraDistance / AUTOMATIC_MOVEMENT_SPEED,
+                AutomationProgressState.ExitingToMargin => (
+                    DURA_MARGIN_DISTANCE - (distanceToTarget - targetDistanceToDura)
+                ) / (baseSpeed * EXIT_DRIVE_SPEED_MULTIPLIER)
+                    + actualExitMarginToDuraDistance / AUTOMATIC_MOVEMENT_SPEED,
+                AutomationProgressState.ExitingToTargetEntryCoordinate => (
+                    IDEAL_ENTRY_COORDINATE_TO_DURA_DISTANCE
+                    - (distanceToTarget - targetDistanceToDura)
+                ) / AUTOMATIC_MOVEMENT_SPEED,
+                _ => 0,
+            };
+
+            return (int)secondsToDestination;
+        }
+
+        /// <summary>
+        ///     Log a drive event.
+        /// </summary>
+        /// <param name="targetDepth">Target depth of drive.</param>
+        /// <param name="baseSpeed">Base speed of drive.</param>
+        /// <param name="drivePastDistance">Distance (mm) driven past the target.</param>
+        private void LogDriveToTargetInsertion(
+            float targetDepth,
+            float baseSpeed,
+            float drivePastDistance = 0
+        )
+        {
+            OutputLog.Log(
+                new[]
+                {
+                    "Automation",
+                    DateTime.Now.ToString(CultureInfo.InvariantCulture),
+                    "DriveToTargetInsertion",
+                    ActiveManipulatorId,
+                    AutomationProgressState.ToString(),
+                    (targetDepth * 1000).ToString(CultureInfo.InvariantCulture),
+                    (baseSpeed * 1000).ToString(CultureInfo.InvariantCulture),
+                    (drivePastDistance * 1000).ToString(CultureInfo.InvariantCulture),
+                }
+            );
+        }
+
+        #endregion
     }
 }
diff --git a/Assets/Scripts/UI/Views/AutomationInspectorView.cs b/Assets/Scripts/UI/Views/AutomationInspectorView.cs
index c9fafd36..002fd089 100644
--- a/Assets/Scripts/UI/Views/AutomationInspectorView.cs
+++ b/Assets/Scripts/UI/Views/AutomationInspectorView.cs
@@ -182,6 +182,10 @@ public AutomationInspectorView(AutomationInspectorViewModel automationInspectorV
             var targetInsertionDrivePastDistanceField = root.Q<IntField>(
                 "automation-inspector__target-insertion--drive-past-distance-field"
             );
+            targetInsertionDrivePastDistanceField.RegisterValueChangedCallback(evt =>
+                _automationInspectorViewModel.SetDrivePastDistanceCommand.Execute(evt.newValue)
+            );
+
             var targetInsertionETAText = root.Q<Text>(
                 "automation-inspector__target-insertion--eta-text"
             );
@@ -191,12 +195,23 @@ public AutomationInspectorView(AutomationInspectorViewModel automationInspectorV
             var targetInsertionDriveButton = root.Q<Button>(
                 "automation-inspector__target-insertion--drive-button"
             );
+            targetInsertionDriveButton.clickable.clicked += _automationInspectorViewModel
+                .InsertionDriveCommand
+                .Execute;
+
             var targetInsertionExitButton = root.Q<Button>(
                 "automation-inspector__target-insertion--exit-button"
             );
+            targetInsertionExitButton.clickable.clicked += _automationInspectorViewModel
+                .InsertionExitCommand
+                .Execute;
+
             var targetInsertionStopButton = root.Q<Button>(
                 "automation-inspector__target-insertion--stop-button"
             );
+            targetInsertionStopButton.clickable.clicked += _automationInspectorViewModel
+                .StopInsertionDriveCommand
+                .Execute;
 
             // Register property change handlers.
             _automationInspectorViewModel.PropertyChanged += OnPropertyChanged;

From 0a3fb3625a619de74f2d58ef0d8e67a558814ae6 Mon Sep 17 00:00:00 2001
From: Kenneth Yang <kjy5@uw.edu>
Date: Mon, 29 Dec 2025 23:37:51 -0800
Subject: [PATCH 07/12] Fixed UI ID

---
 Assets/UI/Views/AutomationInspector.uxml | 80 ++++++++++++------------
 1 file changed, 40 insertions(+), 40 deletions(-)

diff --git a/Assets/UI/Views/AutomationInspector.uxml b/Assets/UI/Views/AutomationInspector.uxml
index be3a1134..8dbb2722 100644
--- a/Assets/UI/Views/AutomationInspector.uxml
+++ b/Assets/UI/Views/AutomationInspector.uxml
@@ -1,106 +1,106 @@
 <engine:UXML xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:engine="UnityEngine.UIElements" xmlns:editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../../UIElementsSchema/UIElements.xsd" editor-extension-mode="False">
-    <Style src="project://database/Assets/UI/Styles/GeneralStyles.uss?fileID=7433441132597879392&amp;guid=a584e5b7cc579974fb178eba0841b4cb&amp;type=3#GeneralStyles" />
+    <Style src="project://database/Assets/UI/Styles/GeneralStyles.uss?fileID=7433441132597879392&amp;guid=a584e5b7cc579974fb178eba0841b4cb&amp;type=3#GeneralStyles"/>
     <engine:VisualElement data-source-type="UI.ViewModels.AutomationInspectorViewModel, Assembly-CSharp" style="flex-grow: 1;">
         <engine:VisualElement class="inspector-panel">
-            <Unity.AppUI.UI.Heading text="Calibrate Reference Coordinate Offset (mm)" size="S" />
+            <Unity.AppUI.UI.Heading text="Calibrate Reference Coordinate Offset (mm)" size="S"/>
             <Unity.AppUI.UI.Vector4Field tooltip="Manipulator&apos;s coordinates when its probe is at the reference coordinate" format-string="0.###" name="automation-inspector__reference-coordinate-offset-field">
                 <Bindings>
-                    <engine:DataBinding property="value" data-source-path="ReferenceCoordinate" binding-mode="ToTarget" />
+                    <engine:DataBinding property="value" data-source-path="ReferenceCoordinate" binding-mode="ToTarget"/>
                 </Bindings>
             </Unity.AppUI.UI.Vector4Field>
-            <Unity.AppUI.UI.Button title="Use Current Position" leading-icon="waypoint-home" name="automation-inspector__set-reference-coordinate-offset-button" />
+            <Unity.AppUI.UI.Button title="Use Current Position" leading-icon="waypoint-home" name="automation-inspector__set-reference-coordinate-offset-button"/>
         </engine:VisualElement>
         <engine:VisualElement class="inspectorBox inspector-panel">
-            <Unity.AppUI.UI.Heading text="Choose a Target Insertion" size="S" />
+            <Unity.AppUI.UI.Heading text="Choose a Target Insertion" size="S"/>
             <engine:VisualElement style="flex-grow: 1; flex-direction: row;">
-                <Unity.AppUI.UI.Dropdown name="automation-inspector__target-selection--dropdown" default-message="Select target" style="flex-grow: 1;" />
-                <Unity.AppUI.UI.Spacer />
-                <Unity.AppUI.UI.IconButton icon="x" name="automation-inspector__target-selection--reset-button" />
+                <Unity.AppUI.UI.Dropdown name="automation-inspector__target-selection--dropdown" default-message="Select target" style="flex-grow: 1;"/>
+                <Unity.AppUI.UI.Spacer/>
+                <Unity.AppUI.UI.IconButton icon="x" name="automation-inspector__target-selection--reset-button"/>
                 <Bindings>
-                    <engine:DataBinding property="enabledSelf" data-source-path="AutomationProgressState" binding-mode="ToTarget" source-to-ui-converters="AutomationProgressStateToTargetSelectionEnabled" />
+                    <engine:DataBinding property="enabledSelf" data-source-path="AutomationProgressState" binding-mode="ToTarget" source-to-ui-converters="AutomationProgressStateToTargetSelectionEnabled"/>
                 </Bindings>
             </engine:VisualElement>
-            <Unity.AppUI.UI.Spacer />
+            <Unity.AppUI.UI.Spacer/>
             <Unity.AppUI.UI.Button title="Drive to Target Entry Coordinate" variant="Default" name="automation-inspector__target-entry--drive-button">
                 <Bindings>
-                    <engine:DataBinding property="style.display" data-source-path="AutomationProgressState" binding-mode="ToTarget" source-to-ui-converters="AutomationProgressStateToDriveToTargetEntryCoordinateButtonVisibility" />
+                    <engine:DataBinding property="style.display" data-source-path="AutomationProgressState" binding-mode="ToTarget" source-to-ui-converters="AutomationProgressStateToDriveToTargetEntryCoordinateButtonVisibility"/>
                 </Bindings>
             </Unity.AppUI.UI.Button>
             <Unity.AppUI.UI.Button title="Stop" variant="Destructive" size="L" name="automation-inspector__target-entry--stop-button">
                 <Bindings>
-                    <engine:DataBinding property="style.display" data-source-path="AutomationProgressState" binding-mode="ToTarget" source-to-ui-converters="AutomationProgressStateToStopDriveToTargetEntryCoordinateButtonVisibility" />
+                    <engine:DataBinding property="style.display" data-source-path="AutomationProgressState" binding-mode="ToTarget" source-to-ui-converters="AutomationProgressStateToStopDriveToTargetEntryCoordinateButtonVisibility"/>
                 </Bindings>
             </Unity.AppUI.UI.Button>
         </engine:VisualElement>
         <engine:VisualElement class="inspectorBox inspector-panel">
-            <Unity.AppUI.UI.Heading text="Calibrate Dura Offset" size="S" />
+            <Unity.AppUI.UI.Heading text="Calibrate Dura Offset" size="S"/>
             <engine:VisualElement style="flex-grow: 1; flex-direction: row;">
                 <Unity.AppUI.UI.FloatField tooltip="The difference between the atlas&apos;s dura and the real dura" format-string="0.###" unit="mm" focusable="false" style="flex-grow: 1;">
                     <Bindings>
-                        <engine:DataBinding property="value" data-source-path="DuraOffset" binding-mode="ToTarget" />
+                        <engine:DataBinding property="value" data-source-path="DuraOffset" binding-mode="ToTarget"/>
                     </Bindings>
                 </Unity.AppUI.UI.FloatField>
-                <Unity.AppUI.UI.Spacer />
-                <Unity.AppUI.UI.IconButton icon="x" name="automation-inspector__dura-offset--reset-button" />
+                <Unity.AppUI.UI.Spacer/>
+                <Unity.AppUI.UI.IconButton icon="x" name="automation-inspector__dura-offset--reset-button"/>
             </engine:VisualElement>
-            <Unity.AppUI.UI.Spacer />
-            <Unity.AppUI.UI.Button title="Recalculate" leading-icon="align-bottom-simple" name="automation-inspector__recalculate-dura-offset-button" />
+            <Unity.AppUI.UI.Spacer/>
+            <Unity.AppUI.UI.Button title="Recalculate" leading-icon="align-bottom-simple" name="automation-inspector__recalculate-dura-offset-button"/>
         </engine:VisualElement>
         <engine:VisualElement class="inspectorBox inspector-panel">
-            <Unity.AppUI.UI.Heading text="Drive to Target Insertion" size="S" />
+            <Unity.AppUI.UI.Heading text="Drive to Target Insertion" size="S"/>
             <engine:VisualElement style="flex-grow: 1;">
-                <Unity.AppUI.UI.Dropdown default-message="Select insertion speed..." tooltip="Insertion speed (µm/s)" name="automation-inspector__target-insertion--speed-dropdown" />
-                <Unity.AppUI.UI.Spacer />
+                <Unity.AppUI.UI.Dropdown default-message="Select insertion speed..." tooltip="Insertion speed (µm/s)" name="automation-inspector__target-insertion--speed-dropdown"/>
+                <Unity.AppUI.UI.Spacer/>
                 <engine:VisualElement style="flex-grow: 1;">
                     <Unity.AppUI.UI.IntField unit="Custom speed (µm/s)" value="0" name="automation-inspector__target-insertion--custom-speed-field">
                         <Bindings>
-                            <engine:DataBinding property="value" data-source-path="CustomInsertionSpeed" binding-mode="TwoWay" />
-                            <engine:DataBinding property="style.display" data-source-path="SelectedInsertionSpeedIndex" binding-mode="ToTarget" source-to-ui-converters="SelectedInsertionSpeedIndexToCustomSpeedVisibility" />
+                            <engine:DataBinding property="value" data-source-path="CustomInsertionSpeed" binding-mode="TwoWay"/>
+                            <engine:DataBinding property="style.display" data-source-path="SelectedInsertionSpeedIndex" binding-mode="ToTarget" source-to-ui-converters="SelectedInsertionSpeedIndexToCustomSpeedVisibility"/>
                         </Bindings>
                     </Unity.AppUI.UI.IntField>
-                    <Unity.AppUI.UI.Spacer />
+                    <Unity.AppUI.UI.Spacer/>
                     <Bindings>
-                        <engine:DataBinding property="style.display" data-source-path="SelectedInsertionSpeedIndex" binding-mode="ToTarget" source-to-ui-converters="SelectedInsertionSpeedIndexToCustomSpeedVisibility" />
+                        <engine:DataBinding property="style.display" data-source-path="SelectedInsertionSpeedIndex" binding-mode="ToTarget" source-to-ui-converters="SelectedInsertionSpeedIndexToCustomSpeedVisibility"/>
                     </Bindings>
                 </engine:VisualElement>
                 <Unity.AppUI.UI.IntField unit="Drive Past by (µm)" value="50" name="automation-inspector__target-insertion--drive-past-distance-field">
                     <Bindings>
-                        <engine:DataBinding property="value" data-source-path="DrivePastDistance" binding-mode="TwoWay" />
+                        <engine:DataBinding property="value" data-source-path="DrivePastDistance" binding-mode="TwoWay"/>
                     </Bindings>
                 </Unity.AppUI.UI.IntField>
                 <Bindings>
-                    <engine:DataBinding property="enabledSelf" data-source-path="AutomationProgressState" binding-mode="ToTarget" source-to-ui-converters="AutomationProgressStateToTargetInsertionEnabled" />
+                    <engine:DataBinding property="enabledSelf" data-source-path="AutomationProgressState" binding-mode="ToTarget" source-to-ui-converters="AutomationProgressStateToTargetInsertionEnabled"/>
                 </Bindings>
             </engine:VisualElement>
-            <Unity.AppUI.UI.Spacer />
+            <Unity.AppUI.UI.Spacer/>
             <Unity.AppUI.UI.Text text="ETA: 00:00" name="automation-inspector__target-insertion--eta-text">
                 <Bindings>
-                    <engine:DataBinding property="text" data-source-path="Eta" binding-mode="ToTarget" source-to-ui-converters="ETASecondsToETAText" />
-                    <engine:DataBinding property="style.display" data-source-path="Eta" binding-mode="ToTarget" source-to-ui-converters="ETASecondsToETAVisibility" />
+                    <engine:DataBinding property="text" data-source-path="Eta" binding-mode="ToTarget" source-to-ui-converters="ETASecondsToETAText"/>
+                    <engine:DataBinding property="style.display" data-source-path="Eta" binding-mode="ToTarget" source-to-ui-converters="ETASecondsToETAVisibility"/>
                 </Bindings>
             </Unity.AppUI.UI.Text>
-            <Unity.AppUI.UI.Spacer />
+            <Unity.AppUI.UI.Spacer/>
             <Unity.AppUI.UI.LinearProgress variant="Determinate" value="0" tooltip="ETA" name="automation-inspector__target-insertion--progress-bar">
                 <Bindings>
-                    <engine:DataBinding property="value" data-source-path="DriveProgressPercentage" binding-mode="ToTarget" />
-                    <engine:DataBinding property="style.display" data-source-path="Eta" binding-mode="ToTarget" source-to-ui-converters="ETASecondsToETAVisibility" />
+                    <engine:DataBinding property="value" data-source-path="DriveProgressPercentage" binding-mode="ToTarget"/>
+                    <engine:DataBinding property="style.display" data-source-path="Eta" binding-mode="ToTarget" source-to-ui-converters="ETASecondsToETAVisibility"/>
                 </Bindings>
             </Unity.AppUI.UI.LinearProgress>
-            <Unity.AppUI.UI.Spacer />
+            <Unity.AppUI.UI.Spacer/>
             <Unity.AppUI.UI.Button title="Drive" variant="Accent" name="automation-inspector__target-insertion--drive-button">
                 <Bindings>
-                    <engine:DataBinding property="style.display" data-source-path="AutomationProgressState" binding-mode="ToTarget" source-to-ui-converters="AutomationProgressStateToInsertionDriveButtonVisibility" />
+                    <engine:DataBinding property="style.display" data-source-path="AutomationProgressState" binding-mode="ToTarget" source-to-ui-converters="AutomationProgressStateToInsertionDriveButtonVisibility"/>
                 </Bindings>
             </Unity.AppUI.UI.Button>
-            <Unity.AppUI.UI.Spacer />
-            <Unity.AppUI.UI.Button name="automation-inspector__target-insertion__exit-button" title="Exit">
+            <Unity.AppUI.UI.Spacer/>
+            <Unity.AppUI.UI.Button name="automation-inspector__target-insertion--exit-button" title="Exit">
                 <Bindings>
-                    <engine:DataBinding property="style.display" data-source-path="AutomationProgressState" binding-mode="ToTarget" source-to-ui-converters="AutomationProgressStateToInsertionExitButtonVisibility" />
+                    <engine:DataBinding property="style.display" data-source-path="AutomationProgressState" binding-mode="ToTarget" source-to-ui-converters="AutomationProgressStateToInsertionExitButtonVisibility"/>
                 </Bindings>
             </Unity.AppUI.UI.Button>
-            <Unity.AppUI.UI.Button name="automation-inspector__target-insertion__stop-button" title="Stop" size="L" variant="Destructive">
+            <Unity.AppUI.UI.Button name="automation-inspector__target-insertion--stop-button" title="Stop" size="L" variant="Destructive">
                 <Bindings>
-                    <engine:DataBinding property="style.display" data-source-path="AutomationProgressState" binding-mode="ToTarget" source-to-ui-converters="AutomationProgressStateToInsertionStopButtonVisibility" />
+                    <engine:DataBinding property="style.display" data-source-path="AutomationProgressState" binding-mode="ToTarget" source-to-ui-converters="AutomationProgressStateToInsertionStopButtonVisibility"/>
                 </Bindings>
             </Unity.AppUI.UI.Button>
         </engine:VisualElement>

From dbdd3e3aefea0c341948a526f8b4973803c3aa80 Mon Sep 17 00:00:00 2001
From: Kenneth Yang <kjy5@uw.edu>
Date: Mon, 29 Dec 2025 23:46:40 -0800
Subject: [PATCH 08/12] Fix drive button not showing

---
 .../Scripts/UI/ViewModels/AutomationInspectorViewModel.cs   | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
index 0a34978a..a5aca94c 100644
--- a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
+++ b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
@@ -548,12 +548,18 @@ private async void StopDriveToTargetEntryCoordinate()
         private void ResetDuraOffset()
         {
             _storeService.Store.Dispatch(SceneActions.RESET_DURA_OFFSET, ActiveManipulatorId);
+            
+            // If offset is reset, we have no idea where we could be so we reset to IsCalibrated.
+            _storeService.Store.Dispatch(SceneActions.SET_AUTOMATION_PROGRESS_STATE, (ActiveManipulatorId, AutomationProgressState.IsCalibrated));
         }
 
         [ICommand]
         private async void RecalculateDuraOffset()
         {
             await _ephysLinkService.SetManipulatorDuraOffsetToCurrentDepth(ActiveManipulatorId);
+            
+            // After recalculating the dura offset, we are at the Dura insert state.
+            _storeService.Store.Dispatch(SceneActions.SET_AUTOMATION_PROGRESS_STATE, (ActiveManipulatorId, AutomationProgressState.AtDuraInsert));
         }
 
         [ICommand]

From e8db9b0ed7ea138f5935f7183d2b319b31df1b59 Mon Sep 17 00:00:00 2001
From: Kenneth Yang <kjy5@uw.edu>
Date: Tue, 30 Dec 2025 13:41:03 -0800
Subject: [PATCH 09/12] Can start driving

---
 Assets/Scripts/Models/Scene/SceneReducers.cs  |   7 +-
 .../AutomationInspectorViewModel.cs           | 163 +++++++++---------
 2 files changed, 89 insertions(+), 81 deletions(-)

diff --git a/Assets/Scripts/Models/Scene/SceneReducers.cs b/Assets/Scripts/Models/Scene/SceneReducers.cs
index 54868ec5..b41378b4 100644
--- a/Assets/Scripts/Models/Scene/SceneReducers.cs
+++ b/Assets/Scripts/Models/Scene/SceneReducers.cs
@@ -750,13 +750,16 @@ public static SceneState SetTargetInsertionProbeNameReducer(
 
             try
             {
-                // Verify selected target exists and is targetable.
+                // Verify selected target exists and is targetable:
+                // 1. Target name must not be empty
+                // 2. Target probe must exist in the probes list
+                // 3. Target probe must NOT be a visualization probe (those are manipulator-controlled)
                 if (
                     string.IsNullOrEmpty(action.payload.targetName)
                     || !state.Probes.Exists(probeState =>
                         probeState.Name == action.payload.targetName
                     )
-                    || !state.Manipulators.Exists(manipulatorState =>
+                    || state.Manipulators.Exists(manipulatorState =>
                         manipulatorState.VisualizationProbeName == action.payload.targetName
                     )
                 )
diff --git a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
index a5aca94c..881a4c76 100644
--- a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
+++ b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
@@ -11,7 +11,6 @@
 using Models;
 using Models.Scene;
 using Pinpoint.CoordinateSystems;
-using Pinpoint.Probes;
 using Services;
 using Unity.AppUI.MVVM;
 using Unity.AppUI.Redux;
@@ -32,6 +31,16 @@ public partial class AutomationInspectorViewModel
         private string ActiveManipulatorId =>
             _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE).ActiveManipulatorId;
 
+        /// <summary>
+        ///     Helper to get a probe's world state from Redux.
+        /// </summary>
+        private ProbeWorldState GetProbeWorldState(string probeName)
+        {
+            return _storeService.Store
+                .GetState<ProbeWorldStateSlice>(SliceNames.PROBE_WORLD_SLICE)
+                .GetProbeWorldState(probeName);
+        }
+
         #endregion
 
         #region Properties
@@ -214,11 +223,8 @@ private void OnSceneStateChanged(SceneState state)
                 // 3. Is in the brain.
                 .Where(probeState =>
                 {
-                    var probeManager = ProbeManager.Instances.FirstOrDefault(manager =>
-                        manager.name == probeState.Name
-                    );
-                    return probeManager != null
-                        && probeManager.CalculateEntryCoordinate().probeInBrain;
+                    var probeWorldState = GetProbeWorldState(probeState.Name);
+                    return probeWorldState != null && probeWorldState.IsProbeInBrain;
                 })
                 // 4. Is not already selected by other manipulator probes (unless it was selected by this active probe).
                 .Where(probeState =>
@@ -323,15 +329,12 @@ private void SelectTargetInsertionProbe(int index)
             // Get the selected target insertion probe
             var selectedTargetInsertionProbeState = TargetInsertionProbeStates.ElementAt(index);
 
-            // Get the probe manager for the selected target
-            var targetProbeManager = ProbeManager.Instances.FirstOrDefault(manager =>
-                manager.name == selectedTargetInsertionProbeState.Name
-            );
-
-            if (targetProbeManager == null)
+            // Validate the target probe world state exists
+            var targetProbeWorldState = GetProbeWorldState(selectedTargetInsertionProbeState.Name);
+            if (targetProbeWorldState == null)
             {
                 Debug.LogError(
-                    $"Target probe manager not found: {selectedTargetInsertionProbeState.Name}"
+                    $"Target probe world state not found: {selectedTargetInsertionProbeState.Name}"
                 );
                 return;
             }
@@ -342,8 +345,8 @@ private void SelectTargetInsertionProbe(int index)
                 (ActiveManipulatorId, selectedTargetInsertionProbeState.Name)
             );
 
-            // Compute and visualize trajectory with the target probe manager
-            var entryCoordinate = ComputeTargetEntryCoordinateTrajectory(targetProbeManager);
+            // Compute and visualize trajectory with the target probe name
+            var entryCoordinate = ComputeTargetEntryCoordinateTrajectory(selectedTargetInsertionProbeState.Name);
 
             if (float.IsNegativeInfinity(entryCoordinate.x))
             {
@@ -606,17 +609,16 @@ private async void InsertionDrive()
                 return;
             }
 
-            // Get scene state and target probe manager.
+            // Get scene state and target probe name.
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
             var manipulatorState = sceneState.ActiveManipulatorState;
-
-            var targetProbeManager = ProbeManager.Instances.FirstOrDefault(m =>
-                m.name == manipulatorState.TargetInsertionProbeName
-            );
-            if (targetProbeManager == null)
+            var targetProbeName = manipulatorState.TargetInsertionProbeName;
+            
+            var targetProbeWorldState = GetProbeWorldState(targetProbeName);
+            if (targetProbeWorldState == null)
             {
                 Debug.LogError(
-                    $"Target probe manager not found: {manipulatorState.TargetInsertionProbeName}"
+                    $"Target probe world state not found: {targetProbeName}"
                 );
                 return;
             }
@@ -629,7 +631,7 @@ private async void InsertionDrive()
             _insertionDriveCts = new CancellationTokenSource();
 
             // Store initial ETA for progress calculation.
-            _originalETA = ComputeEtaSeconds(targetProbeManager, baseSpeed, drivePastDistance);
+            _originalETA = ComputeEtaSeconds(targetProbeName, baseSpeed, drivePastDistance);
 
             try
             {
@@ -639,7 +641,7 @@ private async void InsertionDrive()
                     _insertionDriveCts.Token.ThrowIfCancellationRequested();
 
                     // Get target depth.
-                    var targetDepth = GetTargetDepth(targetProbeManager);
+                    var targetDepth = GetTargetDepth(targetProbeName);
 
                     // Set state to next driving state.
                     _storeService.Store.Dispatch(
@@ -651,7 +653,7 @@ private async void InsertionDrive()
                     LogDriveToTargetInsertion(targetDepth, baseSpeed, drivePastDistance);
 
                     // Update ETA.
-                    Eta = ComputeEtaSeconds(targetProbeManager, baseSpeed, drivePastDistance);
+                    Eta = ComputeEtaSeconds(targetProbeName, baseSpeed, drivePastDistance);
                     DriveProgressPercentage =
                         _originalETA > 0 ? 1f - (float)Eta / _originalETA : 0f;
 
@@ -661,7 +663,7 @@ private async void InsertionDrive()
                         case AutomationProgressState.DrivingToNearTarget:
                             // Drive to near target if not already there.
                             if (
-                                GetCurrentDistanceToTarget(targetProbeManager)
+                                GetCurrentDistanceToTarget(targetProbeName)
                                 > NEAR_TARGET_DISTANCE
                             )
                             {
@@ -759,17 +761,16 @@ private async void InsertionExit()
                 return;
             }
 
-            // Get scene state and target probe manager.
+            // Get scene state and target probe name.
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
             var manipulatorState = sceneState.ActiveManipulatorState;
+            var targetProbeName = manipulatorState.TargetInsertionProbeName;
 
-            var targetProbeManager = ProbeManager.Instances.FirstOrDefault(m =>
-                m.name == manipulatorState.TargetInsertionProbeName
-            );
-            if (targetProbeManager == null)
+            var targetProbeWorldState = GetProbeWorldState(targetProbeName);
+            if (targetProbeWorldState == null)
             {
                 Debug.LogError(
-                    $"Target probe manager not found: {manipulatorState.TargetInsertionProbeName}"
+                    $"Target probe world state not found: {targetProbeName}"
                 );
                 return;
             }
@@ -782,7 +783,7 @@ private async void InsertionExit()
             _insertionDriveCts = new CancellationTokenSource();
 
             // Store initial ETA for progress calculation.
-            _originalETA = ComputeEtaSeconds(targetProbeManager, baseSpeed, drivePastDistance);
+            _originalETA = ComputeEtaSeconds(targetProbeName, baseSpeed, drivePastDistance);
 
             try
             {
@@ -807,7 +808,7 @@ private async void InsertionExit()
                     LogDriveToTargetInsertion(duraDepth, baseSpeed);
 
                     // Update ETA.
-                    Eta = ComputeEtaSeconds(targetProbeManager, baseSpeed, drivePastDistance);
+                    Eta = ComputeEtaSeconds(targetProbeName, baseSpeed, drivePastDistance);
                     DriveProgressPercentage =
                         _originalETA > 0 ? 1f - (float)Eta / _originalETA : 0f;
 
@@ -968,16 +969,17 @@ private void SetDrivePastDistance(int distance)
         /// <summary>
         ///     Compute the entry coordinate and trajectory for the target insertion. Also, create and update the trajectory visualization lines.
         /// </summary>
-        /// <param name="targetProbeManager">The probe manager of the target insertion probe.</param>
+        /// <param name="targetProbeName">The name of the target insertion probe.</param>
         /// <returns>
         ///     The computed entry coordinate in AP, ML, DV coordinates. Vector3.negativeInfinity if target is unset or computation fails.
         /// </returns>
-        private Vector3 ComputeTargetEntryCoordinateTrajectory(ProbeManager targetProbeManager)
+        private Vector3 ComputeTargetEntryCoordinateTrajectory(string targetProbeName)
         {
-            // Validate target probe manager
-            if (targetProbeManager == null)
+            // Validate target probe world state exists
+            var targetProbeWorldState = GetProbeWorldState(targetProbeName);
+            if (targetProbeWorldState == null)
             {
-                Debug.LogError("Target probe manager is null");
+                Debug.LogError($"Target probe world state is null: {targetProbeName}");
                 RemoveTrajectoryLines();
                 return Vector3.negativeInfinity;
             }
@@ -993,11 +995,9 @@ private Vector3 ComputeTargetEntryCoordinateTrajectory(ProbeManager targetProbeM
                 return Vector3.negativeInfinity;
             }
 
-            // Compute entry coordinate in world space
-            var surfaceCoordinateWorldT = targetProbeManager.GetSurfaceCoordinateWorldT();
-            var tipForwardWorldU = targetProbeManager
-                .ProbeController.GetTipWorldU()
-                .tipForwardWorldU;
+            // Compute entry coordinate in world space using Redux state
+            var surfaceCoordinateWorldT = targetProbeWorldState.SurfaceCoordinateWorldT;
+            var tipForwardWorldU = targetProbeWorldState.TipForwardWorldU;
 
             var entryCoordinateWorld =
                 surfaceCoordinateWorldT
@@ -1011,12 +1011,18 @@ private Vector3 ComputeTargetEntryCoordinateTrajectory(ProbeManager targetProbeM
                 entryCoordinateAtlasU
             );
 
-            // Get current manipulator coordinate.
+            // Get current manipulator coordinate from Redux.
             var currentState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
             var visualizationProbeName = currentState.ActiveManipulatorState.VisualizationProbeName;
-            var currentCoordinate = currentState
-                .Probes.FirstOrDefault(state => state.Name == visualizationProbeName)!
-                .APMLDV;
+            var visualizationProbeState = currentState.Probes.FirstOrDefault(state => state.Name == visualizationProbeName);
+
+            if (visualizationProbeState == null)
+            {
+                Debug.LogError($"Visualization probe state not found: {visualizationProbeName}");
+                return Vector3.negativeInfinity;
+            }
+
+            var currentCoordinate = visualizationProbeState.APMLDV;
 
             // Create 3-stage trajectory
             // Stage 1: DV movement (change depth only)
@@ -1107,19 +1113,18 @@ private void UpdateTrajectoryLines()
             )
                 return;
 
-            // Get active probe manager for current tip position
+            // Get active probe world state for current tip position from Redux
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
-            var activeProbeManager = ProbeManager.Instances.FirstOrDefault(manager =>
-                manager.name == sceneState.ActiveManipulatorState.VisualizationProbeName
-            );
+            var visualizationProbeName = sceneState.ActiveManipulatorState.VisualizationProbeName;
+            var activeProbeWorldState = GetProbeWorldState(visualizationProbeName);
 
-            if (activeProbeManager == null)
+            if (activeProbeWorldState == null)
                 return;
 
             // DV line: From current probe tip to first coordinate
             _trajectoryLineRenderers.dv.SetPosition(
                 0,
-                activeProbeManager.ProbeController.ProbeTipT.position
+                activeProbeWorldState.TipPositionWorldT
             );
             _trajectoryLineRenderers.dv.SetPosition(
                 1,
@@ -1278,26 +1283,26 @@ or AutomationProgressState.AtDuraExit
         /// <summary>
         ///     Compute the target coordinate adjusted for the probe's actual position.
         /// </summary>
-        /// <param name="targetInsertionProbeManager">Target probe manager.</param>
+        /// <param name="targetProbeName">Target probe name.</param>
         /// <returns>APMLDV coordinates of where the probe should actually go.</returns>
-        private Vector3 GetOffsetAdjustedTargetCoordinate(ProbeManager targetInsertionProbeManager)
+        private Vector3 GetOffsetAdjustedTargetCoordinate(string targetProbeName)
         {
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
             var visualizationProbeName = sceneState.ActiveManipulatorState.VisualizationProbeName;
-            var visualizationProbeManager = ProbeManager.Instances.FirstOrDefault(m =>
-                m.name == visualizationProbeName
-            );
 
-            if (visualizationProbeManager == null)
+            // Get world states from Redux
+            var targetProbeWorldState = GetProbeWorldState(targetProbeName);
+            var visualizationProbeWorldState = GetProbeWorldState(visualizationProbeName);
+
+            if (targetProbeWorldState == null || visualizationProbeWorldState == null)
                 return Vector3.negativeInfinity;
 
-            // Extract target insertion.
-            var targetInsertion = targetInsertionProbeManager.ProbeController.Insertion;
+            // Get world positions from Redux
+            var targetWorldT = targetProbeWorldState.TipPositionWorldT;
+            var visualizationWorldT = visualizationProbeWorldState.TipPositionWorldT;
+            var probeTipTForward = visualizationProbeWorldState.TipForwardWorldU;
 
-            var targetWorldT = targetInsertion.PositionWorldT();
-            var relativePositionWorldT =
-                visualizationProbeManager.ProbeController.Insertion.PositionWorldT() - targetWorldT;
-            var probeTipTForward = visualizationProbeManager.ProbeController.ProbeTipT.forward;
+            var relativePositionWorldT = visualizationWorldT - targetWorldT;
             var offsetAdjustedRelativeTargetPositionWorldT = Vector3.ProjectOnPlane(
                 relativePositionWorldT,
                 probeTipTForward
@@ -1318,14 +1323,14 @@ private Vector3 GetOffsetAdjustedTargetCoordinate(ProbeManager targetInsertionPr
         /// <summary>
         ///     Compute the absolute distance from the target insertion to the Dura.
         /// </summary>
-        /// <param name="targetInsertionProbeManager">Target to compute distance to.</param>
+        /// <param name="targetProbeName">Target probe name to compute distance to.</param>
         /// <returns>Distance in mm to the target from the Dura.</returns>
-        private float GetTargetDistanceToDura(ProbeManager targetInsertionProbeManager)
+        private float GetTargetDistanceToDura(string targetProbeName)
         {
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
             var duraCoordinate = sceneState.ActiveManipulatorState.DuraCoordinate;
             return Vector3.Distance(
-                GetOffsetAdjustedTargetCoordinate(targetInsertionProbeManager),
+                GetOffsetAdjustedTargetCoordinate(targetProbeName),
                 new Vector3(duraCoordinate.x, duraCoordinate.y, duraCoordinate.z)
             );
         }
@@ -1333,9 +1338,9 @@ private float GetTargetDistanceToDura(ProbeManager targetInsertionProbeManager)
         /// <summary>
         ///     Compute the current distance to the target insertion.
         /// </summary>
-        /// <param name="targetInsertionProbeManager">Target probe manager.</param>
+        /// <param name="targetProbeName">Target probe name.</param>
         /// <returns>Distance in mm to the target from the probe.</returns>
-        private float GetCurrentDistanceToTarget(ProbeManager targetInsertionProbeManager)
+        private float GetCurrentDistanceToTarget(string targetProbeName)
         {
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
             var visualizationProbeName = sceneState.ActiveManipulatorState.VisualizationProbeName;
@@ -1348,31 +1353,31 @@ private float GetCurrentDistanceToTarget(ProbeManager targetInsertionProbeManage
 
             return Vector3.Distance(
                 visualizationProbeState.APMLDV,
-                GetOffsetAdjustedTargetCoordinate(targetInsertionProbeManager)
+                GetOffsetAdjustedTargetCoordinate(targetProbeName)
             );
         }
 
         /// <summary>
         ///     Compute the target depth for the probe to drive to.
         /// </summary>
-        /// <param name="targetInsertionProbeManager">Target to drive (insert) to.</param>
+        /// <param name="targetProbeName">Target probe name to drive (insert) to.</param>
         /// <returns>The depth the manipulator needs to drive to reach the target insertion.</returns>
-        private float GetTargetDepth(ProbeManager targetInsertionProbeManager)
+        private float GetTargetDepth(string targetProbeName)
         {
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
             var duraDepth = sceneState.ActiveManipulatorState.DuraDepth;
-            return duraDepth + GetTargetDistanceToDura(targetInsertionProbeManager);
+            return duraDepth + GetTargetDistanceToDura(targetProbeName);
         }
 
         /// <summary>
         ///     Compute the ETA in seconds for a probe to reach a target insertion (or exit).
         /// </summary>
-        /// <param name="targetInsertionProbeManager">Target to calculate ETA to.</param>
+        /// <param name="targetProbeName">Target probe name to calculate ETA to.</param>
         /// <param name="baseSpeed">Base driving speed in mm/s.</param>
         /// <param name="drivePastDistance">Distance to drive past target in mm.</param>
         /// <returns>ETA in seconds for reaching a target or exiting.</returns>
         private int ComputeEtaSeconds(
-            ProbeManager targetInsertionProbeManager,
+            string targetProbeName,
             float baseSpeed,
             float drivePastDistance
         )
@@ -1380,8 +1385,8 @@ float drivePastDistance
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
             var manipulatorState = sceneState.ActiveManipulatorState;
 
-            var distanceToTarget = GetCurrentDistanceToTarget(targetInsertionProbeManager);
-            var targetDistanceToDura = GetTargetDistanceToDura(targetInsertionProbeManager);
+            var distanceToTarget = GetCurrentDistanceToTarget(targetProbeName);
+            var targetDistanceToDura = GetTargetDistanceToDura(targetProbeName);
             var actualExitMarginToDuraDistance = manipulatorState.DuraDepth - _entryCoordinateDepth;
 
             var secondsToDestination = AutomationProgressState switch

From 111bfe424c8aa9fdb15de7bbb420ca38ab24f045 Mon Sep 17 00:00:00 2001
From: Kenneth Yang <kjy5@uw.edu>
Date: Wed, 31 Dec 2025 00:34:40 -0800
Subject: [PATCH 10/12] WIP trying to fix insertion

---
 Assets/Scripts/Services/EphysLinkService.cs   |   2 +-
 .../AutomationInspectorViewModel.cs           | 130 +++++++++++++-----
 2 files changed, 97 insertions(+), 35 deletions(-)

diff --git a/Assets/Scripts/Services/EphysLinkService.cs b/Assets/Scripts/Services/EphysLinkService.cs
index 37592ca5..e07511cb 100644
--- a/Assets/Scripts/Services/EphysLinkService.cs
+++ b/Assets/Scripts/Services/EphysLinkService.cs
@@ -718,7 +718,7 @@ var manipulatorState in sceneState.Manipulators.Where(state =>
 
                 var depth = sceneState.NumberOfAxesOnManipulator switch
                 {
-                    3 => duraOffsetAdjustment,
+                    3 => duraOffsetAdjustment, // Positive moves probe forward/deeper into brain
                     4 => referenceCoordinateAdjustedManipulatorPosition.w,
                     _ => throw new ValueOutOfRangeException(
                         "Number of axes on manipulator is invalid."
diff --git a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
index 881a4c76..693b7bba 100644
--- a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
+++ b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
@@ -1011,18 +1011,15 @@ private Vector3 ComputeTargetEntryCoordinateTrajectory(string targetProbeName)
                 entryCoordinateAtlasU
             );
 
-            // Get current manipulator coordinate from Redux.
-            var currentState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
-            var visualizationProbeName = currentState.ActiveManipulatorState.VisualizationProbeName;
-            var visualizationProbeState = currentState.Probes.FirstOrDefault(state => state.Name == visualizationProbeName);
-
-            if (visualizationProbeState == null)
+            // Get current visualization probe coordinate using ProbeController local values.
+            var currentCoordinateNullable = GetVisualizationProbeAPMLDV();
+            if (currentCoordinateNullable == null)
             {
-                Debug.LogError($"Visualization probe state not found: {visualizationProbeName}");
+                Debug.LogError("Visualization probe not found");
                 return Vector3.negativeInfinity;
             }
 
-            var currentCoordinate = visualizationProbeState.APMLDV;
+            var currentCoordinate = currentCoordinateNullable.Value;
 
             // Create 3-stage trajectory
             // Stage 1: DV movement (change depth only)
@@ -1113,18 +1110,15 @@ private void UpdateTrajectoryLines()
             )
                 return;
 
-            // Get active probe world state for current tip position from Redux
-            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
-            var visualizationProbeName = sceneState.ActiveManipulatorState.VisualizationProbeName;
-            var activeProbeWorldState = GetProbeWorldState(visualizationProbeName);
-
-            if (activeProbeWorldState == null)
+            // Get visualization probe tip position using ProbeController local values
+            var tipWorldT = GetVisualizationProbeTipWorldT();
+            if (tipWorldT == null)
                 return;
 
             // DV line: From current probe tip to first coordinate
             _trajectoryLineRenderers.dv.SetPosition(
                 0,
-                activeProbeWorldState.TipPositionWorldT
+                tipWorldT.Value
             );
             _trajectoryLineRenderers.dv.SetPosition(
                 1,
@@ -1254,6 +1248,77 @@ private void RemoveTrajectoryLines()
 
         #region Insertion Helper Methods
 
+        /// <summary>
+        ///     Get the visualization probe's current tip position in world space.
+        ///     For visualization probes, uses ProbeController local values; otherwise uses ProbeWorldState.
+        /// </summary>
+        private Vector3? GetVisualizationProbeTipWorldT()
+        {
+            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
+            var visualizationProbeName = sceneState.ActiveManipulatorState.VisualizationProbeName;
+
+            var visualizationProbeManager = ProbeManager.Instances.FirstOrDefault(m =>
+                m.name == visualizationProbeName
+            );
+            if (visualizationProbeManager == null)
+                return null;
+
+            var probeController = visualizationProbeManager.ProbeController;
+            if (probeController.IsVisualizationProbe)
+            {
+                // Convert local APMLDV to world position
+                return BrainAtlasManager.ActiveReferenceAtlas.Atlas2World(
+                    BrainAtlasManager.ActiveAtlasTransform.T2U_Vector(
+                        probeController.VisualizationLocalAPMLDV
+                    )
+                );
+            }
+
+            var probeWorldState = GetProbeWorldState(visualizationProbeName);
+            return probeWorldState?.TipPositionWorldT;
+        }
+
+        /// <summary>
+        ///     Get the visualization probe's current APMLDV coordinates.
+        ///     For visualization probes, uses ProbeController local values.
+        /// </summary>
+        private Vector3? GetVisualizationProbeAPMLDV()
+        {
+            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
+            var visualizationProbeName = sceneState.ActiveManipulatorState.VisualizationProbeName;
+
+            var visualizationProbeManager = ProbeManager.Instances.FirstOrDefault(m =>
+                m.name == visualizationProbeName
+            );
+            if (visualizationProbeManager == null)
+                return null;
+
+            var probeController = visualizationProbeManager.ProbeController;
+            return probeController.IsVisualizationProbe
+                ? probeController.VisualizationLocalAPMLDV
+                : probeController.Insertion.APMLDV;
+        }
+
+        /// <summary>
+        ///     Get the visualization probe's forward direction in transformed space.
+        /// </summary>
+        private Vector3? GetVisualizationProbeForwardT()
+        {
+            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
+            var visualizationProbeName = sceneState.ActiveManipulatorState.VisualizationProbeName;
+
+            var visualizationProbeManager = ProbeManager.Instances.FirstOrDefault(m =>
+                m.name == visualizationProbeName
+            );
+            if (visualizationProbeManager == null)
+                return null;
+
+            var probeController = visualizationProbeManager.ProbeController;
+            return probeController.IsVisualizationProbe
+                ? probeController.VisualizationLocalForwardT
+                : probeController.ProbeTipT.forward;
+        }
+
         /// <summary>
         ///     Check if the current state allows starting or resuming insertion drive.
         /// </summary>
@@ -1287,25 +1352,24 @@ or AutomationProgressState.AtDuraExit
         /// <returns>APMLDV coordinates of where the probe should actually go.</returns>
         private Vector3 GetOffsetAdjustedTargetCoordinate(string targetProbeName)
         {
-            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
-            var visualizationProbeName = sceneState.ActiveManipulatorState.VisualizationProbeName;
-
-            // Get world states from Redux
+            // Get target probe world state from Redux (target probes are NOT visualization probes)
             var targetProbeWorldState = GetProbeWorldState(targetProbeName);
-            var visualizationProbeWorldState = GetProbeWorldState(visualizationProbeName);
+            if (targetProbeWorldState == null)
+                return Vector3.negativeInfinity;
 
-            if (targetProbeWorldState == null || visualizationProbeWorldState == null)
+            // Get visualization probe position and forward using ProbeController local values
+            var visualizationWorldT = GetVisualizationProbeTipWorldT();
+            var probeTipForward = GetVisualizationProbeForwardT();
+
+            if (visualizationWorldT == null || probeTipForward == null)
                 return Vector3.negativeInfinity;
 
-            // Get world positions from Redux
             var targetWorldT = targetProbeWorldState.TipPositionWorldT;
-            var visualizationWorldT = visualizationProbeWorldState.TipPositionWorldT;
-            var probeTipTForward = visualizationProbeWorldState.TipForwardWorldU;
 
-            var relativePositionWorldT = visualizationWorldT - targetWorldT;
+            var relativePositionWorldT = visualizationWorldT.Value - targetWorldT;
             var offsetAdjustedRelativeTargetPositionWorldT = Vector3.ProjectOnPlane(
                 relativePositionWorldT,
-                probeTipTForward
+                probeTipForward.Value
             );
             var offsetAdjustedTargetCoordinateWorldT =
                 targetWorldT + offsetAdjustedRelativeTargetPositionWorldT;
@@ -1342,17 +1406,13 @@ private float GetTargetDistanceToDura(string targetProbeName)
         /// <returns>Distance in mm to the target from the probe.</returns>
         private float GetCurrentDistanceToTarget(string targetProbeName)
         {
-            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
-            var visualizationProbeName = sceneState.ActiveManipulatorState.VisualizationProbeName;
-            var visualizationProbeState = sceneState.Probes.FirstOrDefault(p =>
-                p.Name == visualizationProbeName
-            );
-
-            if (visualizationProbeState == null)
+            // Get visualization probe APMLDV using ProbeController local values
+            var visualizationAPMLDV = GetVisualizationProbeAPMLDV();
+            if (visualizationAPMLDV == null)
                 return float.NaN;
 
             return Vector3.Distance(
-                visualizationProbeState.APMLDV,
+                visualizationAPMLDV.Value,
                 GetOffsetAdjustedTargetCoordinate(targetProbeName)
             );
         }
@@ -1366,6 +1426,8 @@ private float GetTargetDepth(string targetProbeName)
         {
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
             var duraDepth = sceneState.ActiveManipulatorState.DuraDepth;
+
+            // DuraOffset is for visualization only - do not apply it to manipulator depth calculations
             return duraDepth + GetTargetDistanceToDura(targetProbeName);
         }
 

From d4b5430b097c7870f313aa007eeecf28e53aa5ea Mon Sep 17 00:00:00 2001
From: Kenneth Yang <kjy5@uw.edu>
Date: Wed, 31 Dec 2025 12:18:44 -0800
Subject: [PATCH 11/12] Progres on depth and dura offset

---
 .../Probes/Controllers/CartesianProbeController.cs        | 7 -------
 Assets/Scripts/Pinpoint/Probes/ProbeController.cs         | 5 -----
 Assets/Scripts/Services/EphysLinkService.cs               | 8 +++++---
 .../Scripts/UI/ViewModels/AutomationInspectorViewModel.cs | 2 +-
 4 files changed, 6 insertions(+), 16 deletions(-)

diff --git a/Assets/Scripts/Pinpoint/Probes/Controllers/CartesianProbeController.cs b/Assets/Scripts/Pinpoint/Probes/Controllers/CartesianProbeController.cs
index d14b61fb..dcd7e8dd 100644
--- a/Assets/Scripts/Pinpoint/Probes/Controllers/CartesianProbeController.cs
+++ b/Assets/Scripts/Pinpoint/Probes/Controllers/CartesianProbeController.cs
@@ -942,13 +942,6 @@ private void UpdateVisualizationProbePosition()
         transform.RotateAround(_probeTipT.position, transform.right, VisualizationLocalAngles.y);
         transform.RotateAround(_probeTipT.position, transform.forward, -VisualizationLocalAngles.z);
 
-        // Apply brain surface depth offset (persistent offset from manipulator position).
-        // This offset is set by EphysLinkService and should not be reset.
-        if (VisualizationLocalDepth != 0f)
-        {
-            transform.position += transform.forward * VisualizationLocalDepth;
-        }
-
         // Update tip coords.
         SetTipWorldU();
 
diff --git a/Assets/Scripts/Pinpoint/Probes/ProbeController.cs b/Assets/Scripts/Pinpoint/Probes/ProbeController.cs
index bf6745dc..e5ddacb0 100644
--- a/Assets/Scripts/Pinpoint/Probes/ProbeController.cs
+++ b/Assets/Scripts/Pinpoint/Probes/ProbeController.cs
@@ -36,11 +36,6 @@ public void Register(ProbeManager probeManager)
     /// </summary>
     public Vector3 VisualizationLocalAPMLDV { get; set; }
     
-    /// <summary>
-    /// Local field for visualization probe depth.
-    /// </summary>
-    public float VisualizationLocalDepth { get; set; }
-    
     /// <summary>
     /// Local field for visualization probe angles.
     /// </summary>
diff --git a/Assets/Scripts/Services/EphysLinkService.cs b/Assets/Scripts/Services/EphysLinkService.cs
index e07511cb..089f0b5d 100644
--- a/Assets/Scripts/Services/EphysLinkService.cs
+++ b/Assets/Scripts/Services/EphysLinkService.cs
@@ -716,7 +716,7 @@ var manipulatorState in sceneState.Manipulators.Where(state =>
                 if (probeController == null)
                     continue;
 
-                var depth = sceneState.NumberOfAxesOnManipulator switch
+                var depthToApply = sceneState.NumberOfAxesOnManipulator switch
                 {
                     3 => duraOffsetAdjustment, // Positive moves probe forward/deeper into brain
                     4 => referenceCoordinateAdjustedManipulatorPosition.w,
@@ -725,9 +725,11 @@ var manipulatorState in sceneState.Manipulators.Where(state =>
                     ),
                 };
 
+                // Bake depth into APMLDV along forward vector
+                var finalAPMLDV = transformedAPMLDV + forwardT * depthToApply;
+
                 // Write position data directly to ProbeController's local fields
-                probeController.VisualizationLocalAPMLDV = transformedAPMLDV;
-                probeController.VisualizationLocalDepth = depth;
+                probeController.VisualizationLocalAPMLDV = finalAPMLDV;
                 probeController.VisualizationLocalAngles = manipulatorState.Angles;
                 probeController.VisualizationLocalForwardT = forwardT;
 
diff --git a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
index 693b7bba..d6a79fe7 100644
--- a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
+++ b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
@@ -1296,7 +1296,7 @@ private void RemoveTrajectoryLines()
             var probeController = visualizationProbeManager.ProbeController;
             return probeController.IsVisualizationProbe
                 ? probeController.VisualizationLocalAPMLDV
-                : probeController.Insertion.APMLDV;
+                : null;
         }
 
         /// <summary>

From cc5b1e02b42dfef509828e6ffb8cc7bd44d004c6 Mon Sep 17 00:00:00 2001
From: Kenneth Yang <kjy5@uw.edu>
Date: Wed, 31 Dec 2025 17:56:33 -0800
Subject: [PATCH 12/12] Allow switching off

---
 .../AutomationInspectorViewModel.cs           | 180 ++++++++++--------
 Assets/Scripts/Utils/EphysLinkConstants.cs    |   2 +-
 2 files changed, 105 insertions(+), 77 deletions(-)

diff --git a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
index d6a79fe7..c88f2428 100644
--- a/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
+++ b/Assets/Scripts/UI/ViewModels/AutomationInspectorViewModel.cs
@@ -370,29 +370,38 @@ private void ResetTargetInsertionProbeSelection()
         [ICommand]
         private async void DriveToTargetEntryCoordinate()
         {
+            // Capture manipulator ID and state at command start for async safety.
+            var manipulatorId = ActiveManipulatorId;
+            var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
+            var manipulatorState = sceneState.ActiveManipulatorState;
+
             // Validate trajectory exists
             if (float.IsNegativeInfinity(_trajectoryCoordinates.first.x))
             {
-                Debug.LogError($"No trajectory planned for manipulator {ActiveManipulatorId}");
+                Debug.LogError($"No trajectory planned for manipulator {manipulatorId}");
                 return;
             }
 
             // Convert coordinates to manipulator positions
             var dvPosition = ConvertInsertionAPMLDVToManipulatorPosition(
-                _trajectoryCoordinates.first
+                _trajectoryCoordinates.first,
+                manipulatorState
             );
             var apPosition = ConvertInsertionAPMLDVToManipulatorPosition(
-                _trajectoryCoordinates.second
+                _trajectoryCoordinates.second,
+                manipulatorState
             );
             var mlPosition = ConvertInsertionAPMLDVToManipulatorPosition(
-                _trajectoryCoordinates.third
+                _trajectoryCoordinates.third,
+                manipulatorState
             );
 
             // Check if conversion failed
             if (dvPosition == null || apPosition == null || mlPosition == null)
             {
                 HandleDriveFailed(
-                    "Failed to convert trajectory coordinates to manipulator positions"
+                    "Failed to convert trajectory coordinates to manipulator positions",
+                    manipulatorId
                 );
                 return;
             }
@@ -400,7 +409,7 @@ private async void DriveToTargetEntryCoordinate()
             // Set state to driving
             _storeService.Store.Dispatch(
                 SceneActions.SET_AUTOMATION_PROGRESS_STATE,
-                (ActiveManipulatorId, AutomationProgressState.DrivingToTargetEntryCoordinate)
+                (manipulatorId, AutomationProgressState.DrivingToTargetEntryCoordinate)
             );
 
             // Log that movement is starting
@@ -410,7 +419,7 @@ private async void DriveToTargetEntryCoordinate()
                     "Automation",
                     DateTime.Now.ToString(CultureInfo.InvariantCulture),
                     "DriveToTargetEntryCoordinate",
-                    ActiveManipulatorId,
+                    manipulatorId,
                     "Start",
                 }
             );
@@ -418,7 +427,7 @@ private async void DriveToTargetEntryCoordinate()
             // Stage 1: DV movement
             var dvResponse = await _ephysLinkService.SetPosition(
                 new SetPositionRequest(
-                    ActiveManipulatorId,
+                    manipulatorId,
                     dvPosition.Value,
                     AUTOMATIC_MOVEMENT_SPEED
                 )
@@ -426,14 +435,14 @@ private async void DriveToTargetEntryCoordinate()
 
             if (EphysLinkService.HasError(dvResponse.Error))
             {
-                HandleDriveFailed("Failed to move to DV position");
+                HandleDriveFailed("Failed to move to DV position", manipulatorId);
                 return;
             }
 
             // Stage 2: AP movement
             var apResponse = await _ephysLinkService.SetPosition(
                 new SetPositionRequest(
-                    ActiveManipulatorId,
+                    manipulatorId,
                     apPosition.Value,
                     AUTOMATIC_MOVEMENT_SPEED
                 )
@@ -441,14 +450,14 @@ private async void DriveToTargetEntryCoordinate()
 
             if (EphysLinkService.HasError(apResponse.Error))
             {
-                HandleDriveFailed("Failed to move to AP position");
+                HandleDriveFailed("Failed to move to AP position", manipulatorId);
                 return;
             }
 
             // Stage 3: ML movement
             var mlResponse = await _ephysLinkService.SetPosition(
                 new SetPositionRequest(
-                    ActiveManipulatorId,
+                    manipulatorId,
                     mlPosition.Value,
                     AUTOMATIC_MOVEMENT_SPEED
                 )
@@ -456,15 +465,15 @@ private async void DriveToTargetEntryCoordinate()
 
             if (EphysLinkService.HasError(mlResponse.Error))
             {
-                HandleDriveFailed("Failed to move to ML position");
+                HandleDriveFailed("Failed to move to ML position", manipulatorId);
                 return;
             }
 
             // Record entry coordinate depth
-            var finalPositionResponse = await _ephysLinkService.GetPosition(ActiveManipulatorId);
+            var finalPositionResponse = await _ephysLinkService.GetPosition(manipulatorId);
             if (EphysLinkService.HasError(finalPositionResponse.Error))
             {
-                HandleDriveFailed("Failed to get final position at entry coordinate");
+                HandleDriveFailed("Failed to get final position at entry coordinate", manipulatorId);
                 return;
             }
 
@@ -476,7 +485,7 @@ private async void DriveToTargetEntryCoordinate()
             // Complete the drive state
             _storeService.Store.Dispatch(
                 SceneActions.COMPLETE_AUTOMATION_INTERMEDIATE_PROGRESS,
-                ActiveManipulatorId
+                manipulatorId
             );
 
             // Log completion
@@ -486,13 +495,13 @@ private async void DriveToTargetEntryCoordinate()
                     "Automation",
                     DateTime.Now.ToString(CultureInfo.InvariantCulture),
                     "DriveToTargetEntryCoordinate",
-                    ActiveManipulatorId,
+                    manipulatorId,
                     "Finish",
                 }
             );
         }
 
-        private void HandleDriveFailed(string errorMessage)
+        private void HandleDriveFailed(string errorMessage, string manipulatorId)
         {
             Debug.LogError(errorMessage);
             OutputLog.Log(
@@ -501,7 +510,7 @@ private void HandleDriveFailed(string errorMessage)
                     "Automation",
                     DateTime.Now.ToString(CultureInfo.InvariantCulture),
                     "DriveToTargetEntryCoordinate",
-                    ActiveManipulatorId,
+                    manipulatorId,
                     $"Failed: {errorMessage}",
                 }
             );
@@ -509,7 +518,7 @@ private void HandleDriveFailed(string errorMessage)
             // Revert state to calibrated
             _storeService.Store.Dispatch(
                 SceneActions.CANCEL_AUTOMATION_INTERMEDIATE_PROGRESS,
-                ActiveManipulatorId
+                manipulatorId
             );
         }
 
@@ -609,11 +618,12 @@ private async void InsertionDrive()
                 return;
             }
 
-            // Get scene state and target probe name.
+            // Capture manipulator ID and state at command start for async safety.
+            var manipulatorId = ActiveManipulatorId;
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
             var manipulatorState = sceneState.ActiveManipulatorState;
             var targetProbeName = manipulatorState.TargetInsertionProbeName;
-            
+
             var targetProbeWorldState = GetProbeWorldState(targetProbeName);
             if (targetProbeWorldState == null)
             {
@@ -631,7 +641,7 @@ private async void InsertionDrive()
             _insertionDriveCts = new CancellationTokenSource();
 
             // Store initial ETA for progress calculation.
-            _originalETA = ComputeEtaSeconds(targetProbeName, baseSpeed, drivePastDistance);
+            _originalETA = ComputeEtaSeconds(targetProbeName, baseSpeed, drivePastDistance, manipulatorState);
 
             try
             {
@@ -641,19 +651,19 @@ private async void InsertionDrive()
                     _insertionDriveCts.Token.ThrowIfCancellationRequested();
 
                     // Get target depth.
-                    var targetDepth = GetTargetDepth(targetProbeName);
+                    var targetDepth = GetTargetDepth(targetProbeName, manipulatorState);
 
                     // Set state to next driving state.
                     _storeService.Store.Dispatch(
                         SceneActions.SET_AUTOMATION_PROGRESS_STATE_TO_NEXT_DRIVING,
-                        ActiveManipulatorId
+                        manipulatorId
                     );
 
                     // Log set to driving state.
-                    LogDriveToTargetInsertion(targetDepth, baseSpeed, drivePastDistance);
+                    LogDriveToTargetInsertion(manipulatorId, targetDepth, baseSpeed, drivePastDistance);
 
                     // Update ETA.
-                    Eta = ComputeEtaSeconds(targetProbeName, baseSpeed, drivePastDistance);
+                    Eta = ComputeEtaSeconds(targetProbeName, baseSpeed, drivePastDistance, manipulatorState);
                     DriveProgressPercentage =
                         _originalETA > 0 ? 1f - (float)Eta / _originalETA : 0f;
 
@@ -663,13 +673,13 @@ private async void InsertionDrive()
                         case AutomationProgressState.DrivingToNearTarget:
                             // Drive to near target if not already there.
                             if (
-                                GetCurrentDistanceToTarget(targetProbeName)
+                                GetCurrentDistanceToTarget(targetProbeName, manipulatorState)
                                 > NEAR_TARGET_DISTANCE
                             )
                             {
                                 var driveToNearTargetResponse = await _ephysLinkService.SetDepth(
                                     new SetDepthRequest(
-                                        ActiveManipulatorId,
+                                        manipulatorId,
                                         targetDepth - NEAR_TARGET_DISTANCE,
                                         baseSpeed
                                     )
@@ -689,7 +699,7 @@ private async void InsertionDrive()
                             // Drive past target at reduced speed.
                             var driveToPastTargetResponse = await _ephysLinkService.SetDepth(
                                 new SetDepthRequest(
-                                    ActiveManipulatorId,
+                                    manipulatorId,
                                     targetDepth + drivePastDistance,
                                     baseSpeed * NEAR_TARGET_SPEED_MULTIPLIER
                                 )
@@ -708,7 +718,7 @@ private async void InsertionDrive()
                             // Return to target at reduced speed.
                             var returnToTargetResponse = await _ephysLinkService.SetDepth(
                                 new SetDepthRequest(
-                                    ActiveManipulatorId,
+                                    manipulatorId,
                                     targetDepth,
                                     baseSpeed * NEAR_TARGET_SPEED_MULTIPLIER
                                 )
@@ -727,11 +737,11 @@ private async void InsertionDrive()
                     // Complete this phase.
                     _storeService.Store.Dispatch(
                         SceneActions.COMPLETE_AUTOMATION_INTERMEDIATE_PROGRESS,
-                        ActiveManipulatorId
+                        manipulatorId
                     );
 
                     // Log the event.
-                    LogDriveToTargetInsertion(targetDepth, baseSpeed, drivePastDistance);
+                    LogDriveToTargetInsertion(manipulatorId, targetDepth, baseSpeed, drivePastDistance);
                 }
 
                 // Drive complete - reset ETA and progress.
@@ -761,7 +771,8 @@ private async void InsertionExit()
                 return;
             }
 
-            // Get scene state and target probe name.
+            // Capture manipulator ID and state at command start for async safety.
+            var manipulatorId = ActiveManipulatorId;
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
             var manipulatorState = sceneState.ActiveManipulatorState;
             var targetProbeName = manipulatorState.TargetInsertionProbeName;
@@ -783,7 +794,7 @@ private async void InsertionExit()
             _insertionDriveCts = new CancellationTokenSource();
 
             // Store initial ETA for progress calculation.
-            _originalETA = ComputeEtaSeconds(targetProbeName, baseSpeed, drivePastDistance);
+            _originalETA = ComputeEtaSeconds(targetProbeName, baseSpeed, drivePastDistance, manipulatorState);
 
             try
             {
@@ -792,23 +803,22 @@ private async void InsertionExit()
                     // Check for cancellation.
                     _insertionDriveCts.Token.ThrowIfCancellationRequested();
 
-                    // Get dura depth for exit calculations.
-                    var currentManipulatorState = _storeService
-                        .Store.GetState<SceneState>(SliceNames.SCENE_SLICE)
-                        .ActiveManipulatorState;
-                    var duraDepth = currentManipulatorState.DuraDepth;
+                    // Get fresh manipulator state for this specific manipulator (DuraDepth may change during exit).
+                    var currentSceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
+                    var currentManipulatorState = currentSceneState.Manipulators.FirstOrDefault(m => m.Id == manipulatorId);
+                    var duraDepth = currentManipulatorState?.DuraDepth ?? manipulatorState.DuraDepth;
 
                     // Set state to next exiting state.
                     _storeService.Store.Dispatch(
                         SceneActions.SET_AUTOMATION_PROGRESS_STATE_TO_NEXT_EXITING,
-                        ActiveManipulatorId
+                        manipulatorId
                     );
 
                     // Log set to exiting state.
-                    LogDriveToTargetInsertion(duraDepth, baseSpeed);
+                    LogDriveToTargetInsertion(manipulatorId, duraDepth, baseSpeed);
 
                     // Update ETA.
-                    Eta = ComputeEtaSeconds(targetProbeName, baseSpeed, drivePastDistance);
+                    Eta = ComputeEtaSeconds(targetProbeName, baseSpeed, drivePastDistance, manipulatorState);
                     DriveProgressPercentage =
                         _originalETA > 0 ? 1f - (float)Eta / _originalETA : 0f;
 
@@ -819,7 +829,7 @@ private async void InsertionExit()
                             // Exit back up to the Dura.
                             var exitToDuraResponse = await _ephysLinkService.SetDepth(
                                 new SetDepthRequest(
-                                    ActiveManipulatorId,
+                                    manipulatorId,
                                     duraDepth,
                                     baseSpeed * EXIT_DRIVE_SPEED_MULTIPLIER
                                 )
@@ -838,13 +848,13 @@ private async void InsertionExit()
                             // Reset dura offset.
                             _storeService.Store.Dispatch(
                                 SceneActions.RESET_DURA_OFFSET,
-                                ActiveManipulatorId
+                                manipulatorId
                             );
 
                             // Exit to the safe margin above the Dura.
                             var exitToMarginResponse = await _ephysLinkService.SetDepth(
                                 new SetDepthRequest(
-                                    ActiveManipulatorId,
+                                    manipulatorId,
                                     duraDepth - DURA_MARGIN_DISTANCE,
                                     baseSpeed * EXIT_DRIVE_SPEED_MULTIPLIER
                                 )
@@ -862,7 +872,8 @@ private async void InsertionExit()
                         case AutomationProgressState.ExitingToTargetEntryCoordinate:
                             // Drive to the target entry coordinate.
                             var entryPosition = ConvertInsertionAPMLDVToManipulatorPosition(
-                                _trajectoryCoordinates.third
+                                _trajectoryCoordinates.third,
+                                manipulatorState
                             );
                             if (entryPosition == null)
                             {
@@ -874,7 +885,7 @@ private async void InsertionExit()
 
                             var exitToEntryCoordinateResponse = await _ephysLinkService.SetPosition(
                                 new SetPositionRequest(
-                                    ActiveManipulatorId,
+                                    manipulatorId,
                                     entryPosition.Value,
                                     AUTOMATIC_MOVEMENT_SPEED
                                 )
@@ -893,11 +904,11 @@ private async void InsertionExit()
                     // Complete this phase.
                     _storeService.Store.Dispatch(
                         SceneActions.COMPLETE_AUTOMATION_INTERMEDIATE_PROGRESS,
-                        ActiveManipulatorId
+                        manipulatorId
                     );
 
                     // Log the event.
-                    LogDriveToTargetInsertion(duraDepth, baseSpeed);
+                    LogDriveToTargetInsertion(manipulatorId, duraDepth, baseSpeed);
                 }
 
                 // Exit complete - reset ETA and progress.
@@ -1185,11 +1196,12 @@ private void RemoveTrajectoryLines()
         ///     Convert insertion AP, ML, DV coordinates to manipulator translation stage position.
         /// </summary>
         /// <param name="insertionAPMLDV">AP, ML, DV coordinates from an insertion.</param>
+        /// <param name="manipulatorState">Optional manipulator state to use. If null, uses active manipulator state.</param>
         /// <returns>Computed manipulator translation stage positions to match this coordinate, or null if conversion fails.</returns>
-        private Vector4? ConvertInsertionAPMLDVToManipulatorPosition(Vector3 insertionAPMLDV)
+        private Vector4? ConvertInsertionAPMLDVToManipulatorPosition(Vector3 insertionAPMLDV, ManipulatorState manipulatorState = null)
         {
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
-            var activeManipulatorState = sceneState.ActiveManipulatorState;
+            var activeManipulatorState = manipulatorState ?? sceneState.ActiveManipulatorState;
 
             // Validate we have the necessary data
             if (BrainAtlasManager.ActiveReferenceAtlas == null)
@@ -1252,10 +1264,12 @@ private void RemoveTrajectoryLines()
         ///     Get the visualization probe's current tip position in world space.
         ///     For visualization probes, uses ProbeController local values; otherwise uses ProbeWorldState.
         /// </summary>
-        private Vector3? GetVisualizationProbeTipWorldT()
+        /// <param name="manipulatorState">Optional manipulator state to use. If null, uses active manipulator state.</param>
+        private Vector3? GetVisualizationProbeTipWorldT(ManipulatorState manipulatorState = null)
         {
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
-            var visualizationProbeName = sceneState.ActiveManipulatorState.VisualizationProbeName;
+            var activeManipulatorState = manipulatorState ?? sceneState.ActiveManipulatorState;
+            var visualizationProbeName = activeManipulatorState.VisualizationProbeName;
 
             var visualizationProbeManager = ProbeManager.Instances.FirstOrDefault(m =>
                 m.name == visualizationProbeName
@@ -1282,10 +1296,12 @@ private void RemoveTrajectoryLines()
         ///     Get the visualization probe's current APMLDV coordinates.
         ///     For visualization probes, uses ProbeController local values.
         /// </summary>
-        private Vector3? GetVisualizationProbeAPMLDV()
+        /// <param name="manipulatorState">Optional manipulator state to use. If null, uses active manipulator state.</param>
+        private Vector3? GetVisualizationProbeAPMLDV(ManipulatorState manipulatorState = null)
         {
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
-            var visualizationProbeName = sceneState.ActiveManipulatorState.VisualizationProbeName;
+            var activeManipulatorState = manipulatorState ?? sceneState.ActiveManipulatorState;
+            var visualizationProbeName = activeManipulatorState.VisualizationProbeName;
 
             var visualizationProbeManager = ProbeManager.Instances.FirstOrDefault(m =>
                 m.name == visualizationProbeName
@@ -1302,10 +1318,12 @@ private void RemoveTrajectoryLines()
         /// <summary>
         ///     Get the visualization probe's forward direction in transformed space.
         /// </summary>
-        private Vector3? GetVisualizationProbeForwardT()
+        /// <param name="manipulatorState">Optional manipulator state to use. If null, uses active manipulator state.</param>
+        private Vector3? GetVisualizationProbeForwardT(ManipulatorState manipulatorState = null)
         {
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
-            var visualizationProbeName = sceneState.ActiveManipulatorState.VisualizationProbeName;
+            var activeManipulatorState = manipulatorState ?? sceneState.ActiveManipulatorState;
+            var visualizationProbeName = activeManipulatorState.VisualizationProbeName;
 
             var visualizationProbeManager = ProbeManager.Instances.FirstOrDefault(m =>
                 m.name == visualizationProbeName
@@ -1349,8 +1367,9 @@ or AutomationProgressState.AtDuraExit
         ///     Compute the target coordinate adjusted for the probe's actual position.
         /// </summary>
         /// <param name="targetProbeName">Target probe name.</param>
+        /// <param name="manipulatorState">Optional manipulator state to use. If null, uses active manipulator state.</param>
         /// <returns>APMLDV coordinates of where the probe should actually go.</returns>
-        private Vector3 GetOffsetAdjustedTargetCoordinate(string targetProbeName)
+        private Vector3 GetOffsetAdjustedTargetCoordinate(string targetProbeName, ManipulatorState manipulatorState = null)
         {
             // Get target probe world state from Redux (target probes are NOT visualization probes)
             var targetProbeWorldState = GetProbeWorldState(targetProbeName);
@@ -1358,8 +1377,8 @@ private Vector3 GetOffsetAdjustedTargetCoordinate(string targetProbeName)
                 return Vector3.negativeInfinity;
 
             // Get visualization probe position and forward using ProbeController local values
-            var visualizationWorldT = GetVisualizationProbeTipWorldT();
-            var probeTipForward = GetVisualizationProbeForwardT();
+            var visualizationWorldT = GetVisualizationProbeTipWorldT(manipulatorState);
+            var probeTipForward = GetVisualizationProbeForwardT(manipulatorState);
 
             if (visualizationWorldT == null || probeTipForward == null)
                 return Vector3.negativeInfinity;
@@ -1388,13 +1407,15 @@ private Vector3 GetOffsetAdjustedTargetCoordinate(string targetProbeName)
         ///     Compute the absolute distance from the target insertion to the Dura.
         /// </summary>
         /// <param name="targetProbeName">Target probe name to compute distance to.</param>
+        /// <param name="manipulatorState">Optional manipulator state to use. If null, uses active manipulator state.</param>
         /// <returns>Distance in mm to the target from the Dura.</returns>
-        private float GetTargetDistanceToDura(string targetProbeName)
+        private float GetTargetDistanceToDura(string targetProbeName, ManipulatorState manipulatorState = null)
         {
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
-            var duraCoordinate = sceneState.ActiveManipulatorState.DuraCoordinate;
+            var activeManipulatorState = manipulatorState ?? sceneState.ActiveManipulatorState;
+            var duraCoordinate = activeManipulatorState.DuraCoordinate;
             return Vector3.Distance(
-                GetOffsetAdjustedTargetCoordinate(targetProbeName),
+                GetOffsetAdjustedTargetCoordinate(targetProbeName, manipulatorState),
                 new Vector3(duraCoordinate.x, duraCoordinate.y, duraCoordinate.z)
             );
         }
@@ -1403,17 +1424,18 @@ private float GetTargetDistanceToDura(string targetProbeName)
         ///     Compute the current distance to the target insertion.
         /// </summary>
         /// <param name="targetProbeName">Target probe name.</param>
+        /// <param name="manipulatorState">Optional manipulator state to use. If null, uses active manipulator state.</param>
         /// <returns>Distance in mm to the target from the probe.</returns>
-        private float GetCurrentDistanceToTarget(string targetProbeName)
+        private float GetCurrentDistanceToTarget(string targetProbeName, ManipulatorState manipulatorState = null)
         {
             // Get visualization probe APMLDV using ProbeController local values
-            var visualizationAPMLDV = GetVisualizationProbeAPMLDV();
+            var visualizationAPMLDV = GetVisualizationProbeAPMLDV(manipulatorState);
             if (visualizationAPMLDV == null)
                 return float.NaN;
 
             return Vector3.Distance(
                 visualizationAPMLDV.Value,
-                GetOffsetAdjustedTargetCoordinate(targetProbeName)
+                GetOffsetAdjustedTargetCoordinate(targetProbeName, manipulatorState)
             );
         }
 
@@ -1421,14 +1443,16 @@ private float GetCurrentDistanceToTarget(string targetProbeName)
         ///     Compute the target depth for the probe to drive to.
         /// </summary>
         /// <param name="targetProbeName">Target probe name to drive (insert) to.</param>
+        /// <param name="manipulatorState">Optional manipulator state to use. If null, uses active manipulator state.</param>
         /// <returns>The depth the manipulator needs to drive to reach the target insertion.</returns>
-        private float GetTargetDepth(string targetProbeName)
+        private float GetTargetDepth(string targetProbeName, ManipulatorState manipulatorState = null)
         {
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
-            var duraDepth = sceneState.ActiveManipulatorState.DuraDepth;
+            var activeManipulatorState = manipulatorState ?? sceneState.ActiveManipulatorState;
+            var duraDepth = activeManipulatorState.DuraDepth;
 
             // DuraOffset is for visualization only - do not apply it to manipulator depth calculations
-            return duraDepth + GetTargetDistanceToDura(targetProbeName);
+            return duraDepth + GetTargetDistanceToDura(targetProbeName, manipulatorState);
         }
 
         /// <summary>
@@ -1437,19 +1461,21 @@ private float GetTargetDepth(string targetProbeName)
         /// <param name="targetProbeName">Target probe name to calculate ETA to.</param>
         /// <param name="baseSpeed">Base driving speed in mm/s.</param>
         /// <param name="drivePastDistance">Distance to drive past target in mm.</param>
+        /// <param name="manipulatorState">Optional manipulator state to use. If null, uses active manipulator state.</param>
         /// <returns>ETA in seconds for reaching a target or exiting.</returns>
         private int ComputeEtaSeconds(
             string targetProbeName,
             float baseSpeed,
-            float drivePastDistance
+            float drivePastDistance,
+            ManipulatorState manipulatorState = null
         )
         {
             var sceneState = _storeService.Store.GetState<SceneState>(SliceNames.SCENE_SLICE);
-            var manipulatorState = sceneState.ActiveManipulatorState;
+            var activeManipulatorState = manipulatorState ?? sceneState.ActiveManipulatorState;
 
-            var distanceToTarget = GetCurrentDistanceToTarget(targetProbeName);
-            var targetDistanceToDura = GetTargetDistanceToDura(targetProbeName);
-            var actualExitMarginToDuraDistance = manipulatorState.DuraDepth - _entryCoordinateDepth;
+            var distanceToTarget = GetCurrentDistanceToTarget(targetProbeName, manipulatorState);
+            var targetDistanceToDura = GetTargetDistanceToDura(targetProbeName, manipulatorState);
+            var actualExitMarginToDuraDistance = activeManipulatorState.DuraDepth - _entryCoordinateDepth;
 
             var secondsToDestination = AutomationProgressState switch
             {
@@ -1485,10 +1511,12 @@ float drivePastDistance
         /// <summary>
         ///     Log a drive event.
         /// </summary>
+        /// <param name="manipulatorId">ID of the manipulator being driven.</param>
         /// <param name="targetDepth">Target depth of drive.</param>
         /// <param name="baseSpeed">Base speed of drive.</param>
         /// <param name="drivePastDistance">Distance (mm) driven past the target.</param>
         private void LogDriveToTargetInsertion(
+            string manipulatorId,
             float targetDepth,
             float baseSpeed,
             float drivePastDistance = 0
@@ -1500,7 +1528,7 @@ private void LogDriveToTargetInsertion(
                     "Automation",
                     DateTime.Now.ToString(CultureInfo.InvariantCulture),
                     "DriveToTargetInsertion",
-                    ActiveManipulatorId,
+                    manipulatorId,
                     AutomationProgressState.ToString(),
                     (targetDepth * 1000).ToString(CultureInfo.InvariantCulture),
                     (baseSpeed * 1000).ToString(CultureInfo.InvariantCulture),
diff --git a/Assets/Scripts/Utils/EphysLinkConstants.cs b/Assets/Scripts/Utils/EphysLinkConstants.cs
index 753c6621..37190608 100644
--- a/Assets/Scripts/Utils/EphysLinkConstants.cs
+++ b/Assets/Scripts/Utils/EphysLinkConstants.cs
@@ -7,7 +7,7 @@ public static class EphysLinkConstants
     {
         public const int EPHYS_LINK_MIN_VERSION_MAJOR = 2;
         public const int EPHYS_LINK_MIN_VERSION_MINOR = 2;
-        public const int EPHYS_LINK_MIN_VERSION_PATCH = 1;
+        public const int EPHYS_LINK_MIN_VERSION_PATCH = 2;
 
         public static readonly string EphysLinkMinVersion =
             $"{EPHYS_LINK_MIN_VERSION_MAJOR}.{EPHYS_LINK_MIN_VERSION_MINOR}.{EPHYS_LINK_MIN_VERSION_PATCH}";