diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatAdbCommandCatalog.cs b/com.unity.mobile.android-logcat/Editor/AndroidLogcatAdbCommandCatalog.cs
new file mode 100644
index 00000000..f9d36505
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatAdbCommandCatalog.cs
@@ -0,0 +1,148 @@
+namespace Unity.Android.Logcat
+{
+    internal static class AndroidLogcatAdbCommandCatalog
+    {
+        internal static readonly AndroidLogcatCommandEntry[] All = new[]
+        {
+            // --- Device Management ---
+            new AndroidLogcatCommandEntry("List Devices", "adb devices"),
+            new AndroidLogcatCommandEntry("List Devices (Verbose)", "adb devices -l"),
+            new AndroidLogcatCommandEntry("Start Server", "adb start-server"),
+            new AndroidLogcatCommandEntry("Kill Server", "adb kill-server"),
+            new AndroidLogcatCommandEntry("Reboot Device", "adb reboot"),
+            new AndroidLogcatCommandEntry("Reboot to Bootloader", "adb reboot bootloader"),
+            new AndroidLogcatCommandEntry("Reboot to Recovery", "adb reboot recovery"),
+            new AndroidLogcatCommandEntry("Get Device State", "adb get-state"),
+            new AndroidLogcatCommandEntry("Get Serial Number", "adb get-serialno"),
+            new AndroidLogcatCommandEntry("Wait for Device", "adb wait-for-device"),
+
+            // --- App Management ---
+            new AndroidLogcatCommandEntry("List All Packages", "adb shell pm list packages"),
+            new AndroidLogcatCommandEntry("List Third-Party Packages", "adb shell pm list packages -3"),
+            new AndroidLogcatCommandEntry("List System Packages", "adb shell pm list packages -s"),
+            new AndroidLogcatCommandEntry("Clear App Data", "adb shell pm clear <package>"),
+            new AndroidLogcatCommandEntry("Force Stop App", "adb shell am force-stop <package>"),
+            new AndroidLogcatCommandEntry("Start Activity", "adb shell am start -n <package/activity>"),
+            new AndroidLogcatCommandEntry("Start App (Launcher)", "adb shell monkey -p <package> -c android.intent.category.LAUNCHER 1"),
+            new AndroidLogcatCommandEntry("Start App (UnityPlayerActivity)", "adb shell am start -n <package>/com.unity3d.player.UnityPlayerActivity"),
+            new AndroidLogcatCommandEntry("Start App (GameActivity)", "adb shell am start -n <package>/com.google.androidgamesdk.GameActivity"),
+            new AndroidLogcatCommandEntry("Uninstall App", "adb uninstall <package>"),
+            new AndroidLogcatCommandEntry("Install APK", "adb install <path.apk>"),
+            new AndroidLogcatCommandEntry("Install APK (Replace)", "adb install -r <path.apk>"),
+            new AndroidLogcatCommandEntry("Install Multiple APKs (Split)", "adb install-multiple -r <path1.apk> <path2.apk>"),
+            new AndroidLogcatCommandEntry("Push OBB File", "adb push <local.obb> /sdcard/Android/obb/<package>/"),
+            new AndroidLogcatCommandEntry("Create OBB Directory", "adb shell mkdir -p /sdcard/Android/obb/<package>"),
+            new AndroidLogcatCommandEntry("Grant Permission", "adb shell pm grant <package> <permission>"),
+            new AndroidLogcatCommandEntry("Revoke Permission", "adb shell pm revoke <package> <permission>"),
+            new AndroidLogcatCommandEntry("Dump App Info", "adb shell dumpsys package <package>"),
+
+            // --- File Transfer ---
+            new AndroidLogcatCommandEntry("Push File to Device", "adb push <local> <remote>"),
+            new AndroidLogcatCommandEntry("Pull File from Device", "adb pull <remote> <local>"),
+            new AndroidLogcatCommandEntry("List Directory", "adb shell ls -la <path>"),
+            new AndroidLogcatCommandEntry("Remove File", "adb shell rm <path>"),
+            new AndroidLogcatCommandEntry("Make Directory", "adb shell mkdir -p <path>"),
+
+            // --- Logcat ---
+            new AndroidLogcatCommandEntry("View Logcat", "adb logcat"),
+            new AndroidLogcatCommandEntry("Clear Logcat", "adb logcat -c"),
+            new AndroidLogcatCommandEntry("Dump Logcat & Exit", "adb logcat -d"),
+            new AndroidLogcatCommandEntry("Logcat Errors Only", "adb logcat *:E"),
+            new AndroidLogcatCommandEntry("Logcat Warnings & Above", "adb logcat *:W"),
+            new AndroidLogcatCommandEntry("Logcat with Timestamps", "adb logcat -v time"),
+            new AndroidLogcatCommandEntry("Logcat by Tag", "adb logcat -s <TAG>"),
+            new AndroidLogcatCommandEntry("Logcat Unity Only", "adb logcat -s Unity"),
+
+            // --- Screen Capture ---
+            new AndroidLogcatCommandEntry("Take Screenshot", "adb shell screencap /sdcard/screenshot.png"),
+            new AndroidLogcatCommandEntry("Record Screen", "adb shell screenrecord /sdcard/recording.mp4"),
+            new AndroidLogcatCommandEntry("Record Screen (30s)", "adb shell screenrecord --time-limit 30 /sdcard/recording.mp4"),
+
+            // --- System Info ---
+            new AndroidLogcatCommandEntry("Get Android Version", "adb shell getprop ro.build.version.release"),
+            new AndroidLogcatCommandEntry("Get SDK Version", "adb shell getprop ro.build.version.sdk"),
+            new AndroidLogcatCommandEntry("Get Device Model", "adb shell getprop ro.product.model"),
+            new AndroidLogcatCommandEntry("Get Device Manufacturer", "adb shell getprop ro.product.manufacturer"),
+            new AndroidLogcatCommandEntry("Get All Properties", "adb shell getprop"),
+            new AndroidLogcatCommandEntry("Get Screen Resolution", "adb shell wm size"),
+            new AndroidLogcatCommandEntry("Get Screen Density", "adb shell wm density"),
+            new AndroidLogcatCommandEntry("Get Battery Info", "adb shell dumpsys battery"),
+            new AndroidLogcatCommandEntry("Get CPU Info", "adb shell cat /proc/cpuinfo"),
+            new AndroidLogcatCommandEntry("Get Memory Info", "adb shell cat /proc/meminfo"),
+            new AndroidLogcatCommandEntry("Get Disk Usage", "adb shell df"),
+            new AndroidLogcatCommandEntry("Get Running Processes", "adb shell ps"),
+            new AndroidLogcatCommandEntry("Get Top Processes", "adb shell top -n 1"),
+            new AndroidLogcatCommandEntry("Get Build Properties", "adb shell cat /system/build.prop"),
+
+            // --- Input Simulation ---
+            new AndroidLogcatCommandEntry("Send Keyevent (Home)", "adb shell input keyevent KEYCODE_HOME"),
+            new AndroidLogcatCommandEntry("Send Keyevent (Back)", "adb shell input keyevent KEYCODE_BACK"),
+            new AndroidLogcatCommandEntry("Send Keyevent (Menu)", "adb shell input keyevent KEYCODE_MENU"),
+            new AndroidLogcatCommandEntry("Send Keyevent (Power)", "adb shell input keyevent KEYCODE_POWER"),
+            new AndroidLogcatCommandEntry("Send Keyevent (Volume Up)", "adb shell input keyevent KEYCODE_VOLUME_UP"),
+            new AndroidLogcatCommandEntry("Send Keyevent (Volume Down)", "adb shell input keyevent KEYCODE_VOLUME_DOWN"),
+            new AndroidLogcatCommandEntry("Send Keyevent (Enter)", "adb shell input keyevent KEYCODE_ENTER"),
+            new AndroidLogcatCommandEntry("Send Keyevent (Tab)", "adb shell input keyevent KEYCODE_TAB"),
+            new AndroidLogcatCommandEntry("Send Text", "adb shell input text <text>"),
+            new AndroidLogcatCommandEntry("Tap Screen", "adb shell input tap <x> <y>"),
+            new AndroidLogcatCommandEntry("Swipe Screen", "adb shell input swipe <x1> <y1> <x2> <y2>"),
+
+            // --- Networking ---
+            new AndroidLogcatCommandEntry("Enable WiFi ADB", "adb tcpip 5555"),
+            new AndroidLogcatCommandEntry("Connect via IP", "adb connect <ip>:5555"),
+            new AndroidLogcatCommandEntry("Disconnect All", "adb disconnect"),
+            new AndroidLogcatCommandEntry("Forward Port", "adb forward tcp:<local> tcp:<remote>"),
+            new AndroidLogcatCommandEntry("Reverse Port", "adb reverse tcp:<remote> tcp:<local>"),
+            new AndroidLogcatCommandEntry("Get IP Address", "adb shell ip addr show wlan0"),
+            new AndroidLogcatCommandEntry("Ping Host", "adb shell ping -c 4 <host>"),
+
+            // --- Dumpsys ---
+            new AndroidLogcatCommandEntry("Dump Activity Stack", "adb shell dumpsys activity activities"),
+            new AndroidLogcatCommandEntry("Dump Memory Info", "adb shell dumpsys meminfo"),
+            new AndroidLogcatCommandEntry("Dump Window Info", "adb shell dumpsys window"),
+            new AndroidLogcatCommandEntry("Dump Display Info", "adb shell dumpsys display"),
+            new AndroidLogcatCommandEntry("Dump CPU Info", "adb shell dumpsys cpuinfo"),
+            new AndroidLogcatCommandEntry("Dump Battery Stats", "adb shell dumpsys batterystats"),
+            new AndroidLogcatCommandEntry("Dump SurfaceFlinger", "adb shell dumpsys SurfaceFlinger"),
+            new AndroidLogcatCommandEntry("Dump Graphics Stats", "adb shell dumpsys gfxinfo <package>"),
+            new AndroidLogcatCommandEntry("Dump Wifi Info", "adb shell dumpsys wifi"),
+            new AndroidLogcatCommandEntry("Dump Alarm Info", "adb shell dumpsys alarm"),
+            new AndroidLogcatCommandEntry("Dump Notification Info", "adb shell dumpsys notification"),
+
+            // --- Settings ---
+            new AndroidLogcatCommandEntry("Enable Stay Awake", "adb shell settings put global stay_on_while_plugged_in 3"),
+            new AndroidLogcatCommandEntry("Disable Stay Awake", "adb shell settings put global stay_on_while_plugged_in 0"),
+            new AndroidLogcatCommandEntry("Show Touches On", "adb shell settings put system show_touches 1"),
+            new AndroidLogcatCommandEntry("Show Touches Off", "adb shell settings put system show_touches 0"),
+            new AndroidLogcatCommandEntry("Enable USB Debugging", "adb shell settings put global adb_enabled 1"),
+            new AndroidLogcatCommandEntry("Set Screen Off Timeout", "adb shell settings put system screen_off_timeout <ms>"),
+
+            // --- Debug / Advanced ---
+            new AndroidLogcatCommandEntry("Bug Report", "adb bugreport"),
+            new AndroidLogcatCommandEntry("Remount System", "adb remount"),
+            new AndroidLogcatCommandEntry("Root Shell", "adb root"),
+            new AndroidLogcatCommandEntry("Unroot Shell", "adb unroot"),
+            new AndroidLogcatCommandEntry("Disable Verity", "adb disable-verity"),
+            new AndroidLogcatCommandEntry("Enable Verity", "adb enable-verity"),
+            new AndroidLogcatCommandEntry("Wait for Device Boot", "adb wait-for-device shell getprop sys.boot_completed"),
+            new AndroidLogcatCommandEntry("List Tombstones", "adb shell ls -lt /data/tombstones/"),
+            new AndroidLogcatCommandEntry("Pull Tombstone", "adb pull /data/tombstones/<tombstone_XX> <local_path>"),
+
+            // --- Meta Quest / XR ---
+            new AndroidLogcatCommandEntry("List OVR Packages", "adb shell pm list packages | grep oculus"),
+            new AndroidLogcatCommandEntry("Get Guardian State", "adb shell dumpsys OVRGuardianService"),
+            new AndroidLogcatCommandEntry("Get Compositor Stats", "adb shell dumpsys OVRCompositor"),
+            new AndroidLogcatCommandEntry("Set GPU Level", "adb shell setprop debug.oculus.gpuLevel <0-4>"),
+            new AndroidLogcatCommandEntry("Set CPU Level", "adb shell setprop debug.oculus.cpuLevel <0-4>"),
+            new AndroidLogcatCommandEntry("Enable Perf Overlay", "adb shell setprop debug.oculus.enablePerfOverlay 1"),
+            new AndroidLogcatCommandEntry("Disable Perf Overlay", "adb shell setprop debug.oculus.enablePerfOverlay 0"),
+            new AndroidLogcatCommandEntry("Set Fixed Foveation", "adb shell setprop debug.oculus.foveation.level <0-4>"),
+            new AndroidLogcatCommandEntry("Set Refresh Rate", "adb shell setprop debug.oculus.refreshRate <72|90|120>"),
+
+            // --- AAB / Bundletool ---
+            new AndroidLogcatCommandEntry("bundletool: Build Split APKs", "java -jar bundletool.jar build-apks --bundle=<path.aab> --output=<output.apks> --connected-device"),
+            new AndroidLogcatCommandEntry("bundletool: Install APKs", "java -jar bundletool.jar install-apks --apks=<path.apks>"),
+            new AndroidLogcatCommandEntry("bundletool: Get Device Spec", "java -jar bundletool.jar get-device-spec --output=<device-spec.json>"),
+        };
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatAdbCommandCatalog.cs.meta b/com.unity.mobile.android-logcat/Editor/AndroidLogcatAdbCommandCatalog.cs.meta
new file mode 100644
index 00000000..0a6503d9
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatAdbCommandCatalog.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: c184fe6fa853c48a29bcb98002dc77fd
\ No newline at end of file
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatAddCommandDialog.cs b/com.unity.mobile.android-logcat/Editor/AndroidLogcatAddCommandDialog.cs
new file mode 100644
index 00000000..5301a661
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatAddCommandDialog.cs
@@ -0,0 +1,71 @@
+using System;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace Unity.Android.Logcat
+{
+    internal class AndroidLogcatAddCommandDialog : EditorWindow
+    {
+        string m_Name = "";
+        string m_Command = "";
+        Action<AndroidLogcatCommandEntry> m_OnSave;
+        bool m_IsEdit;
+
+        internal static void Show(Action<AndroidLogcatCommandEntry> onSave, AndroidLogcatCommandEntry existing = null)
+        {
+            var wnd = CreateInstance<AndroidLogcatAddCommandDialog>();
+            wnd.titleContent = new GUIContent(existing != null ? "Edit Command" : "Add Command");
+            wnd.m_OnSave = onSave;
+            wnd.minSize = new Vector2(400, 200);
+            wnd.maxSize = new Vector2(600, 400);
+
+            if (existing != null)
+            {
+                wnd.m_Name = existing.name;
+                wnd.m_Command = existing.command;
+                wnd.m_IsEdit = true;
+            }
+
+            wnd.ShowUtility();
+        }
+
+        void OnEnable()
+        {
+            LoadUI();
+        }
+
+        void LoadUI()
+        {
+            var r = rootVisualElement;
+            var tree = AndroidLogcatUtilities.LoadUXML("AndroidLogcatAddCommand.uxml");
+            tree.CloneTree(r);
+
+            var nameField = r.Q<TextField>("NameField");
+            nameField.value = m_Name;
+            nameField.RegisterValueChangedCallback(evt => m_Name = evt.newValue);
+
+            var commandField = r.Q<TextField>("CommandField");
+            commandField.value = m_Command;
+            commandField.RegisterValueChangedCallback(evt => m_Command = evt.newValue);
+
+            var saveButton = r.Q<Button>("SaveButton");
+            saveButton.text = m_IsEdit ? "Save" : "Add";
+            saveButton.clicked += OnSaveClicked;
+
+            r.Q<Button>("CancelButton").clicked += () => Close();
+        }
+
+        void OnSaveClicked()
+        {
+            if (string.IsNullOrWhiteSpace(m_Name) || string.IsNullOrWhiteSpace(m_Command))
+            {
+                EditorUtility.DisplayDialog("Android Logcat", "Both name and command are required.", "OK");
+                return;
+            }
+
+            m_OnSave?.Invoke(new AndroidLogcatCommandEntry(m_Name.Trim(), m_Command.Trim()));
+            Close();
+        }
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatAddCommandDialog.cs.meta b/com.unity.mobile.android-logcat/Editor/AndroidLogcatAddCommandDialog.cs.meta
new file mode 100644
index 00000000..91361f81
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatAddCommandDialog.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b9328feb6e55441ecaaf37b9b821eedd
\ No newline at end of file
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandEntry.cs b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandEntry.cs
new file mode 100644
index 00000000..ebe1a502
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandEntry.cs
@@ -0,0 +1,27 @@
+using System;
+using UnityEngine;
+
+namespace Unity.Android.Logcat
+{
+    [Serializable]
+    internal class AndroidLogcatCommandEntry
+    {
+        [SerializeField] internal string name;
+        [SerializeField] internal string command;
+
+        internal AndroidLogcatCommandEntry() { }
+
+        internal AndroidLogcatCommandEntry(string name, string command)
+        {
+            this.name = name;
+            this.command = command;
+        }
+    }
+
+    [Serializable]
+    internal class AndroidLogcatCommandExportData
+    {
+        public AndroidLogcatCommandEntry[] favorites = Array.Empty<AndroidLogcatCommandEntry>();
+        public AndroidLogcatCommandEntry[] general = Array.Empty<AndroidLogcatCommandEntry>();
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandEntry.cs.meta b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandEntry.cs.meta
new file mode 100644
index 00000000..7587f65f
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandEntry.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 751f57b4a1fa443a6a25067ac8f7e7cc
\ No newline at end of file
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandOutputWindow.cs b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandOutputWindow.cs
new file mode 100644
index 00000000..8a613dc6
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandOutputWindow.cs
@@ -0,0 +1,123 @@
+using System.Collections.Generic;
+using System.Text;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace Unity.Android.Logcat
+{
+    internal class AndroidLogcatCommandOutputWindow : EditorWindow
+    {
+        static AndroidLogcatCommandOutputWindow s_Instance;
+
+        readonly List<AndroidLogcatCommandsWindow.OutputLine> m_Lines = new List<AndroidLogcatCommandsWindow.OutputLine>();
+        bool m_AutoScroll = true;
+        const int kMaxLines = 5000;
+
+        ScrollView m_ScrollView;
+        VisualElement m_OutputContainer;
+
+        internal static void Open(List<AndroidLogcatCommandsWindow.OutputLine> existingLines)
+        {
+            var wnd = GetWindow<AndroidLogcatCommandOutputWindow>();
+            wnd.titleContent = new GUIContent("Command Output");
+            wnd.minSize = new Vector2(500, 300);
+            s_Instance = wnd;
+
+            wnd.m_Lines.Clear();
+            if (existingLines != null)
+                wnd.m_Lines.AddRange(existingLines);
+            wnd.RefreshOutput();
+        }
+
+        internal static void AppendIfOpen(string text, Color color)
+        {
+            if (s_Instance == null || string.IsNullOrEmpty(text))
+                return;
+
+            foreach (var line in text.Split('\n'))
+            {
+                var ol = new AndroidLogcatCommandsWindow.OutputLine { text = line, color = color };
+                s_Instance.m_Lines.Add(ol);
+                s_Instance.AddLineElement(ol);
+            }
+
+            if (s_Instance.m_Lines.Count > kMaxLines)
+            {
+                var excess = s_Instance.m_Lines.Count - kMaxLines;
+                s_Instance.m_Lines.RemoveRange(0, excess);
+                for (int i = 0; i < excess && s_Instance.m_OutputContainer.childCount > 0; i++)
+                    s_Instance.m_OutputContainer.RemoveAt(0);
+            }
+
+            if (s_Instance.m_AutoScroll)
+                s_Instance.ScrollToBottom();
+        }
+
+        void OnEnable()
+        {
+            s_Instance = this;
+            LoadUI();
+        }
+
+        void LoadUI()
+        {
+            var r = rootVisualElement;
+            var tree = AndroidLogcatUtilities.LoadUXML("AndroidLogcatCommandOutput.uxml");
+            tree.CloneTree(r);
+
+            m_ScrollView = r.Q<ScrollView>("OutputScroll");
+            m_OutputContainer = r.Q<VisualElement>("OutputContainer");
+
+            r.Q<Button>("ClearButton").clicked += () => { m_Lines.Clear(); m_OutputContainer?.Clear(); };
+            r.Q<Button>("CopyAllButton").clicked += CopyAll;
+
+            var autoScrollToggle = r.Q<Toggle>("AutoScrollToggle");
+            autoScrollToggle.value = m_AutoScroll;
+            autoScrollToggle.RegisterValueChangedCallback(evt => m_AutoScroll = evt.newValue);
+
+            foreach (var line in m_Lines)
+                AddLineElement(line);
+        }
+
+        void AddLineElement(AndroidLogcatCommandsWindow.OutputLine line)
+        {
+            var label = new Label(line.text);
+            label.style.color = new StyleColor(line.color);
+            label.style.whiteSpace = WhiteSpace.Normal;
+            m_OutputContainer.Add(label);
+        }
+
+        void RefreshOutput()
+        {
+            if (m_OutputContainer == null)
+                return;
+            m_OutputContainer.Clear();
+            foreach (var line in m_Lines)
+                AddLineElement(line);
+            if (m_AutoScroll)
+                ScrollToBottom();
+        }
+
+        void ScrollToBottom()
+        {
+            if (m_ScrollView == null || m_OutputContainer == null || m_OutputContainer.childCount == 0)
+                return;
+            m_ScrollView.schedule.Execute(() => m_ScrollView.ScrollTo(m_OutputContainer[m_OutputContainer.childCount - 1])).StartingIn(10);
+        }
+
+        void CopyAll()
+        {
+            var sb = new StringBuilder();
+            foreach (var line in m_Lines)
+                sb.AppendLine(line.text);
+            EditorGUIUtility.systemCopyBuffer = sb.ToString();
+        }
+
+        void OnDestroy()
+        {
+            if (s_Instance == this)
+                s_Instance = null;
+        }
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandOutputWindow.cs.meta b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandOutputWindow.cs.meta
new file mode 100644
index 00000000..4ed31bde
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandOutputWindow.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: fbfc680dc3b744bf5b317b7f336d8b11
\ No newline at end of file
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandSearchWindow.cs b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandSearchWindow.cs
new file mode 100644
index 00000000..9a996f07
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandSearchWindow.cs
@@ -0,0 +1,183 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace Unity.Android.Logcat
+{
+    internal class AndroidLogcatCommandSearchWindow : EditorWindow
+    {
+        static AndroidLogcatCommandSearchWindow s_Instance;
+
+        List<AndroidLogcatCommandEntry> m_Favorites;
+        List<AndroidLogcatCommandEntry> m_GeneralCommands;
+        Action<AndroidLogcatCommandEntry> m_OnAddCommand;
+        Action<AndroidLogcatCommandEntry> m_OnRunCommand;
+
+        string m_SearchQuery = "";
+
+        TextField m_SearchTextField;
+        HelpBox m_EmptyMessage;
+        VisualElement m_ResultsContainer;
+        ScrollView m_ResultsScroll;
+
+        static readonly string[] s_ChipTerms =
+            { "devices", "packages", "logcat", "permissions", "input", "screen", "network", "dumpsys", "quest" };
+
+        static readonly Color kCommandColor = new Color(0.6f, 0.6f, 0.6f);
+        static readonly Color kSavedSourceColor = new Color(0.4f, 0.7f, 0.4f);
+        static readonly Color kCatalogSourceColor = new Color(0.5f, 0.6f, 0.9f);
+
+        internal static void Open(
+            List<AndroidLogcatCommandEntry> favorites,
+            List<AndroidLogcatCommandEntry> generalCommands,
+            Action<AndroidLogcatCommandEntry> onAdd,
+            Action<AndroidLogcatCommandEntry> onRun)
+        {
+            var wnd = GetWindow<AndroidLogcatCommandSearchWindow>();
+            wnd.titleContent = new GUIContent("Search Commands");
+            wnd.minSize = new Vector2(500, 400);
+            s_Instance = wnd;
+            wnd.m_Favorites = favorites;
+            wnd.m_GeneralCommands = generalCommands;
+            wnd.m_OnAddCommand = onAdd;
+            wnd.m_OnRunCommand = onRun;
+            wnd.RebuildResults();
+        }
+
+        void OnEnable()
+        {
+            s_Instance = this;
+            LoadUI();
+        }
+
+        void LoadUI()
+        {
+            var r = rootVisualElement;
+            var tree = AndroidLogcatUtilities.LoadUXML("AndroidLogcatCommandSearch.uxml");
+            tree.CloneTree(r);
+
+            m_SearchTextField = r.Q<TextField>("SearchField");
+            m_EmptyMessage = r.Q<HelpBox>("EmptyMessage");
+            m_ResultsContainer = r.Q<VisualElement>("ResultsContainer");
+            m_ResultsScroll = r.Q<ScrollView>("ResultsScroll");
+
+            m_SearchTextField.value = m_SearchQuery;
+            m_SearchTextField.RegisterValueChangedCallback(evt => { m_SearchQuery = evt.newValue; RebuildResults(); });
+
+            var chipsRow = r.Q<VisualElement>("ChipsRow");
+            foreach (var term in s_ChipTerms)
+            {
+                var chip = new Button(() => m_SearchTextField.value = term) { text = term };
+                chip.style.marginRight = 2;
+                chipsRow.Add(chip);
+            }
+
+            RebuildResults();
+        }
+
+        void RebuildResults()
+        {
+            if (m_ResultsContainer == null)
+                return;
+
+            m_ResultsContainer.Clear();
+
+            if (string.IsNullOrWhiteSpace(m_SearchQuery))
+            {
+                SetEmptyState("Type a search term or click a chip to find commands.");
+                return;
+            }
+
+            var terms = m_SearchQuery.Trim().ToLowerInvariant();
+            var favorites = m_Favorites ?? new List<AndroidLogcatCommandEntry>();
+            var general = m_GeneralCommands ?? new List<AndroidLogcatCommandEntry>();
+
+            foreach (var e in favorites)
+                if (MatchesSearch(e, terms))
+                    m_ResultsContainer.Add(CreateResultRow(e, "Favorite", true));
+            foreach (var e in general)
+                if (MatchesSearch(e, terms))
+                    m_ResultsContainer.Add(CreateResultRow(e, "General", true));
+
+            var savedCommands = new HashSet<string>(
+                favorites.Concat(general).Select(c => c.command), StringComparer.OrdinalIgnoreCase);
+            foreach (var e in AndroidLogcatAdbCommandCatalog.All)
+                if (MatchesSearch(e, terms) && !savedCommands.Contains(e.command))
+                    m_ResultsContainer.Add(CreateResultRow(e, "Catalog", false));
+
+            if (m_ResultsContainer.childCount == 0)
+                SetEmptyState("No matching commands found.");
+            else
+            {
+                m_EmptyMessage.style.display = DisplayStyle.None;
+                m_ResultsScroll.style.display = DisplayStyle.Flex;
+            }
+        }
+
+        void SetEmptyState(string message)
+        {
+            m_EmptyMessage.text = message;
+            m_EmptyMessage.style.display = DisplayStyle.Flex;
+            m_ResultsScroll.style.display = DisplayStyle.None;
+        }
+
+        VisualElement CreateResultRow(AndroidLogcatCommandEntry entry, string source, bool isSaved)
+        {
+            var row = new VisualElement();
+            row.style.flexDirection = FlexDirection.Row;
+            row.style.alignItems = Align.Center;
+            row.style.paddingLeft = 4;
+            row.style.paddingRight = 4;
+            row.style.paddingTop = 2;
+            row.style.paddingBottom = 2;
+            row.style.borderBottomWidth = 1;
+            row.style.borderBottomColor = new Color(0.2f, 0.2f, 0.2f, 0.5f);
+
+            var nameLabel = new Label(entry.name);
+            nameLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
+            nameLabel.style.width = 180;
+            nameLabel.style.minWidth = 180;
+            row.Add(nameLabel);
+
+            var cmdLabel = new Label(entry.command);
+            cmdLabel.style.color = new StyleColor(kCommandColor);
+            cmdLabel.style.flexGrow = 1;
+            cmdLabel.style.overflow = Overflow.Hidden;
+            row.Add(cmdLabel);
+
+            var sourceLabel = new Label(source);
+            sourceLabel.style.width = 55;
+            sourceLabel.style.fontSize = 10;
+            sourceLabel.style.color = new StyleColor(isSaved ? kSavedSourceColor : kCatalogSourceColor);
+            row.Add(sourceLabel);
+
+            if (!isSaved)
+            {
+                var addBtn = new Button(() => m_OnAddCommand?.Invoke(new AndroidLogcatCommandEntry(entry.name, entry.command))) { text = "Add" };
+                addBtn.style.width = 40;
+                row.Add(addBtn);
+            }
+
+            var runBtn = new Button(() => m_OnRunCommand?.Invoke(entry)) { text = "Run" };
+            runBtn.style.width = 40;
+            row.Add(runBtn);
+
+            return row;
+        }
+
+        static bool MatchesSearch(AndroidLogcatCommandEntry entry, string terms)
+        {
+            return entry.name.ToLowerInvariant().Contains(terms)
+                || entry.command.ToLowerInvariant().Contains(terms);
+        }
+
+        void OnDestroy()
+        {
+            if (s_Instance == this)
+                s_Instance = null;
+        }
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandSearchWindow.cs.meta b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandSearchWindow.cs.meta
new file mode 100644
index 00000000..3a97a5f7
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandSearchWindow.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: f2d601788783b46278a4bb0e43b8e34d
\ No newline at end of file
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandsWindow.cs b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandsWindow.cs
new file mode 100644
index 00000000..a3c00032
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandsWindow.cs
@@ -0,0 +1,483 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace Unity.Android.Logcat
+{
+    internal class AndroidLogcatCommandsWindow : EditorWindow
+    {
+        static readonly AndroidLogcatCommandEntry[] s_DefaultCommands = new[]
+        {
+            new AndroidLogcatCommandEntry("List Devices", "adb devices"),
+            new AndroidLogcatCommandEntry("Kill Server", "adb kill-server"),
+            new AndroidLogcatCommandEntry("Reboot Device", "adb reboot")
+        };
+
+        internal struct OutputLine
+        {
+            internal string text;
+            internal Color color;
+        }
+
+        AndroidLogcatRuntimeBase m_Runtime;
+        AndroidLogcatDeviceSelection m_DeviceSelection;
+
+        List<AndroidLogcatCommandEntry> m_Favorites = new List<AndroidLogcatCommandEntry>();
+        List<AndroidLogcatCommandEntry> m_GeneralCommands = new List<AndroidLogcatCommandEntry>();
+        readonly List<OutputLine> m_OutputLines = new List<OutputLine>();
+
+        bool m_EditMode;
+
+        VisualElement m_FavoritesContainer;
+        VisualElement m_GeneralContainer;
+        VisualElement m_OutputContainer;
+        ScrollView m_OutputScroll;
+        Label m_RunningLabel;
+
+        VisualElement m_SelectedFavRow;
+        VisualElement m_SelectedGenRow;
+
+        const int kMaxOutputLines = 3000;
+
+        static readonly Color kCommandColor = new Color(0.6f, 0.6f, 0.6f);
+        static readonly Color kAccentColor = new Color(0.4f, 0.8f, 0.4f);
+        static readonly Color kErrorColor = new Color(0.9f, 0.3f, 0.3f);
+        static readonly Color kSelectedRowColor = new Color(0.3f, 0.5f, 0.8f, 0.3f);
+        static readonly char[] kNewlineChars = { '\r', '\n' };
+
+        internal static void ShowWindow()
+        {
+            var wnd = GetWindow<AndroidLogcatCommandsWindow>("Commands");
+            wnd.minSize = new Vector2(600, 400);
+        }
+
+        void OnEnable()
+        {
+            if (!AndroidBridge.AndroidExtensionsInstalled)
+                return;
+
+            m_Runtime = AndroidLogcatManager.instance.Runtime;
+            m_DeviceSelection = new AndroidLogcatDeviceSelection(m_Runtime, _ => Repaint(), nameof(AndroidLogcatCommandsWindow) + "_DeviceId");
+            m_Runtime.Closing += OnDisable;
+            m_Runtime.DeviceQuery.UpdateConnectedDevicesList(true);
+
+            LoadCommands();
+            LoadUI();
+        }
+
+        void OnDisable()
+        {
+            if (!AndroidBridge.AndroidExtensionsInstalled || m_Runtime == null)
+                return;
+
+            SaveCommands();
+            m_Runtime.Closing -= OnDisable;
+            m_DeviceSelection.Dispose();
+            m_DeviceSelection = null;
+            m_Runtime = null;
+        }
+
+        // --- UI Setup ---
+
+        void LoadUI()
+        {
+            var r = rootVisualElement;
+            r.Insert(0, new IMGUIContainer(DoToolbarGUI));
+
+            var tree = AndroidLogcatUtilities.LoadUXML("AndroidLogcatCommands.uxml");
+            tree.CloneTree(r);
+
+            m_FavoritesContainer = r.Q<VisualElement>("FavoritesContainer");
+            m_GeneralContainer = r.Q<VisualElement>("GeneralContainer");
+            m_OutputContainer = r.Q<VisualElement>("OutputContainer");
+            m_OutputScroll = r.Q<ScrollView>("OutputScroll");
+            m_RunningLabel = r.Q<Label>("RunningLabel");
+
+            r.Q<Button>("ClearButton").clicked += () => { m_OutputLines.Clear(); m_OutputContainer.Clear(); };
+            r.Q<Button>("PopOutButton").clicked += () => AndroidLogcatCommandOutputWindow.Open(m_OutputLines);
+
+            RebuildCommandList(m_FavoritesContainer, m_Favorites, true, "No favorites. Use Edit Mode to move commands here.", ref m_SelectedFavRow);
+            RebuildCommandList(m_GeneralContainer, m_GeneralCommands, false, "No commands. Click 'Add Command' or 'Search Catalog'.", ref m_SelectedGenRow);
+        }
+
+        // --- Toolbar (IMGUI - contains DeviceSelection which is IMGUI-only) ---
+
+        void DoToolbarGUI()
+        {
+            EditorGUILayout.BeginHorizontal(EditorStyles.toolbar);
+
+            if (m_DeviceSelection != null)
+                m_DeviceSelection.DoGUI();
+            GUILayout.Space(3);
+
+            if (GUILayout.Button("Add Command", EditorStyles.toolbarButton))
+                OnAddCommand();
+
+            if (GUILayout.Button(m_EditMode ? "Edit Mode: ON" : "Edit Mode: OFF", EditorStyles.toolbarButton))
+            {
+                m_EditMode = !m_EditMode;
+                RebuildLists();
+            }
+
+            if (GUILayout.Button("Import", EditorStyles.toolbarButton))
+                OnImportCommands();
+
+            if (GUILayout.Button("Export", EditorStyles.toolbarButton))
+                OnExportCommands();
+
+            if (GUILayout.Button("Search Catalog", EditorStyles.toolbarButton))
+                OpenSearchWindow();
+
+            if (GUILayout.Button("Open Output", EditorStyles.toolbarButton))
+                AndroidLogcatCommandOutputWindow.Open(m_OutputLines);
+
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.EndHorizontal();
+        }
+
+        // --- Command Lists ---
+
+        void RebuildLists()
+        {
+            RebuildCommandList(m_FavoritesContainer, m_Favorites, true, "No favorites. Use Edit Mode to move commands here.", ref m_SelectedFavRow);
+            RebuildCommandList(m_GeneralContainer, m_GeneralCommands, false, "No commands. Click 'Add Command' or 'Search Catalog'.", ref m_SelectedGenRow);
+        }
+
+        void RebuildCommandList(VisualElement container, List<AndroidLogcatCommandEntry> list, bool isFavorites, string emptyMessage, ref VisualElement selectedRow)
+        {
+            if (container == null)
+                return;
+
+            container.Clear();
+            selectedRow = null;
+
+            if (list.Count == 0)
+            {
+                var label = new Label(emptyMessage);
+                label.style.color = new StyleColor(new Color(0.5f, 0.5f, 0.5f));
+                label.style.fontSize = 10;
+                label.style.unityTextAlign = TextAnchor.MiddleCenter;
+                label.style.paddingTop = 4;
+                label.style.paddingBottom = 4;
+                container.Add(label);
+                return;
+            }
+
+            for (int i = 0; i < list.Count; i++)
+                container.Add(CreateCommandRow(list[i], list, i, isFavorites));
+        }
+
+        VisualElement CreateCommandRow(AndroidLogcatCommandEntry entry, List<AndroidLogcatCommandEntry> list, int index, bool isFavorites)
+        {
+            var row = CreateStyledRow(22);
+
+            // Click to select
+            row.RegisterCallback<MouseDownEvent>(_ =>
+            {
+                ref var selected = ref (isFavorites ? ref m_SelectedFavRow : ref m_SelectedGenRow);
+                if (selected != null)
+                    selected.style.backgroundColor = StyleKeyword.Null;
+                selected = row;
+                row.style.backgroundColor = new StyleColor(kSelectedRowColor);
+            });
+
+            // Name
+            var nameLabel = new Label(entry.name);
+            nameLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
+            nameLabel.style.width = 180;
+            nameLabel.style.minWidth = 180;
+            row.Add(nameLabel);
+
+            // Command preview
+            var cmdDisplay = entry.command;
+            if (cmdDisplay.IndexOfAny(kNewlineChars) >= 0)
+            {
+                var cmdLines = cmdDisplay.Split(kNewlineChars, StringSplitOptions.RemoveEmptyEntries);
+                if (cmdLines.Length > 1)
+                    cmdDisplay = $"{cmdLines[0].Trim()} (+{cmdLines.Length - 1} more)";
+                else
+                    cmdDisplay = cmdLines[0].Trim();
+            }
+            var cmdLabel = new Label(cmdDisplay);
+            cmdLabel.style.color = new StyleColor(kCommandColor);
+            cmdLabel.style.flexGrow = 1;
+            cmdLabel.style.overflow = Overflow.Hidden;
+            row.Add(cmdLabel);
+
+            // Edit mode buttons
+            if (m_EditMode)
+            {
+                AddRowButton(row, "\u25B2", 22, () =>
+                {
+                    list.RemoveAt(index);
+                    list.Insert(index - 1, entry);
+                    SaveAndRebuild();
+                }, index > 0);
+
+                AddRowButton(row, "\u25BC", 22, () =>
+                {
+                    list.RemoveAt(index);
+                    list.Insert(index + 1, entry);
+                    SaveAndRebuild();
+                }, index < list.Count - 1);
+
+                AddRowButton(row, isFavorites ? "Unfav" : "Fav", 40, () =>
+                {
+                    if (isFavorites) { m_Favorites.Remove(entry); m_GeneralCommands.Add(entry); }
+                    else { m_GeneralCommands.Remove(entry); m_Favorites.Add(entry); }
+                    SaveAndRebuild();
+                });
+
+                AddRowButton(row, "Edit", 35, () =>
+                {
+                    AndroidLogcatAddCommandDialog.Show(updated =>
+                    {
+                        if (m_Runtime == null) return;
+                        entry.name = updated.name;
+                        entry.command = updated.command;
+                        SaveAndRebuild();
+                    }, entry);
+                });
+
+                AddRowButton(row, "Del", 30, () =>
+                {
+                    if (EditorUtility.DisplayDialog("Delete Command", $"Delete \"{entry.name}\"?", "Delete", "Cancel"))
+                    {
+                        list.Remove(entry);
+                        SaveAndRebuild();
+                    }
+                });
+            }
+
+            AddRowButton(row, "Run", 35, () => RunCommand(entry));
+            return row;
+        }
+
+        void SaveAndRebuild()
+        {
+            SaveCommands();
+            RebuildLists();
+        }
+
+        // --- Row Helpers ---
+
+        static VisualElement CreateStyledRow(int height = 0)
+        {
+            var row = new VisualElement();
+            row.style.flexDirection = FlexDirection.Row;
+            row.style.alignItems = Align.Center;
+            row.style.paddingLeft = 4;
+            row.style.paddingRight = 4;
+            row.style.paddingTop = 2;
+            row.style.paddingBottom = 2;
+            row.style.borderBottomWidth = 1;
+            row.style.borderBottomColor = new Color(0.2f, 0.2f, 0.2f, 0.5f);
+            if (height > 0)
+                row.style.height = height;
+            return row;
+        }
+
+        static void AddRowButton(VisualElement row, string text, int width, Action action, bool enabled = true)
+        {
+            var btn = new Button(action) { text = text };
+            btn.style.width = width;
+            btn.SetEnabled(enabled);
+            row.Add(btn);
+        }
+
+        // --- Output ---
+
+        void AppendOutput(string text, Color color)
+        {
+            if (string.IsNullOrEmpty(text))
+                return;
+
+            foreach (var line in text.Split('\n'))
+            {
+                m_OutputLines.Add(new OutputLine { text = line, color = color });
+                if (m_OutputContainer != null)
+                {
+                    var label = new Label(line);
+                    label.style.color = new StyleColor(color);
+                    label.style.whiteSpace = WhiteSpace.Normal;
+                    m_OutputContainer.Add(label);
+                }
+            }
+
+            if (m_OutputLines.Count > kMaxOutputLines)
+            {
+                var excess = m_OutputLines.Count - kMaxOutputLines;
+                m_OutputLines.RemoveRange(0, excess);
+                if (m_OutputContainer != null)
+                    for (int i = 0; i < excess && m_OutputContainer.childCount > 0; i++)
+                        m_OutputContainer.RemoveAt(0);
+            }
+
+            if (m_OutputScroll != null && m_OutputContainer != null && m_OutputContainer.childCount > 0)
+                m_OutputScroll.schedule.Execute(() => m_OutputScroll.ScrollTo(m_OutputContainer[m_OutputContainer.childCount - 1])).StartingIn(10);
+
+            AndroidLogcatCommandOutputWindow.AppendIfOpen(text, color);
+        }
+
+        // --- Command Execution ---
+
+        void RunCommand(AndroidLogcatCommandEntry entry)
+        {
+            AndroidLogcatPlaceholderDialog.Show(entry.command, resolved => ExecuteCommand(resolved));
+        }
+
+        // TODO: Make async using AndroidLogcatDispatcher to avoid blocking the main thread
+        void ExecuteCommand(string resolvedCommand)
+        {
+            if (m_Runtime == null) return;
+
+            var lines = resolvedCommand.Split(kNewlineChars, StringSplitOptions.RemoveEmptyEntries);
+            if (m_RunningLabel != null)
+                m_RunningLabel.style.display = DisplayStyle.Flex;
+
+            var deviceId = m_DeviceSelection?.SelectedDevice?.Id;
+
+            foreach (var rawLine in lines)
+            {
+                var cmd = rawLine.Trim();
+                if (string.IsNullOrEmpty(cmd))
+                    continue;
+
+                AppendOutput($"> {cmd}", kAccentColor);
+
+                try
+                {
+                    string result;
+                    if (cmd.StartsWith("adb ", StringComparison.OrdinalIgnoreCase))
+                    {
+                        var adbArgs = cmd.Substring(4);
+                        if (!string.IsNullOrEmpty(deviceId) && !adbArgs.TrimStart().StartsWith("-s "))
+                            adbArgs = $"-s {deviceId} {adbArgs}";
+                        result = m_Runtime.Tools.ADB.Run(new[] { adbArgs }, "");
+                    }
+                    else
+                    {
+                        var parts = cmd.Split(new[] { ' ' }, 2);
+                        var shellResult = Shell.RunProcess(parts[0], parts.Length > 1 ? parts[1] : "");
+                        result = shellResult.GetStandardOut();
+                        var err = shellResult.GetStandardErr();
+                        if (!string.IsNullOrEmpty(err))
+                            result = string.IsNullOrEmpty(result) ? err : result + "\n" + err;
+                    }
+
+                    AppendOutput(result, GUI.skin.label.normal.textColor);
+                }
+                catch (Exception ex)
+                {
+                    AppendOutput($"[Error] {ex.Message}", kErrorColor);
+                }
+            }
+
+            if (m_RunningLabel != null)
+                m_RunningLabel.style.display = DisplayStyle.None;
+        }
+
+        // --- Add / Import / Export ---
+
+        void OnAddCommand()
+        {
+            AndroidLogcatAddCommandDialog.Show(entry =>
+            {
+                if (m_Runtime == null) return;
+                m_GeneralCommands.Add(entry);
+                SaveAndRebuild();
+            });
+        }
+
+        void OpenSearchWindow()
+        {
+            AndroidLogcatCommandSearchWindow.Open(
+                m_Favorites, m_GeneralCommands,
+                entry =>
+                {
+                    if (m_Runtime == null) return;
+                    m_GeneralCommands.Add(entry);
+                    SaveAndRebuild();
+                },
+                entry =>
+                {
+                    if (m_Runtime == null) return;
+                    RunCommand(entry);
+                });
+        }
+
+        void OnExportCommands()
+        {
+            var json = JsonUtility.ToJson(new AndroidLogcatCommandExportData
+            {
+                favorites = m_Favorites.ToArray(),
+                general = m_GeneralCommands.ToArray()
+            }, true);
+
+            var path = EditorUtility.SaveFilePanel("Export Commands", "", "logcat-commands", "json");
+            if (!string.IsNullOrEmpty(path))
+            {
+                File.WriteAllText(path, json);
+                Debug.Log($"[Android Logcat] Commands exported to {path}");
+            }
+        }
+
+        void OnImportCommands()
+        {
+            var path = EditorUtility.OpenFilePanel("Import Commands", "", "json");
+            if (string.IsNullOrEmpty(path))
+                return;
+
+            AndroidLogcatCommandExportData data;
+            try { data = JsonUtility.FromJson<AndroidLogcatCommandExportData>(File.ReadAllText(path)); }
+            catch (Exception ex)
+            {
+                EditorUtility.DisplayDialog("Import Failed", $"Could not parse the selected file:\n{ex.Message}", "OK");
+                return;
+            }
+
+            if ((data.favorites == null || data.favorites.Length == 0) && (data.general == null || data.general.Length == 0))
+            {
+                EditorUtility.DisplayDialog("Import Failed", "The file contains no commands.", "OK");
+                return;
+            }
+
+            if (!EditorUtility.DisplayDialog("Import Commands", "This will replace all your current commands. Continue?", "Import", "Cancel"))
+                return;
+
+            m_Favorites.Clear();
+            if (data.favorites != null) m_Favorites.AddRange(data.favorites);
+            m_GeneralCommands.Clear();
+            if (data.general != null) m_GeneralCommands.AddRange(data.general);
+
+            SaveAndRebuild();
+            Debug.Log($"[Android Logcat] Commands imported from {path}");
+        }
+
+        // --- Persistence ---
+
+        void LoadCommands()
+        {
+            var settings = m_Runtime.UserSettings.CommandsSettings;
+            m_Favorites.Clear();
+            m_GeneralCommands.Clear();
+
+            if (settings.Favorites != null) m_Favorites.AddRange(settings.Favorites);
+            if (settings.GeneralCommands != null) m_GeneralCommands.AddRange(settings.GeneralCommands);
+
+            if (m_GeneralCommands.Count == 0 && m_Favorites.Count == 0)
+                m_GeneralCommands.AddRange(s_DefaultCommands);
+        }
+
+        void SaveCommands()
+        {
+            var settings = m_Runtime.UserSettings.CommandsSettings;
+            settings.Favorites = new List<AndroidLogcatCommandEntry>(m_Favorites);
+            settings.GeneralCommands = new List<AndroidLogcatCommandEntry>(m_GeneralCommands);
+        }
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandsWindow.cs.meta b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandsWindow.cs.meta
new file mode 100644
index 00000000..80fa9b3f
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatCommandsWindow.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b07e946eed7fc401a89c81b7c89a812b
\ No newline at end of file
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatConsoleWindow.cs b/com.unity.mobile.android-logcat/Editor/AndroidLogcatConsoleWindow.cs
index 5ce27cda..2bca569d 100644
--- a/com.unity.mobile.android-logcat/Editor/AndroidLogcatConsoleWindow.cs
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatConsoleWindow.cs
@@ -338,6 +338,9 @@ private void MenuToolsSelection(object userData, string[] options, int selected)
                 case ToolsContextMenu.LayoutViewer:
                     AndroidLogcatLayoutViewerWindow.ShowWindow();
                     break;
+                case ToolsContextMenu.Commands:
+                    AndroidLogcatCommandsWindow.ShowWindow();
+                    break;
                 case ToolsContextMenu.WindowMemory:
                     m_Runtime.UserSettings.ExtraWindowState.Type = ExtraWindow.Memory;
                     break;
@@ -363,6 +366,7 @@ private void DoToolsGUI()
                 contextMenu.Add(ToolsContextMenu.StacktraceUtility, "Stacktrace Utility");
                 if (Unsupported.IsDeveloperMode())
                     contextMenu.Add(ToolsContextMenu.LayoutViewer, "Experimental/Layout Viewer");
+                contextMenu.Add(ToolsContextMenu.Commands, "Commands");
                 var b = m_Runtime.UserSettings.ExtraWindowState.Type;
                 contextMenu.Add(ToolsContextMenu.WindowMemory, "Window/Memory", b == ExtraWindow.Memory);
                 contextMenu.Add(ToolsContextMenu.WindowInputs, "Window/Inputs", b == ExtraWindow.Inputs);
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatContextMenu.cs b/com.unity.mobile.android-logcat/Editor/AndroidLogcatContextMenu.cs
index 46b747e1..242eddbe 100644
--- a/com.unity.mobile.android-logcat/Editor/AndroidLogcatContextMenu.cs
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatContextMenu.cs
@@ -28,6 +28,7 @@ internal enum ToolsContextMenu
         OpenTerminal,
         StacktraceUtility,
         LayoutViewer,
+        Commands,
         WindowMemory,
         WindowInputs,
         WindowHidden
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatPlaceholderDialog.cs b/com.unity.mobile.android-logcat/Editor/AndroidLogcatPlaceholderDialog.cs
new file mode 100644
index 00000000..bf0b0a85
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatPlaceholderDialog.cs
@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace Unity.Android.Logcat
+{
+    internal class AndroidLogcatPlaceholderDialog : EditorWindow
+    {
+        static readonly Regex s_PlaceholderRegex = new Regex(@"<([^>]+)>", RegexOptions.Compiled);
+
+        string m_OriginalCommand;
+        Action<string> m_OnConfirm;
+        List<PlaceholderInfo> m_Placeholders = new List<PlaceholderInfo>();
+
+        class PlaceholderInfo
+        {
+            internal string token;
+            internal string value;
+        }
+
+        internal static void Show(string command, Action<string> onConfirm)
+        {
+            var matches = s_PlaceholderRegex.Matches(command);
+            if (matches.Count == 0)
+            {
+                onConfirm?.Invoke(command);
+                return;
+            }
+
+            var wnd = CreateInstance<AndroidLogcatPlaceholderDialog>();
+            wnd.titleContent = new GUIContent("Resolve Placeholders");
+            wnd.m_OriginalCommand = command;
+            wnd.m_OnConfirm = onConfirm;
+            wnd.minSize = new Vector2(400, 150);
+            wnd.maxSize = new Vector2(600, 400);
+
+            var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            foreach (Match match in matches)
+            {
+                var token = match.Groups[1].Value;
+                if (!seen.Add(token))
+                    continue;
+
+                var defaultValue = "";
+                if (token.Equals("package", StringComparison.OrdinalIgnoreCase))
+                    defaultValue = PlayerSettings.applicationIdentifier;
+
+                wnd.m_Placeholders.Add(new PlaceholderInfo { token = token, value = defaultValue });
+            }
+
+            wnd.ShowUtility();
+        }
+
+        void OnEnable()
+        {
+            LoadUI();
+        }
+
+        void LoadUI()
+        {
+            var r = rootVisualElement;
+            var tree = AndroidLogcatUtilities.LoadUXML("AndroidLogcatPlaceholder.uxml");
+            tree.CloneTree(r);
+
+            r.Q<Label>("CommandPreview").text = m_OriginalCommand ?? "";
+
+            var container = r.Q<VisualElement>("PlaceholderContainer");
+            foreach (var placeholder in m_Placeholders)
+            {
+                var ph = placeholder;
+                var tf = new TextField($"<{ph.token}>");
+                tf.value = ph.value;
+                tf.RegisterValueChangedCallback(evt => ph.value = evt.newValue);
+                container.Add(tf);
+            }
+
+            r.Q<Button>("CancelButton").clicked += () => Close();
+            r.Q<Button>("RunButton").clicked += OnRunClicked;
+        }
+
+        void OnRunClicked()
+        {
+            var placeholderValues = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            foreach (var placeholder in m_Placeholders)
+                placeholderValues[placeholder.token] = placeholder.value;
+
+            var resolved = s_PlaceholderRegex.Replace(m_OriginalCommand, match =>
+            {
+                var token = match.Groups[1].Value;
+                return placeholderValues.TryGetValue(token, out var value) ? value : match.Value;
+            });
+
+            m_OnConfirm?.Invoke(resolved);
+            Close();
+        }
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatPlaceholderDialog.cs.meta b/com.unity.mobile.android-logcat/Editor/AndroidLogcatPlaceholderDialog.cs.meta
new file mode 100644
index 00000000..c5ff994d
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatPlaceholderDialog.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 46a4bebaf15ee43c5bbf7012104e2359
\ No newline at end of file
diff --git a/com.unity.mobile.android-logcat/Editor/AndroidLogcatUserSettings.cs b/com.unity.mobile.android-logcat/Editor/AndroidLogcatUserSettings.cs
index 2f7edd09..84f997aa 100644
--- a/com.unity.mobile.android-logcat/Editor/AndroidLogcatUserSettings.cs
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatUserSettings.cs
@@ -89,6 +89,15 @@ internal class QueryLayoutSettings
             internal string LastScreenshotSaveLocation;
         }
 
+        [Serializable]
+        internal class CommandsSettingsData
+        {
+            [SerializeField]
+            internal List<AndroidLogcatCommandEntry> Favorites = new List<AndroidLogcatCommandEntry>();
+            [SerializeField]
+            internal List<AndroidLogcatCommandEntry> GeneralCommands = new List<AndroidLogcatCommandEntry>();
+        }
+
         [SerializeField]
         private string m_SelectedDeviceId;
         [SerializeField]
@@ -116,6 +125,8 @@ internal class QueryLayoutSettings
         private QueryLayoutSettings m_QueryLayoutSettings;
         [SerializeField]
         private InputSettings m_InputSettings;
+        [SerializeField]
+        private CommandsSettingsData m_CommandsSettings;
 
         [SerializeField]
         private AutoScroll m_AutoScroll;
@@ -178,6 +189,7 @@ public Priority SelectedPriority
         public ScreenCaptureSettings CaptureSettings { set => m_ScreenCaptureSettings = value; get => m_ScreenCaptureSettings; }
         public QueryLayoutSettings LayoutSettings { set => m_QueryLayoutSettings = value; get => m_QueryLayoutSettings; }
         public InputSettings DeviceInputSettings { set => m_InputSettings = value; get => m_InputSettings; }
+        public CommandsSettingsData CommandsSettings { set => m_CommandsSettings = value; get => m_CommandsSettings; }
 
         public AutoScroll AutoScroll { set => m_AutoScroll = value; get => m_AutoScroll; }
 
@@ -360,6 +372,8 @@ internal void Reset()
                 SendText = string.Empty,
                 TargetProcess = new ProcessInformation()
             };
+
+            m_CommandsSettings = new CommandsSettingsData();
         }
 
         internal void ResetCaptureVideoSettings()
diff --git a/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatAddCommand.uxml b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatAddCommand.uxml
new file mode 100644
index 00000000..25a17ac9
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatAddCommand.uxml
@@ -0,0 +1,12 @@
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xsi="http://www.w3.org/2001/XMLSchema-instance" engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../../UIElementsSchema/UIElements.xsd" editor-extension-mode="True">
+    <ui:VisualElement style="padding: 8px; flex-grow: 1;">
+        <ui:TextField name="NameField" label="Name" style="margin-bottom: 4px;" />
+        <ui:Label text="Commands" style="-unity-font-style: bold; margin-top: 4px;" />
+        <ui:Label text="Enter one command per line. All commands run sequentially." style="font-size: 10px; color: rgb(160, 160, 160);" />
+        <ui:TextField name="CommandField" multiline="true" style="flex-grow: 1; min-height: 80px; max-height: 200px; margin-top: 4px;" />
+        <ui:VisualElement style="flex-direction: row; justify-content: flex-end; margin-top: 8px;">
+            <ui:Button name="CancelButton" text="Cancel" style="width: 80px;" />
+            <ui:Button name="SaveButton" text="Add" style="width: 80px;" />
+        </ui:VisualElement>
+    </ui:VisualElement>
+</ui:UXML>
diff --git a/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatAddCommand.uxml.meta b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatAddCommand.uxml.meta
new file mode 100644
index 00000000..c9839613
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatAddCommand.uxml.meta
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: c66f7e69b156e40ee9f2eea8c2b2bcd4
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommandOutput.uxml b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommandOutput.uxml
new file mode 100644
index 00000000..bfa203f1
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommandOutput.uxml
@@ -0,0 +1,13 @@
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xsi="http://www.w3.org/2001/XMLSchema-instance" engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../../UIElementsSchema/UIElements.xsd" editor-extension-mode="True">
+    <ui:VisualElement style="flex-grow: 1;">
+        <ui:VisualElement name="Toolbar" style="flex-direction: row; align-items: center; background-color: rgba(0, 0, 0, 0.1); padding-left: 4px; padding-right: 4px; height: 22px;">
+            <ui:Button name="ClearButton" text="Clear" style="height: 18px;" />
+            <ui:Button name="CopyAllButton" text="Copy All" style="height: 18px;" />
+            <ui:VisualElement style="flex-grow: 1;" />
+            <ui:Toggle name="AutoScrollToggle" label="Auto Scroll" value="true" />
+        </ui:VisualElement>
+        <ui:ScrollView name="OutputScroll" style="flex-grow: 1;">
+            <ui:VisualElement name="OutputContainer" />
+        </ui:ScrollView>
+    </ui:VisualElement>
+</ui:UXML>
diff --git a/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommandOutput.uxml.meta b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommandOutput.uxml.meta
new file mode 100644
index 00000000..80c6ab5c
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommandOutput.uxml.meta
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 52e043af3ff934758adb4b47fb97dd69
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommandSearch.uxml b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommandSearch.uxml
new file mode 100644
index 00000000..5a06a340
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommandSearch.uxml
@@ -0,0 +1,10 @@
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xsi="http://www.w3.org/2001/XMLSchema-instance" engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../../UIElementsSchema/UIElements.xsd" editor-extension-mode="True">
+    <ui:VisualElement style="padding: 4px; flex-grow: 1;">
+        <ui:TextField name="SearchField" label="Search" />
+        <ui:VisualElement name="ChipsRow" style="flex-direction: row; flex-wrap: wrap; margin-top: 4px; margin-bottom: 4px;" />
+        <ui:HelpBox name="EmptyMessage" message-type="Info" text="Type a search term or click a chip to find commands." />
+        <ui:ScrollView name="ResultsScroll" style="flex-grow: 1;">
+            <ui:VisualElement name="ResultsContainer" />
+        </ui:ScrollView>
+    </ui:VisualElement>
+</ui:UXML>
diff --git a/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommandSearch.uxml.meta b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommandSearch.uxml.meta
new file mode 100644
index 00000000..7a9a5080
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommandSearch.uxml.meta
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 19a466bc1060c4d3291dede5b4343324
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommands.uxml b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommands.uxml
new file mode 100644
index 00000000..a7e1503f
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommands.uxml
@@ -0,0 +1,26 @@
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xsi="http://www.w3.org/2001/XMLSchema-instance" engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../../UIElementsSchema/UIElements.xsd" editor-extension-mode="True">
+    <ui:TwoPaneSplitView name="MainSplit" orientation="Vertical" fixed-pane-index="1" fixed-pane-initial-dimension="150">
+        <ui:VisualElement name="ListsPane" style="flex-grow: 1;">
+            <ui:Label name="FavoritesHeader" text="Favorites" style="-unity-font-style: bold; margin-left: 4px; margin-top: 4px;" />
+            <ui:ScrollView name="FavoritesScroll" style="min-height: 26px; max-height: 40%;">
+                <ui:VisualElement name="FavoritesContainer" />
+            </ui:ScrollView>
+            <ui:Label name="GeneralHeader" text="General Commands" style="-unity-font-style: bold; margin-left: 4px; margin-top: 4px;" />
+            <ui:ScrollView name="GeneralScroll" style="flex-grow: 1;">
+                <ui:VisualElement name="GeneralContainer" />
+            </ui:ScrollView>
+        </ui:VisualElement>
+        <ui:VisualElement name="OutputPane">
+            <ui:VisualElement name="OutputToolbar" style="flex-direction: row; align-items: center; background-color: rgba(0, 0, 0, 0.1); padding-left: 4px; padding-right: 4px; height: 22px;">
+                <ui:Label text="Output" style="-unity-font-style: bold; width: 50px;" />
+                <ui:Button name="ClearButton" text="Clear" style="height: 18px;" />
+                <ui:Button name="PopOutButton" text="Pop Out" style="height: 18px;" />
+                <ui:VisualElement style="flex-grow: 1;" />
+                <ui:Label name="RunningLabel" text="Running..." style="font-size: 10px; display: none;" />
+            </ui:VisualElement>
+            <ui:ScrollView name="OutputScroll" style="flex-grow: 1;">
+                <ui:VisualElement name="OutputContainer" />
+            </ui:ScrollView>
+        </ui:VisualElement>
+    </ui:TwoPaneSplitView>
+</ui:UXML>
diff --git a/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommands.uxml.meta b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommands.uxml.meta
new file mode 100644
index 00000000..38116efb
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatCommands.uxml.meta
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: f3df13520f3924740b85497eff7dec6a
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatPlaceholder.uxml b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatPlaceholder.uxml
new file mode 100644
index 00000000..2b37bdfd
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatPlaceholder.uxml
@@ -0,0 +1,11 @@
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements" xsi="http://www.w3.org/2001/XMLSchema-instance" engine="UnityEngine.UIElements" editor="UnityEditor.UIElements" noNamespaceSchemaLocation="../../../UIElementsSchema/UIElements.xsd" editor-extension-mode="True">
+    <ui:VisualElement style="padding: 8px; flex-grow: 1;">
+        <ui:Label name="TitleLabel" text="Fill in the placeholder values:" style="-unity-font-style: bold;" />
+        <ui:Label name="CommandPreview" style="white-space: normal; font-size: 10px; color: rgb(160, 160, 160); margin-top: 4px; margin-bottom: 8px;" />
+        <ui:VisualElement name="PlaceholderContainer" style="margin-top: 8px;" />
+        <ui:VisualElement style="flex-direction: row; justify-content: flex-end; margin-top: 8px;">
+            <ui:Button name="CancelButton" text="Cancel" style="width: 80px;" />
+            <ui:Button name="RunButton" text="Run" style="width: 80px;" />
+        </ui:VisualElement>
+    </ui:VisualElement>
+</ui:UXML>
diff --git a/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatPlaceholder.uxml.meta b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatPlaceholder.uxml.meta
new file mode 100644
index 00000000..29d28b35
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/AndroidLogcatPlaceholder.uxml.meta
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: f9b0518a40af440fcbcbe78d351f7007
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}