diff --git a/com.unity.mobile.android-logcat/CHANGELOG.md b/com.unity.mobile.android-logcat/CHANGELOG.md
index cfe34db8..900965a8 100644
--- a/com.unity.mobile.android-logcat/CHANGELOG.md
+++ b/com.unity.mobile.android-logcat/CHANGELOG.md
@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Changes & Improvements:
  - Unity 6.0 or later is required.
+ - Added a Commands window, accessible via the Tools menu in the Android Logcat window. It lets you save, organize, search and run adb commands which don't have a dedicated UI in this package, such as package management, permissions, dumpsys, settings and Meta Quest properties. Commands run asynchronously so the Editor stays responsive, support `<placeholder>` substitution, and can be imported and exported as JSON.
 
 ## [1.4.7] - 2025-12-12
 ### Fixes & Improvements
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/AndroidLogcatDevice.cs b/com.unity.mobile.android-logcat/Editor/AndroidLogcatDevice.cs
index 43d3d6d2..e7459955 100644
--- a/com.unity.mobile.android-logcat/Editor/AndroidLogcatDevice.cs
+++ b/com.unity.mobile.android-logcat/Editor/AndroidLogcatDevice.cs
@@ -111,6 +111,16 @@ internal virtual void UninstallPackage(string packageName) { }
         internal virtual void KillProcess(int processId, PosixSignal signal = PosixSignal.SIGNONE) { }
         internal virtual void KillProcess(string packageName, int processId, PosixSignal signal = PosixSignal.SIGNONE) { }
 
+        /// <summary>
+        /// Runs an arbitrary adb command against this device asynchronously.
+        /// The device is targeted with -s automatically unless the caller already specified one.
+        /// <paramref name="onComplete"/> is invoked on the main thread.
+        /// </summary>
+        internal virtual void RunAdbCommandAsync(AndroidLogcatDispatcher dispatcher, string arguments, Action<AndroidLogcatCommandResult> onComplete)
+        {
+            onComplete?.Invoke(AndroidLogcatCommandResult.CreateFailure(arguments, "No device selected."));
+        }
+
         internal bool SupportsFilteringByPid
         {
             get { return OSVersion >= kAndroidVersion70; }
@@ -471,6 +481,48 @@ internal override void UninstallPackage(string packageName)
             m_ADB.Run(args, $"Failed to uninstall package '{packageName}'");
         }
 
+        /// <summary>
+        /// Runs an arbitrary adb command against this device on the dispatcher's worker thread, so a
+        /// slow or hanging command cannot block the Editor's main thread.
+        /// </summary>
+        internal override void RunAdbCommandAsync(AndroidLogcatDispatcher dispatcher, string arguments, Action<AndroidLogcatCommandResult> onComplete)
+        {
+            if (dispatcher == null)
+            {
+                onComplete?.Invoke(AndroidLogcatCommandResult.CreateFailure(arguments, "Dispatcher is not available."));
+                return;
+            }
+
+            // Target this device unless the caller already picked one explicitly.
+            var effectiveArgs = AndroidLogcatCommandParser.SpecifiesDevice(arguments)
+                ? arguments
+                : $"-s {Id} {arguments}";
+
+            dispatcher.Schedule(
+                new AndroidLogcatTaskInput<AndroidBridge.ADB, string, string>()
+                {
+                    data1 = m_ADB,
+                    data2 = effectiveArgs,
+                    data3 = arguments
+                },
+                (input) =>
+                {
+                    var inputData = (AndroidLogcatTaskInput<AndroidBridge.ADB, string, string>)input;
+                    AndroidLogcatInternalLog.Log($"adb {inputData.data2}");
+                    try
+                    {
+                        var output = inputData.data1.Run(new[] { inputData.data2 }, $"Failed to run 'adb {inputData.data3}'");
+                        return AndroidLogcatCommandResult.CreateSuccess(inputData.data3, output);
+                    }
+                    catch (Exception ex)
+                    {
+                        return AndroidLogcatCommandResult.CreateFailure(inputData.data3, AndroidLogcatCommandResult.Unwrap(ex).Message);
+                    }
+                },
+                (result) => onComplete?.Invoke((AndroidLogcatCommandResult)result),
+                false);
+        }
+
         internal override void KillProcess(int processId, PosixSignal signal = PosixSignal.SIGNONE)
         {
             var packageName = AndroidLogcatUtilities.GetProcessNameFromPid(m_ADB, this, processId);
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/AndroidTools/Shell.cs b/com.unity.mobile.android-logcat/Editor/AndroidTools/Shell.cs
index 2c3ba270..b8ee9eb3 100644
--- a/com.unity.mobile.android-logcat/Editor/AndroidTools/Shell.cs
+++ b/com.unity.mobile.android-logcat/Editor/AndroidTools/Shell.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using System.Text;
+using System.Threading;
 
 namespace Unity.Android.Logcat
 {
@@ -66,7 +67,21 @@ internal static ShellReturnInfo RunProcess(string fileName, string arguments, st
             return RunProcess(new ShellStartInfo() { FileName = fileName, Arguments = arguments, WorkingDirectory = workingDirectory });
         }
 
+        /// <summary>
+        /// Runs a process, killing it if it doesn't finish within <paramref name="timeoutMs"/>.
+        /// Use this for commands supplied by the user, which may never exit on their own.
+        /// </summary>
+        internal static ShellReturnInfo RunProcess(string fileName, string arguments, int timeoutMs, out bool timedOut)
+        {
+            return RunProcess(new ShellStartInfo() { FileName = fileName, Arguments = arguments }, timeoutMs, out timedOut);
+        }
+
         internal static ShellReturnInfo RunProcess(ShellStartInfo startInfo)
+        {
+            return RunProcess(startInfo, Timeout.Infinite, out _);
+        }
+
+        internal static ShellReturnInfo RunProcess(ShellStartInfo startInfo, int timeoutMs, out bool timedOut)
         {
             Process process = new Process();
             process.StartInfo.FileName = startInfo.FileName;
@@ -76,12 +91,16 @@ internal static ShellReturnInfo RunProcess(ShellStartInfo startInfo)
             process.StartInfo.RedirectStandardOutput = true;
             process.StartInfo.RedirectStandardError = true;
             process.StartInfo.CreateNoWindow = true;
+            // The data received handlers are invoked on threadpool threads, so all access to these
+            // builders is guarded by a lock - StringBuilder is not thread safe.
+            var streamLock = new object();
             var output = new StringBuilder();
             process.OutputDataReceived += new DataReceivedEventHandler((sender, e) =>
             {
                 if (!string.IsNullOrEmpty(e.Data))
                 {
-                    output.AppendLine(e.Data);
+                    lock (streamLock)
+                        output.AppendLine(e.Data);
                 }
             });
 
@@ -90,18 +109,60 @@ internal static ShellReturnInfo RunProcess(ShellStartInfo startInfo)
             {
                 if (!string.IsNullOrEmpty(e.Data))
                 {
-                    error.AppendLine(e.Data);
+                    lock (streamLock)
+                        error.AppendLine(e.Data);
                 }
             });
 
             process.Start();
             process.BeginOutputReadLine();
             process.BeginErrorReadLine();
-            process.WaitForExit();
-            var exitCode = process.ExitCode;
+
+            timedOut = false;
+            if (timeoutMs == Timeout.Infinite)
+            {
+                process.WaitForExit();
+            }
+            else if (process.WaitForExit(timeoutMs))
+            {
+                // WaitForExit(int) only waits for the process to exit, not for the asynchronous
+                // output handlers to drain. The parameterless overload does, and returns immediately
+                // here because the process has already exited.
+                process.WaitForExit();
+            }
+            else
+            {
+                timedOut = true;
+                try
+                {
+                    process.Kill();
+                    // Give the process a moment to actually die so we can read its exit code.
+                    process.WaitForExit(1000);
+                }
+                catch (Exception)
+                {
+                    // Kill can fail if the process exited between the timeout and this call, or if
+                    // the OS denies access. Either way there's nothing useful to do about it.
+                }
+
+                // Stop the readers rather than waiting for them, so a process that could not be
+                // killed doesn't block this thread indefinitely.
+                try
+                {
+                    process.CancelOutputRead();
+                    process.CancelErrorRead();
+                }
+                catch (InvalidOperationException)
+                {
+                    // Reads were already stopped.
+                }
+            }
+
+            var exitCode = process.HasExited ? process.ExitCode : -1;
             process.Close();
 
-            return new ShellReturnInfo(startInfo, exitCode, output.ToString(), error.ToString());
+            lock (streamLock)
+                return new ShellReturnInfo(startInfo, exitCode, output.ToString(), error.ToString());
         }
     }
 }
diff --git a/com.unity.mobile.android-logcat/Editor/Commands.meta b/com.unity.mobile.android-logcat/Editor/Commands.meta
new file mode 100644
index 00000000..7e282815
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b519f304cd5e4d978def1bb860e01a1f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatAdbCommandCatalog.cs b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatAdbCommandCatalog.cs
new file mode 100644
index 00000000..5015e1c8
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatAdbCommandCatalog.cs
@@ -0,0 +1,142 @@
+namespace Unity.Android.Logcat
+{
+    /// <summary>
+    /// A catalog of ready made adb commands the user can search, save and run.
+    ///
+    /// Scope note: this catalog intentionally does NOT cover functionality the package already
+    /// implements as first class features. Specifically omitted:
+    ///   - logcat streaming/filtering  -> the main Android Logcat window
+    ///   - input simulation            -> AndroidLogcatInputs / Device Input window
+    ///   - screenshot & video capture  -> AndroidLogcatScreenCaptureWindow
+    ///   - process termination         -> the process list context menu
+    /// The catalog covers the remaining adb surface which has no dedicated UI, so it complements
+    /// the package rather than duplicating it.
+    /// </summary>
+    internal static class AndroidLogcatAdbCommandCatalog
+    {
+        internal static readonly AndroidLogcatCommandEntry[] All = new[]
+        {
+            // --- Device Management ---
+            new AndroidLogcatCommandEntry("List Devices", "adb devices", AndroidLogcatCommandCategory.DeviceManagement),
+            new AndroidLogcatCommandEntry("List Devices (Verbose)", "adb devices -l", AndroidLogcatCommandCategory.DeviceManagement),
+            new AndroidLogcatCommandEntry("Start Server", "adb start-server", AndroidLogcatCommandCategory.DeviceManagement),
+            new AndroidLogcatCommandEntry("Kill Server", "adb kill-server", AndroidLogcatCommandCategory.DeviceManagement),
+            new AndroidLogcatCommandEntry("Reboot Device", "adb reboot", AndroidLogcatCommandCategory.DeviceManagement),
+            new AndroidLogcatCommandEntry("Reboot to Bootloader", "adb reboot bootloader", AndroidLogcatCommandCategory.DeviceManagement),
+            new AndroidLogcatCommandEntry("Reboot to Recovery", "adb reboot recovery", AndroidLogcatCommandCategory.DeviceManagement),
+            new AndroidLogcatCommandEntry("Get Device State", "adb get-state", AndroidLogcatCommandCategory.DeviceManagement),
+            new AndroidLogcatCommandEntry("Get Serial Number", "adb get-serialno", AndroidLogcatCommandCategory.DeviceManagement),
+
+            // --- Packages ---
+            new AndroidLogcatCommandEntry("List All Packages", "adb shell pm list packages", AndroidLogcatCommandCategory.Packages),
+            new AndroidLogcatCommandEntry("List Third-Party Packages", "adb shell pm list packages -3", AndroidLogcatCommandCategory.Packages),
+            new AndroidLogcatCommandEntry("List System Packages", "adb shell pm list packages -s", AndroidLogcatCommandCategory.Packages),
+            new AndroidLogcatCommandEntry("Clear App Data", "adb shell pm clear <package>", AndroidLogcatCommandCategory.Packages),
+            new AndroidLogcatCommandEntry("Force Stop App", "adb shell am force-stop <package>", AndroidLogcatCommandCategory.Packages),
+            new AndroidLogcatCommandEntry("Start Activity", "adb shell am start -n <package/activity>", AndroidLogcatCommandCategory.Packages),
+            new AndroidLogcatCommandEntry("Start App (Launcher)", "adb shell monkey -p <package> -c android.intent.category.LAUNCHER 1", AndroidLogcatCommandCategory.Packages),
+            new AndroidLogcatCommandEntry("Start App (UnityPlayerActivity)", "adb shell am start -n <package>/com.unity3d.player.UnityPlayerActivity", AndroidLogcatCommandCategory.Packages),
+            new AndroidLogcatCommandEntry("Start App (GameActivity)", "adb shell am start -n <package>/com.google.androidgamesdk.GameActivity", AndroidLogcatCommandCategory.Packages),
+            new AndroidLogcatCommandEntry("Uninstall App", "adb uninstall <package>", AndroidLogcatCommandCategory.Packages),
+            new AndroidLogcatCommandEntry("Install APK", "adb install <path.apk>", AndroidLogcatCommandCategory.Packages),
+            new AndroidLogcatCommandEntry("Install APK (Replace)", "adb install -r <path.apk>", AndroidLogcatCommandCategory.Packages),
+            new AndroidLogcatCommandEntry("Install Multiple APKs (Split)", "adb install-multiple -r <path1.apk> <path2.apk>", AndroidLogcatCommandCategory.Packages),
+            new AndroidLogcatCommandEntry("Push OBB File", "adb push <local.obb> /sdcard/Android/obb/<package>/", AndroidLogcatCommandCategory.Packages),
+            new AndroidLogcatCommandEntry("Create OBB Directory", "adb shell mkdir -p /sdcard/Android/obb/<package>", AndroidLogcatCommandCategory.Packages),
+            new AndroidLogcatCommandEntry("Dump App Info", "adb shell dumpsys package <package>", AndroidLogcatCommandCategory.Packages),
+
+            // --- Permissions ---
+            new AndroidLogcatCommandEntry("Grant Permission", "adb shell pm grant <package> <permission>", AndroidLogcatCommandCategory.Permissions),
+            new AndroidLogcatCommandEntry("Revoke Permission", "adb shell pm revoke <package> <permission>", AndroidLogcatCommandCategory.Permissions),
+            new AndroidLogcatCommandEntry("List Granted Permissions", "adb shell dumpsys package <package> | grep permission", AndroidLogcatCommandCategory.Permissions),
+            new AndroidLogcatCommandEntry("List All Permissions", "adb shell pm list permissions -g", AndroidLogcatCommandCategory.Permissions),
+            new AndroidLogcatCommandEntry("List Dangerous Permissions", "adb shell pm list permissions -d -g", AndroidLogcatCommandCategory.Permissions),
+            new AndroidLogcatCommandEntry("Reset All Permissions", "adb shell pm reset-permissions -p <package>", AndroidLogcatCommandCategory.Permissions),
+
+            // --- File Transfer ---
+            new AndroidLogcatCommandEntry("Push File to Device", "adb push <local> <remote>", AndroidLogcatCommandCategory.FileTransfer),
+            new AndroidLogcatCommandEntry("Pull File from Device", "adb pull <remote> <local>", AndroidLogcatCommandCategory.FileTransfer),
+            new AndroidLogcatCommandEntry("List Directory", "adb shell ls -la <path>", AndroidLogcatCommandCategory.FileTransfer),
+            new AndroidLogcatCommandEntry("Remove File", "adb shell rm <path>", AndroidLogcatCommandCategory.FileTransfer),
+            new AndroidLogcatCommandEntry("Make Directory", "adb shell mkdir -p <path>", AndroidLogcatCommandCategory.FileTransfer),
+
+            // --- System Info ---
+            new AndroidLogcatCommandEntry("Get Android Version", "adb shell getprop ro.build.version.release", AndroidLogcatCommandCategory.SystemInfo),
+            new AndroidLogcatCommandEntry("Get SDK Version", "adb shell getprop ro.build.version.sdk", AndroidLogcatCommandCategory.SystemInfo),
+            new AndroidLogcatCommandEntry("Get Device Model", "adb shell getprop ro.product.model", AndroidLogcatCommandCategory.SystemInfo),
+            new AndroidLogcatCommandEntry("Get Device Manufacturer", "adb shell getprop ro.product.manufacturer", AndroidLogcatCommandCategory.SystemInfo),
+            new AndroidLogcatCommandEntry("Get All Properties", "adb shell getprop", AndroidLogcatCommandCategory.SystemInfo),
+            new AndroidLogcatCommandEntry("Get Screen Resolution", "adb shell wm size", AndroidLogcatCommandCategory.SystemInfo),
+            new AndroidLogcatCommandEntry("Get Screen Density", "adb shell wm density", AndroidLogcatCommandCategory.SystemInfo),
+            new AndroidLogcatCommandEntry("Get Battery Info", "adb shell dumpsys battery", AndroidLogcatCommandCategory.SystemInfo),
+            new AndroidLogcatCommandEntry("Get CPU Info", "adb shell cat /proc/cpuinfo", AndroidLogcatCommandCategory.SystemInfo),
+            new AndroidLogcatCommandEntry("Get Memory Info", "adb shell cat /proc/meminfo", AndroidLogcatCommandCategory.SystemInfo),
+            new AndroidLogcatCommandEntry("Get Disk Usage", "adb shell df", AndroidLogcatCommandCategory.SystemInfo),
+            new AndroidLogcatCommandEntry("Get Running Processes", "adb shell ps", AndroidLogcatCommandCategory.SystemInfo),
+            new AndroidLogcatCommandEntry("Get Build Properties", "adb shell cat /system/build.prop", AndroidLogcatCommandCategory.SystemInfo),
+
+            // --- Dumpsys ---
+            new AndroidLogcatCommandEntry("Dump Activity Stack", "adb shell dumpsys activity activities", AndroidLogcatCommandCategory.Dumpsys),
+            new AndroidLogcatCommandEntry("Dump Memory Info", "adb shell dumpsys meminfo", AndroidLogcatCommandCategory.Dumpsys),
+            new AndroidLogcatCommandEntry("Dump Window Info", "adb shell dumpsys window", AndroidLogcatCommandCategory.Dumpsys),
+            new AndroidLogcatCommandEntry("Dump Display Info", "adb shell dumpsys display", AndroidLogcatCommandCategory.Dumpsys),
+            new AndroidLogcatCommandEntry("Dump CPU Info", "adb shell dumpsys cpuinfo", AndroidLogcatCommandCategory.Dumpsys),
+            new AndroidLogcatCommandEntry("Dump Battery Stats", "adb shell dumpsys batterystats", AndroidLogcatCommandCategory.Dumpsys),
+            new AndroidLogcatCommandEntry("Dump SurfaceFlinger", "adb shell dumpsys SurfaceFlinger", AndroidLogcatCommandCategory.Dumpsys),
+            new AndroidLogcatCommandEntry("Dump Graphics Stats", "adb shell dumpsys gfxinfo <package>", AndroidLogcatCommandCategory.Dumpsys),
+            new AndroidLogcatCommandEntry("Dump Wifi Info", "adb shell dumpsys wifi", AndroidLogcatCommandCategory.Dumpsys),
+            new AndroidLogcatCommandEntry("Dump Alarm Info", "adb shell dumpsys alarm", AndroidLogcatCommandCategory.Dumpsys),
+            new AndroidLogcatCommandEntry("Dump Notification Info", "adb shell dumpsys notification", AndroidLogcatCommandCategory.Dumpsys),
+
+            // --- Settings ---
+            new AndroidLogcatCommandEntry("Enable Stay Awake", "adb shell settings put global stay_on_while_plugged_in 3", AndroidLogcatCommandCategory.Settings),
+            new AndroidLogcatCommandEntry("Disable Stay Awake", "adb shell settings put global stay_on_while_plugged_in 0", AndroidLogcatCommandCategory.Settings),
+            new AndroidLogcatCommandEntry("Show Touches On", "adb shell settings put system show_touches 1", AndroidLogcatCommandCategory.Settings),
+            new AndroidLogcatCommandEntry("Show Touches Off", "adb shell settings put system show_touches 0", AndroidLogcatCommandCategory.Settings),
+            new AndroidLogcatCommandEntry("Enable USB Debugging", "adb shell settings put global adb_enabled 1", AndroidLogcatCommandCategory.Settings),
+            new AndroidLogcatCommandEntry("Set Screen Off Timeout", "adb shell settings put system screen_off_timeout <ms>", AndroidLogcatCommandCategory.Settings),
+
+            // --- Networking ---
+            new AndroidLogcatCommandEntry("Enable Network ADB", "adb tcpip 5555", AndroidLogcatCommandCategory.Networking),
+            new AndroidLogcatCommandEntry("Connect via IP", "adb connect <ip>:5555", AndroidLogcatCommandCategory.Networking),
+            new AndroidLogcatCommandEntry("Disconnect All", "adb disconnect", AndroidLogcatCommandCategory.Networking),
+            new AndroidLogcatCommandEntry("Forward Port", "adb forward tcp:<local> tcp:<remote>", AndroidLogcatCommandCategory.Networking),
+            new AndroidLogcatCommandEntry("Reverse Port", "adb reverse tcp:<remote> tcp:<local>", AndroidLogcatCommandCategory.Networking),
+            new AndroidLogcatCommandEntry("List Port Forwards", "adb forward --list", AndroidLogcatCommandCategory.Networking),
+            new AndroidLogcatCommandEntry("Get Network IP Address", "adb shell ip addr show wlan0", AndroidLogcatCommandCategory.Networking),
+            new AndroidLogcatCommandEntry("Get Network Interfaces", "adb shell ip link show", AndroidLogcatCommandCategory.Networking),
+            new AndroidLogcatCommandEntry("Dump Network Stats", "adb shell dumpsys netstats", AndroidLogcatCommandCategory.Networking),
+            new AndroidLogcatCommandEntry("Dump Network Connectivity", "adb shell dumpsys connectivity", AndroidLogcatCommandCategory.Networking),
+            new AndroidLogcatCommandEntry("Ping Host", "adb shell ping -c 4 <host>", AndroidLogcatCommandCategory.Networking),
+
+            // --- Advanced ---
+            new AndroidLogcatCommandEntry("Bug Report", "adb bugreport", AndroidLogcatCommandCategory.Advanced),
+            new AndroidLogcatCommandEntry("Remount System", "adb remount", AndroidLogcatCommandCategory.Advanced),
+            new AndroidLogcatCommandEntry("Root Shell", "adb root", AndroidLogcatCommandCategory.Advanced),
+            new AndroidLogcatCommandEntry("Unroot Shell", "adb unroot", AndroidLogcatCommandCategory.Advanced),
+            new AndroidLogcatCommandEntry("Disable Verity", "adb disable-verity", AndroidLogcatCommandCategory.Advanced),
+            new AndroidLogcatCommandEntry("Enable Verity", "adb enable-verity", AndroidLogcatCommandCategory.Advanced),
+            new AndroidLogcatCommandEntry("Check Boot Completed", "adb shell getprop sys.boot_completed", AndroidLogcatCommandCategory.Advanced),
+            new AndroidLogcatCommandEntry("List Tombstones", "adb shell ls -lt /data/tombstones/", AndroidLogcatCommandCategory.Advanced),
+            new AndroidLogcatCommandEntry("Pull Tombstone", "adb pull /data/tombstones/<tombstone_XX> <local_path>", AndroidLogcatCommandCategory.Advanced),
+
+            // --- Meta Quest / XR ---
+            new AndroidLogcatCommandEntry("Quest: List OVR Packages", "adb shell pm list packages | grep oculus", AndroidLogcatCommandCategory.Quest),
+            new AndroidLogcatCommandEntry("Quest: Get Guardian State", "adb shell dumpsys OVRGuardianService", AndroidLogcatCommandCategory.Quest),
+            new AndroidLogcatCommandEntry("Quest: Get Compositor Stats", "adb shell dumpsys OVRCompositor", AndroidLogcatCommandCategory.Quest),
+            new AndroidLogcatCommandEntry("Quest: Set GPU Level", "adb shell setprop debug.oculus.gpuLevel <0-4>", AndroidLogcatCommandCategory.Quest),
+            new AndroidLogcatCommandEntry("Quest: Set CPU Level", "adb shell setprop debug.oculus.cpuLevel <0-4>", AndroidLogcatCommandCategory.Quest),
+            new AndroidLogcatCommandEntry("Quest: Enable Perf Overlay", "adb shell setprop debug.oculus.enablePerfOverlay 1", AndroidLogcatCommandCategory.Quest),
+            new AndroidLogcatCommandEntry("Quest: Disable Perf Overlay", "adb shell setprop debug.oculus.enablePerfOverlay 0", AndroidLogcatCommandCategory.Quest),
+            new AndroidLogcatCommandEntry("Quest: Set Fixed Foveation", "adb shell setprop debug.oculus.foveation.level <0-4>", AndroidLogcatCommandCategory.Quest),
+            new AndroidLogcatCommandEntry("Quest: Set Refresh Rate", "adb shell setprop debug.oculus.refreshRate <72|90|120>", AndroidLogcatCommandCategory.Quest),
+
+            // --- AAB / Bundletool ---
+            // Note: non-adb commands resolve relative to the Editor's working directory, so
+            // bundletool.jar is a placeholder to be filled in with an absolute path.
+            new AndroidLogcatCommandEntry("bundletool: Build Split APKs", "java -jar <path-to-bundletool.jar> build-apks --bundle=<path.aab> --output=<output.apks> --connected-device", AndroidLogcatCommandCategory.Bundletool),
+            new AndroidLogcatCommandEntry("bundletool: Install APKs", "java -jar <path-to-bundletool.jar> install-apks --apks=<path.apks>", AndroidLogcatCommandCategory.Bundletool),
+            new AndroidLogcatCommandEntry("bundletool: Get Device Spec", "java -jar <path-to-bundletool.jar> get-device-spec --output=<device-spec.json>", AndroidLogcatCommandCategory.Bundletool),
+        };
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatAdbCommandCatalog.cs.meta b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatAdbCommandCatalog.cs.meta
new file mode 100644
index 00000000..0a6503d9
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/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/Commands/AndroidLogcatAddCommandDialog.cs b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatAddCommandDialog.cs
new file mode 100644
index 00000000..f7de4ba9
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatAddCommandDialog.cs
@@ -0,0 +1,100 @@
+using System;
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace Unity.Android.Logcat
+{
+    internal class AndroidLogcatAddCommandDialog : EditorWindow
+    {
+        // Serialized so the dialog survives a domain reload with its contents intact.
+        [SerializeField] string m_Name = "";
+        [SerializeField] string m_Command = "";
+        [SerializeField] AndroidLogcatCommandCategory m_Category = AndroidLogcatCommandCategory.Uncategorized;
+        [SerializeField] bool m_IsEdit;
+
+        // The callback cannot be serialized, so close rather than present a dialog whose Save does nothing.
+        Action<AndroidLogcatCommandEntry> m_OnSave;
+
+        void OnEnable()
+        {
+            AssemblyReloadEvents.beforeAssemblyReload += Close;
+        }
+
+        void OnDisable()
+        {
+            AssemblyReloadEvents.beforeAssemblyReload -= Close;
+        }
+
+        /// <summary>
+        /// Opens the dialog. When <paramref name="existing"/> is supplied the fields are prefilled with
+        /// its values and the dialog acts as an editor for that entry.
+        /// </summary>
+        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_Category = existing.category;
+                wnd.m_IsEdit = true;
+            }
+
+            // Note: the UI is built in CreateGUI, which runs after this point, so the assignments
+            // above are guaranteed to be visible to it. Building the UI in OnEnable would run before
+            // CreateInstance returns and leave the fields blank.
+            wnd.ShowUtility();
+        }
+
+        void CreateGUI()
+        {
+            var r = rootVisualElement;
+            r.Clear();
+
+            var tree = AndroidLogcatUtilities.LoadUXML("Command/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);
+
+            // A category lets the command show up under the matching filter chip in the search window.
+            var categoryField = new EnumField("Category", m_Category);
+            categoryField.RegisterValueChangedCallback(evt => m_Category = (AndroidLogcatCommandCategory)evt.newValue);
+            r.Q<VisualElement>("CategoryContainer").Add(categoryField);
+
+            var saveButton = r.Q<Button>("SaveButton");
+            saveButton.text = m_IsEdit ? "Save" : "Add";
+            saveButton.clicked += OnSaveClicked;
+
+            r.Q<Button>("CancelButton").clicked += Close;
+
+            // Focus the first field so the dialog is usable straight from the keyboard.
+            // Scheduled because focusing before the first layout pass is unreliable.
+            nameField.schedule.Execute(() => nameField.Focus());
+        }
+
+        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(), m_Category));
+            Close();
+        }
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatAddCommandDialog.cs.meta b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatAddCommandDialog.cs.meta
new file mode 100644
index 00000000..91361f81
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/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/Commands/AndroidLogcatCommandEntry.cs b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandEntry.cs
new file mode 100644
index 00000000..65b74657
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandEntry.cs
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Unity.Android.Logcat
+{
+    /// <summary>
+    /// Groups catalog commands so the search window can offer category filters.
+    /// Note: categories which duplicate functionality already provided by this package
+    /// (logcat streaming, input simulation, screen capture) are deliberately absent -
+    /// use the dedicated windows for those instead.
+    /// </summary>
+    internal enum AndroidLogcatCommandCategory
+    {
+        Uncategorized = 0,
+        DeviceManagement,
+        Packages,
+        Permissions,
+        FileTransfer,
+        SystemInfo,
+        Dumpsys,
+        Settings,
+        Networking,
+        Advanced,
+        Quest,
+        Bundletool
+    }
+
+    [Serializable]
+    internal class AndroidLogcatCommandEntry
+    {
+        [SerializeField] internal string name;
+        [SerializeField] internal string command;
+        [SerializeField] internal AndroidLogcatCommandCategory category;
+
+        internal AndroidLogcatCommandEntry() { }
+
+        internal AndroidLogcatCommandEntry(string name, string command,
+                                           AndroidLogcatCommandCategory category = AndroidLogcatCommandCategory.Uncategorized)
+        {
+            this.name = name;
+            this.command = command;
+            this.category = category;
+        }
+
+        /// <summary>
+        /// An entry is only usable if it has both a name and a command. Entries deserialized from
+        /// user supplied JSON may be missing either, which would throw further down in the UI.
+        /// </summary>
+        internal bool IsValid => !string.IsNullOrWhiteSpace(name) && !string.IsNullOrWhiteSpace(command);
+
+        internal AndroidLogcatCommandEntry Clone() => new AndroidLogcatCommandEntry(name, command, category);
+    }
+
+    [Serializable]
+    internal class AndroidLogcatCommandExportData
+    {
+        public AndroidLogcatCommandEntry[] favorites = Array.Empty<AndroidLogcatCommandEntry>();
+        public AndroidLogcatCommandEntry[] general = Array.Empty<AndroidLogcatCommandEntry>();
+    }
+
+    /// <summary>
+    /// Pure helpers for sanitizing imported command data. Kept free of UI so they can be unit tested.
+    /// </summary>
+    internal static class AndroidLogcatCommandImport
+    {
+        /// <summary>
+        /// Drops null and incomplete entries, trimming the survivors.
+        /// </summary>
+        internal static List<AndroidLogcatCommandEntry> Sanitize(IEnumerable<AndroidLogcatCommandEntry> entries)
+        {
+            var result = new List<AndroidLogcatCommandEntry>();
+            if (entries == null)
+                return result;
+
+            foreach (var entry in entries)
+            {
+                if (entry == null || !entry.IsValid)
+                    continue;
+                result.Add(new AndroidLogcatCommandEntry(entry.name.Trim(), entry.command.Trim(), entry.category));
+            }
+            return result;
+        }
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandEntry.cs.meta b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandEntry.cs.meta
new file mode 100644
index 00000000..7587f65f
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/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/Commands/AndroidLogcatCommandMatcher.cs b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandMatcher.cs
new file mode 100644
index 00000000..a714d02a
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandMatcher.cs
@@ -0,0 +1,71 @@
+using System;
+
+namespace Unity.Android.Logcat
+{
+    /// <summary>
+    /// Search matching for command entries. Deliberately free of any UI dependency so the behaviour
+    /// can be unit tested, and null safe because entries may originate from user supplied JSON.
+    /// </summary>
+    internal static class AndroidLogcatCommandMatcher
+    {
+        /// <summary>
+        /// Case insensitive substring match against the entry name and command.
+        /// An empty search term matches everything; a null entry matches nothing.
+        /// </summary>
+        internal static bool Matches(AndroidLogcatCommandEntry entry, string searchTerm)
+        {
+            if (entry == null)
+                return false;
+
+            if (string.IsNullOrWhiteSpace(searchTerm))
+                return true;
+
+            var term = searchTerm.Trim();
+            return Contains(entry.name, term) || Contains(entry.command, term);
+        }
+
+        /// <summary>
+        /// Matches an entry against both a category filter and a search term.
+        /// Pass null for <paramref name="category"/> to skip category filtering.
+        /// </summary>
+        internal static bool Matches(AndroidLogcatCommandEntry entry, AndroidLogcatCommandCategory? category, string searchTerm)
+        {
+            if (entry == null)
+                return false;
+
+            if (category.HasValue && entry.category != category.Value)
+                return false;
+
+            return Matches(entry, searchTerm);
+        }
+
+        static bool Contains(string haystack, string needle)
+        {
+            if (string.IsNullOrEmpty(haystack))
+                return false;
+            return haystack.IndexOf(needle, StringComparison.OrdinalIgnoreCase) >= 0;
+        }
+
+        /// <summary>
+        /// Human readable label for a category, used for the filter chips.
+        /// </summary>
+        internal static string GetCategoryDisplayName(AndroidLogcatCommandCategory category)
+        {
+            switch (category)
+            {
+                case AndroidLogcatCommandCategory.DeviceManagement: return "Devices";
+                case AndroidLogcatCommandCategory.Packages: return "Packages";
+                case AndroidLogcatCommandCategory.Permissions: return "Permissions";
+                case AndroidLogcatCommandCategory.FileTransfer: return "Files";
+                case AndroidLogcatCommandCategory.SystemInfo: return "System Info";
+                case AndroidLogcatCommandCategory.Dumpsys: return "Dumpsys";
+                case AndroidLogcatCommandCategory.Settings: return "Settings";
+                case AndroidLogcatCommandCategory.Networking: return "Network";
+                case AndroidLogcatCommandCategory.Advanced: return "Advanced";
+                case AndroidLogcatCommandCategory.Quest: return "Quest";
+                case AndroidLogcatCommandCategory.Bundletool: return "Bundletool";
+                default: return "Other";
+            }
+        }
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandMatcher.cs.meta b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandMatcher.cs.meta
new file mode 100644
index 00000000..f0d9d487
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandMatcher.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 1a19ecf155d846e49354ecd32de52f55
\ No newline at end of file
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandParser.cs b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandParser.cs
new file mode 100644
index 00000000..81eada33
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandParser.cs
@@ -0,0 +1,182 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Unity.Android.Logcat
+{
+    /// <summary>
+    /// Splitting and classification of raw command strings entered by the user.
+    /// Deliberately free of any UI dependency so the behaviour can be unit tested.
+    /// </summary>
+    internal static class AndroidLogcatCommandParser
+    {
+        internal static readonly char[] NewlineChars = { '\r', '\n' };
+
+        const string kAdbPrefix = "adb ";
+
+        /// <summary>
+        /// Splits a possibly multiline command block into individual trimmed, non empty commands.
+        /// Handles CR, LF and CRLF line endings.
+        /// </summary>
+        internal static List<string> SplitLines(string text)
+        {
+            var result = new List<string>();
+            if (string.IsNullOrEmpty(text))
+                return result;
+
+            foreach (var line in text.Split(NewlineChars, StringSplitOptions.RemoveEmptyEntries))
+            {
+                var trimmed = line.Trim();
+                if (trimmed.Length > 0)
+                    result.Add(trimmed);
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Splits captured process output into display lines.
+        ///
+        /// Carriage returns are stripped rather than treated as separators: adb on Windows emits
+        /// "\r\r\n" for shell command output, so splitting on '\r' would yield two empty lines per
+        /// real line (rendering as visibly double/triple spaced output), and leaving them in makes
+        /// UIToolkit render each stray '\r' as an extra line break. '\r' is never meaningful here,
+        /// it's purely a newline translation artifact.
+        ///
+        /// Genuinely blank lines (from "\n\n") are preserved, since tools like dumpsys use them as
+        /// section separators.
+        /// </summary>
+        internal static string[] SplitOutputLines(string text)
+        {
+            if (string.IsNullOrEmpty(text))
+                return new string[0];
+
+            return text.Replace("\r", string.Empty).Split('\n');
+        }
+
+        /// <summary>
+        /// True when the command should be routed through the package's adb wrapper.
+        /// </summary>
+        internal static bool IsAdbCommand(string command)
+        {
+            return !string.IsNullOrEmpty(command) &&
+                command.TrimStart().StartsWith(kAdbPrefix, StringComparison.OrdinalIgnoreCase);
+        }
+
+        /// <summary>
+        /// Strips the leading "adb " from a command, returning the remaining arguments.
+        /// </summary>
+        internal static string StripAdbPrefix(string command)
+        {
+            if (!IsAdbCommand(command))
+                return command;
+            return command.TrimStart().Substring(kAdbPrefix.Length).Trim();
+        }
+
+        /// <summary>
+        /// True when the arguments already target a specific device, in which case we must not
+        /// inject our own -s flag.
+        /// </summary>
+        internal static bool SpecifiesDevice(string adbArguments)
+        {
+            if (string.IsNullOrEmpty(adbArguments))
+                return false;
+
+            foreach (var token in Tokenize(adbArguments))
+            {
+                if (token == "-s" || token == "--serial")
+                    return true;
+                // Stop at the first non-flag token; -s only counts as a global option before the subcommand.
+                if (!token.StartsWith("-", StringComparison.Ordinal))
+                    return false;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Splits a command line into tokens, honouring double and single quotes so that paths
+        /// containing spaces survive intact. Quote characters themselves are removed.
+        /// </summary>
+        internal static List<string> Tokenize(string commandLine)
+        {
+            var tokens = new List<string>();
+            if (string.IsNullOrEmpty(commandLine))
+                return tokens;
+
+            var current = new StringBuilder();
+            var quoteChar = '\0';
+            var inToken = false;
+
+            foreach (var c in commandLine)
+            {
+                if (quoteChar != '\0')
+                {
+                    if (c == quoteChar)
+                        quoteChar = '\0';
+                    else
+                        current.Append(c);
+                    continue;
+                }
+
+                if (c == '"' || c == '\'')
+                {
+                    quoteChar = c;
+                    inToken = true;
+                    continue;
+                }
+
+                if (char.IsWhiteSpace(c))
+                {
+                    if (inToken)
+                    {
+                        tokens.Add(current.ToString());
+                        current.Clear();
+                        inToken = false;
+                    }
+                    continue;
+                }
+
+                current.Append(c);
+                inToken = true;
+            }
+
+            if (inToken)
+                tokens.Add(current.ToString());
+
+            return tokens;
+        }
+
+        /// <summary>
+        /// Splits a non-adb command into an executable and its argument string, honouring quotes so
+        /// that executables with spaces in their path (common on Windows) are handled correctly.
+        /// Returns false when no executable could be determined.
+        /// </summary>
+        internal static bool TrySplitExecutable(string command, out string executable, out string arguments)
+        {
+            executable = null;
+            arguments = null;
+
+            var tokens = Tokenize(command);
+            if (tokens.Count == 0)
+                return false;
+
+            executable = tokens[0];
+
+            // Re-quote any argument that contains whitespace so the child process sees the same value.
+            var sb = new StringBuilder();
+            for (int i = 1; i < tokens.Count; i++)
+            {
+                if (sb.Length > 0)
+                    sb.Append(' ');
+
+                var token = tokens[i];
+                if (token.IndexOf(' ') >= 0 || token.IndexOf('\t') >= 0)
+                    sb.Append('"').Append(token).Append('"');
+                else
+                    sb.Append(token);
+            }
+
+            arguments = sb.ToString();
+            return true;
+        }
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandParser.cs.meta b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandParser.cs.meta
new file mode 100644
index 00000000..f546e53a
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandParser.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 014210e310ce4161837d2b0205b03614
\ No newline at end of file
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandPlaceholders.cs b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandPlaceholders.cs
new file mode 100644
index 00000000..28b317ed
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandPlaceholders.cs
@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+
+namespace Unity.Android.Logcat
+{
+    /// <summary>
+    /// Parsing and substitution of &lt;placeholder&gt; tokens inside command strings.
+    /// Deliberately free of any UI dependency so the behaviour can be unit tested.
+    /// </summary>
+    internal static class AndroidLogcatCommandPlaceholders
+    {
+        internal static readonly Regex PlaceholderRegex = new Regex(@"<([^<>]+)>", RegexOptions.Compiled);
+
+        internal class Placeholder
+        {
+            internal string Token;
+            internal string Value;
+
+            internal Placeholder(string token, string value)
+            {
+                Token = token;
+                Value = value;
+            }
+        }
+
+        internal static bool HasPlaceholders(string command)
+        {
+            return !string.IsNullOrEmpty(command) && PlaceholderRegex.IsMatch(command);
+        }
+
+        /// <summary>
+        /// Returns the distinct placeholder tokens in the order they appear.
+        /// Tokens are compared case insensitively, so "&lt;Package&gt;" and "&lt;package&gt;" collapse into one entry.
+        /// </summary>
+        internal static List<Placeholder> Parse(string command, Func<string, string> defaultValueProvider = null)
+        {
+            var result = new List<Placeholder>();
+            if (string.IsNullOrEmpty(command))
+                return result;
+
+            var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            foreach (Match match in PlaceholderRegex.Matches(command))
+            {
+                var token = match.Groups[1].Value;
+                if (!seen.Add(token))
+                    continue;
+
+                var defaultValue = defaultValueProvider != null ? defaultValueProvider(token) : string.Empty;
+                result.Add(new Placeholder(token, defaultValue ?? string.Empty));
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Replaces every occurrence of each token with its value. Tokens with no supplied value are
+        /// left untouched so the user can still see what was unresolved.
+        /// </summary>
+        internal static string Resolve(string command, IEnumerable<Placeholder> placeholders)
+        {
+            if (string.IsNullOrEmpty(command))
+                return command;
+
+            var values = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+            if (placeholders != null)
+            {
+                foreach (var placeholder in placeholders)
+                {
+                    if (placeholder == null || string.IsNullOrEmpty(placeholder.Token))
+                        continue;
+                    values[placeholder.Token] = placeholder.Value ?? string.Empty;
+                }
+            }
+
+            return PlaceholderRegex.Replace(command, match =>
+            {
+                var token = match.Groups[1].Value;
+                return values.TryGetValue(token, out var value) ? value : match.Value;
+            });
+        }
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandPlaceholders.cs.meta b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandPlaceholders.cs.meta
new file mode 100644
index 00000000..3d4b0efb
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandPlaceholders.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 88d34443a1324d01a22606b056d9602b
\ No newline at end of file
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandResult.cs b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandResult.cs
new file mode 100644
index 00000000..55ea44b3
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandResult.cs
@@ -0,0 +1,112 @@
+using System;
+using System.Reflection;
+
+namespace Unity.Android.Logcat
+{
+    /// <summary>
+    /// Outcome of running a single command, passed back to the main thread by the dispatcher.
+    /// </summary>
+    internal class AndroidLogcatCommandResult : IAndroidLogcatTaskResult
+    {
+        internal string Command { get; private set; }
+        internal string Output { get; private set; }
+        internal string Error { get; private set; }
+
+        internal bool Failed => !string.IsNullOrEmpty(Error);
+
+        AndroidLogcatCommandResult(string command, string output, string error)
+        {
+            Command = command;
+            Output = output;
+            Error = error;
+        }
+
+        internal static AndroidLogcatCommandResult CreateSuccess(string command, string output)
+        {
+            return new AndroidLogcatCommandResult(command, output, null);
+        }
+
+        internal static AndroidLogcatCommandResult CreateFailure(string command, string error)
+        {
+            return new AndroidLogcatCommandResult(command, null, string.IsNullOrEmpty(error) ? "Unknown error." : error);
+        }
+
+        /// <summary>
+        /// ADB is invoked through reflection, so a failure surfaces as a TargetInvocationException
+        /// whose message says nothing useful. Unwrap it to recover adb's actual error.
+        /// </summary>
+        internal static Exception Unwrap(Exception ex)
+        {
+            while (ex is TargetInvocationException && ex.InnerException != null)
+                ex = ex.InnerException;
+            return ex;
+        }
+    }
+
+    /// <summary>
+    /// Runs non-adb commands (for example bundletool) on the dispatcher's worker thread.
+    /// adb commands go through <see cref="IAndroidLogcatDevice.RunAdbCommandAsync"/> instead.
+    /// </summary>
+    internal static class AndroidLogcatHostCommand
+    {
+        /// <summary>
+        /// Commands entered by the user may never exit on their own, so they are always bounded.
+        /// </summary>
+        internal const int kTimeoutMs = 60 * 1000;
+
+        internal static void RunAsync(AndroidLogcatDispatcher dispatcher, string command, Action<AndroidLogcatCommandResult> onComplete)
+        {
+            if (dispatcher == null)
+            {
+                onComplete?.Invoke(AndroidLogcatCommandResult.CreateFailure(command, "Dispatcher is not available."));
+                return;
+            }
+
+            if (!AndroidLogcatCommandParser.TrySplitExecutable(command, out var executable, out var arguments))
+            {
+                onComplete?.Invoke(AndroidLogcatCommandResult.CreateFailure(command, "Could not determine which executable to run."));
+                return;
+            }
+
+            dispatcher.Schedule(
+                new AndroidLogcatTaskInput<string, string, string>()
+                {
+                    data1 = executable,
+                    data2 = arguments,
+                    data3 = command
+                },
+                (input) =>
+                {
+                    var inputData = (AndroidLogcatTaskInput<string, string, string>)input;
+                    AndroidLogcatInternalLog.Log($"{inputData.data1} {inputData.data2}");
+                    try
+                    {
+                        var shellResult = Shell.RunProcess(inputData.data1, inputData.data2, kTimeoutMs, out var timedOut);
+                        var output = shellResult.GetStandardOut();
+                        var error = shellResult.GetStandardErr();
+
+                        if (timedOut)
+                        {
+                            return AndroidLogcatCommandResult.CreateFailure(inputData.data3,
+                                $"Command did not finish within {kTimeoutMs / 1000} seconds and was terminated.\n{output}{error}");
+                        }
+
+                        if (!string.IsNullOrEmpty(error) && shellResult.GetExitCode() != 0)
+                            return AndroidLogcatCommandResult.CreateFailure(inputData.data3, error);
+
+                        // Non-zero stderr with a zero exit code is usually warnings, keep it in the output.
+                        if (!string.IsNullOrEmpty(error))
+                            output = string.IsNullOrEmpty(output) ? error : output + "\n" + error;
+
+                        return AndroidLogcatCommandResult.CreateSuccess(inputData.data3, output);
+                    }
+                    catch (Exception ex)
+                    {
+                        return AndroidLogcatCommandResult.CreateFailure(inputData.data3, AndroidLogcatCommandResult.Unwrap(ex).Message);
+                    }
+                },
+                (result) => onComplete?.Invoke((AndroidLogcatCommandResult)result),
+                false);
+        }
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandResult.cs.meta b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandResult.cs.meta
new file mode 100644
index 00000000..53dc42c9
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandResult.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: bc0ead3754fa4aa59982a461ca4b5a21
\ No newline at end of file
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandSearchWindow.cs b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandSearchWindow.cs
new file mode 100644
index 00000000..f462bd53
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandSearchWindow.cs
@@ -0,0 +1,220 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace Unity.Android.Logcat
+{
+    internal class AndroidLogcatCommandSearchWindow : EditorWindow
+    {
+        List<AndroidLogcatCommandEntry> m_Favorites;
+        List<AndroidLogcatCommandEntry> m_GeneralCommands;
+        Action<AndroidLogcatCommandEntry> m_OnAddCommand;
+        Action<AndroidLogcatCommandEntry> m_OnRunCommand;
+
+        string m_SearchQuery = "";
+        AndroidLogcatCommandCategory? m_CategoryFilter;
+
+        TextField m_SearchTextField;
+        HelpBox m_EmptyMessage;
+        VisualElement m_ResultsContainer;
+        ScrollView m_ResultsScroll;
+        VisualElement m_ChipsRow;
+
+        /// <summary>
+        /// Categories offered as filter chips. Built from the catalog so a category can never appear
+        /// as an empty chip, which is what happened previously with the hardcoded term list.
+        /// </summary>
+        static AndroidLogcatCommandCategory[] GetPopulatedCategories()
+        {
+            return AndroidLogcatAdbCommandCatalog.All
+                .Select(e => e.category)
+                .Distinct()
+                .OrderBy(c => (int)c)
+                .ToArray();
+        }
+
+        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);
+        static readonly Color kActiveChipColor = new Color(0.3f, 0.5f, 0.8f, 0.6f);
+
+        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);
+            wnd.m_Favorites = favorites;
+            wnd.m_GeneralCommands = generalCommands;
+            wnd.m_OnAddCommand = onAdd;
+            wnd.m_OnRunCommand = onRun;
+            wnd.RebuildResults();
+        }
+
+        void CreateGUI()
+        {
+            var r = rootVisualElement;
+            r.Clear();
+
+            var tree = AndroidLogcatUtilities.LoadUXML("Command/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_ChipsRow = r.Q<VisualElement>("ChipsRow");
+
+            m_SearchTextField.value = m_SearchQuery;
+            m_SearchTextField.RegisterValueChangedCallback(evt =>
+            {
+                m_SearchQuery = evt.newValue;
+                RebuildResults();
+            });
+
+            RebuildChips();
+            RebuildResults();
+        }
+
+        void RebuildChips()
+        {
+            if (m_ChipsRow == null)
+                return;
+
+            m_ChipsRow.Clear();
+            m_ChipsRow.style.flexWrap = Wrap.Wrap;
+
+            AddChip("All", null);
+            foreach (var category in GetPopulatedCategories())
+                AddChip(AndroidLogcatCommandMatcher.GetCategoryDisplayName(category), category);
+        }
+
+        void AddChip(string label, AndroidLogcatCommandCategory? category)
+        {
+            var chip = new Button(() =>
+            {
+                m_CategoryFilter = category;
+                RebuildChips();
+                RebuildResults();
+            })
+            { text = label };
+
+            chip.style.marginRight = 2;
+            chip.style.marginBottom = 2;
+
+            var isActive = m_CategoryFilter.HasValue == category.HasValue &&
+                (!category.HasValue || m_CategoryFilter.Value == category.Value);
+            if (isActive)
+                chip.style.backgroundColor = new StyleColor(kActiveChipColor);
+
+            m_ChipsRow.Add(chip);
+        }
+
+        void RebuildResults()
+        {
+            if (m_ResultsContainer == null)
+                return;
+
+            m_ResultsContainer.Clear();
+
+            var favorites = m_Favorites ?? new List<AndroidLogcatCommandEntry>();
+            var general = m_GeneralCommands ?? new List<AndroidLogcatCommandEntry>();
+
+            // Saved commands are matched on the search term only; the category filter applies to the
+            // catalog, since user commands are frequently uncategorized.
+            if (!string.IsNullOrWhiteSpace(m_SearchQuery))
+            {
+                foreach (var e in favorites)
+                    if (AndroidLogcatCommandMatcher.Matches(e, m_SearchQuery))
+                        m_ResultsContainer.Add(CreateResultRow(e, "Favorite", true));
+
+                foreach (var e in general)
+                    if (AndroidLogcatCommandMatcher.Matches(e, m_SearchQuery))
+                        m_ResultsContainer.Add(CreateResultRow(e, "General", true));
+            }
+
+            var savedCommands = new HashSet<string>(
+                favorites.Concat(general).Where(c => c != null && !string.IsNullOrEmpty(c.command)).Select(c => c.command),
+                StringComparer.OrdinalIgnoreCase);
+
+            foreach (var e in AndroidLogcatAdbCommandCatalog.All)
+            {
+                if (!AndroidLogcatCommandMatcher.Matches(e, m_CategoryFilter, m_SearchQuery))
+                    continue;
+                if (savedCommands.Contains(e.command))
+                    continue;
+                m_ResultsContainer.Add(CreateResultRow(e, "Catalog", false));
+            }
+
+            if (m_ResultsContainer.childCount == 0)
+            {
+                SetEmptyState(string.IsNullOrWhiteSpace(m_SearchQuery)
+                    ? "No commands in this category."
+                    : "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;
+            cmdLabel.tooltip = entry.command;
+            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(entry.Clone())) { 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;
+        }
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandSearchWindow.cs.meta b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandSearchWindow.cs.meta
new file mode 100644
index 00000000..3a97a5f7
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/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/Commands/AndroidLogcatCommandsWindow.cs b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandsWindow.cs
new file mode 100644
index 00000000..1cd3defa
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandsWindow.cs
@@ -0,0 +1,647 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+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", AndroidLogcatCommandCategory.DeviceManagement),
+            new AndroidLogcatCommandEntry("Kill Server", "adb kill-server", AndroidLogcatCommandCategory.DeviceManagement),
+            new AndroidLogcatCommandEntry("Reboot Device", "adb reboot", AndroidLogcatCommandCategory.DeviceManagement)
+        };
+
+        AndroidLogcatRuntimeBase m_Runtime;
+        AndroidLogcatDeviceSelection m_DeviceSelection;
+
+        List<AndroidLogcatCommandEntry> m_Favorites = new List<AndroidLogcatCommandEntry>();
+        List<AndroidLogcatCommandEntry> m_GeneralCommands = new List<AndroidLogcatCommandEntry>();
+        readonly List<AndroidLogcatOutputLine> m_OutputLines = new List<AndroidLogcatOutputLine>();
+
+        // Commands from a single multiline entry run one after another; the queue holds what's left.
+        readonly Queue<string> m_PendingCommands = new Queue<string>();
+        bool m_IsRunning;
+        bool m_CancelRequested;
+
+        bool m_EditMode;
+
+        VisualElement m_FavoritesContainer;
+        VisualElement m_GeneralContainer;
+        VisualElement m_OutputContainer;
+        ScrollView m_OutputScroll;
+        Label m_RunningLabel;
+        Button m_CancelButton;
+
+        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);
+
+        internal static void ShowWindow()
+        {
+            var wnd = GetWindow<AndroidLogcatCommandsWindow>("Commands");
+            wnd.minSize = new Vector2(600, 400);
+        }
+
+        void OnEnable()
+        {
+            if (!AndroidBridge.AndroidExtensionsInstalled)
+            {
+                LoadNotInstalledUI();
+                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;
+
+            // Don't leave the window latched in the running state if a command was still in flight.
+            m_PendingCommands.Clear();
+            m_CancelRequested = false;
+            SetRunning(false);
+
+            SaveCommands();
+            m_Runtime.Closing -= OnDisable;
+            m_DeviceSelection.Dispose();
+            m_DeviceSelection = null;
+            m_Runtime = null;
+        }
+
+        // --- UI Setup ---
+
+        /// <summary>
+        /// Shown instead of the normal UI when the Android module isn't available, so the window is
+        /// never just blank.
+        /// </summary>
+        void LoadNotInstalledUI()
+        {
+            var r = rootVisualElement;
+            r.Clear();
+            r.Add(new HelpBox("Android Logcat requires Android support to be installed.", HelpBoxMessageType.Info));
+        }
+
+        void LoadUI()
+        {
+            var r = rootVisualElement;
+            // Guard against OnEnable running twice on the same instance (e.g. re-docking), which
+            // would otherwise clone the tree a second time and leave Q() returning stale elements.
+            r.Clear();
+
+            // The device selection popup is IMGUI-only, so the toolbar is hosted in an IMGUIContainer.
+            // Its height must be pinned, otherwise it claims flexible space and squashes the panes.
+            var toolbar = new IMGUIContainer(DoToolbarGUI);
+            toolbar.style.height = AndroidLogcatStyles.kFixedHeight;
+            toolbar.style.flexShrink = 0;
+            toolbar.style.flexGrow = 0;
+            r.Add(toolbar);
+
+            var tree = AndroidLogcatUtilities.LoadUXML("Command/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");
+            m_CancelButton = r.Q<Button>("CancelButton");
+
+            r.Q<Button>("ClearButton").clicked += ClearOutput;
+            r.Q<Button>("CopyAllButton").clicked += CopyAllOutput;
+            m_CancelButton.clicked += () => m_CancelRequested = true;
+
+            // Right click anywhere in the output for copy actions.
+            m_OutputContainer.AddManipulator(new ContextualMenuManipulator(evt =>
+            {
+                evt.menu.AppendAction("Copy All", _ => CopyAllOutput(),
+                    m_OutputLines.Count > 0 ? DropdownMenuAction.Status.Normal : DropdownMenuAction.Status.Disabled);
+                evt.menu.AppendAction("Clear", _ => ClearOutput(),
+                    m_OutputLines.Count > 0 ? DropdownMenuAction.Status.Normal : DropdownMenuAction.Status.Disabled);
+            }));
+
+            RebuildLists();
+        }
+
+        // --- Toolbar (IMGUI - contains DeviceSelection which is IMGUI-only) ---
+
+        void DoToolbarGUI()
+        {
+            // Use the package's own styles so the buttons line up with the device selection popup,
+            // which is drawn with AndroidLogcatStyles.
+            EditorGUILayout.BeginHorizontal(AndroidLogcatStyles.toolbar);
+
+            if (m_DeviceSelection != null)
+                m_DeviceSelection.DoGUI();
+            GUILayout.Space(3);
+
+            if (GUILayout.Button("Add Command", AndroidLogcatStyles.toolbarButton))
+                OnAddCommand();
+
+            if (GUILayout.Button(m_EditMode ? "Edit Mode: ON" : "Edit Mode: OFF", AndroidLogcatStyles.toolbarButton))
+            {
+                m_EditMode = !m_EditMode;
+                RebuildLists();
+            }
+
+            if (GUILayout.Button("Import", AndroidLogcatStyles.toolbarButton))
+                OnImportCommands();
+
+            if (GUILayout.Button("Export", AndroidLogcatStyles.toolbarButton))
+                OnExportCommands();
+
+            if (GUILayout.Button("Search Catalog", AndroidLogcatStyles.toolbarButton))
+                OpenSearchWindow();
+
+            GUILayout.FlexibleSpace();
+            EditorGUILayout.EndHorizontal();
+        }
+
+        // --- Command Lists ---
+
+        void RebuildLists()
+        {
+            RebuildCommandList(m_FavoritesContainer, m_Favorites, true, "No favorites. Use Edit Mode to move commands here.");
+            RebuildCommandList(m_GeneralContainer, m_GeneralCommands, false, "No commands. Click 'Add Command' or 'Search Catalog'.");
+        }
+
+        void RebuildCommandList(VisualElement container, List<AndroidLogcatCommandEntry> list, bool isFavorites, string emptyMessage)
+        {
+            if (container == null)
+                return;
+
+            container.Clear();
+            if (isFavorites)
+                m_SelectedFavRow = null;
+            else
+                m_SelectedGenRow = 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));
+        }
+
+        void SetSelectedRow(VisualElement row, bool isFavorites)
+        {
+            var previous = isFavorites ? m_SelectedFavRow : m_SelectedGenRow;
+            if (previous != null)
+                previous.style.backgroundColor = StyleKeyword.Null;
+
+            if (isFavorites)
+                m_SelectedFavRow = row;
+            else
+                m_SelectedGenRow = row;
+
+            row.style.backgroundColor = new StyleColor(kSelectedRowColor);
+        }
+
+        VisualElement CreateCommandRow(AndroidLogcatCommandEntry entry, List<AndroidLogcatCommandEntry> list, int index, bool isFavorites)
+        {
+            var row = CreateStyledRow(22);
+
+            row.RegisterCallback<MouseDownEvent>(_ => SetSelectedRow(row, isFavorites));
+
+            var nameLabel = new Label(entry.name);
+            nameLabel.style.unityFontStyleAndWeight = FontStyle.Bold;
+            nameLabel.style.width = 180;
+            nameLabel.style.minWidth = 180;
+            row.Add(nameLabel);
+
+            // Collapse multiline commands into a single line preview.
+            var cmdLines = AndroidLogcatCommandParser.SplitLines(entry.command);
+            var cmdDisplay = cmdLines.Count == 0
+                ? string.Empty
+                : cmdLines.Count > 1 ? $"{cmdLines[0]} (+{cmdLines.Count - 1} more)" : cmdLines[0];
+
+            var cmdLabel = new Label(cmdDisplay);
+            cmdLabel.style.color = new StyleColor(kCommandColor);
+            cmdLabel.style.flexGrow = 1;
+            cmdLabel.style.overflow = Overflow.Hidden;
+            cmdLabel.tooltip = entry.command;
+            row.Add(cmdLabel);
+
+            if (m_EditMode)
+            {
+                AddRowButton(row, "▲", 22, () =>
+                {
+                    list.RemoveAt(index);
+                    list.Insert(index - 1, entry);
+                    SaveAndRebuild();
+                }, index > 0);
+
+                AddRowButton(row, "▼", 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;
+                        entry.category = updated.category;
+                        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 ClearOutput()
+        {
+            m_OutputLines.Clear();
+            m_OutputContainer?.Clear();
+        }
+
+        void CopyAllOutput()
+        {
+            var sb = new StringBuilder();
+            foreach (var line in m_OutputLines)
+                sb.AppendLine(line.Text);
+            EditorGUIUtility.systemCopyBuffer = sb.ToString();
+        }
+
+        void AppendOutput(string text, Color color)
+        {
+            if (string.IsNullOrEmpty(text))
+                return;
+
+            // Strips '\r' and splits on '\n' - see SplitOutputLines for why adb's "\r\r\n" matters.
+            foreach (var line in AndroidLogcatCommandParser.SplitOutputLines(text))
+            {
+                m_OutputLines.Add(new AndroidLogcatOutputLine(line, color));
+                if (m_OutputContainer != null)
+                    m_OutputContainer.Add(CreateOutputLabel(line, color));
+            }
+
+            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);
+            }
+
+            ScrollOutputToBottom();
+        }
+
+        static Label CreateOutputLabel(string text, Color color)
+        {
+            var label = new Label(text);
+            label.style.color = new StyleColor(color);
+            label.style.whiteSpace = WhiteSpace.Normal;
+
+            // Keep lines compact - the default Label margins would space the output out noticeably.
+            label.style.marginTop = 0;
+            label.style.marginBottom = 0;
+            label.style.paddingTop = 0;
+            label.style.paddingBottom = 0;
+
+            // Allow the user to select and copy output text.
+            label.selection.isSelectable = true;
+            label.selection.doubleClickSelectsWord = true;
+            return label;
+        }
+
+        void ScrollOutputToBottom()
+        {
+            if (m_OutputScroll == null || m_OutputContainer == null || m_OutputContainer.childCount == 0)
+                return;
+            m_OutputScroll.schedule
+                .Execute(() => m_OutputScroll.ScrollTo(m_OutputContainer[m_OutputContainer.childCount - 1]))
+                .StartingIn(10);
+        }
+
+        // --- Command Execution ---
+
+        void RunCommand(AndroidLogcatCommandEntry entry)
+        {
+            if (m_IsRunning)
+            {
+                AppendOutput("[Error] A command is already running.", kErrorColor);
+                return;
+            }
+
+            AndroidLogcatPlaceholderDialog.Show(entry.command, ExecuteCommand);
+        }
+
+        /// <summary>
+        /// Queues each line of the command and starts draining the queue. Execution happens on the
+        /// dispatcher's worker thread so the Editor stays responsive.
+        /// </summary>
+        void ExecuteCommand(string resolvedCommand)
+        {
+            if (m_Runtime == null)
+                return;
+
+            // Re-check here as well as in RunCommand: the placeholder dialog is modeless, so another
+            // batch may have started while it was open.
+            if (m_IsRunning)
+            {
+                AppendOutput("[Error] A command is already running.", kErrorColor);
+                return;
+            }
+
+            m_PendingCommands.Clear();
+            foreach (var line in AndroidLogcatCommandParser.SplitLines(resolvedCommand))
+                m_PendingCommands.Enqueue(line);
+
+            if (m_PendingCommands.Count == 0)
+                return;
+
+            m_CancelRequested = false;
+            SetRunning(true);
+            RunNextPendingCommand();
+        }
+
+        void RunNextPendingCommand()
+        {
+            if (m_CancelRequested)
+            {
+                // Only report a cancellation if something was actually skipped.
+                if (m_PendingCommands.Count > 0)
+                {
+                    AppendOutput("[Cancelled] Remaining commands were skipped.", kErrorColor);
+                    m_PendingCommands.Clear();
+                }
+                m_CancelRequested = false;
+                SetRunning(false);
+                return;
+            }
+
+            if (m_PendingCommands.Count == 0)
+            {
+                SetRunning(false);
+                return;
+            }
+
+            var cmd = m_PendingCommands.Dequeue();
+            AppendOutput($"> {cmd}", kAccentColor);
+
+            if (AndroidLogcatCommandParser.IsAdbCommand(cmd))
+            {
+                var device = m_DeviceSelection?.SelectedDevice;
+                if (device == null)
+                {
+                    AppendOutput("[Error] No device selected.", kErrorColor);
+                    m_PendingCommands.Clear();
+                    SetRunning(false);
+                    return;
+                }
+
+                device.RunAdbCommandAsync(m_Runtime.Dispatcher, AndroidLogcatCommandParser.StripAdbPrefix(cmd), OnCommandCompleted);
+            }
+            else
+            {
+                AndroidLogcatHostCommand.RunAsync(m_Runtime.Dispatcher, cmd, OnCommandCompleted);
+            }
+        }
+
+        void OnCommandCompleted(AndroidLogcatCommandResult result)
+        {
+            // The window may have been closed while the command was in flight.
+            if (m_Runtime == null)
+                return;
+
+            if (result == null)
+                AppendOutput("[Error] Command produced no result.", kErrorColor);
+            else if (result.Failed)
+                AppendOutput($"[Error] {result.Error}", kErrorColor);
+            else
+                AppendOutput(result.Output, GetDefaultOutputColor());
+
+            RunNextPendingCommand();
+        }
+
+        static Color GetDefaultOutputColor()
+        {
+            return EditorGUIUtility.isProSkin ? new Color(0.82f, 0.82f, 0.82f) : new Color(0.1f, 0.1f, 0.1f);
+        }
+
+        void SetRunning(bool running)
+        {
+            m_IsRunning = running;
+
+            if (m_RunningLabel != null)
+                m_RunningLabel.style.display = running ? DisplayStyle.Flex : DisplayStyle.None;
+            if (m_CancelButton != null)
+                m_CancelButton.style.display = running ? DisplayStyle.Flex : 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))
+                return;
+
+            try
+            {
+                File.WriteAllText(path, json);
+                AndroidLogcatInternalLog.Log($"Commands exported to {path}");
+            }
+            catch (Exception ex)
+            {
+                EditorUtility.DisplayDialog("Export Failed", $"Could not write the file:\n{ex.Message}", "OK");
+            }
+        }
+
+        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 == null)
+            {
+                EditorUtility.DisplayDialog("Import Failed", "The file contains no commands.", "OK");
+                return;
+            }
+
+            // Drop null/incomplete entries so they can't throw later in the UI.
+            var favorites = AndroidLogcatCommandImport.Sanitize(data.favorites);
+            var general = AndroidLogcatCommandImport.Sanitize(data.general);
+
+            if (favorites.Count == 0 && general.Count == 0)
+            {
+                EditorUtility.DisplayDialog("Import Failed",
+                    "The file contains no valid commands. Each entry needs both a name and a command.", "OK");
+                return;
+            }
+
+            if (!EditorUtility.DisplayDialog("Import Commands", "This will replace all your current commands. Continue?", "Import", "Cancel"))
+                return;
+
+            // Mutate in place rather than reassigning: an open Search window holds references to
+            // these lists, and would otherwise keep showing the pre-import contents.
+            m_Favorites.Clear();
+            m_Favorites.AddRange(favorites);
+            m_GeneralCommands.Clear();
+            m_GeneralCommands.AddRange(general);
+
+            SaveAndRebuild();
+            AndroidLogcatInternalLog.Log($"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)
+                foreach (var entry in s_DefaultCommands)
+                    m_GeneralCommands.Add(entry.Clone());
+        }
+
+        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/Commands/AndroidLogcatCommandsWindow.cs.meta b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatCommandsWindow.cs.meta
new file mode 100644
index 00000000..80fa9b3f
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/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/Commands/AndroidLogcatOutputLine.cs b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatOutputLine.cs
new file mode 100644
index 00000000..aa95b552
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatOutputLine.cs
@@ -0,0 +1,21 @@
+using UnityEngine;
+
+namespace Unity.Android.Logcat
+{
+    /// <summary>
+    /// A single line of command output together with the colour it should be rendered in.
+    /// </summary>
+    internal readonly struct AndroidLogcatOutputLine
+    {
+        internal string Text { get; }
+
+        // Named LineColor rather than Color so it doesn't shadow UnityEngine.Color inside this type.
+        internal Color LineColor { get; }
+
+        internal AndroidLogcatOutputLine(string text, Color color)
+        {
+            Text = text;
+            LineColor = color;
+        }
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatOutputLine.cs.meta b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatOutputLine.cs.meta
new file mode 100644
index 00000000..a51a7c94
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatOutputLine.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 15e16bd0af92469c97982f010b6758a9
\ No newline at end of file
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatPlaceholderDialog.cs b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatPlaceholderDialog.cs
new file mode 100644
index 00000000..165dc03e
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatPlaceholderDialog.cs
@@ -0,0 +1,107 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace Unity.Android.Logcat
+{
+    /// <summary>
+    /// Prompts the user to fill in &lt;placeholder&gt; tokens before a command is run.
+    /// The parsing and substitution logic lives in <see cref="AndroidLogcatCommandPlaceholders"/>.
+    /// </summary>
+    internal class AndroidLogcatPlaceholderDialog : EditorWindow
+    {
+        string m_OriginalCommand;
+        Action<string> m_OnConfirm;
+        List<AndroidLogcatCommandPlaceholders.Placeholder> m_Placeholders = new List<AndroidLogcatCommandPlaceholders.Placeholder>();
+
+        // Neither the callback nor the placeholder list survive a domain reload, so rather than
+        // leave a dialog whose Run button silently does nothing, close it.
+        void OnEnable()
+        {
+            AssemblyReloadEvents.beforeAssemblyReload += Close;
+        }
+
+        void OnDisable()
+        {
+            AssemblyReloadEvents.beforeAssemblyReload -= Close;
+        }
+
+        /// <summary>
+        /// Shows the dialog if <paramref name="command"/> contains placeholders, otherwise invokes
+        /// <paramref name="onConfirm"/> immediately with the unchanged command.
+        /// </summary>
+        internal static void Show(string command, Action<string> onConfirm)
+        {
+            if (!AndroidLogcatCommandPlaceholders.HasPlaceholders(command))
+            {
+                onConfirm?.Invoke(command);
+                return;
+            }
+
+            var wnd = CreateInstance<AndroidLogcatPlaceholderDialog>();
+            wnd.titleContent = new GUIContent("Resolve Placeholders");
+            wnd.m_OriginalCommand = command;
+            wnd.m_OnConfirm = onConfirm;
+            wnd.m_Placeholders = AndroidLogcatCommandPlaceholders.Parse(command, GetDefaultValue);
+            wnd.minSize = new Vector2(400, 150);
+            wnd.maxSize = new Vector2(600, 400);
+
+            // Note: the UI is built in CreateGUI, which runs after this point, so the assignments
+            // above are guaranteed to be visible to it. Building the UI in OnEnable would run before
+            // CreateInstance returns and render an empty dialog.
+            wnd.ShowUtility();
+        }
+
+        /// <summary>
+        /// Prefills tokens we can infer from the project.
+        /// </summary>
+        static string GetDefaultValue(string token)
+        {
+            if (token.Equals("package", StringComparison.OrdinalIgnoreCase))
+                return PlayerSettings.applicationIdentifier;
+            return string.Empty;
+        }
+
+        void CreateGUI()
+        {
+            var r = rootVisualElement;
+            r.Clear();
+
+            var tree = AndroidLogcatUtilities.LoadUXML("Command/AndroidLogcatPlaceholder.uxml");
+            tree.CloneTree(r);
+
+            r.Q<Label>("CommandPreview").text = m_OriginalCommand ?? "";
+
+            var container = r.Q<VisualElement>("PlaceholderContainer");
+            TextField firstField = null;
+
+            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);
+
+                if (firstField == null)
+                    firstField = tf;
+            }
+
+            r.Q<Button>("CancelButton").clicked += Close;
+            r.Q<Button>("RunButton").clicked += OnRunClicked;
+
+            // Scheduled because focusing before the first layout pass is unreliable.
+            if (firstField != null)
+                firstField.schedule.Execute(() => firstField.Focus());
+        }
+
+        void OnRunClicked()
+        {
+            var resolved = AndroidLogcatCommandPlaceholders.Resolve(m_OriginalCommand, m_Placeholders);
+            m_OnConfirm?.Invoke(resolved);
+            Close();
+        }
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatPlaceholderDialog.cs.meta b/com.unity.mobile.android-logcat/Editor/Commands/AndroidLogcatPlaceholderDialog.cs.meta
new file mode 100644
index 00000000..c5ff994d
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/Commands/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/UI/Layouts/Command.meta b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command.meta
new file mode 100644
index 00000000..2d243818
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0e86817804ed4d8194532bd17ad2fc55
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/AndroidLogcatAddCommand.uxml b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/AndroidLogcatAddCommand.uxml
new file mode 100644
index 00000000..62f11dac
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/AndroidLogcatAddCommand.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="padding: 8px; flex-grow: 1;">
+        <ui:TextField name="NameField" label="Name" style="margin-bottom: 4px;" />
+        <ui:VisualElement name="CategoryContainer" 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/Command/AndroidLogcatAddCommand.uxml.meta b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/AndroidLogcatAddCommand.uxml.meta
new file mode 100644
index 00000000..c9839613
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/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/Command/AndroidLogcatCommandSearch.uxml b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/AndroidLogcatCommandSearch.uxml
new file mode 100644
index 00000000..2aed8b9e
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/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/Command/AndroidLogcatCommandSearch.uxml.meta b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/AndroidLogcatCommandSearch.uxml.meta
new file mode 100644
index 00000000..7a9a5080
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/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/Command/AndroidLogcatCommands.uxml b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/AndroidLogcatCommands.uxml
new file mode 100644
index 00000000..42881827
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/AndroidLogcatCommands.uxml
@@ -0,0 +1,27 @@
+<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" style="flex-grow: 1;">
+        <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; flex-shrink: 0; 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; height: 18px; margin: 0; -unity-text-align: middle-left; flex-shrink: 0;" />
+                <ui:Button name="ClearButton" text="Clear" style="height: 18px; margin-top: 0; margin-bottom: 0; flex-shrink: 0;" />
+                <ui:Button name="CopyAllButton" text="Copy All" style="height: 18px; margin-top: 0; margin-bottom: 0; flex-shrink: 0;" />
+                <ui:Button name="CancelButton" text="Cancel" style="height: 18px; margin-top: 0; margin-bottom: 0; flex-shrink: 0; display: none;" />
+                <ui:VisualElement style="flex-grow: 1;" />
+                <ui:Label name="RunningLabel" text="Running..." style="font-size: 10px; height: 18px; margin: 0; -unity-text-align: middle-right; 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/Command/AndroidLogcatCommands.uxml.meta b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/AndroidLogcatCommands.uxml.meta
new file mode 100644
index 00000000..38116efb
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/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/Command/AndroidLogcatPlaceholder.uxml b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/AndroidLogcatPlaceholder.uxml
new file mode 100644
index 00000000..8290b47e
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/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/Command/AndroidLogcatPlaceholder.uxml.meta b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/AndroidLogcatPlaceholder.uxml.meta
new file mode 100644
index 00000000..29d28b35
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Editor/UI/Layouts/Command/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}
diff --git a/com.unity.mobile.android-logcat/Tests/Editor/AndroidLogcatCommandTests.cs b/com.unity.mobile.android-logcat/Tests/Editor/AndroidLogcatCommandTests.cs
new file mode 100644
index 00000000..93b43d28
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Tests/Editor/AndroidLogcatCommandTests.cs
@@ -0,0 +1,519 @@
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using Unity.Android.Logcat;
+
+class AndroidLogcatCommandPlaceholderTests
+{
+    [Test]
+    public void HasPlaceholders_DetectsTokens()
+    {
+        Assert.IsTrue(AndroidLogcatCommandPlaceholders.HasPlaceholders("adb shell pm clear <package>"));
+        Assert.IsFalse(AndroidLogcatCommandPlaceholders.HasPlaceholders("adb devices"));
+        Assert.IsFalse(AndroidLogcatCommandPlaceholders.HasPlaceholders(""));
+        Assert.IsFalse(AndroidLogcatCommandPlaceholders.HasPlaceholders(null));
+    }
+
+    [Test]
+    public void Parse_ReturnsTokensInOrder()
+    {
+        var result = AndroidLogcatCommandPlaceholders.Parse("adb push <local> <remote>");
+
+        Assert.AreEqual(2, result.Count);
+        Assert.AreEqual("local", result[0].Token);
+        Assert.AreEqual("remote", result[1].Token);
+    }
+
+    [Test]
+    public void Parse_DeduplicatesTokensCaseInsensitively()
+    {
+        var result = AndroidLogcatCommandPlaceholders.Parse("adb shell am start -n <package>/<Package>.MainActivity <PACKAGE>");
+
+        Assert.AreEqual(1, result.Count, "Tokens differing only by case should collapse into a single entry");
+        Assert.AreEqual("package", result[0].Token);
+    }
+
+    [Test]
+    public void Parse_AppliesDefaultValueProvider()
+    {
+        var result = AndroidLogcatCommandPlaceholders.Parse(
+            "adb shell pm clear <package> <other>",
+            token => token == "package" ? "com.unity.test" : string.Empty);
+
+        Assert.AreEqual("com.unity.test", result.First(p => p.Token == "package").Value);
+        Assert.AreEqual(string.Empty, result.First(p => p.Token == "other").Value);
+    }
+
+    [Test]
+    public void Parse_NullDefaultProviderYieldsEmptyValue()
+    {
+        var result = AndroidLogcatCommandPlaceholders.Parse("adb shell pm clear <package>", _ => null);
+
+        Assert.AreEqual(1, result.Count);
+        Assert.AreEqual(string.Empty, result[0].Value);
+    }
+
+    [Test]
+    public void Parse_EmptyOrNullCommandReturnsEmptyList()
+    {
+        Assert.AreEqual(0, AndroidLogcatCommandPlaceholders.Parse(null).Count);
+        Assert.AreEqual(0, AndroidLogcatCommandPlaceholders.Parse("").Count);
+        Assert.AreEqual(0, AndroidLogcatCommandPlaceholders.Parse("adb devices").Count);
+    }
+
+    [Test]
+    public void Resolve_ReplacesAllOccurrencesOfRepeatedToken()
+    {
+        var command = "adb shell am start -n <package>/<package>.MainActivity";
+        var placeholders = AndroidLogcatCommandPlaceholders.Parse(command);
+        placeholders[0].Value = "com.unity.test";
+
+        var resolved = AndroidLogcatCommandPlaceholders.Resolve(command, placeholders);
+
+        Assert.AreEqual("adb shell am start -n com.unity.test/com.unity.test.MainActivity", resolved);
+    }
+
+    [Test]
+    public void Resolve_ReplacesTokensDifferingByCase()
+    {
+        var command = "adb shell <Package> <package>";
+        var placeholders = AndroidLogcatCommandPlaceholders.Parse(command);
+        placeholders[0].Value = "abc";
+
+        Assert.AreEqual("adb shell abc abc", AndroidLogcatCommandPlaceholders.Resolve(command, placeholders));
+    }
+
+    [Test]
+    public void Resolve_LeavesUnknownTokensIntact()
+    {
+        var command = "adb push <local> <remote>";
+        var placeholders = new List<AndroidLogcatCommandPlaceholders.Placeholder>
+        {
+            new AndroidLogcatCommandPlaceholders.Placeholder("local", "/tmp/file")
+        };
+
+        Assert.AreEqual("adb push /tmp/file <remote>", AndroidLogcatCommandPlaceholders.Resolve(command, placeholders));
+    }
+
+    [Test]
+    public void Resolve_HandlesNullInputsGracefully()
+    {
+        Assert.IsNull(AndroidLogcatCommandPlaceholders.Resolve(null, null));
+        Assert.AreEqual("adb devices", AndroidLogcatCommandPlaceholders.Resolve("adb devices", null));
+    }
+
+    [Test]
+    public void Resolve_EmptyValueRemovesToken()
+    {
+        var command = "adb shell input text <text>";
+        var placeholders = AndroidLogcatCommandPlaceholders.Parse(command);
+        placeholders[0].Value = "";
+
+        Assert.AreEqual("adb shell input text ", AndroidLogcatCommandPlaceholders.Resolve(command, placeholders));
+    }
+}
+
+class AndroidLogcatCommandParserTests
+{
+    [Test]
+    public void SplitLines_HandlesAllLineEndings()
+    {
+        Assert.AreEqual(new[] { "a", "b", "c" }, AndroidLogcatCommandParser.SplitLines("a\r\nb\rc").ToArray());
+        Assert.AreEqual(new[] { "a", "b" }, AndroidLogcatCommandParser.SplitLines("a\nb").ToArray());
+    }
+
+    [Test]
+    public void SplitLines_TrimsAndDropsEmptyLines()
+    {
+        var result = AndroidLogcatCommandParser.SplitLines("  adb devices  \n\n\t\n adb reboot ");
+
+        Assert.AreEqual(new[] { "adb devices", "adb reboot" }, result.ToArray());
+    }
+
+    [Test]
+    public void SplitLines_NullOrEmptyReturnsEmpty()
+    {
+        Assert.AreEqual(0, AndroidLogcatCommandParser.SplitLines(null).Count);
+        Assert.AreEqual(0, AndroidLogcatCommandParser.SplitLines("   ").Count);
+    }
+
+    /// <summary>
+    /// adb on Windows emits "\r\r\n" for shell output. Splitting on '\r' would produce two empty
+    /// lines per real line, which rendered as visibly double spaced output in the Editor.
+    /// </summary>
+    [Test]
+    public void SplitOutputLines_HandlesAdbDoubleCarriageReturn()
+    {
+        var adbOutput = "package:com.google.android.euicc\r\r\npackage:com.android.dynsystem\r\r\n";
+
+        var result = AndroidLogcatCommandParser.SplitOutputLines(adbOutput);
+
+        // Trailing newline yields one final empty entry; the real lines must not be padded.
+        Assert.AreEqual(3, result.Length);
+        Assert.AreEqual("package:com.google.android.euicc", result[0]);
+        Assert.AreEqual("package:com.android.dynsystem", result[1]);
+        Assert.AreEqual("", result[2]);
+    }
+
+    [Test]
+    public void SplitOutputLines_StripsCarriageReturnsFromLineEnds()
+    {
+        var result = AndroidLogcatCommandParser.SplitOutputLines("a\r\nb\r\nc");
+
+        Assert.AreEqual(new[] { "a", "b", "c" }, result);
+        foreach (var line in result)
+            Assert.IsFalse(line.Contains("\r"), "No line may retain a carriage return");
+    }
+
+    [Test]
+    public void SplitOutputLines_PreservesIntentionalBlankLines()
+    {
+        // dumpsys and similar tools use blank lines as section separators.
+        var result = AndroidLogcatCommandParser.SplitOutputLines("section one\n\nsection two");
+
+        Assert.AreEqual(new[] { "section one", "", "section two" }, result);
+    }
+
+    [Test]
+    public void SplitOutputLines_LoneCarriageReturnsDoNotCreateBlankLines()
+    {
+        // Old Mac style endings are rare, but must not silently join or double up.
+        Assert.AreEqual(new[] { "ab" }, AndroidLogcatCommandParser.SplitOutputLines("a\rb"));
+    }
+
+    [Test]
+    public void SplitOutputLines_EmptyOrNullReturnsEmptyArray()
+    {
+        Assert.AreEqual(0, AndroidLogcatCommandParser.SplitOutputLines(null).Length);
+        Assert.AreEqual(0, AndroidLogcatCommandParser.SplitOutputLines("").Length);
+    }
+
+    [Test]
+    public void IsAdbCommand_RecognizesPrefixCaseInsensitively()
+    {
+        Assert.IsTrue(AndroidLogcatCommandParser.IsAdbCommand("adb devices"));
+        Assert.IsTrue(AndroidLogcatCommandParser.IsAdbCommand("ADB devices"));
+        Assert.IsTrue(AndroidLogcatCommandParser.IsAdbCommand("  adb devices"));
+        Assert.IsFalse(AndroidLogcatCommandParser.IsAdbCommand("java -jar bundletool.jar"));
+        Assert.IsFalse(AndroidLogcatCommandParser.IsAdbCommand("adb"), "Bare 'adb' has no arguments and is not a runnable adb command");
+        Assert.IsFalse(AndroidLogcatCommandParser.IsAdbCommand(null));
+    }
+
+    [Test]
+    public void StripAdbPrefix_RemovesPrefixOnly()
+    {
+        Assert.AreEqual("devices -l", AndroidLogcatCommandParser.StripAdbPrefix("adb devices -l"));
+        Assert.AreEqual("devices", AndroidLogcatCommandParser.StripAdbPrefix("  adb   devices  "));
+        Assert.AreEqual("java -jar x.jar", AndroidLogcatCommandParser.StripAdbPrefix("java -jar x.jar"));
+    }
+
+    [Test]
+    public void SpecifiesDevice_DetectsExplicitSerialFlag()
+    {
+        Assert.IsTrue(AndroidLogcatCommandParser.SpecifiesDevice("-s emulator-5554 shell ls"));
+        Assert.IsTrue(AndroidLogcatCommandParser.SpecifiesDevice("--serial emulator-5554 shell ls"));
+        Assert.IsFalse(AndroidLogcatCommandParser.SpecifiesDevice("shell ls"));
+        Assert.IsFalse(AndroidLogcatCommandParser.SpecifiesDevice(""));
+        Assert.IsFalse(AndroidLogcatCommandParser.SpecifiesDevice(null));
+    }
+
+    [Test]
+    public void SpecifiesDevice_IgnoresSerialFlagAfterSubcommand()
+    {
+        // Here '-s' is an argument to logcat, not adb's device selector.
+        Assert.IsFalse(AndroidLogcatCommandParser.SpecifiesDevice("shell dumpsys -s foo"));
+    }
+
+    [Test]
+    public void Tokenize_RespectsDoubleQuotes()
+    {
+        var result = AndroidLogcatCommandParser.Tokenize("\"C:\\Program Files\\java.exe\" -jar tool.jar");
+
+        Assert.AreEqual(3, result.Count);
+        Assert.AreEqual("C:\\Program Files\\java.exe", result[0]);
+        Assert.AreEqual("-jar", result[1]);
+        Assert.AreEqual("tool.jar", result[2]);
+    }
+
+    [Test]
+    public void Tokenize_RespectsSingleQuotes()
+    {
+        var result = AndroidLogcatCommandParser.Tokenize("echo 'hello world' done");
+
+        Assert.AreEqual(new[] { "echo", "hello world", "done" }, result.ToArray());
+    }
+
+    [Test]
+    public void Tokenize_CollapsesRepeatedWhitespace()
+    {
+        Assert.AreEqual(new[] { "a", "b" }, AndroidLogcatCommandParser.Tokenize("  a \t  b  ").ToArray());
+    }
+
+    [Test]
+    public void Tokenize_EmptyReturnsEmpty()
+    {
+        Assert.AreEqual(0, AndroidLogcatCommandParser.Tokenize("").Count);
+        Assert.AreEqual(0, AndroidLogcatCommandParser.Tokenize(null).Count);
+    }
+
+    [Test]
+    public void TrySplitExecutable_HandlesQuotedPathWithSpaces()
+    {
+        Assert.IsTrue(AndroidLogcatCommandParser.TrySplitExecutable(
+            "\"C:\\Program Files\\Java\\java.exe\" -jar bundletool.jar", out var exe, out var args));
+
+        Assert.AreEqual("C:\\Program Files\\Java\\java.exe", exe);
+        Assert.AreEqual("-jar bundletool.jar", args);
+    }
+
+    [Test]
+    public void TrySplitExecutable_RequotesArgumentsContainingSpaces()
+    {
+        Assert.IsTrue(AndroidLogcatCommandParser.TrySplitExecutable(
+            "java -jar \"my tool.jar\"", out var exe, out var args));
+
+        Assert.AreEqual("java", exe);
+        Assert.AreEqual("-jar \"my tool.jar\"", args);
+    }
+
+    [Test]
+    public void TrySplitExecutable_NoArgumentsYieldsEmptyArgs()
+    {
+        Assert.IsTrue(AndroidLogcatCommandParser.TrySplitExecutable("adb", out var exe, out var args));
+
+        Assert.AreEqual("adb", exe);
+        Assert.AreEqual(string.Empty, args);
+    }
+
+    [Test]
+    public void TrySplitExecutable_EmptyCommandFails()
+    {
+        Assert.IsFalse(AndroidLogcatCommandParser.TrySplitExecutable("   ", out _, out _));
+        Assert.IsFalse(AndroidLogcatCommandParser.TrySplitExecutable(null, out _, out _));
+    }
+}
+
+class AndroidLogcatCommandMatcherTests
+{
+    [Test]
+    public void Matches_IsCaseInsensitiveOnNameAndCommand()
+    {
+        var entry = new AndroidLogcatCommandEntry("List Devices", "adb devices");
+
+        Assert.IsTrue(AndroidLogcatCommandMatcher.Matches(entry, "list"));
+        Assert.IsTrue(AndroidLogcatCommandMatcher.Matches(entry, "DEVICES"));
+        Assert.IsTrue(AndroidLogcatCommandMatcher.Matches(entry, "adb dev"));
+        Assert.IsFalse(AndroidLogcatCommandMatcher.Matches(entry, "logcat"));
+    }
+
+    [Test]
+    public void Matches_NullEntryDoesNotThrow()
+    {
+        Assert.IsFalse(AndroidLogcatCommandMatcher.Matches(null, "anything"));
+    }
+
+    [Test]
+    public void Matches_EntryWithNullFieldsDoesNotThrow()
+    {
+        var entry = new AndroidLogcatCommandEntry(null, null);
+
+        Assert.IsFalse(AndroidLogcatCommandMatcher.Matches(entry, "abc"));
+        Assert.IsTrue(AndroidLogcatCommandMatcher.Matches(entry, ""), "An empty search term matches everything");
+    }
+
+    [Test]
+    public void Matches_PartiallyNullEntryStillMatchesPopulatedField()
+    {
+        Assert.IsTrue(AndroidLogcatCommandMatcher.Matches(new AndroidLogcatCommandEntry("Name", null), "name"));
+        Assert.IsTrue(AndroidLogcatCommandMatcher.Matches(new AndroidLogcatCommandEntry(null, "adb devices"), "adb"));
+    }
+
+    [Test]
+    public void Matches_EmptySearchTermMatchesEverything()
+    {
+        var entry = new AndroidLogcatCommandEntry("List Devices", "adb devices");
+
+        Assert.IsTrue(AndroidLogcatCommandMatcher.Matches(entry, null));
+        Assert.IsTrue(AndroidLogcatCommandMatcher.Matches(entry, "   "));
+    }
+
+    [Test]
+    public void Matches_CategoryFilterIsApplied()
+    {
+        var entry = new AndroidLogcatCommandEntry("List Devices", "adb devices", AndroidLogcatCommandCategory.DeviceManagement);
+
+        Assert.IsTrue(AndroidLogcatCommandMatcher.Matches(entry, AndroidLogcatCommandCategory.DeviceManagement, ""));
+        Assert.IsFalse(AndroidLogcatCommandMatcher.Matches(entry, AndroidLogcatCommandCategory.Quest, ""));
+        Assert.IsTrue(AndroidLogcatCommandMatcher.Matches(entry, null, ""), "A null category means no category filtering");
+    }
+
+    [Test]
+    public void GetCategoryDisplayName_ReturnsNonEmptyForEveryCategory()
+    {
+        foreach (AndroidLogcatCommandCategory category in System.Enum.GetValues(typeof(AndroidLogcatCommandCategory)))
+            Assert.IsFalse(string.IsNullOrEmpty(AndroidLogcatCommandMatcher.GetCategoryDisplayName(category)),
+                $"Category {category} has no display name");
+    }
+}
+
+class AndroidLogcatCommandImportTests
+{
+    [Test]
+    public void Sanitize_DropsNullEntries()
+    {
+        var result = AndroidLogcatCommandImport.Sanitize(new[]
+        {
+            null,
+            new AndroidLogcatCommandEntry("Valid", "adb devices"),
+            null
+        });
+
+        Assert.AreEqual(1, result.Count);
+        Assert.AreEqual("Valid", result[0].name);
+    }
+
+    [Test]
+    public void Sanitize_DropsEntriesMissingNameOrCommand()
+    {
+        var result = AndroidLogcatCommandImport.Sanitize(new[]
+        {
+            new AndroidLogcatCommandEntry(null, "adb devices"),
+            new AndroidLogcatCommandEntry("No Command", null),
+            new AndroidLogcatCommandEntry("", "adb devices"),
+            new AndroidLogcatCommandEntry("Whitespace", "   "),
+            new AndroidLogcatCommandEntry("Valid", "adb devices")
+        });
+
+        Assert.AreEqual(1, result.Count);
+        Assert.AreEqual("Valid", result[0].name);
+    }
+
+    [Test]
+    public void Sanitize_TrimsSurvivingEntries()
+    {
+        var result = AndroidLogcatCommandImport.Sanitize(new[]
+        {
+            new AndroidLogcatCommandEntry("  Padded  ", "  adb devices  ")
+        });
+
+        Assert.AreEqual("Padded", result[0].name);
+        Assert.AreEqual("adb devices", result[0].command);
+    }
+
+    [Test]
+    public void Sanitize_PreservesCategory()
+    {
+        var result = AndroidLogcatCommandImport.Sanitize(new[]
+        {
+            new AndroidLogcatCommandEntry("Quest Thing", "adb shell x", AndroidLogcatCommandCategory.Quest)
+        });
+
+        Assert.AreEqual(AndroidLogcatCommandCategory.Quest, result[0].category);
+    }
+
+    [Test]
+    public void Sanitize_NullInputReturnsEmptyList()
+    {
+        Assert.AreEqual(0, AndroidLogcatCommandImport.Sanitize(null).Count);
+    }
+
+    [Test]
+    public void IsValid_RequiresBothFields()
+    {
+        Assert.IsTrue(new AndroidLogcatCommandEntry("a", "b").IsValid);
+        Assert.IsFalse(new AndroidLogcatCommandEntry("a", "").IsValid);
+        Assert.IsFalse(new AndroidLogcatCommandEntry("", "b").IsValid);
+        Assert.IsFalse(new AndroidLogcatCommandEntry(null, null).IsValid);
+    }
+}
+
+class AndroidLogcatCommandCatalogTests
+{
+    [Test]
+    public void Catalog_AllEntriesAreValid()
+    {
+        foreach (var entry in AndroidLogcatAdbCommandCatalog.All)
+            Assert.IsTrue(entry.IsValid, $"Catalog entry '{entry.name}' is missing a name or command");
+    }
+
+    [Test]
+    public void Catalog_HasNoDuplicateCommands()
+    {
+        var duplicates = AndroidLogcatAdbCommandCatalog.All
+            .GroupBy(e => e.command, System.StringComparer.OrdinalIgnoreCase)
+            .Where(g => g.Count() > 1)
+            .Select(g => g.Key)
+            .ToArray();
+
+        Assert.IsEmpty(duplicates, "Duplicate commands in catalog: " + string.Join(", ", duplicates));
+    }
+
+    [Test]
+    public void Catalog_HasNoDuplicateNames()
+    {
+        var duplicates = AndroidLogcatAdbCommandCatalog.All
+            .GroupBy(e => e.name, System.StringComparer.OrdinalIgnoreCase)
+            .Where(g => g.Count() > 1)
+            .Select(g => g.Key)
+            .ToArray();
+
+        Assert.IsEmpty(duplicates, "Duplicate names in catalog: " + string.Join(", ", duplicates));
+    }
+
+    [Test]
+    public void Catalog_EveryEntryHasACategory()
+    {
+        foreach (var entry in AndroidLogcatAdbCommandCatalog.All)
+            Assert.AreNotEqual(AndroidLogcatCommandCategory.Uncategorized, entry.category,
+                $"Catalog entry '{entry.name}' is uncategorized, so it would not appear under any filter chip");
+    }
+
+    /// <summary>
+    /// The catalog must not duplicate functionality the package already provides as a dedicated
+    /// feature. See the scope note on AndroidLogcatAdbCommandCatalog.
+    /// </summary>
+    [Test]
+    public void Catalog_DoesNotDuplicateExistingPackageFeatures()
+    {
+        foreach (var entry in AndroidLogcatAdbCommandCatalog.All)
+        {
+            var command = entry.command.ToLowerInvariant();
+
+            Assert.IsFalse(command.Contains("logcat"),
+                $"'{entry.name}' duplicates the main logcat window");
+            Assert.IsFalse(command.Contains("shell input "),
+                $"'{entry.name}' duplicates the input simulation window");
+            Assert.IsFalse(command.Contains("screencap"),
+                $"'{entry.name}' duplicates the screen capture window");
+            Assert.IsFalse(command.Contains("screenrecord"),
+                $"'{entry.name}' duplicates the screen recording window");
+        }
+    }
+
+    [Test]
+    public void Catalog_PlaceholdersAreWellFormed()
+    {
+        foreach (var entry in AndroidLogcatAdbCommandCatalog.All)
+        {
+            Assert.AreEqual(
+                entry.command.Count(c => c == '<'),
+                entry.command.Count(c => c == '>'),
+                $"Unbalanced placeholder brackets in '{entry.name}'");
+
+            foreach (var placeholder in AndroidLogcatCommandPlaceholders.Parse(entry.command))
+                Assert.IsFalse(string.IsNullOrWhiteSpace(placeholder.Token),
+                    $"Empty placeholder token in '{entry.name}'");
+        }
+    }
+
+    [Test]
+    public void Catalog_EveryPopulatedCategoryHasEntries()
+    {
+        var categories = AndroidLogcatAdbCommandCatalog.All.Select(e => e.category).Distinct();
+
+        foreach (var category in categories)
+            Assert.IsNotEmpty(
+                AndroidLogcatAdbCommandCatalog.All.Where(e => e.category == category).ToArray(),
+                $"Category {category} is offered as a chip but has no entries");
+    }
+}
diff --git a/com.unity.mobile.android-logcat/Tests/Editor/AndroidLogcatCommandTests.cs.meta b/com.unity.mobile.android-logcat/Tests/Editor/AndroidLogcatCommandTests.cs.meta
new file mode 100644
index 00000000..9a12f155
--- /dev/null
+++ b/com.unity.mobile.android-logcat/Tests/Editor/AndroidLogcatCommandTests.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 89ccf22748814f8792819a40c8cefbf7
\ No newline at end of file