diff --git a/Assets/Tests/Editor/CliSetupSectionTests.cs b/Assets/Tests/Editor/CliSetupSectionTests.cs
index 0bb74f313..54b671318 100644
--- a/Assets/Tests/Editor/CliSetupSectionTests.cs
+++ b/Assets/Tests/Editor/CliSetupSectionTests.cs
@@ -1,3 +1,5 @@
+using System.Collections.Generic;
+
 using NUnit.Framework;
 using UnityEditor.UIElements;
 using UnityEngine.UIElements;
@@ -82,51 +84,10 @@ public void IsUninstallCliAction_ReturnsExpectedValue(
             Assert.That(result, Is.EqualTo(expected));
         }
 
-        [TestCase(false, false, SkillInstallState.Missing, "Install Skills")]
-        [TestCase(true, true, SkillInstallState.Missing, "Installing...")]
-        [TestCase(true, false, SkillInstallState.Checking, "Checking...")]
-        [TestCase(true, false, SkillInstallState.Outdated, "Update Skills")]
-        [TestCase(true, false, SkillInstallState.Missing, "Install Skills")]
-        [TestCase(true, false, SkillInstallState.Installed, "Installed")]
-        public void GetInstallSkillsButtonText_ReturnsExpectedText(
-            bool isCliInstalled,
-            bool isInstallingSkills,
-            SkillInstallState installState,
-            string expectedText)
-        {
-            string text = CliSetupSection.GetInstallSkillsButtonText(
-                isCliInstalled,
-                isInstallingSkills,
-                installState);
-
-            Assert.That(text, Is.EqualTo(expectedText));
-        }
-
-        [TestCase(false, false, SkillInstallState.Missing, false)]
-        [TestCase(true, true, SkillInstallState.Missing, false)]
-        [TestCase(true, false, SkillInstallState.Checking, false)]
-        [TestCase(true, false, SkillInstallState.Installed, false)]
-        [TestCase(true, false, SkillInstallState.Outdated, true)]
-        [TestCase(true, false, SkillInstallState.Missing, true)]
-        public void IsInstallSkillsButtonEnabled_ReturnsExpectedValue(
-            bool isCliInstalled,
-            bool isInstallingSkills,
-            SkillInstallState installState,
-            bool expectedEnabled)
-        {
-            // Verifies that the Skills install button follows only Skills state.
-            bool enabled = CliSetupSection.IsInstallSkillsButtonEnabled(
-                isCliInstalled,
-                isInstallingSkills,
-                installState);
-
-            Assert.That(enabled, Is.EqualTo(expectedEnabled));
-        }
-
         [Test]
-        public void Update_WhenCliRefreshIsChecking_KeepsSkillsControlsEnabled()
+        public void Update_WhenCliRefreshIsChecking_ShowsSkillsCheckingState()
         {
-            // Verifies that a CLI-only refresh does not gray out Skills controls.
+            // Verifies that IsChecking routes the shared skills panel into ShowChecking.
             VisualElement root = CreateRootElement();
             CliSetupSection section = new(root);
             CliSetupData data = CreateData(
@@ -138,12 +99,18 @@ public void Update_WhenCliRefreshIsChecking_KeepsSkillsControlsEnabled()
 
             Button refreshSkillsButton = root.Q<Button>("refresh-skills-state-button");
             VisualElement skillsSubsection = root.Q<VisualElement>("skills-subsection");
+            Button installAllSkillsButton = root.Q<Button>("install-all-skills-button");
+            Button installSelectedSkillsButton = root.Q<Button>("install-selected-skills-button");
             EnumField skillsTargetField = root.Q<EnumField>("skills-target-field");
-            Button installSkillsButton = root.Q<Button>("install-skills-button");
-            Assert.That(refreshSkillsButton.enabledSelf, Is.True);
+            Toggle groupSkillsToggle = root.Q<Toggle>("group-skills-toggle");
+            Assert.That(refreshSkillsButton.enabledSelf, Is.False);
             Assert.That(skillsSubsection.enabledSelf, Is.True);
-            Assert.That(skillsTargetField.enabledSelf, Is.True);
-            Assert.That(installSkillsButton.enabledSelf, Is.True);
+            Assert.That(installAllSkillsButton.enabledSelf, Is.False);
+            Assert.That(installAllSkillsButton.text, Is.EqualTo("Checking..."));
+            Assert.That(installSelectedSkillsButton.enabledSelf, Is.False);
+            Assert.That(installSelectedSkillsButton.text, Is.EqualTo("Checking..."));
+            Assert.That(skillsTargetField.enabledSelf, Is.False);
+            Assert.That(groupSkillsToggle.enabledSelf, Is.False);
         }
 
         [Test]
@@ -173,13 +140,26 @@ private static VisualElement CreateRootElement()
             VisualElement installProgress = new() { name = "cli-install-progress" };
             installProgress.Add(new Label { name = "cli-install-progress-label" });
             root.Add(installProgress);
-            root.Add(new EnumField { name = "skills-target-field" });
-            root.Add(new Button { name = "refresh-skills-state-button" });
-            root.Add(new VisualElement { name = "group-skills-row" });
-            root.Add(new Toggle { name = "group-skills-toggle" });
-            root.Add(new Label { name = "group-skills-label" });
-            root.Add(new Button { name = "install-skills-button" });
-            root.Add(new VisualElement { name = "skills-subsection" });
+
+            VisualElement skillsSubsection = new() { name = "skills-subsection" };
+            VisualElement skillsSetupPanel = new() { name = "skills-setup-panel" };
+            skillsSetupPanel.Add(new VisualElement { name = "skill-target-status-list" });
+            skillsSetupPanel.Add(new VisualElement { name = "skill-target-status-divider" });
+            skillsSetupPanel.Add(new Label { name = "skill-target-status-summary" });
+            skillsSetupPanel.Add(new Button { name = "install-all-skills-button" });
+            Foldout specificTargetFoldout = new() { name = "install-specific-target-foldout" };
+            VisualElement groupSkillsRow = new() { name = "group-skills-row" };
+            groupSkillsRow.Add(new Toggle { name = "group-skills-toggle" });
+            groupSkillsRow.Add(new Label { name = "group-skills-label" });
+            specificTargetFoldout.Add(groupSkillsRow);
+            VisualElement skillsTargetRow = new() { name = "skills-target-row" };
+            skillsTargetRow.Add(new EnumField { name = "skills-target-field" });
+            skillsTargetRow.Add(new Button { name = "refresh-skills-state-button" });
+            specificTargetFoldout.Add(skillsTargetRow);
+            specificTargetFoldout.Add(new Button { name = "install-selected-skills-button" });
+            skillsSetupPanel.Add(specificTargetFoldout);
+            skillsSubsection.Add(skillsSetupPanel);
+            root.Add(skillsSubsection);
             return root;
         }
 
@@ -206,7 +186,8 @@ private static CliSetupData CreateData(
                 selectedTargetInstallState,
                 SkillsTarget.Claude,
                 groupSkillsUnderUnityCliLoop: false,
-                isInstallingSkills: false);
+                isInstallingSkills: false,
+                installableSkillTargets: new List<SkillSetupTargetInfo>());
         }
     }
 }
diff --git a/Assets/Tests/Editor/SetupWizardWindowTests.cs b/Assets/Tests/Editor/SetupWizardWindowTests.cs
index 18d4ed31c..32495c41b 100644
--- a/Assets/Tests/Editor/SetupWizardWindowTests.cs
+++ b/Assets/Tests/Editor/SetupWizardWindowTests.cs
@@ -418,6 +418,7 @@ public void GetGitHubRepositoryUrl_ReturnsProjectRepositoryUrl()
         [Test]
         public void PrepareForOpen_PopulatesWindowStateBeforeShowing()
         {
+            // Verifies PrepareForOpen writes title, position, and record-version flag before Show.
             SetupWizardWindow window = ScriptableObject.CreateInstance<SetupWizardWindow>();
             try
             {
@@ -427,19 +428,14 @@ public void PrepareForOpen_PopulatesWindowStateBeforeShowing()
                     window,
                     "Unity CLI Loop Setup",
                     position,
-                    "1.9.0",
                     true);
 
                 SerializedObject serializedWindow = new(window);
-                SerializedProperty lastSeenVersionProperty =
-                    serializedWindow.FindProperty("_lastSeenSetupWizardVersionBeforeOpen");
                 SerializedProperty recordVersionProperty =
                     serializedWindow.FindProperty("_shouldRecordLastSeenVersionAfterCreateGui");
 
                 Assert.That(window.titleContent.text, Is.EqualTo("Unity CLI Loop Setup"));
                 Assert.That(window.position, Is.EqualTo(position));
-                Assert.That(lastSeenVersionProperty, Is.Not.Null);
-                Assert.That(lastSeenVersionProperty.stringValue, Is.EqualTo("1.9.0"));
                 Assert.That(recordVersionProperty, Is.Not.Null);
                 Assert.That(recordVersionProperty.boolValue, Is.True);
             }
@@ -449,70 +445,6 @@ public void PrepareForOpen_PopulatesWindowStateBeforeShowing()
             }
         }
 
-        [Test]
-        public void FilterInstallableSkillTargets_ExcludesTargetsWithoutSkillsDirectory()
-        {
-            List<SkillSetupTargetInfo> targets = new()
-            {
-                new("Claude Code", ".claude", "--claude", true, true),
-                new("Cursor", ".cursor", "--cursor", false, false),
-                new("Codex CLI", ".codex", "--codex", true, false, hasDifferentLayoutSkills: true)
-            };
-
-            List<SkillSetupTargetInfo> installableTargets =
-                SetupWizardSkillsStepPresenter.FilterInstallableSkillTargets(targets);
-
-            Assert.That(installableTargets.Count, Is.EqualTo(2));
-            Assert.That(installableTargets[0].DirName, Is.EqualTo(".claude"));
-            Assert.That(installableTargets[1].DirName, Is.EqualTo(".codex"));
-        }
-
-        [TestCase(true, 0, true)]
-        [TestCase(false, 0, true)]
-        [TestCase(false, 1, false)]
-        public void ResolveUseFirstInstallSkillsUi_ReturnsExpectedMode(
-            bool shouldUseFirstInstallSkillsUi,
-            int installableTargetCount,
-            bool expected)
-        {
-            // Verifies that empty installable target results fall back to the first-install skill UI.
-            bool actual = SetupWizardSkillsStepPresenter.ResolveUseFirstInstallSkillsUi(
-                shouldUseFirstInstallSkillsUi,
-                installableTargetCount);
-
-            Assert.That(actual, Is.EqualTo(expected));
-        }
-
-        [Test]
-        public void ResolveUseFirstInstallSkillsUi_WhenLatched_RemainsEnabled()
-        {
-            // Verifies that the first-install UI remains enabled after a target folder is created.
-            bool latchedMode = SetupWizardSkillsStepPresenter.ResolveUseFirstInstallSkillsUi(
-                shouldUseFirstInstallSkillsUi: false,
-                installableTargetCount: 0);
-            bool actual = SetupWizardSkillsStepPresenter.ResolveUseFirstInstallSkillsUi(
-                latchedMode,
-                installableTargetCount: 1);
-
-            Assert.That(actual, Is.True);
-        }
-
-        [Test]
-        public void ShouldUseFirstInstallSkillsUi_WhenVersionWasNeverSeen_ReturnsTrue()
-        {
-            bool shouldUseFirstInstallUi = SetupWizardWindow.ShouldUseFirstInstallSkillsUi("");
-
-            Assert.That(shouldUseFirstInstallUi, Is.True);
-        }
-
-        [Test]
-        public void ShouldUseFirstInstallSkillsUi_WhenVersionWasSeen_ReturnsFalse()
-        {
-            bool shouldUseFirstInstallUi = SetupWizardWindow.ShouldUseFirstInstallSkillsUi("1.9.0");
-
-            Assert.That(shouldUseFirstInstallUi, Is.False);
-        }
-
         [Test]
         public void CanManageSkills_WhenCliIsMissing_ReturnsFalse()
         {
@@ -529,48 +461,6 @@ public void CanManageSkills_WhenCliIsInstalled_ReturnsTrue()
             Assert.That(canManageSkills, Is.True);
         }
 
-        [Test]
-        public void ShouldShowSkillsTargetRow_WhenFirstInstallAndCliMissing_ReturnsTrue()
-        {
-            // Verifies that first-time setup can choose a skill target before CLI installation.
-            bool shouldShow = SetupWizardSkillsStepPresenter.ShouldShowSkillsTargetRowForSetupWizard(
-                shouldUseFirstInstallSkillsUi: true);
-
-            Assert.That(shouldShow, Is.True);
-        }
-
-        [Test]
-        public void ShouldShowSkillsTargetRow_WhenNotFirstInstall_ReturnsFalse()
-        {
-            // Verifies that returning setup keeps the compact target row hidden.
-            bool shouldShow = SetupWizardSkillsStepPresenter.ShouldShowSkillsTargetRowForSetupWizard(
-                shouldUseFirstInstallSkillsUi: false);
-
-            Assert.That(shouldShow, Is.False);
-        }
-
-        [Test]
-        public void ShouldShowSkillsTargetList_WhenCliMissing_ReturnsFalse()
-        {
-            // Verifies that multi-target status rows stay hidden until the CLI can inspect skill state.
-            bool shouldShow = SetupWizardSkillsStepPresenter.ShouldShowSkillsTargetListForSetupWizard(
-                canManageSkills: false,
-                shouldUseFirstInstallSkillsUi: false);
-
-            Assert.That(shouldShow, Is.False);
-        }
-
-        [Test]
-        public void ShouldShowSkillsTargetList_WhenCliInstalledAndNotFirstInstall_ReturnsTrue()
-        {
-            // Verifies that returning users keep the multi-target skill status view.
-            bool shouldShow = SetupWizardSkillsStepPresenter.ShouldShowSkillsTargetListForSetupWizard(
-                canManageSkills: true,
-                shouldUseFirstInstallSkillsUi: false);
-
-            Assert.That(shouldShow, Is.True);
-        }
-
         [TestCase(false, false, false, false, false, null, "3.0.0", "Install CLI")]
         [TestCase(false, false, false, false, true, null, "3.0.0", "Fix PATH")]
         [TestCase(true, false, false, false, false, "3.0.0", "3.0.0", "Installed")]
@@ -680,163 +570,6 @@ public void ShouldCheckCliPathSetupForSetupWizard_RequiresPackageOwnedCli(
             Assert.That(result, Is.EqualTo(expected));
         }
 
-        [Test]
-        public void CreateFirstInstallSkillTarget_WhenClaudeSelected_ReturnsClaudeProjectTarget()
-        {
-            SkillSetupTargetInfo target =
-                SetupWizardSkillsStepPresenter.CreateFirstInstallSkillTarget(SkillsTarget.Claude, true);
-
-            Assert.That(target.DisplayName, Is.EqualTo("Claude Code"));
-            Assert.That(target.DirName, Is.EqualTo(".claude"));
-            Assert.That(target.InstallFlag, Is.EqualTo("--claude"));
-            Assert.That(target.HasSkillsDirectory, Is.False);
-            Assert.That(target.HasExistingSkills, Is.False);
-        }
-
-        [TestCase(SkillsTarget.Cursor, "Cursor", ".cursor", "--cursor")]
-        [TestCase(SkillsTarget.Gemini, "Gemini CLI", ".gemini", "--gemini")]
-        [TestCase(SkillsTarget.Codex, "Codex CLI", ".codex", "--codex")]
-        [TestCase(SkillsTarget.Agents, "Other (.agents)", ".agents", "--agents")]
-        public void CreateFirstInstallSkillTarget_ReturnsMappedTarget(
-            SkillsTarget targetType,
-            string expectedDisplayName,
-            string expectedDirName,
-            string expectedInstallFlag)
-        {
-            SkillSetupTargetInfo target =
-                SetupWizardSkillsStepPresenter.CreateFirstInstallSkillTarget(targetType, true);
-
-            Assert.That(target.DisplayName, Is.EqualTo(expectedDisplayName));
-            Assert.That(target.DirName, Is.EqualTo(expectedDirName));
-            Assert.That(target.InstallFlag, Is.EqualTo(expectedInstallFlag));
-            Assert.That(target.HasSkillsDirectory, Is.False);
-            Assert.That(target.HasExistingSkills, Is.False);
-        }
-
-        [Test]
-        public void CreateFirstInstallSkillTarget_WhenGroupingDisabled_KeepsTargetMetadata()
-        {
-            SkillSetupTargetInfo target =
-                SetupWizardSkillsStepPresenter.CreateFirstInstallSkillTarget(SkillsTarget.Claude, false);
-
-            Assert.That(target.DisplayName, Is.EqualTo("Claude Code"));
-            Assert.That(target.DirName, Is.EqualTo(".claude"));
-            Assert.That(target.InstallFlag, Is.EqualTo("--claude"));
-        }
-
-        [Test]
-        public void GetSelectedSkillTargetInfo_WhenDetectedTargetExists_ReturnsDetectedState()
-        {
-            List<SkillSetupTargetInfo> targets = new()
-            {
-                new(
-                    "Claude Code",
-                    ".claude",
-                    "--claude",
-                    hasSkillsDirectory: true,
-                    hasExistingSkills: true,
-                    installState: SkillInstallState.Installed)
-            };
-
-            SkillSetupTargetInfo target = SetupWizardSkillsStepPresenter.GetSelectedSkillTargetInfo(
-                targets,
-                SkillsTarget.Claude,
-                groupSkillsUnderUnityCliLoop: true);
-
-            Assert.That(target.DirName, Is.EqualTo(".claude"));
-            Assert.That(target.InstallState, Is.EqualTo(SkillInstallState.Installed));
-        }
-
-        [Test]
-        public void GetFirstInstallableSkillTargets_WhenSelectedTargetIsInstalled_ReturnsEmpty()
-        {
-            List<SkillSetupTargetInfo> targets = new()
-            {
-                new(
-                    "Claude Code",
-                    ".claude",
-                    "--claude",
-                    hasSkillsDirectory: true,
-                    hasExistingSkills: true,
-                    installState: SkillInstallState.Installed)
-            };
-
-            List<SkillSetupTargetInfo> installableTargets =
-                SetupWizardSkillsStepPresenter.GetFirstInstallableSkillTargets(
-                    targets,
-                    SkillsTarget.Claude,
-                    groupSkillsUnderUnityCliLoop: true);
-
-            Assert.That(installableTargets, Is.Empty);
-        }
-
-        [Test]
-        public void GetFirstInstallableSkillTargets_WhenSelectedTargetIsMissing_ReturnsMappedTarget()
-        {
-            List<SkillSetupTargetInfo> installableTargets =
-                SetupWizardSkillsStepPresenter.GetFirstInstallableSkillTargets(
-                    new List<SkillSetupTargetInfo>(),
-                    SkillsTarget.Claude,
-                    groupSkillsUnderUnityCliLoop: true);
-
-            Assert.That(installableTargets.Count, Is.EqualTo(1));
-            Assert.That(installableTargets[0].DirName, Is.EqualTo(".claude"));
-            Assert.That(installableTargets[0].InstallState, Is.EqualTo(SkillInstallState.Missing));
-        }
-
-        [TestCase(SkillInstallState.Installed, false, true, "Installed")]
-        [TestCase(SkillInstallState.Checking, false, true, "Checking...")]
-        [TestCase(SkillInstallState.Outdated, false, true, "Outdated")]
-        [TestCase(SkillInstallState.Missing, false, true, "Missing")]
-        [TestCase(SkillInstallState.Missing, true, true, "Not grouped")]
-        [TestCase(SkillInstallState.Missing, true, false, "Grouped")]
-        public void GetSkillInstallStatusText_ReturnsExpectedLabel(
-            SkillInstallState installState,
-            bool hasDifferentLayoutSkills,
-            bool groupSkillsUnderUnityCliLoop,
-            string expectedLabel)
-        {
-            string label = SetupWizardSkillsStepPresenter.GetSkillInstallStatusText(
-                installState,
-                hasDifferentLayoutSkills,
-                groupSkillsUnderUnityCliLoop);
-
-            Assert.That(label, Is.EqualTo(expectedLabel));
-        }
-
-        [TestCase(true, false, "Installing...")]
-        [TestCase(false, true, "Update Skills")]
-        [TestCase(false, false, "Install Skills")]
-        public void GetInstallSkillsButtonText_ReturnsExpectedLabel(
-            bool isInstallingSkills,
-            bool hasOutdatedSkills,
-            string expectedLabel)
-        {
-            string label = SetupWizardSkillsStepPresenter.GetInstallSkillsButtonText(
-                isInstallingSkills,
-                hasOutdatedSkills);
-
-            Assert.That(label, Is.EqualTo(expectedLabel));
-        }
-
-        [TestCase(false, false, false, "Install Skills")]
-        [TestCase(true, true, false, "Installing...")]
-        [TestCase(true, false, true, "Update Skills")]
-        [TestCase(true, false, false, "Install Skills")]
-        public void GetSkillsButtonTextForSetupWizard_ReturnsExpectedLabel(
-            bool cliInstalled,
-            bool isInstallingSkills,
-            bool hasOutdatedSkills,
-            string expectedLabel)
-        {
-            string label = SetupWizardSkillsStepPresenter.GetSkillsButtonTextForSetupWizard(
-                cliInstalled,
-                isInstallingSkills,
-                hasOutdatedSkills);
-
-            Assert.That(label, Is.EqualTo(expectedLabel));
-        }
-
         [Test]
         public void ShouldShowSkillsInstalledDialog_WhenTargetsAreMissing_ReturnsTrue()
         {
@@ -889,24 +622,6 @@ public void ShouldShowSkillsInstalledDialog_WhenAnyTargetUsesDifferentLayout_Ret
             Assert.That(shouldShowDialog, Is.False);
         }
 
-        [TestCase(SkillInstallState.Installed, false, "setup-target-item__status--installed")]
-        [TestCase(SkillInstallState.Checking, false, "setup-target-item__status--checking")]
-        [TestCase(SkillInstallState.Outdated, false, "setup-target-item__status--outdated")]
-        [TestCase(SkillInstallState.Missing, false, "setup-target-item__status--missing")]
-        [TestCase(SkillInstallState.Missing, true, "setup-target-item__status--different-layout")]
-        public void GetSkillInstallStatusClass_ReturnsExpectedClass(
-            SkillInstallState installState,
-            bool hasDifferentLayoutSkills,
-            string expectedClass)
-        {
-            // Verifies that each skill install state maps to the expected status style class.
-            string className = SetupWizardSkillsStepPresenter.GetSkillInstallStatusClass(
-                installState,
-                hasDifferentLayoutSkills);
-
-            Assert.That(className, Is.EqualTo(expectedClass));
-        }
-
         [Test]
         public void EstimateWrappedLineCount_WithPositiveHeight_ReturnsRoundedLineCount()
         {
diff --git a/Assets/Tests/Editor/SkillsSetupPanelViewTests.cs b/Assets/Tests/Editor/SkillsSetupPanelViewTests.cs
new file mode 100644
index 000000000..7b79484b9
--- /dev/null
+++ b/Assets/Tests/Editor/SkillsSetupPanelViewTests.cs
@@ -0,0 +1,267 @@
+using System.Collections.Generic;
+
+using NUnit.Framework;
+
+using io.github.hatayama.UnityCliLoop.Domain;
+using io.github.hatayama.UnityCliLoop.Presentation;
+
+namespace io.github.hatayama.UnityCliLoop.Tests.Editor
+{
+    /// <summary>
+    /// Test fixture that verifies shared SkillsSetupPanelView pure helpers.
+    /// </summary>
+    public class SkillsSetupPanelViewTests
+    {
+        [Test]
+        public void FilterInstallableSkillTargets_ExcludesTargetsWithoutSkillsDirectory()
+        {
+            // Verifies that only targets with a skills directory remain installable.
+            List<SkillSetupTargetInfo> targets = new()
+            {
+                new("Claude Code", ".claude", "--claude", true, true),
+                new("Cursor", ".cursor", "--cursor", false, false),
+                new("Codex CLI", ".codex", "--codex", true, false, hasDifferentLayoutSkills: true)
+            };
+
+            List<SkillSetupTargetInfo> installableTargets =
+                SkillsSetupPanelView.FilterInstallableSkillTargets(targets);
+
+            Assert.That(installableTargets.Count, Is.EqualTo(2));
+            Assert.That(installableTargets[0].DirName, Is.EqualTo(".claude"));
+            Assert.That(installableTargets[1].DirName, Is.EqualTo(".codex"));
+        }
+
+        [Test]
+        public void CreateFirstInstallSkillTarget_WhenClaudeSelected_ReturnsClaudeProjectTarget()
+        {
+            // Verifies Claude maps to the project-level first-install target metadata.
+            SkillSetupTargetInfo target =
+                SkillsSetupPanelView.CreateFirstInstallSkillTarget(SkillsTarget.Claude, true);
+
+            Assert.That(target.DisplayName, Is.EqualTo("Claude Code"));
+            Assert.That(target.DirName, Is.EqualTo(".claude"));
+            Assert.That(target.InstallFlag, Is.EqualTo("--claude"));
+            Assert.That(target.HasSkillsDirectory, Is.False);
+            Assert.That(target.HasExistingSkills, Is.False);
+        }
+
+        [TestCase(SkillsTarget.Cursor, "Cursor", ".cursor", "--cursor")]
+        [TestCase(SkillsTarget.Gemini, "Gemini CLI", ".gemini", "--gemini")]
+        [TestCase(SkillsTarget.Codex, "Codex CLI", ".codex", "--codex")]
+        [TestCase(SkillsTarget.Agents, "Other (.agents)", ".agents", "--agents")]
+        public void CreateFirstInstallSkillTarget_ReturnsMappedTarget(
+            SkillsTarget targetType,
+            string expectedDisplayName,
+            string expectedDirName,
+            string expectedInstallFlag)
+        {
+            // Verifies each SkillsTarget maps to the expected first-install metadata.
+            SkillSetupTargetInfo target =
+                SkillsSetupPanelView.CreateFirstInstallSkillTarget(targetType, true);
+
+            Assert.That(target.DisplayName, Is.EqualTo(expectedDisplayName));
+            Assert.That(target.DirName, Is.EqualTo(expectedDirName));
+            Assert.That(target.InstallFlag, Is.EqualTo(expectedInstallFlag));
+            Assert.That(target.HasSkillsDirectory, Is.False);
+            Assert.That(target.HasExistingSkills, Is.False);
+        }
+
+        [Test]
+        public void CreateFirstInstallSkillTarget_WhenGroupingDisabled_KeepsTargetMetadata()
+        {
+            // Verifies grouping-off does not change target display/dir/flag metadata.
+            SkillSetupTargetInfo target =
+                SkillsSetupPanelView.CreateFirstInstallSkillTarget(SkillsTarget.Claude, false);
+
+            Assert.That(target.DisplayName, Is.EqualTo("Claude Code"));
+            Assert.That(target.DirName, Is.EqualTo(".claude"));
+            Assert.That(target.InstallFlag, Is.EqualTo("--claude"));
+        }
+
+        [Test]
+        public void GetSelectedSkillTargetInfo_WhenDetectedTargetExists_ReturnsDetectedState()
+        {
+            // Verifies a detected target wins over a synthetic first-install fallback.
+            List<SkillSetupTargetInfo> targets = new()
+            {
+                new(
+                    "Claude Code",
+                    ".claude",
+                    "--claude",
+                    hasSkillsDirectory: true,
+                    hasExistingSkills: true,
+                    installState: SkillInstallState.Installed)
+            };
+
+            SkillSetupTargetInfo target = SkillsSetupPanelView.GetSelectedSkillTargetInfo(
+                targets,
+                SkillsTarget.Claude,
+                groupSkillsUnderUnityCliLoop: true);
+
+            Assert.That(target.DirName, Is.EqualTo(".claude"));
+            Assert.That(target.InstallState, Is.EqualTo(SkillInstallState.Installed));
+        }
+
+        [Test]
+        public void BuildSingleTargetInstallList_WhenSelectedTargetIsInstalled_ReturnsEmpty()
+        {
+            // Verifies an already-installed selected target yields an empty install list.
+            List<SkillSetupTargetInfo> targets = new()
+            {
+                new(
+                    "Claude Code",
+                    ".claude",
+                    "--claude",
+                    hasSkillsDirectory: true,
+                    hasExistingSkills: true,
+                    installState: SkillInstallState.Installed)
+            };
+
+            List<SkillSetupTargetInfo> installableTargets =
+                SkillsSetupPanelView.BuildSingleTargetInstallList(
+                    targets,
+                    SkillsTarget.Claude,
+                    groupSkillsUnderUnityCliLoop: true);
+
+            Assert.That(installableTargets, Is.Empty);
+        }
+
+        [Test]
+        public void BuildSingleTargetInstallList_WhenSelectedTargetIsMissing_ReturnsMappedTarget()
+        {
+            // Verifies a missing selected target is mapped into a one-item install list.
+            List<SkillSetupTargetInfo> installableTargets =
+                SkillsSetupPanelView.BuildSingleTargetInstallList(
+                    new List<SkillSetupTargetInfo>(),
+                    SkillsTarget.Claude,
+                    groupSkillsUnderUnityCliLoop: true);
+
+            Assert.That(installableTargets.Count, Is.EqualTo(1));
+            Assert.That(installableTargets[0].DirName, Is.EqualTo(".claude"));
+            Assert.That(installableTargets[0].InstallState, Is.EqualTo(SkillInstallState.Missing));
+        }
+
+        [TestCase(SkillInstallState.Installed, false, true, "Installed")]
+        [TestCase(SkillInstallState.Checking, false, true, "Checking...")]
+        [TestCase(SkillInstallState.Outdated, false, true, "Outdated")]
+        [TestCase(SkillInstallState.Missing, false, true, "Missing")]
+        [TestCase(SkillInstallState.Missing, true, true, "Not grouped")]
+        [TestCase(SkillInstallState.Missing, true, false, "Grouped")]
+        public void GetSkillInstallStatusText_ReturnsExpectedLabel(
+            SkillInstallState installState,
+            bool hasDifferentLayoutSkills,
+            bool groupSkillsUnderUnityCliLoop,
+            string expectedLabel)
+        {
+            // Verifies each install state maps to the status label shown in the panel list.
+            string label = SkillsSetupPanelView.GetSkillInstallStatusText(
+                installState,
+                hasDifferentLayoutSkills,
+                groupSkillsUnderUnityCliLoop);
+
+            Assert.That(label, Is.EqualTo(expectedLabel));
+        }
+
+        [TestCase(SkillInstallState.Installed, false, "skill-target-item__status--installed")]
+        [TestCase(SkillInstallState.Checking, false, "skill-target-item__status--checking")]
+        [TestCase(SkillInstallState.Outdated, false, "skill-target-item__status--outdated")]
+        [TestCase(SkillInstallState.Missing, false, "skill-target-item__status--missing")]
+        [TestCase(SkillInstallState.Missing, true, "skill-target-item__status--different-layout")]
+        public void GetSkillInstallStatusClass_ReturnsExpectedClass(
+            SkillInstallState installState,
+            bool hasDifferentLayoutSkills,
+            string expectedClass)
+        {
+            // Verifies each skill install state maps to the shared panel status style class.
+            string className = SkillsSetupPanelView.GetSkillInstallStatusClass(
+                installState,
+                hasDifferentLayoutSkills);
+
+            Assert.That(className, Is.EqualTo(expectedClass));
+        }
+
+        [TestCase(false, false, SkillInstallState.Missing, "Install Skills")]
+        [TestCase(true, true, SkillInstallState.Missing, "Installing...")]
+        [TestCase(true, false, SkillInstallState.Checking, "Checking...")]
+        [TestCase(true, false, SkillInstallState.Outdated, "Update Skills")]
+        [TestCase(true, false, SkillInstallState.Missing, "Install Skills")]
+        [TestCase(true, false, SkillInstallState.Installed, "Installed")]
+        public void GetInstallSkillsButtonText_ReturnsExpectedText(
+            bool isCliInstalled,
+            bool isInstallingSkills,
+            SkillInstallState installState,
+            string expectedText)
+        {
+            // Verifies the single-target Install button text follows CLI and install state.
+            string text = SkillsSetupPanelView.GetInstallSkillsButtonText(
+                isCliInstalled,
+                isInstallingSkills,
+                installState);
+
+            Assert.That(text, Is.EqualTo(expectedText));
+        }
+
+        [TestCase(false, false, SkillInstallState.Missing, false)]
+        [TestCase(true, true, SkillInstallState.Missing, false)]
+        [TestCase(true, false, SkillInstallState.Checking, false)]
+        [TestCase(true, false, SkillInstallState.Installed, false)]
+        [TestCase(true, false, SkillInstallState.Outdated, true)]
+        [TestCase(true, false, SkillInstallState.Missing, true)]
+        public void IsInstallSkillsButtonEnabled_ReturnsExpectedValue(
+            bool isCliInstalled,
+            bool isInstallingSkills,
+            SkillInstallState installState,
+            bool expectedEnabled)
+        {
+            // Verifies the single-target Install button enablement follows only Skills state.
+            bool enabled = SkillsSetupPanelView.IsInstallSkillsButtonEnabled(
+                isCliInstalled,
+                isInstallingSkills,
+                installState);
+
+            Assert.That(enabled, Is.EqualTo(expectedEnabled));
+        }
+
+        [TestCase(false, false, false, "Install Skills")]
+        [TestCase(true, true, false, "Installing...")]
+        [TestCase(true, false, true, "Update Skills")]
+        [TestCase(true, false, false, "Install Skills")]
+        public void GetBulkInstallButtonText_ReturnsExpectedLabel(
+            bool canManageSkills,
+            bool isInstallingSkills,
+            bool hasOutdatedSkills,
+            string expectedLabel)
+        {
+            // Verifies the bulk Install button text for manageability, install, and outdated states.
+            string label = SkillsSetupPanelView.GetBulkInstallButtonText(
+                canManageSkills,
+                isInstallingSkills,
+                hasOutdatedSkills);
+
+            Assert.That(label, Is.EqualTo(expectedLabel));
+        }
+
+        [Test]
+        public void BuildInstalledSummaryText_ReturnsInstalledForNTargetsFormat()
+        {
+            // Verifies the status summary uses the shared "Installed for N targets" format.
+            string summary = SkillsSetupPanelView.BuildInstalledSummaryText(2);
+
+            Assert.That(summary, Is.EqualTo("Installed for 2 targets"));
+        }
+
+        [TestCase(0, true)]
+        [TestCase(1, false)]
+        [TestCase(3, false)]
+        public void ShouldExpandSpecificTargetFoldout_ReturnsExpectedValue(
+            int installableTargetCount,
+            bool expected)
+        {
+            // Verifies the specific-target foldout auto-expands only when no installable targets exist.
+            bool shouldExpand = SkillsSetupPanelView.ShouldExpandSpecificTargetFoldout(
+                installableTargetCount);
+
+            Assert.That(shouldExpand, Is.EqualTo(expected));
+        }
+    }
+}
diff --git a/Packages/src/Editor/Presentation/Setup/SetupWizardSkillsStepPresenter.cs.meta b/Assets/Tests/Editor/SkillsSetupPanelViewTests.cs.meta
similarity index 83%
rename from Packages/src/Editor/Presentation/Setup/SetupWizardSkillsStepPresenter.cs.meta
rename to Assets/Tests/Editor/SkillsSetupPanelViewTests.cs.meta
index 55265289e..5200fd0a8 100644
--- a/Packages/src/Editor/Presentation/Setup/SetupWizardSkillsStepPresenter.cs.meta
+++ b/Assets/Tests/Editor/SkillsSetupPanelViewTests.cs.meta
@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: f22074d3a0cc4d2895895bc150236085
+guid: 52e7a0e2d6aef4a949140eda5bc63834
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2
diff --git a/Assets/Tests/Editor/SkillsTargetSelectionResolverTests.cs b/Assets/Tests/Editor/SkillsTargetSelectionResolverTests.cs
index 0b9dc93d5..6ae6e7174 100644
--- a/Assets/Tests/Editor/SkillsTargetSelectionResolverTests.cs
+++ b/Assets/Tests/Editor/SkillsTargetSelectionResolverTests.cs
@@ -61,7 +61,8 @@ public void IsInstalled_ReturnsExpectedStateForTarget(
                 selectedTargetInstallState: SkillInstallState.Installed,
                 selectedTarget: target,
                 groupSkillsUnderUnityCliLoop: true,
-                isInstallingSkills: false);
+                isInstallingSkills: false,
+                installableSkillTargets: System.Array.Empty<SkillSetupTargetInfo>());
 
             bool isInstalled = SkillsTargetSelectionResolver.IsInstalled(data, target);
 
diff --git a/Assets/Tests/Editor/StaticFacadeStateGuardTests.cs b/Assets/Tests/Editor/StaticFacadeStateGuardTests.cs
index 1fac4292d..ca1b733df 100644
--- a/Assets/Tests/Editor/StaticFacadeStateGuardTests.cs
+++ b/Assets/Tests/Editor/StaticFacadeStateGuardTests.cs
@@ -93,7 +93,7 @@ public sealed class StaticFacadeStateGuardTests
             },
             {
                 "Packages/src/Editor/Presentation/UnityCliLoopSettingsSkillsPresenter.cs",
-                new[] { "GetSelectedTargetInstallStateForCurrentProject", "GetSelectedTargetInstallStateAtProjectRoot" }
+                new[] { "HandleInstallSkills", "HandleInstallAllSkills" }
             }
         };
 
diff --git a/Packages/src/Editor/Presentation/Setup/SetupWizardSkillsStepPresenter.cs b/Packages/src/Editor/Presentation/Setup/SetupWizardSkillsStepPresenter.cs
deleted file mode 100644
index b20c0a31d..000000000
--- a/Packages/src/Editor/Presentation/Setup/SetupWizardSkillsStepPresenter.cs
+++ /dev/null
@@ -1,325 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using UnityEngine;
-using UnityEngine.UIElements;
-
-using io.github.hatayama.UnityCliLoop.Domain;
-
-namespace io.github.hatayama.UnityCliLoop.Presentation
-{
-    /// <summary>
-    /// Presents the setup wizard skill installation step.
-    /// </summary>
-    internal sealed class SetupWizardSkillsStepPresenter
-    {
-        private readonly VisualElement _skillsTargetRow;
-        private readonly VisualElement _skillsTargetList;
-        private readonly VisualElement _skillsStatusDivider;
-        private readonly Label _skillsStatusLabel;
-        private readonly Button _installSkillsButton;
-
-        internal SetupWizardSkillsStepPresenter(
-            VisualElement skillsTargetRow,
-            VisualElement skillsTargetList,
-            VisualElement skillsStatusDivider,
-            Label skillsStatusLabel,
-            Button installSkillsButton,
-            System.Action onInstallSkillsClicked)
-        {
-            Debug.Assert(skillsTargetRow != null, "skillsTargetRow must not be null");
-            Debug.Assert(skillsTargetList != null, "skillsTargetList must not be null");
-            Debug.Assert(skillsStatusDivider != null, "skillsStatusDivider must not be null");
-            Debug.Assert(skillsStatusLabel != null, "skillsStatusLabel must not be null");
-            Debug.Assert(installSkillsButton != null, "installSkillsButton must not be null");
-            Debug.Assert(onInstallSkillsClicked != null, "onInstallSkillsClicked must not be null");
-
-            _skillsTargetRow = skillsTargetRow
-                ?? throw new System.ArgumentNullException(nameof(skillsTargetRow));
-            _skillsTargetList = skillsTargetList
-                ?? throw new System.ArgumentNullException(nameof(skillsTargetList));
-            _skillsStatusDivider = skillsStatusDivider
-                ?? throw new System.ArgumentNullException(nameof(skillsStatusDivider));
-            _skillsStatusLabel = skillsStatusLabel
-                ?? throw new System.ArgumentNullException(nameof(skillsStatusLabel));
-            _installSkillsButton = installSkillsButton
-                ?? throw new System.ArgumentNullException(nameof(installSkillsButton));
-            _installSkillsButton.clicked += onInstallSkillsClicked
-                ?? throw new System.ArgumentNullException(nameof(onInstallSkillsClicked));
-        }
-
-        internal void ShowChecking(bool shouldUseFirstInstallSkillsUi)
-        {
-            UpdateSkillsStatusLabel("Checking installed skills...");
-            _installSkillsButton.SetEnabled(false);
-            _installSkillsButton.text = "Checking...";
-            ViewDataBinder.SetVisible(_skillsTargetRow, shouldUseFirstInstallSkillsUi);
-            ViewDataBinder.SetVisible(_skillsTargetList, !shouldUseFirstInstallSkillsUi);
-            _skillsTargetList.Clear();
-        }
-
-        internal void Update(
-            bool canManageSkills,
-            List<SkillSetupTargetInfo> targets,
-            bool shouldUseFirstInstallSkillsUi,
-            SkillsTarget selectedTarget,
-            bool groupSkillsUnderUnityCliLoop,
-            bool isInstallingSkills)
-        {
-            List<SkillSetupTargetInfo> installableTargets = FilterInstallableSkillTargets(targets);
-            _skillsTargetList.Clear();
-            ViewDataBinder.SetVisible(
-                _skillsTargetRow,
-                ShouldShowSkillsTargetRowForSetupWizard(shouldUseFirstInstallSkillsUi));
-            ViewDataBinder.SetVisible(
-                _skillsTargetList,
-                ShouldShowSkillsTargetListForSetupWizard(canManageSkills, shouldUseFirstInstallSkillsUi));
-
-            if (!canManageSkills)
-            {
-                UpdateSkillsStatusLabel(string.Empty);
-                _installSkillsButton.SetEnabled(false);
-                _installSkillsButton.text = GetSkillsButtonTextForSetupWizard(
-                    cliInstalled: false,
-                    isInstallingSkills,
-                    hasOutdatedSkills: false);
-                return;
-            }
-
-            if (shouldUseFirstInstallSkillsUi)
-            {
-                SkillSetupTargetInfo selectedTargetInfo = GetSelectedSkillTargetInfo(
-                    targets,
-                    selectedTarget,
-                    groupSkillsUnderUnityCliLoop);
-                UpdateSkillsStatusLabel(string.Empty);
-                _installSkillsButton.text = CliSetupSection.GetInstallSkillsButtonText(
-                    isCliInstalled: true,
-                    isInstallingSkills,
-                    selectedTargetInfo.InstallState);
-                _installSkillsButton.SetEnabled(CliSetupSection.IsInstallSkillsButtonEnabled(
-                    isCliInstalled: true,
-                    isInstallingSkills,
-                    selectedTargetInfo.InstallState));
-                return;
-            }
-
-            foreach (SkillSetupTargetInfo target in installableTargets)
-            {
-                VisualElement item = new();
-                item.AddToClassList("setup-target-item");
-
-                Label nameLabel = new($"{target.DisplayName} ({target.DirName}/)");
-                nameLabel.AddToClassList("setup-target-item__label");
-                item.Add(nameLabel);
-
-                Label statusLabel = new(GetSkillInstallStatusText(
-                    target.InstallState,
-                    target.HasDifferentLayoutSkills,
-                    groupSkillsUnderUnityCliLoop));
-                statusLabel.AddToClassList("setup-target-item__status");
-                statusLabel.AddToClassList(GetSkillInstallStatusClass(
-                    target.InstallState,
-                    target.HasDifferentLayoutSkills));
-                item.Add(statusLabel);
-
-                _skillsTargetList.Add(item);
-            }
-
-            bool isCheckingSkills = installableTargets.Any(
-                t => t.InstallState == SkillInstallState.Checking);
-            if (isCheckingSkills)
-            {
-                UpdateSkillsStatusLabel("Checking installed skills...");
-                _installSkillsButton.SetEnabled(false);
-                _installSkillsButton.text = "Checking...";
-                return;
-            }
-
-            bool allSkillsInstalled = installableTargets.All(
-                t => t.InstallState == SkillInstallState.Installed);
-            if (allSkillsInstalled)
-            {
-                UpdateSkillsStatusLabel($"Installed for {installableTargets.Count} targets");
-                _installSkillsButton.SetEnabled(false);
-                _installSkillsButton.text = "Installed";
-            }
-            else
-            {
-                bool hasOutdatedSkills = installableTargets.Any(
-                    t => t.InstallState == SkillInstallState.Outdated);
-                UpdateSkillsStatusLabel(string.Empty);
-                _installSkillsButton.SetEnabled(!isInstallingSkills);
-                _installSkillsButton.text = GetSkillsButtonTextForSetupWizard(
-                    cliInstalled: true,
-                    isInstallingSkills,
-                    hasOutdatedSkills);
-            }
-        }
-
-        internal static List<SkillSetupTargetInfo> FilterInstallableSkillTargets(
-            IEnumerable<SkillSetupTargetInfo> targets)
-        {
-            Debug.Assert(targets != null, "targets must not be null");
-            return targets
-                .Where(target => target.HasSkillsDirectory)
-                .ToList();
-        }
-
-        /// <summary>
-        /// Resolves whether the setup wizard should show the first-install skill UI.
-        /// </summary>
-        internal static bool ResolveUseFirstInstallSkillsUi(
-            bool shouldUseFirstInstallSkillsUi,
-            int installableTargetCount)
-        {
-            Debug.Assert(installableTargetCount >= 0, "installableTargetCount must not be negative");
-            return shouldUseFirstInstallSkillsUi || installableTargetCount == 0;
-        }
-
-        internal static bool ShouldShowSkillsTargetRowForSetupWizard(bool shouldUseFirstInstallSkillsUi)
-        {
-            return shouldUseFirstInstallSkillsUi;
-        }
-
-        internal static bool ShouldShowSkillsTargetListForSetupWizard(
-            bool canManageSkills,
-            bool shouldUseFirstInstallSkillsUi)
-        {
-            return canManageSkills && !shouldUseFirstInstallSkillsUi;
-        }
-
-        internal static SkillSetupTargetInfo CreateFirstInstallSkillTarget(
-            SkillsTarget target,
-            bool groupSkillsUnderUnityCliLoop)
-        {
-            SkillsTargetSelection selection = SkillsTargetSelectionResolver.Resolve(
-                target,
-                groupSkillsUnderUnityCliLoop);
-            return new(
-                selection.DisplayName,
-                selection.DirectoryName,
-                selection.InstallFlag,
-                hasSkillsDirectory: false,
-                hasExistingSkills: false,
-                hasDifferentLayoutSkills: false,
-                SkillInstallState.Missing);
-        }
-
-        internal static SkillSetupTargetInfo GetSelectedSkillTargetInfo(
-            IEnumerable<SkillSetupTargetInfo> targets,
-            SkillsTarget target,
-            bool groupSkillsUnderUnityCliLoop)
-        {
-            Debug.Assert(targets != null, "targets must not be null");
-
-            SkillsTargetSelection selection = SkillsTargetSelectionResolver.Resolve(
-                target,
-                groupSkillsUnderUnityCliLoop);
-            SkillSetupTargetInfo selectedTargetInfo = targets
-                .FirstOrDefault(info => info.DirName == selection.DirectoryName);
-            return string.IsNullOrEmpty(selectedTargetInfo.DirName)
-                ? CreateFirstInstallSkillTarget(target, groupSkillsUnderUnityCliLoop)
-                : selectedTargetInfo;
-        }
-
-        internal static List<SkillSetupTargetInfo> GetFirstInstallableSkillTargets(
-            IEnumerable<SkillSetupTargetInfo> targets,
-            SkillsTarget target,
-            bool groupSkillsUnderUnityCliLoop)
-        {
-            SkillSetupTargetInfo selectedTargetInfo = GetSelectedSkillTargetInfo(
-                targets,
-                target,
-                groupSkillsUnderUnityCliLoop);
-            return selectedTargetInfo.InstallState == SkillInstallState.Installed
-                   || selectedTargetInfo.InstallState == SkillInstallState.Checking
-                ? new List<SkillSetupTargetInfo>()
-                : new List<SkillSetupTargetInfo> { selectedTargetInfo };
-        }
-
-        internal static string GetSkillsButtonTextForSetupWizard(
-            bool cliInstalled,
-            bool isInstallingSkills,
-            bool hasOutdatedSkills)
-        {
-            return !cliInstalled
-                ? "Install Skills"
-                : GetInstallSkillsButtonText(isInstallingSkills, hasOutdatedSkills);
-        }
-
-        internal static string GetInstallSkillsButtonText(
-            bool isInstallingSkills,
-            bool hasOutdatedSkills)
-        {
-            if (isInstallingSkills)
-            {
-                return "Installing...";
-            }
-
-            return hasOutdatedSkills ? "Update Skills" : "Install Skills";
-        }
-
-        internal static string GetSkillInstallStatusText(
-            SkillInstallState installState,
-            bool hasDifferentLayoutSkills,
-            bool groupSkillsUnderUnityCliLoop)
-        {
-            if (installState == SkillInstallState.Checking)
-            {
-                return "Checking...";
-            }
-
-            if (installState == SkillInstallState.Installed)
-            {
-                return "Installed";
-            }
-
-            if (installState == SkillInstallState.Outdated)
-            {
-                return "Outdated";
-            }
-
-            if (!hasDifferentLayoutSkills)
-            {
-                return "Missing";
-            }
-
-            return groupSkillsUnderUnityCliLoop ? "Not grouped" : "Grouped";
-        }
-
-        internal static string GetSkillInstallStatusClass(
-            SkillInstallState installState,
-            bool hasDifferentLayoutSkills)
-        {
-            if (installState == SkillInstallState.Checking)
-            {
-                return "setup-target-item__status--checking";
-            }
-
-            if (installState == SkillInstallState.Installed)
-            {
-                return "setup-target-item__status--installed";
-            }
-
-            if (installState == SkillInstallState.Outdated)
-            {
-                return "setup-target-item__status--outdated";
-            }
-
-            if (!hasDifferentLayoutSkills)
-            {
-                return "setup-target-item__status--missing";
-            }
-
-            return "setup-target-item__status--different-layout";
-        }
-
-        private void UpdateSkillsStatusLabel(string text)
-        {
-            _skillsStatusLabel.text = text;
-            bool isVisible = !string.IsNullOrEmpty(text);
-            ViewDataBinder.SetVisible(_skillsStatusDivider, isVisible);
-            ViewDataBinder.SetVisible(_skillsStatusLabel, isVisible);
-        }
-    }
-}
diff --git a/Packages/src/Editor/Presentation/Setup/SetupWizardSkillsWorkflowController.cs b/Packages/src/Editor/Presentation/Setup/SetupWizardSkillsWorkflowController.cs
index 5f4a93e72..573eca952 100644
--- a/Packages/src/Editor/Presentation/Setup/SetupWizardSkillsWorkflowController.cs
+++ b/Packages/src/Editor/Presentation/Setup/SetupWizardSkillsWorkflowController.cs
@@ -4,7 +4,6 @@
 using System.Threading.Tasks;
 
 using UnityEditor;
-using UnityEditor.UIElements;
 using UnityEngine;
 using UnityEngine.UIElements;
 
@@ -19,55 +18,33 @@ namespace io.github.hatayama.UnityCliLoop.Presentation
     /// </summary>
     internal sealed class SetupWizardSkillsWorkflowController
     {
-        private readonly VisualElement _groupSkillsRow;
-        private readonly EnumField _skillsTargetField;
-        private readonly Toggle _groupSkillsToggle;
-        private readonly Label _groupSkillsLabel;
-        private readonly SetupWizardSkillsStepPresenter _skillsStepPresenter;
+        private readonly SkillsSetupPanelView _skillsSetupPanelView;
         private readonly SkillSetupUseCase _skillSetupUseCase;
         private readonly IUnityCliLoopEditorSettingsPort _editorSettingsPort;
         private readonly CliSetupApplicationService _cliSetupApplicationService;
         private readonly Action _scheduleResizeToContent;
 
         private bool _isInstallingSkills;
-        private bool _isSkillsTargetFieldInitialized;
-        private bool _shouldUseFirstInstallSkillsUi;
         private bool _installSkillsFlat;
         private CancellationTokenSource _skillInstallStateRefreshCts;
         private SkillsTarget _skillsTarget = SkillsTarget.Claude;
+        private List<SkillSetupTargetInfo> _latestTargets = new();
 
         internal SetupWizardSkillsWorkflowController(
-            VisualElement groupSkillsRow,
-            EnumField skillsTargetField,
-            Toggle groupSkillsToggle,
-            Label groupSkillsLabel,
-            VisualElement skillsTargetRow,
-            VisualElement skillsTargetList,
-            VisualElement skillsStatusDivider,
-            Label skillsStatusLabel,
-            Button installSkillsButton,
+            SkillsSetupPanelView skillsSetupPanelView,
             SkillSetupUseCase skillSetupUseCase,
             IUnityCliLoopEditorSettingsPort editorSettingsPort,
             CliSetupApplicationService cliSetupApplicationService,
-            Action scheduleResizeToContent,
-            string lastSeenSetupWizardVersionBeforeOpen)
+            Action scheduleResizeToContent)
         {
-            Debug.Assert(groupSkillsRow != null, "groupSkillsRow must not be null");
-            Debug.Assert(skillsTargetField != null, "skillsTargetField must not be null");
-            Debug.Assert(groupSkillsToggle != null, "groupSkillsToggle must not be null");
-            Debug.Assert(groupSkillsLabel != null, "groupSkillsLabel must not be null");
+            Debug.Assert(skillsSetupPanelView != null, "skillsSetupPanelView must not be null");
             Debug.Assert(skillSetupUseCase != null, "skillSetupUseCase must not be null");
             Debug.Assert(editorSettingsPort != null, "editorSettingsPort must not be null");
             Debug.Assert(cliSetupApplicationService != null, "cliSetupApplicationService must not be null");
             Debug.Assert(scheduleResizeToContent != null, "scheduleResizeToContent must not be null");
 
-            _groupSkillsRow = groupSkillsRow ?? throw new ArgumentNullException(nameof(groupSkillsRow));
-            _skillsTargetField = skillsTargetField
-                ?? throw new ArgumentNullException(nameof(skillsTargetField));
-            _groupSkillsToggle = groupSkillsToggle
-                ?? throw new ArgumentNullException(nameof(groupSkillsToggle));
-            _groupSkillsLabel = groupSkillsLabel
-                ?? throw new ArgumentNullException(nameof(groupSkillsLabel));
+            _skillsSetupPanelView = skillsSetupPanelView
+                ?? throw new ArgumentNullException(nameof(skillsSetupPanelView));
             _skillSetupUseCase = skillSetupUseCase
                 ?? throw new ArgumentNullException(nameof(skillSetupUseCase));
             _editorSettingsPort = editorSettingsPort
@@ -77,52 +54,27 @@ internal SetupWizardSkillsWorkflowController(
             _scheduleResizeToContent = scheduleResizeToContent
                 ?? throw new ArgumentNullException(nameof(scheduleResizeToContent));
 
-            _skillsStepPresenter = new SetupWizardSkillsStepPresenter(
-                skillsTargetRow,
-                skillsTargetList,
-                skillsStatusDivider,
-                skillsStatusLabel,
-                installSkillsButton,
-                HandleInstallSkills);
-
-            InitializeFirstInstallSkillsUiState(lastSeenSetupWizardVersionBeforeOpen);
-        }
-
-        internal void InitializeSkillsTargetField()
-        {
-            if (_isSkillsTargetFieldInitialized) return;
-
-            _skillsTargetField.Init(_skillsTarget);
-            _skillsTargetField.RegisterValueChangedCallback(evt =>
-            {
-                if (evt.newValue is SkillsTarget newTarget)
-                {
-                    _skillsTarget = newTarget;
-                    RefreshSkillsSection();
-                }
-            });
-            _isSkillsTargetFieldInitialized = true;
+            _skillsSetupPanelView.OnInstallAllClicked += HandleInstallAllSkills;
+            _skillsSetupPanelView.OnInstallSelectedClicked += HandleInstallSelectedSkills;
+            _skillsSetupPanelView.OnRefreshClicked += RefreshSkillsSection;
+            _skillsSetupPanelView.OnTargetChanged += HandleTargetChanged;
+            _skillsSetupPanelView.OnGroupSkillsChanged += HandleGroupSkillsChanged;
         }
 
         internal void InitializeGroupSkillsToggle()
         {
             ApplyFlatSkillInstallPreference();
-            ViewDataBinder.SetVisible(_groupSkillsRow, false);
-            _groupSkillsToggle.SetValueWithoutNotify(!_installSkillsFlat);
-            _groupSkillsToggle.RegisterValueChangedCallback(evt =>
-            {
-                evt.StopPropagation();
-                ApplyFlatSkillInstallPreference();
-                RefreshSkillsSection();
-            });
-            _groupSkillsLabel.RegisterCallback<ClickEvent>(HandleGroupSkillsRowClicked);
+            _skillsSetupPanelView.UpdateGroupSkillsToggle(
+                groupSkillsUnderUnityCliLoop: !_installSkillsFlat,
+                isEnabled: false);
         }
 
         internal void ShowChecking()
         {
-            ViewDataBinder.SetVisible(_groupSkillsRow, false);
-            _groupSkillsToggle.SetEnabled(false);
-            _skillsStepPresenter.ShowChecking(_shouldUseFirstInstallSkillsUi);
+            _skillsSetupPanelView.UpdateGroupSkillsToggle(
+                groupSkillsUnderUnityCliLoop: !_installSkillsFlat,
+                isEnabled: false);
+            _skillsSetupPanelView.ShowChecking();
         }
 
         internal void RefreshSkillsSection()
@@ -158,12 +110,6 @@ internal void CancelSkillInstallStateRefresh()
             _skillInstallStateRefreshCts = null;
         }
 
-        private void InitializeFirstInstallSkillsUiState(string lastSeenSetupWizardVersionBeforeOpen)
-        {
-            _shouldUseFirstInstallSkillsUi = SetupWizardWindow.ShouldUseFirstInstallSkillsUi(
-                lastSeenSetupWizardVersionBeforeOpen);
-        }
-
         private List<SkillSetupTargetInfo> DetectDisplayedSkillTargets(string projectRoot)
         {
             return _skillSetupUseCase.DetectSkillTargetsForLayoutAtProjectRoot(projectRoot, !_installSkillsFlat);
@@ -205,49 +151,81 @@ private void UpdateSkillsStep(
             bool canManageSkills,
             List<SkillSetupTargetInfo> targets)
         {
+            _latestTargets = targets;
             List<SkillSetupTargetInfo> installableTargets =
-                SetupWizardSkillsStepPresenter.FilterInstallableSkillTargets(targets);
-            _shouldUseFirstInstallSkillsUi = SetupWizardSkillsStepPresenter.ResolveUseFirstInstallSkillsUi(
-                _shouldUseFirstInstallSkillsUi,
-                installableTargets.Count);
-            _groupSkillsToggle.SetEnabled(canManageSkills && !_isInstallingSkills);
-            _skillsStepPresenter.Update(
+                SkillsSetupPanelView.FilterInstallableSkillTargets(targets);
+            bool groupSkillsUnderUnityCliLoop = !_installSkillsFlat;
+            _skillsSetupPanelView.UpdateGroupSkillsToggle(
+                groupSkillsUnderUnityCliLoop,
+                canManageSkills && !_isInstallingSkills);
+            _skillsSetupPanelView.UpdateStatusPanel(
                 canManageSkills,
+                installableTargets,
+                groupSkillsUnderUnityCliLoop,
+                _isInstallingSkills);
+
+            SkillSetupTargetInfo selectedTargetInfo = SkillsSetupPanelView.GetSelectedSkillTargetInfo(
                 targets,
-                _shouldUseFirstInstallSkillsUi,
                 _skillsTarget,
-                !_installSkillsFlat,
+                groupSkillsUnderUnityCliLoop);
+            _skillsSetupPanelView.UpdateSelectedTargetInstall(
+                _skillsTarget,
+                selectedTargetInfo.InstallState,
+                isCliInstalled: canManageSkills,
                 _isInstallingSkills);
         }
 
-        private void HandleInstallSkills()
+        private void HandleInstallAllSkills()
         {
-            HandleInstallSkillsAsync(CancellationToken.None).Forget();
+            HandleInstallSkillsAsync(isBulkInstall: true, CancellationToken.None).Forget();
         }
 
-        private async Task HandleInstallSkillsAsync(CancellationToken ct)
+        private void HandleInstallSelectedSkills()
         {
-            CancelSkillInstallStateRefresh();
-            string projectRoot = UnityCliLoopPathResolver.GetProjectRoot();
-            List<SkillSetupTargetInfo> targets = DetectDisplayedSkillTargets(projectRoot);
-            List<SkillSetupTargetInfo> installableTargets = _shouldUseFirstInstallSkillsUi
-                ? SetupWizardSkillsStepPresenter.GetFirstInstallableSkillTargets(
-                    targets,
-                    _skillsTarget,
-                    !_installSkillsFlat)
-                : SetupWizardSkillsStepPresenter.FilterInstallableSkillTargets(targets);
-            if (installableTargets.Count == 0) return;
-
-            bool shouldShowSkillsInstalledDialog =
-                SkillInstallDialogPolicy.ShouldShowForInstallableTargets(installableTargets);
+            HandleInstallSkillsAsync(isBulkInstall: false, CancellationToken.None).Forget();
+        }
+
+        private async Task HandleInstallSkillsAsync(bool isBulkInstall, CancellationToken ct)
+        {
+            if (_isInstallingSkills)
+            {
+                return;
+            }
+
+            // Latch before the first await so a second Install click cannot start a parallel install.
             _isInstallingSkills = true;
-            UpdateSkillsStep(true, targets);
+            CancelSkillInstallStateRefresh();
+            UpdateSkillsStep(true, _latestTargets);
 
             try
             {
+                string projectRoot = UnityCliLoopPathResolver.GetProjectRoot();
+                List<SkillSetupTargetInfo> targets =
+                    await Task.Run(() => DetectDisplayedSkillTargets(projectRoot));
+                if (ct.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                bool groupSkillsUnderUnityCliLoop = !_installSkillsFlat;
+                List<SkillSetupTargetInfo> installableTargets = isBulkInstall
+                    ? SkillsSetupPanelView.FilterInstallableSkillTargets(targets)
+                    : SkillsSetupPanelView.BuildSingleTargetInstallList(
+                        targets,
+                        _skillsTarget,
+                        groupSkillsUnderUnityCliLoop);
+                if (installableTargets.Count == 0)
+                {
+                    return;
+                }
+
+                bool shouldShowSkillsInstalledDialog =
+                    SkillInstallDialogPolicy.ShouldShowForInstallableTargets(installableTargets);
+                UpdateSkillsStep(true, targets);
+
                 await _skillSetupUseCase.InstallSkillFilesAsync(
                     installableTargets,
-                    !_installSkillsFlat,
+                    groupSkillsUnderUnityCliLoop,
                     ct);
                 if (shouldShowSkillsInstalledDialog)
                 {
@@ -261,21 +239,17 @@ await _skillSetupUseCase.InstallSkillFilesAsync(
             }
         }
 
-        private void HandleGroupSkillsRowClicked(ClickEvent evt)
+        private void HandleTargetChanged(SkillsTarget newTarget)
         {
-            evt.StopPropagation();
-            if (!_groupSkillsToggle.enabledSelf)
-            {
-                return;
-            }
-
-            if (evt.target is VisualElement targetElement && _groupSkillsToggle.Contains(targetElement))
-            {
-                return;
-            }
+            _skillsTarget = newTarget;
+            string cachedCliVersion = _cliSetupApplicationService.GetCachedCliVersion();
+            bool canManageSkills = SetupWizardWindow.CanManageSkills(IsCliInstalled(cachedCliVersion));
+            UpdateSkillsStep(canManageSkills, _latestTargets);
+            _scheduleResizeToContent();
+        }
 
-            bool newValue = !_groupSkillsToggle.value;
-            _groupSkillsToggle.SetValueWithoutNotify(newValue);
+        private void HandleGroupSkillsChanged(bool _)
+        {
             ApplyFlatSkillInstallPreference();
             RefreshSkillsSection();
         }
diff --git a/Packages/src/Editor/Presentation/Setup/SetupWizardWindow.cs b/Packages/src/Editor/Presentation/Setup/SetupWizardWindow.cs
index a5e9cc186..22328029b 100644
--- a/Packages/src/Editor/Presentation/Setup/SetupWizardWindow.cs
+++ b/Packages/src/Editor/Presentation/Setup/SetupWizardWindow.cs
@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 
 using UnityEditor;
-using UnityEditor.UIElements;
 using UnityEngine;
 using UnityEngine.UIElements;
 using RuntimePlatform = UnityEngine.RuntimePlatform;
@@ -20,6 +19,8 @@ public class SetupWizardWindow : EditorWindow
         private const string WindowTitle = "Unity CLI Loop Setup";
         private const string UXML_RELATIVE_PATH = "Editor/Presentation/Setup/SetupWizardWindow.uxml";
         private const string USS_RELATIVE_PATH = "Editor/Presentation/Setup/SetupWizardWindow.uss";
+        private const string SKILLS_PANEL_UXML_RELATIVE_PATH = "Editor/Presentation/Shared/SkillsSetupPanel.uxml";
+        private const string SKILLS_PANEL_USS_RELATIVE_PATH = "Editor/Presentation/Shared/SkillsSetupPanel.uss";
         private const string GITHUB_ICON_RELATIVE_PATH = "Editor/Presentation/Setup/GitHub_Invertocat_White.png";
         internal const bool ForceFlatSkillInstall = true;
         private static IUnityCliLoopEditorSettingsPort RegisteredEditorSettingsPort;
@@ -111,8 +112,6 @@ private static void ShowWindowInternal(bool shouldRecordVersion)
                 return;
             }
 
-            string lastSeenSetupWizardVersionBeforeOpen =
-                GetEditorSettingsPort().GetLastSeenSetupWizardVersion();
             Rect windowPosition = SetupWizardWindowResizer.CreateCenteredRect(
                 EditorGUIUtility.GetMainWindowPosition(),
                 SetupWizardWindowResizer.MinimumWindowSize);
@@ -121,7 +120,6 @@ private static void ShowWindowInternal(bool shouldRecordVersion)
                 window,
                 WindowTitle,
                 windowPosition,
-                lastSeenSetupWizardVersionBeforeOpen,
                 shouldRecordVersion);
             window.ShowUtility();
             window.ScheduleResizeToContent();
@@ -159,7 +157,6 @@ internal static void PrepareForOpen(
             SetupWizardWindow window,
             string title,
             Rect position,
-            string lastSeenSetupWizardVersionBeforeOpen,
             bool shouldRecordVersionAfterCreateGui)
         {
             Debug.Assert(window != null, "window must not be null");
@@ -167,8 +164,6 @@ internal static void PrepareForOpen(
 
             window.titleContent = new GUIContent(title);
             window.position = position;
-            window._lastSeenSetupWizardVersionBeforeOpen =
-                lastSeenSetupWizardVersionBeforeOpen ?? string.Empty;
             window._shouldRecordLastSeenVersionAfterCreateGui = shouldRecordVersionAfterCreateGui;
         }
 
@@ -218,8 +213,6 @@ private static SkillSetupUseCase GetSkillSetupUseCase()
         private ScrollView _mainScrollView;
         private SetupWizardWorkflowController _controller;
 
-        [SerializeField]
-        private string _lastSeenSetupWizardVersionBeforeOpen = string.Empty;
         [SerializeField]
         private bool _shouldRecordLastSeenVersionAfterCreateGui;
         private SkillSetupUseCase _skillSetupUseCase;
@@ -276,6 +269,24 @@ private void LoadLayout()
             StyleSheet styleSheet = AssetDatabase.LoadAssetAtPath<StyleSheet>(ussPath);
             Debug.Assert(styleSheet != null, $"USS not found at {ussPath}");
             rootVisualElement.styleSheets.Add(styleSheet);
+
+            VisualElement skillsPanelPlaceholder =
+                rootVisualElement.Q<VisualElement>("skills-setup-panel-placeholder");
+            Debug.Assert(skillsPanelPlaceholder != null, "skills-setup-panel-placeholder must not be null");
+
+            string skillsPanelUxmlPath =
+                $"{UnityCliLoopConstants.PackageAssetPath}/{SKILLS_PANEL_UXML_RELATIVE_PATH}";
+            VisualTreeAsset skillsPanelTree =
+                AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(skillsPanelUxmlPath);
+            Debug.Assert(skillsPanelTree != null, $"UXML not found at {skillsPanelUxmlPath}");
+            skillsPanelTree.CloneTree(skillsPanelPlaceholder);
+
+            string skillsPanelUssPath =
+                $"{UnityCliLoopConstants.PackageAssetPath}/{SKILLS_PANEL_USS_RELATIVE_PATH}";
+            StyleSheet skillsPanelStyleSheet =
+                AssetDatabase.LoadAssetAtPath<StyleSheet>(skillsPanelUssPath);
+            Debug.Assert(skillsPanelStyleSheet != null, $"USS not found at {skillsPanelUssPath}");
+            rootVisualElement.styleSheets.Add(skillsPanelStyleSheet);
         }
 
         private void BindElements()
@@ -290,15 +301,9 @@ private void BindElements()
             VisualElement installProgressContainer = rootVisualElement.Q<VisualElement>("cli-install-progress");
             Label installProgressLabel = rootVisualElement.Q<Label>("cli-install-progress-label");
 
-            VisualElement groupSkillsRow = rootVisualElement.Q<VisualElement>("group-skills-row");
-            EnumField skillsTargetField = rootVisualElement.Q<EnumField>("skills-target-field");
-            Toggle groupSkillsToggle = rootVisualElement.Q<Toggle>("group-skills-toggle");
-            Label groupSkillsLabel = rootVisualElement.Q<Label>("group-skills-label");
-            VisualElement skillsTargetRow = rootVisualElement.Q<VisualElement>("skills-target-row");
-            VisualElement skillsTargetList = rootVisualElement.Q<VisualElement>("skills-target-list");
-            VisualElement skillsStatusDivider = rootVisualElement.Q<VisualElement>("skills-status-divider");
-            Label skillsStatusLabel = rootVisualElement.Q<Label>("skills-status-label");
-            Button installSkillsButton = rootVisualElement.Q<Button>("install-skills-button");
+            VisualElement skillsSetupPanel = rootVisualElement.Q<VisualElement>("skills-setup-panel");
+            Debug.Assert(skillsSetupPanel != null, "skills-setup-panel must not be null");
+            SkillsSetupPanelView skillsSetupPanelView = new(skillsSetupPanel);
 
             _suppressAutoShowToggle = rootVisualElement.Q<Toggle>("suppress-auto-show-toggle");
             _openSettingsButton = rootVisualElement.Q<Button>("open-settings-button");
@@ -317,27 +322,17 @@ private void BindElements()
                 installCliButton,
                 installProgressContainer,
                 installProgressLabel,
-                groupSkillsRow,
-                skillsTargetField,
-                groupSkillsToggle,
-                groupSkillsLabel,
-                skillsTargetRow,
-                skillsTargetList,
-                skillsStatusDivider,
-                skillsStatusLabel,
-                installSkillsButton,
+                skillsSetupPanelView,
                 _suppressAutoShowToggle,
                 _skillSetupUseCase,
                 _editorSettingsPort,
                 _cliSetupApplicationService,
-                ScheduleResizeToContent,
-                _lastSeenSetupWizardVersionBeforeOpen);
+                ScheduleResizeToContent);
         }
 
         private void BindEvents()
         {
             _refreshButton.clicked += () => _controller.RefreshUI();
-            _controller.InitializeSkillsTargetField();
             _controller.InitializeGroupSkillsToggle();
             _suppressAutoShowToggle.RegisterValueChangedCallback(evt => HandleSuppressAutoShowChanged(evt.newValue));
             _openSettingsButton.clicked += HandleOpenSettings;
@@ -375,11 +370,6 @@ internal static bool ShouldShowSkillsInstalledDialog(
             return SkillInstallDialogPolicy.ShouldShowForInstallableTargets(targets);
         }
 
-        internal static bool ShouldUseFirstInstallSkillsUi(string lastSeenSetupWizardVersion)
-        {
-            return string.IsNullOrEmpty(lastSeenSetupWizardVersion);
-        }
-
         internal static bool CanManageSkills(bool cliInstalled)
         {
             return cliInstalled;
diff --git a/Packages/src/Editor/Presentation/Setup/SetupWizardWindow.uss b/Packages/src/Editor/Presentation/Setup/SetupWizardWindow.uss
index 8813abbdd..4d489b577 100644
--- a/Packages/src/Editor/Presentation/Setup/SetupWizardWindow.uss
+++ b/Packages/src/Editor/Presentation/Setup/SetupWizardWindow.uss
@@ -156,87 +156,6 @@
     background-color: var(--setup-color-success);
 }
 
-/* ===========================================
-   Block: Target
-   =========================================== */
-.setup-target-row {
-    flex-direction: row;
-    align-items: center;
-    margin-bottom: 6px;
-    overflow: hidden;
-}
-
-.setup-target-row__label {
-    width: 50px;
-    flex-shrink: 0;
-    margin-right: 6px;
-}
-
-.setup-target-row__field {
-    flex-grow: 1;
-    flex-shrink: 1;
-    min-width: 0;
-    overflow: hidden;
-}
-
-.setup-target-list {
-    margin-bottom: 6px;
-}
-
-.setup-toggle-row {
-    flex-direction: row;
-    align-items: center;
-    margin-bottom: 6px;
-}
-
-.setup-toggle-row__toggle {
-    width: 20px;
-    margin-right: 4px;
-}
-
-.setup-toggle-row__label {
-    flex-grow: 1;
-    white-space: normal;
-}
-
-.setup-target-item {
-    flex-direction: row;
-    align-items: center;
-    justify-content: space-between;
-    margin-bottom: 2px;
-    margin-left: 4px;
-}
-
-.setup-target-item__label {
-    flex-grow: 1;
-    margin-right: 8px;
-}
-
-.setup-target-item__status {
-    flex-shrink: 0;
-    -unity-font-style: bold;
-}
-
-.setup-target-item__status--installed {
-    color: var(--setup-color-success);
-}
-
-.setup-target-item__status--checking {
-    color: var(--setup-color-muted);
-}
-
-.setup-target-item__status--outdated {
-    color: var(--setup-color-warning);
-}
-
-.setup-target-item__status--missing {
-    color: var(--setup-color-muted);
-}
-
-.setup-target-item__status--different-layout {
-    color: var(--setup-color-warning);
-}
-
 /* ===========================================
    Block: Button
    =========================================== */
@@ -297,13 +216,6 @@
     margin-top: 4px;
 }
 
-.setup-step__divider {
-    border-top-width: 1px;
-    border-top-color: rgba(255, 255, 255, 0.12);
-    margin-top: 6px;
-    margin-bottom: 12px;
-}
-
 /* ===========================================
    Block: Footer
    =========================================== */
diff --git a/Packages/src/Editor/Presentation/Setup/SetupWizardWindow.uxml b/Packages/src/Editor/Presentation/Setup/SetupWizardWindow.uxml
index 3975d8388..a961e530f 100644
--- a/Packages/src/Editor/Presentation/Setup/SetupWizardWindow.uxml
+++ b/Packages/src/Editor/Presentation/Setup/SetupWizardWindow.uxml
@@ -30,23 +30,7 @@
         <ui:VisualElement name="step-2" class="setup-step">
             <ui:Label text="Step 2: Install Skills (Optional)" class="setup-step__title" />
             <ui:VisualElement class="setup-step__content">
-                <ui:VisualElement name="group-skills-row" class="setup-toggle-row">
-                    <ui:Toggle name="group-skills-toggle" class="setup-toggle-row__toggle" />
-                    <ui:Label
-                        name="group-skills-label"
-                        text="Group in subfolder"
-                        class="setup-toggle-row__label" />
-                </ui:VisualElement>
-                <ui:VisualElement name="skills-target-row" class="setup-target-row">
-                    <ui:Label text="Target:" class="setup-target-row__label" />
-                    <uie:EnumField name="skills-target-field" class="setup-target-row__field" />
-                </ui:VisualElement>
-                <ui:VisualElement name="skills-target-list" class="setup-target-list" />
-                <ui:VisualElement name="skills-status-divider" class="setup-step__divider" />
-                <ui:Label name="skills-status-label" text="" class="setup-step__status-label" />
-                <ui:VisualElement class="setup-step__button-row">
-                    <ui:Button name="install-skills-button" text="Install Skills" class="setup-button" />
-                </ui:VisualElement>
+                <ui:VisualElement name="skills-setup-panel-placeholder" />
                 <ui:Label name="skills-hint-label" text="Install skills later from&#10;Window &gt; Unity CLI Loop &gt; Settings." class="setup-step__hint-label" />
             </ui:VisualElement>
         </ui:VisualElement>
diff --git a/Packages/src/Editor/Presentation/Setup/SetupWizardWorkflowController.cs b/Packages/src/Editor/Presentation/Setup/SetupWizardWorkflowController.cs
index 00752ffa1..bebe5f63b 100644
--- a/Packages/src/Editor/Presentation/Setup/SetupWizardWorkflowController.cs
+++ b/Packages/src/Editor/Presentation/Setup/SetupWizardWorkflowController.cs
@@ -2,14 +2,12 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-using UnityEditor.UIElements;
 using UnityEngine;
 using UnityEngine.UIElements;
 
 using io.github.hatayama.UnityCliLoop.Application;
 using io.github.hatayama.UnityCliLoop.Domain;
 using io.github.hatayama.UnityCliLoop.ToolContracts;
-// Domain: IUnityCliLoopEditorSettingsPort / SkillSetupUseCase live across Application+Domain contracts used below.
 
 namespace io.github.hatayama.UnityCliLoop.Presentation
 {
@@ -38,25 +36,17 @@ internal SetupWizardWorkflowController(
             Button installCliButton,
             VisualElement installProgressContainer,
             Label installProgressLabel,
-            VisualElement groupSkillsRow,
-            EnumField skillsTargetField,
-            Toggle groupSkillsToggle,
-            Label groupSkillsLabel,
-            VisualElement skillsTargetRow,
-            VisualElement skillsTargetList,
-            VisualElement skillsStatusDivider,
-            Label skillsStatusLabel,
-            Button installSkillsButton,
+            SkillsSetupPanelView skillsSetupPanelView,
             Toggle suppressAutoShowToggle,
             SkillSetupUseCase skillSetupUseCase,
             IUnityCliLoopEditorSettingsPort editorSettingsPort,
             CliSetupApplicationService cliSetupApplicationService,
-            Action scheduleResizeToContent,
-            string lastSeenSetupWizardVersionBeforeOpen)
+            Action scheduleResizeToContent)
         {
             Debug.Assert(rootVisualElement != null, "rootVisualElement must not be null");
             Debug.Assert(nodejsWarning != null, "nodejsWarning must not be null");
             Debug.Assert(nodejsOk != null, "nodejsOk must not be null");
+            Debug.Assert(skillsSetupPanelView != null, "skillsSetupPanelView must not be null");
             Debug.Assert(suppressAutoShowToggle != null, "suppressAutoShowToggle must not be null");
             Debug.Assert(editorSettingsPort != null, "editorSettingsPort must not be null");
             Debug.Assert(scheduleResizeToContent != null, "scheduleResizeToContent must not be null");
@@ -81,25 +71,11 @@ internal SetupWizardWorkflowController(
                 cliSetupApplicationService,
                 RefreshUI);
             _skillsWorkflow = new SetupWizardSkillsWorkflowController(
-                groupSkillsRow,
-                skillsTargetField,
-                groupSkillsToggle,
-                groupSkillsLabel,
-                skillsTargetRow,
-                skillsTargetList,
-                skillsStatusDivider,
-                skillsStatusLabel,
-                installSkillsButton,
+                skillsSetupPanelView,
                 skillSetupUseCase,
                 editorSettingsPort,
                 cliSetupApplicationService,
-                scheduleResizeToContent,
-                lastSeenSetupWizardVersionBeforeOpen);
-        }
-
-        internal void InitializeSkillsTargetField()
-        {
-            _skillsWorkflow.InitializeSkillsTargetField();
+                scheduleResizeToContent);
         }
 
         internal void InitializeGroupSkillsToggle()
diff --git a/Packages/src/Editor/Presentation/Shared.meta b/Packages/src/Editor/Presentation/Shared.meta
new file mode 100644
index 000000000..46f5358f7
--- /dev/null
+++ b/Packages/src/Editor/Presentation/Shared.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ed175bc69ee324bb3891b485915f02b0
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/Presentation/Shared/SkillsSetupPanel.uss b/Packages/src/Editor/Presentation/Shared/SkillsSetupPanel.uss
new file mode 100644
index 000000000..7dbbb3c03
--- /dev/null
+++ b/Packages/src/Editor/Presentation/Shared/SkillsSetupPanel.uss
@@ -0,0 +1,105 @@
+/* Shared Skills setup panel — self-contained colors (no Setup Wizard CSS variables). */
+
+.skills-setup-panel {
+    flex-grow: 1;
+}
+
+.skill-target-status-list {
+    margin-bottom: 6px;
+}
+
+.skill-target-item {
+    flex-direction: row;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: 2px;
+    margin-left: 4px;
+}
+
+.skill-target-item__label {
+    flex-grow: 1;
+    margin-right: 8px;
+}
+
+.skill-target-item__status {
+    flex-shrink: 0;
+    -unity-font-style: bold;
+}
+
+.skill-target-item__status--installed {
+    color: #4caf50;
+}
+
+.skill-target-item__status--checking {
+    color: #999999;
+}
+
+.skill-target-item__status--outdated {
+    color: #ffd200;
+}
+
+.skill-target-item__status--missing {
+    color: #999999;
+}
+
+.skill-target-item__status--different-layout {
+    color: #ffd200;
+}
+
+.skill-target-status-divider {
+    border-top-width: 1px;
+    border-top-color: rgba(255, 255, 255, 0.12);
+    margin-top: 6px;
+    margin-bottom: 12px;
+}
+
+.skill-target-status-summary {
+    margin-bottom: 4px;
+}
+
+.skills-setup-panel__install-button {
+    margin-top: 4px;
+    margin-bottom: 4px;
+}
+
+.skills-setup-panel__foldout {
+    margin-left: -8px;
+    margin-top: 4px;
+}
+
+.skills-setup-panel__toggle-row {
+    flex-direction: row;
+    align-items: center;
+    margin-bottom: 6px;
+}
+
+.skills-setup-panel__target-row {
+    flex-direction: row;
+    align-items: center;
+    overflow: hidden;
+    margin-bottom: 4px;
+}
+
+.skills-setup-panel__target-label {
+    width: 50px;
+    flex-shrink: 0;
+    margin-right: 6px;
+}
+
+.skills-setup-panel__target-field {
+    flex-grow: 1;
+    flex-shrink: 1;
+    min-width: 0;
+    overflow: hidden;
+}
+
+.skills-setup-panel__refresh-button {
+    width: 20px;
+    height: 20px;
+    min-width: 20px;
+    margin: 0 3px 0 4px;
+    padding: 0;
+    font-size: 14px;
+    -unity-text-align: middle-center;
+    border-radius: 2px;
+}
diff --git a/Packages/src/Editor/Presentation/Shared/SkillsSetupPanel.uss.meta b/Packages/src/Editor/Presentation/Shared/SkillsSetupPanel.uss.meta
new file mode 100644
index 000000000..27081e174
--- /dev/null
+++ b/Packages/src/Editor/Presentation/Shared/SkillsSetupPanel.uss.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b8bd909dd7cc642bba9fc7cfae2c813b
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
+  disableValidation: 0
diff --git a/Packages/src/Editor/Presentation/Shared/SkillsSetupPanel.uxml b/Packages/src/Editor/Presentation/Shared/SkillsSetupPanel.uxml
new file mode 100644
index 000000000..0e25c8ebe
--- /dev/null
+++ b/Packages/src/Editor/Presentation/Shared/SkillsSetupPanel.uxml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uie="UnityEditor.UIElements">
+    <ui:VisualElement name="skills-setup-panel" class="skills-setup-panel">
+        <ui:VisualElement name="skill-target-status-list" class="skill-target-status-list" />
+        <ui:VisualElement name="skill-target-status-divider" class="skill-target-status-divider" />
+        <ui:Label name="skill-target-status-summary" text="" class="skill-target-status-summary" />
+        <ui:Button name="install-all-skills-button" text="Install Skills" class="skills-setup-panel__install-button" />
+        <ui:Foldout name="install-specific-target-foldout" text="Install to specific target" class="skills-setup-panel__foldout">
+            <ui:VisualElement name="group-skills-row" class="skills-setup-panel__toggle-row">
+                <ui:Toggle name="group-skills-toggle" />
+                <ui:Label name="group-skills-label" text="Group in subfolder" />
+            </ui:VisualElement>
+            <ui:VisualElement name="skills-target-row" class="skills-setup-panel__target-row">
+                <ui:Label text="Target:" class="skills-setup-panel__target-label" />
+                <uie:EnumField name="skills-target-field" class="skills-setup-panel__target-field" />
+                <ui:Button name="refresh-skills-state-button" text="↻" class="skills-setup-panel__refresh-button" />
+            </ui:VisualElement>
+            <ui:Button name="install-selected-skills-button" text="Install Skills" class="skills-setup-panel__install-button" />
+        </ui:Foldout>
+    </ui:VisualElement>
+</ui:UXML>
diff --git a/Packages/src/Editor/Presentation/Shared/SkillsSetupPanel.uxml.meta b/Packages/src/Editor/Presentation/Shared/SkillsSetupPanel.uxml.meta
new file mode 100644
index 000000000..13d48ca94
--- /dev/null
+++ b/Packages/src/Editor/Presentation/Shared/SkillsSetupPanel.uxml.meta
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 27d19594dc2d24a7087434b65708b023
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/Packages/src/Editor/Presentation/Shared/SkillsSetupPanelView.cs b/Packages/src/Editor/Presentation/Shared/SkillsSetupPanelView.cs
new file mode 100644
index 000000000..a39352033
--- /dev/null
+++ b/Packages/src/Editor/Presentation/Shared/SkillsSetupPanelView.cs
@@ -0,0 +1,436 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor.UIElements;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+using io.github.hatayama.UnityCliLoop.Domain;
+
+namespace io.github.hatayama.UnityCliLoop.Presentation
+{
+    /// <summary>
+    /// Shared skills setup panel view used by Settings and Setup Wizard.
+    /// </summary>
+    internal sealed class SkillsSetupPanelView
+    {
+        private readonly VisualElement _skillTargetStatusList;
+        private readonly VisualElement _skillTargetStatusDivider;
+        private readonly Label _skillTargetStatusSummary;
+        private readonly Button _installAllSkillsButton;
+        private readonly Foldout _installSpecificTargetFoldout;
+        private readonly VisualElement _groupSkillsRow;
+        private readonly Toggle _groupSkillsToggle;
+        private readonly Label _groupSkillsLabel;
+        private readonly EnumField _skillsTargetField;
+        private readonly Button _refreshSkillsStateButton;
+        private readonly Button _installSelectedSkillsButton;
+
+        private bool _isTargetFieldInitialized;
+
+        internal event System.Action OnInstallAllClicked;
+        internal event System.Action OnInstallSelectedClicked;
+        internal event System.Action OnRefreshClicked;
+        internal event System.Action<SkillsTarget> OnTargetChanged;
+        internal event System.Action<bool> OnGroupSkillsChanged;
+
+        internal Toggle GroupSkillsToggle => _groupSkillsToggle;
+        internal Label GroupSkillsLabel => _groupSkillsLabel;
+        internal VisualElement GroupSkillsRow => _groupSkillsRow;
+
+        internal SkillsSetupPanelView(VisualElement panelRoot)
+        {
+            Debug.Assert(panelRoot != null, "panelRoot must not be null");
+            VisualElement root = panelRoot ?? throw new System.ArgumentNullException(nameof(panelRoot));
+
+            _skillTargetStatusList = root.Q<VisualElement>("skill-target-status-list");
+            _skillTargetStatusDivider = root.Q<VisualElement>("skill-target-status-divider");
+            _skillTargetStatusSummary = root.Q<Label>("skill-target-status-summary");
+            _installAllSkillsButton = root.Q<Button>("install-all-skills-button");
+            _installSpecificTargetFoldout = root.Q<Foldout>("install-specific-target-foldout");
+            _groupSkillsRow = root.Q<VisualElement>("group-skills-row");
+            _groupSkillsToggle = root.Q<Toggle>("group-skills-toggle");
+            _groupSkillsLabel = root.Q<Label>("group-skills-label");
+            _skillsTargetField = root.Q<EnumField>("skills-target-field");
+            _refreshSkillsStateButton = root.Q<Button>("refresh-skills-state-button");
+            _installSelectedSkillsButton = root.Q<Button>("install-selected-skills-button");
+
+            Debug.Assert(_skillTargetStatusList != null, "skill-target-status-list must not be null");
+            Debug.Assert(_skillTargetStatusDivider != null, "skill-target-status-divider must not be null");
+            Debug.Assert(_skillTargetStatusSummary != null, "skill-target-status-summary must not be null");
+            Debug.Assert(_installAllSkillsButton != null, "install-all-skills-button must not be null");
+            Debug.Assert(_installSpecificTargetFoldout != null, "install-specific-target-foldout must not be null");
+            Debug.Assert(_groupSkillsRow != null, "group-skills-row must not be null");
+            Debug.Assert(_groupSkillsToggle != null, "group-skills-toggle must not be null");
+            Debug.Assert(_groupSkillsLabel != null, "group-skills-label must not be null");
+            Debug.Assert(_skillsTargetField != null, "skills-target-field must not be null");
+            Debug.Assert(_refreshSkillsStateButton != null, "refresh-skills-state-button must not be null");
+            Debug.Assert(_installSelectedSkillsButton != null, "install-selected-skills-button must not be null");
+
+            _ = _skillTargetStatusList ?? throw new System.ArgumentNullException(nameof(_skillTargetStatusList));
+            _ = _skillTargetStatusDivider ?? throw new System.ArgumentNullException(nameof(_skillTargetStatusDivider));
+            _ = _skillTargetStatusSummary ?? throw new System.ArgumentNullException(nameof(_skillTargetStatusSummary));
+            _ = _installAllSkillsButton ?? throw new System.ArgumentNullException(nameof(_installAllSkillsButton));
+            _ = _installSpecificTargetFoldout
+                ?? throw new System.ArgumentNullException(nameof(_installSpecificTargetFoldout));
+            _ = _groupSkillsRow ?? throw new System.ArgumentNullException(nameof(_groupSkillsRow));
+            _ = _groupSkillsToggle ?? throw new System.ArgumentNullException(nameof(_groupSkillsToggle));
+            _ = _groupSkillsLabel ?? throw new System.ArgumentNullException(nameof(_groupSkillsLabel));
+            _ = _skillsTargetField ?? throw new System.ArgumentNullException(nameof(_skillsTargetField));
+            _ = _refreshSkillsStateButton ?? throw new System.ArgumentNullException(nameof(_refreshSkillsStateButton));
+            _ = _installSelectedSkillsButton
+                ?? throw new System.ArgumentNullException(nameof(_installSelectedSkillsButton));
+
+            _installSpecificTargetFoldout.SetValueWithoutNotify(false);
+            ViewDataBinder.SetVisible(_groupSkillsRow, false);
+
+            _installAllSkillsButton.clicked += () => OnInstallAllClicked?.Invoke();
+            _installSelectedSkillsButton.clicked += () => OnInstallSelectedClicked?.Invoke();
+            _refreshSkillsStateButton.clicked += () => OnRefreshClicked?.Invoke();
+            _groupSkillsToggle.RegisterValueChangedCallback(evt =>
+            {
+                evt.StopPropagation();
+                OnGroupSkillsChanged?.Invoke(evt.newValue);
+            });
+            _groupSkillsRow.RegisterCallback<ClickEvent>(HandleGroupSkillsRowClicked);
+        }
+
+        internal void ShowChecking()
+        {
+            _skillTargetStatusList.Clear();
+            UpdateSkillsStatusLabel("Checking installed skills...");
+            _installAllSkillsButton.SetEnabled(false);
+            _installAllSkillsButton.text = "Checking...";
+            _installSelectedSkillsButton.SetEnabled(false);
+            _installSelectedSkillsButton.text = "Checking...";
+            _refreshSkillsStateButton.SetEnabled(false);
+            _skillsTargetField.SetEnabled(false);
+            _groupSkillsToggle.SetEnabled(false);
+        }
+
+        internal void UpdateStatusPanel(
+            bool canManageSkills,
+            List<SkillSetupTargetInfo> installableTargets,
+            bool groupSkillsUnderUnityCliLoop,
+            bool isInstallingSkills)
+        {
+            Debug.Assert(installableTargets != null, "installableTargets must not be null");
+
+            _skillTargetStatusList.Clear();
+            foreach (SkillSetupTargetInfo target in installableTargets)
+            {
+                VisualElement item = new();
+                item.AddToClassList("skill-target-item");
+
+                Label nameLabel = new($"{target.DisplayName} ({target.DirName}/)");
+                nameLabel.AddToClassList("skill-target-item__label");
+                item.Add(nameLabel);
+
+                Label statusLabel = new(GetSkillInstallStatusText(
+                    target.InstallState,
+                    target.HasDifferentLayoutSkills,
+                    groupSkillsUnderUnityCliLoop));
+                statusLabel.AddToClassList("skill-target-item__status");
+                statusLabel.AddToClassList(GetSkillInstallStatusClass(
+                    target.InstallState,
+                    target.HasDifferentLayoutSkills));
+                item.Add(statusLabel);
+
+                _skillTargetStatusList.Add(item);
+            }
+
+            bool listVisible = canManageSkills && installableTargets.Count > 0;
+            ViewDataBinder.SetVisible(_skillTargetStatusList, listVisible);
+
+            bool shouldExpand = ShouldExpandSpecificTargetFoldout(installableTargets.Count);
+            _installSpecificTargetFoldout.SetValueWithoutNotify(
+                shouldExpand ? true : _installSpecificTargetFoldout.value);
+
+            bool isCheckingSkills = installableTargets.Any(
+                target => target.InstallState == SkillInstallState.Checking);
+            if (isCheckingSkills)
+            {
+                UpdateSkillsStatusLabel("Checking installed skills...");
+                _installAllSkillsButton.SetEnabled(false);
+                _installAllSkillsButton.text = "Checking...";
+                return;
+            }
+
+            bool allSkillsInstalled = installableTargets.Count > 0
+                && installableTargets.All(target => target.InstallState == SkillInstallState.Installed);
+            if (allSkillsInstalled)
+            {
+                UpdateSkillsStatusLabel(BuildInstalledSummaryText(installableTargets.Count));
+                _installAllSkillsButton.SetEnabled(false);
+                _installAllSkillsButton.text = "Installed";
+                return;
+            }
+
+            bool hasOutdatedSkills = installableTargets.Any(
+                target => target.InstallState == SkillInstallState.Outdated);
+            UpdateSkillsStatusLabel(string.Empty);
+            _installAllSkillsButton.SetEnabled(
+                canManageSkills && !isInstallingSkills && installableTargets.Count > 0);
+            _installAllSkillsButton.text = GetBulkInstallButtonText(
+                canManageSkills,
+                isInstallingSkills,
+                hasOutdatedSkills);
+        }
+
+        internal void UpdateSelectedTargetInstall(
+            SkillsTarget selectedTarget,
+            SkillInstallState installState,
+            bool isCliInstalled,
+            bool isInstallingSkills)
+        {
+            InitializeTargetFieldIfNeeded(selectedTarget);
+            _installSelectedSkillsButton.text = GetInstallSkillsButtonText(
+                isCliInstalled,
+                isInstallingSkills,
+                installState);
+            _installSelectedSkillsButton.SetEnabled(IsInstallSkillsButtonEnabled(
+                isCliInstalled,
+                isInstallingSkills,
+                installState));
+            _refreshSkillsStateButton.SetEnabled(!isInstallingSkills);
+            _skillsTargetField.SetEnabled(
+                isCliInstalled && installState != SkillInstallState.Checking);
+        }
+
+        internal void UpdateGroupSkillsToggle(bool groupSkillsUnderUnityCliLoop, bool isEnabled)
+        {
+            ViewDataBinder.SetVisible(_groupSkillsRow, false);
+            ViewDataBinder.UpdateToggle(_groupSkillsToggle, groupSkillsUnderUnityCliLoop);
+            _groupSkillsToggle.SetEnabled(isEnabled);
+        }
+
+        internal static List<SkillSetupTargetInfo> FilterInstallableSkillTargets(
+            IEnumerable<SkillSetupTargetInfo> targets)
+        {
+            Debug.Assert(targets != null, "targets must not be null");
+            return targets
+                .Where(target => target.HasSkillsDirectory)
+                .ToList();
+        }
+
+        internal static SkillSetupTargetInfo CreateFirstInstallSkillTarget(
+            SkillsTarget target,
+            bool groupSkillsUnderUnityCliLoop)
+        {
+            SkillsTargetSelection selection = SkillsTargetSelectionResolver.Resolve(
+                target,
+                groupSkillsUnderUnityCliLoop);
+            return new(
+                selection.DisplayName,
+                selection.DirectoryName,
+                selection.InstallFlag,
+                hasSkillsDirectory: false,
+                hasExistingSkills: false,
+                hasDifferentLayoutSkills: false,
+                SkillInstallState.Missing);
+        }
+
+        internal static SkillSetupTargetInfo GetSelectedSkillTargetInfo(
+            IEnumerable<SkillSetupTargetInfo> targets,
+            SkillsTarget target,
+            bool groupSkillsUnderUnityCliLoop)
+        {
+            Debug.Assert(targets != null, "targets must not be null");
+
+            SkillsTargetSelection selection = SkillsTargetSelectionResolver.Resolve(
+                target,
+                groupSkillsUnderUnityCliLoop);
+            SkillSetupTargetInfo selectedTargetInfo = targets
+                .FirstOrDefault(info => info.DirName == selection.DirectoryName);
+            return string.IsNullOrEmpty(selectedTargetInfo.DirName)
+                ? CreateFirstInstallSkillTarget(target, groupSkillsUnderUnityCliLoop)
+                : selectedTargetInfo;
+        }
+
+        internal static List<SkillSetupTargetInfo> BuildSingleTargetInstallList(
+            IEnumerable<SkillSetupTargetInfo> targets,
+            SkillsTarget target,
+            bool groupSkillsUnderUnityCliLoop)
+        {
+            SkillSetupTargetInfo selectedTargetInfo = GetSelectedSkillTargetInfo(
+                targets,
+                target,
+                groupSkillsUnderUnityCliLoop);
+            return selectedTargetInfo.InstallState == SkillInstallState.Installed
+                   || selectedTargetInfo.InstallState == SkillInstallState.Checking
+                ? new List<SkillSetupTargetInfo>()
+                : new List<SkillSetupTargetInfo> { selectedTargetInfo };
+        }
+
+        internal static string GetBulkInstallButtonText(
+            bool canManageSkills,
+            bool isInstallingSkills,
+            bool hasOutdatedSkills)
+        {
+            if (!canManageSkills)
+            {
+                return "Install Skills";
+            }
+
+            if (isInstallingSkills)
+            {
+                return "Installing...";
+            }
+
+            return hasOutdatedSkills ? "Update Skills" : "Install Skills";
+        }
+
+        internal static string GetInstallSkillsButtonText(
+            bool isCliInstalled,
+            bool isInstallingSkills,
+            SkillInstallState installState)
+        {
+            if (isInstallingSkills)
+            {
+                return "Installing...";
+            }
+
+            if (!isCliInstalled)
+            {
+                return "Install Skills";
+            }
+
+            return installState switch
+            {
+                SkillInstallState.Checking => "Checking...",
+                SkillInstallState.Installed => "Installed",
+                SkillInstallState.Outdated => "Update Skills",
+                _ => "Install Skills"
+            };
+        }
+
+        internal static bool IsInstallSkillsButtonEnabled(
+            bool isCliInstalled,
+            bool isInstallingSkills,
+            SkillInstallState installState)
+        {
+            if (!isCliInstalled || isInstallingSkills)
+            {
+                return false;
+            }
+
+            return installState switch
+            {
+                SkillInstallState.Checking => false,
+                SkillInstallState.Installed => false,
+                _ => true
+            };
+        }
+
+        internal static string GetSkillInstallStatusText(
+            SkillInstallState installState,
+            bool hasDifferentLayoutSkills,
+            bool groupSkillsUnderUnityCliLoop)
+        {
+            if (installState == SkillInstallState.Checking)
+            {
+                return "Checking...";
+            }
+
+            if (installState == SkillInstallState.Installed)
+            {
+                return "Installed";
+            }
+
+            if (installState == SkillInstallState.Outdated)
+            {
+                return "Outdated";
+            }
+
+            if (!hasDifferentLayoutSkills)
+            {
+                return "Missing";
+            }
+
+            return groupSkillsUnderUnityCliLoop ? "Not grouped" : "Grouped";
+        }
+
+        internal static string GetSkillInstallStatusClass(
+            SkillInstallState installState,
+            bool hasDifferentLayoutSkills)
+        {
+            if (installState == SkillInstallState.Checking)
+            {
+                return "skill-target-item__status--checking";
+            }
+
+            if (installState == SkillInstallState.Installed)
+            {
+                return "skill-target-item__status--installed";
+            }
+
+            if (installState == SkillInstallState.Outdated)
+            {
+                return "skill-target-item__status--outdated";
+            }
+
+            if (!hasDifferentLayoutSkills)
+            {
+                return "skill-target-item__status--missing";
+            }
+
+            return "skill-target-item__status--different-layout";
+        }
+
+        internal static string BuildInstalledSummaryText(int installedTargetCount)
+        {
+            Debug.Assert(installedTargetCount >= 0, "installedTargetCount must not be negative");
+            return $"Installed for {installedTargetCount} targets";
+        }
+
+        internal static bool ShouldExpandSpecificTargetFoldout(int installableTargetCount)
+        {
+            Debug.Assert(installableTargetCount >= 0, "installableTargetCount must not be negative");
+            return installableTargetCount == 0;
+        }
+
+        private void InitializeTargetFieldIfNeeded(SkillsTarget currentTarget)
+        {
+            if (!_isTargetFieldInitialized)
+            {
+                _skillsTargetField.Init(currentTarget);
+                _skillsTargetField.RegisterValueChangedCallback(evt =>
+                {
+                    if (evt.newValue is SkillsTarget newValue)
+                    {
+                        OnTargetChanged?.Invoke(newValue);
+                    }
+                });
+                _isTargetFieldInitialized = true;
+                return;
+            }
+
+            ViewDataBinder.UpdateEnumField(_skillsTargetField, currentTarget);
+        }
+
+        private void UpdateSkillsStatusLabel(string text)
+        {
+            _skillTargetStatusSummary.text = text;
+            bool isVisible = !string.IsNullOrEmpty(text);
+            ViewDataBinder.SetVisible(_skillTargetStatusDivider, isVisible);
+            ViewDataBinder.SetVisible(_skillTargetStatusSummary, isVisible);
+        }
+
+        private void HandleGroupSkillsRowClicked(ClickEvent evt)
+        {
+            evt.StopPropagation();
+            if (!_groupSkillsToggle.enabledSelf)
+            {
+                return;
+            }
+
+            if (evt.target is VisualElement targetElement && _groupSkillsToggle.Contains(targetElement))
+            {
+                return;
+            }
+
+            bool newValue = !_groupSkillsToggle.value;
+            _groupSkillsToggle.SetValueWithoutNotify(newValue);
+            OnGroupSkillsChanged?.Invoke(newValue);
+        }
+    }
+}
diff --git a/Packages/src/Editor/Presentation/Shared/SkillsSetupPanelView.cs.meta b/Packages/src/Editor/Presentation/Shared/SkillsSetupPanelView.cs.meta
new file mode 100644
index 000000000..d3d3cb35b
--- /dev/null
+++ b/Packages/src/Editor/Presentation/Shared/SkillsSetupPanelView.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fc86c317bb1d14d4aa1c409fa9e2d6d6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/src/Editor/Presentation/UIToolkit/Components/CliSetupSection.cs b/Packages/src/Editor/Presentation/UIToolkit/Components/CliSetupSection.cs
index 1482660c6..b2d19aa67 100644
--- a/Packages/src/Editor/Presentation/UIToolkit/Components/CliSetupSection.cs
+++ b/Packages/src/Editor/Presentation/UIToolkit/Components/CliSetupSection.cs
@@ -1,5 +1,7 @@
 using System;
-using UnityEditor.UIElements;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
 using UnityEngine.UIElements;
 
 using io.github.hatayama.UnityCliLoop.Application;
@@ -17,20 +19,15 @@ public class CliSetupSection
         private readonly Button _refreshCliVersionButton;
         private readonly Button _installCliButton;
         private readonly CliInstallProgressView _installProgressView;
-        private readonly EnumField _skillsTargetField;
-        private readonly Button _refreshSkillsStateButton;
-        private readonly VisualElement _groupSkillsRow;
-        private readonly Toggle _groupSkillsToggle;
-        private readonly Label _groupSkillsLabel;
-        private readonly Button _installSkillsButton;
         private readonly VisualElement _skillsSubsection;
+        private readonly SkillsSetupPanelView _skillsSetupPanelView;
 
         private CliSetupData _lastData;
-        private bool _isTargetFieldInitialized;
 
         public event Action OnRefreshCliVersion;
         public event Action OnInstallCli;
         public event Action OnInstallSkills;
+        public event Action OnInstallAllSkills;
         public event Action OnRefreshSkillsState;
         public event Action<SkillsTarget> OnSkillsTargetChanged;
         public event Action<bool> OnGroupSkillsChanged;
@@ -45,27 +42,23 @@ public CliSetupSection(VisualElement root)
                 root.Q<VisualElement>("cli-install-progress"),
                 _installCliButton,
                 root.Q<Label>("cli-install-progress-label"));
-            _skillsTargetField = root.Q<EnumField>("skills-target-field");
-            _refreshSkillsStateButton = root.Q<Button>("refresh-skills-state-button");
-            _groupSkillsRow = root.Q<VisualElement>("group-skills-row");
-            _groupSkillsToggle = root.Q<Toggle>("group-skills-toggle");
-            _groupSkillsLabel = root.Q<Label>("group-skills-label");
-            _installSkillsButton = root.Q<Button>("install-skills-button");
             _skillsSubsection = root.Q<VisualElement>("skills-subsection");
+
+            VisualElement skillsSetupPanel = root.Q<VisualElement>("skills-setup-panel");
+            Debug.Assert(skillsSetupPanel != null, "skills-setup-panel must not be null");
+            _skillsSetupPanelView = new SkillsSetupPanelView(
+                skillsSetupPanel ?? throw new ArgumentNullException(nameof(skillsSetupPanel)));
         }
 
         public void SetupBindings()
         {
             _refreshCliVersionButton.clicked += () => OnRefreshCliVersion?.Invoke();
             _installCliButton.clicked += () => OnInstallCli?.Invoke();
-            _installSkillsButton.clicked += () => OnInstallSkills?.Invoke();
-            _refreshSkillsStateButton.clicked += () => OnRefreshSkillsState?.Invoke();
-            _groupSkillsToggle.RegisterValueChangedCallback(evt =>
-            {
-                evt.StopPropagation();
-                OnGroupSkillsChanged?.Invoke(evt.newValue);
-            });
-            _groupSkillsRow.RegisterCallback<ClickEvent>(HandleGroupSkillsRowClicked);
+            _skillsSetupPanelView.OnInstallSelectedClicked += () => OnInstallSkills?.Invoke();
+            _skillsSetupPanelView.OnInstallAllClicked += () => OnInstallAllSkills?.Invoke();
+            _skillsSetupPanelView.OnRefreshClicked += () => OnRefreshSkillsState?.Invoke();
+            _skillsSetupPanelView.OnTargetChanged += value => OnSkillsTargetChanged?.Invoke(value);
+            _skillsSetupPanelView.OnGroupSkillsChanged += value => OnGroupSkillsChanged?.Invoke(value);
         }
 
         public void ShowInstallProgress() => _installProgressView.Show();
@@ -86,11 +79,8 @@ public void Update(CliSetupData data)
             UpdateCliStatus(data);
             UpdateRefreshButton(data);
             UpdateInstallCliButton(data);
-            InitializeTargetFieldIfNeeded(data);
-            UpdateRefreshSkillsButton(data);
-            UpdateGroupSkillsToggle(data);
             UpdateSkillsSubsection(data);
-            UpdateInstallSkillsButton(data);
+            UpdateSkillsPanel(data);
         }
 
         private void UpdateCliStatus(CliSetupData data)
@@ -149,67 +139,36 @@ private void SetCliButton(string text, bool enabled, bool useDisabledStyle)
             ViewDataBinder.ToggleClass(_installCliButton, "unity-cli-loop-button--disabled", useDisabledStyle);
         }
 
-        private void InitializeTargetFieldIfNeeded(CliSetupData data)
-        {
-            if (!_isTargetFieldInitialized)
-            {
-                _skillsTargetField.Init(data.SelectedTarget);
-                _skillsTargetField.RegisterValueChangedCallback(evt =>
-                {
-                    if (evt.newValue is SkillsTarget newValue)
-                    {
-                        OnSkillsTargetChanged?.Invoke(newValue);
-                    }
-                });
-                _isTargetFieldInitialized = true;
-            }
-            else
-            {
-                ViewDataBinder.UpdateEnumField(_skillsTargetField, data.SelectedTarget);
-            }
-
-            _skillsTargetField.SetEnabled(
-                data.IsCliInstalled
-                && data.SelectedTargetInstallState != SkillInstallState.Checking);
-        }
-
-        private void UpdateRefreshSkillsButton(CliSetupData data)
-        {
-            bool enabled = data.IsCliInstalled && !data.IsInstallingSkills;
-            _refreshSkillsStateButton.SetEnabled(enabled);
-            ViewDataBinder.ToggleClass(_refreshSkillsStateButton, "unity-cli-loop-button--disabled", !enabled);
-        }
-
-        private void UpdateGroupSkillsToggle(CliSetupData data)
-        {
-            ViewDataBinder.SetVisible(_groupSkillsRow, false);
-            ViewDataBinder.UpdateToggle(_groupSkillsToggle, data.GroupSkillsUnderUnityCliLoop);
-            _groupSkillsToggle.SetEnabled(data.IsCliInstalled && !data.IsInstallingSkills);
-        }
-
         private void UpdateSkillsSubsection(CliSetupData data)
         {
             _skillsSubsection.SetEnabled(data.IsCliInstalled);
         }
 
-        private void UpdateInstallSkillsButton(CliSetupData data)
+        private void UpdateSkillsPanel(CliSetupData data)
         {
-            string label = GetInstallSkillsButtonText(
+            _skillsSetupPanelView.UpdateGroupSkillsToggle(
+                data.GroupSkillsUnderUnityCliLoop,
+                data.IsCliInstalled && !data.IsInstallingSkills);
+
+            if (data.IsChecking)
+            {
+                _skillsSetupPanelView.ShowChecking();
+                return;
+            }
+
+            List<SkillSetupTargetInfo> installableTargets = data.InstallableSkillTargets == null
+                ? new List<SkillSetupTargetInfo>()
+                : data.InstallableSkillTargets.ToList();
+            _skillsSetupPanelView.UpdateStatusPanel(
                 data.IsCliInstalled,
-                data.IsInstallingSkills,
-                data.SelectedTargetInstallState);
-            bool enabled = IsInstallSkillsButtonEnabled(
+                installableTargets,
+                data.GroupSkillsUnderUnityCliLoop,
+                data.IsInstallingSkills);
+            _skillsSetupPanelView.UpdateSelectedTargetInstall(
+                data.SelectedTarget,
+                data.SelectedTargetInstallState,
                 data.IsCliInstalled,
-                data.IsInstallingSkills,
-                data.SelectedTargetInstallState);
-            SetSkillsButton(label, enabled);
-        }
-
-        private void SetSkillsButton(string text, bool enabled)
-        {
-            _installSkillsButton.text = text;
-            _installSkillsButton.SetEnabled(enabled);
-            ViewDataBinder.ToggleClass(_installSkillsButton, "unity-cli-loop-button--disabled", !enabled);
+                data.IsInstallingSkills);
         }
 
         internal static string GetInstallCliButtonText(
@@ -273,65 +232,5 @@ internal static bool IsUninstallCliAction(
                 needsUpdate,
                 canUninstallCli);
         }
-
-        internal static string GetInstallSkillsButtonText(
-            bool isCliInstalled,
-            bool isInstallingSkills,
-            SkillInstallState installState)
-        {
-            if (isInstallingSkills)
-            {
-                return "Installing...";
-            }
-
-            if (!isCliInstalled)
-            {
-                return "Install Skills";
-            }
-
-            return installState switch
-            {
-                SkillInstallState.Checking => "Checking...",
-                SkillInstallState.Installed => "Installed",
-                SkillInstallState.Outdated => "Update Skills",
-                _ => "Install Skills"
-            };
-        }
-
-        internal static bool IsInstallSkillsButtonEnabled(
-            bool isCliInstalled,
-            bool isInstallingSkills,
-            SkillInstallState installState)
-        {
-            if (!isCliInstalled || isInstallingSkills)
-            {
-                return false;
-            }
-
-            return installState switch
-            {
-                SkillInstallState.Checking => false,
-                SkillInstallState.Installed => false,
-                _ => true
-            };
-        }
-
-        private void HandleGroupSkillsRowClicked(ClickEvent evt)
-        {
-            evt.StopPropagation();
-            if (!_groupSkillsToggle.enabledSelf)
-            {
-                return;
-            }
-
-            if (evt.target is VisualElement targetElement && _groupSkillsToggle.Contains(targetElement))
-            {
-                return;
-            }
-
-            bool newValue = !_groupSkillsToggle.value;
-            _groupSkillsToggle.SetValueWithoutNotify(newValue);
-            OnGroupSkillsChanged?.Invoke(newValue);
-        }
     }
 }
diff --git a/Packages/src/Editor/Presentation/UIToolkit/UnityCliLoopSettingsWindow.uxml b/Packages/src/Editor/Presentation/UIToolkit/UnityCliLoopSettingsWindow.uxml
index f5114b655..c037388d0 100644
--- a/Packages/src/Editor/Presentation/UIToolkit/UnityCliLoopSettingsWindow.uxml
+++ b/Packages/src/Editor/Presentation/UIToolkit/UnityCliLoopSettingsWindow.uxml
@@ -19,19 +19,7 @@
 
                         <ui:VisualElement name="skills-subsection">
                             <ui:Label text="Skills" class="unity-cli-loop-cli-subsection-header" />
-                            <ui:VisualElement name="group-skills-row" class="unity-cli-loop-toggle-row">
-                                <ui:Toggle name="group-skills-toggle" class="unity-cli-loop-toggle-row__toggle" />
-                                <ui:Label
-                                    name="group-skills-label"
-                                    text="Group in subfolder"
-                                    class="unity-cli-loop-toggle-row__label" />
-                            </ui:VisualElement>
-                            <ui:VisualElement class="unity-cli-loop-target-row">
-                                <ui:Label text="Target:" class="unity-cli-loop-target-row__label" />
-                                <uie:EnumField name="skills-target-field" class="unity-cli-loop-target-row__field" />
-                                <ui:Button name="refresh-skills-state-button" text="↻" class="unity-cli-loop-button--refresh" />
-                            </ui:VisualElement>
-                            <ui:Button name="install-skills-button" text="Install Skills" class="unity-cli-loop-button unity-cli-loop-button--configure" />
+                            <ui:VisualElement name="skills-setup-panel-placeholder" />
                         </ui:VisualElement>
                     </ui:VisualElement>
                 </ui:Foldout>
diff --git a/Packages/src/Editor/Presentation/UIToolkit/UnityCliLoopSettingsWindowUI.cs b/Packages/src/Editor/Presentation/UIToolkit/UnityCliLoopSettingsWindowUI.cs
index ed3fcc900..bdcd232c8 100644
--- a/Packages/src/Editor/Presentation/UIToolkit/UnityCliLoopSettingsWindowUI.cs
+++ b/Packages/src/Editor/Presentation/UIToolkit/UnityCliLoopSettingsWindowUI.cs
@@ -18,6 +18,8 @@ public class UnityCliLoopSettingsWindowUI : IDisposable
     {
         private const string UXML_RELATIVE_PATH = "Editor/Presentation/UIToolkit/UnityCliLoopSettingsWindow.uxml";
         private const string USS_RELATIVE_PATH = "Editor/Presentation/UIToolkit/UnityCliLoopSettingsWindow.uss";
+        private const string SKILLS_PANEL_UXML_RELATIVE_PATH = "Editor/Presentation/Shared/SkillsSetupPanel.uxml";
+        private const string SKILLS_PANEL_USS_RELATIVE_PATH = "Editor/Presentation/Shared/SkillsSetupPanel.uss";
         private const string GITHUB_ICON_RELATIVE_PATH = "Editor/Presentation/Setup/GitHub_Invertocat_White.png";
 
         private readonly VisualElement _root;
@@ -34,6 +36,7 @@ public class UnityCliLoopSettingsWindowUI : IDisposable
         public event Action OnRefreshCliVersion;
         public event Action OnInstallCli;
         public event Action OnInstallSkills;
+        public event Action OnInstallAllSkills;
         public event Action OnRefreshSkillsState;
         public event Action<SkillsTarget> OnSkillsTargetChanged;
         public event Action<bool> OnGroupSkillsChanged;
@@ -79,6 +82,33 @@ private void LoadLayout()
             }
 
             _root.styleSheets.Add(styleSheet);
+
+            VisualElement skillsPanelPlaceholder = _root.Q<VisualElement>("skills-setup-panel-placeholder");
+            Debug.Assert(skillsPanelPlaceholder != null, "skills-setup-panel-placeholder must not be null");
+
+            string skillsPanelUxmlPath =
+                $"{UnityCliLoopConstants.PackageAssetPath}/{SKILLS_PANEL_UXML_RELATIVE_PATH}";
+            VisualTreeAsset skillsPanelTree =
+                AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(skillsPanelUxmlPath);
+            if (skillsPanelTree == null)
+            {
+                Debug.LogError($"Failed to load UXML from: {skillsPanelUxmlPath}");
+                return;
+            }
+
+            skillsPanelTree.CloneTree(skillsPanelPlaceholder);
+
+            string skillsPanelUssPath =
+                $"{UnityCliLoopConstants.PackageAssetPath}/{SKILLS_PANEL_USS_RELATIVE_PATH}";
+            StyleSheet skillsPanelStyleSheet =
+                AssetDatabase.LoadAssetAtPath<StyleSheet>(skillsPanelUssPath);
+            if (skillsPanelStyleSheet == null)
+            {
+                Debug.LogError($"Failed to load USS from: {skillsPanelUssPath}");
+                return;
+            }
+
+            _root.styleSheets.Add(skillsPanelStyleSheet);
         }
 
         private void InitializeSections()
@@ -92,6 +122,7 @@ private void InitializeSections()
             _cliSetupSection.OnRefreshCliVersion += () => OnRefreshCliVersion?.Invoke();
             _cliSetupSection.OnInstallCli += () => OnInstallCli?.Invoke();
             _cliSetupSection.OnInstallSkills += () => OnInstallSkills?.Invoke();
+            _cliSetupSection.OnInstallAllSkills += () => OnInstallAllSkills?.Invoke();
             _cliSetupSection.OnRefreshSkillsState += () => OnRefreshSkillsState?.Invoke();
             _cliSetupSection.OnSkillsTargetChanged += value => OnSkillsTargetChanged?.Invoke(value);
             _cliSetupSection.OnGroupSkillsChanged += value => OnGroupSkillsChanged?.Invoke(value);
diff --git a/Packages/src/Editor/Presentation/UnityCliLoopSettingsCliSetupPresenter.cs b/Packages/src/Editor/Presentation/UnityCliLoopSettingsCliSetupPresenter.cs
index 9ac4c66df..a093215bf 100644
--- a/Packages/src/Editor/Presentation/UnityCliLoopSettingsCliSetupPresenter.cs
+++ b/Packages/src/Editor/Presentation/UnityCliLoopSettingsCliSetupPresenter.cs
@@ -75,7 +75,8 @@ internal void RefreshSection(bool includeSkillDirectoryChecks = true)
                 skills.InstallSkillsFlat,
                 skills.SelectedTargetInstallState,
                 skills.SkillsTarget,
-                skills.IsInstallingSkills);
+                skills.IsInstallingSkills,
+                skills.InstallableSkillTargets);
         }
 
         internal void Update(
@@ -87,7 +88,8 @@ internal void Update(
             bool installSkillsFlat,
             SkillInstallState selectedTargetInstallState,
             SkillsTarget skillsTarget,
-            bool isInstallingSkills)
+            bool isInstallingSkills,
+            System.Collections.Generic.IReadOnlyList<SkillSetupTargetInfo> installableSkillTargets)
         {
             CliSetupData cliData = CreateCliSetupData(
                 needsCliPathSetup,
@@ -98,7 +100,8 @@ internal void Update(
                 installSkillsFlat,
                 selectedTargetInstallState,
                 skillsTarget,
-                isInstallingSkills);
+                isInstallingSkills,
+                installableSkillTargets);
             _view.UpdateCliSetup(cliData);
         }
 
@@ -423,7 +426,8 @@ private CliSetupData CreateCliSetupData(
             bool installSkillsFlat,
             SkillInstallState selectedTargetInstallState,
             SkillsTarget skillsTarget,
-            bool isInstallingSkills)
+            bool isInstallingSkills,
+            System.Collections.Generic.IReadOnlyList<SkillSetupTargetInfo> installableSkillTargets)
         {
             string cliVersion = _cliSetupApplicationService.GetCachedCliVersion();
             bool cliIsDispatcher = _cliSetupApplicationService.GetCachedCliIsDispatcher();
@@ -465,7 +469,8 @@ private CliSetupData CreateCliSetupData(
                 displayedTargetInstallState,
                 skillsTarget,
                 groupSkillsUnderUnityCliLoop,
-                isInstallingSkills);
+                isInstallingSkills,
+                installableSkillTargets);
         }
     }
 }
diff --git a/Packages/src/Editor/Presentation/UnityCliLoopSettingsSkillsPresenter.cs b/Packages/src/Editor/Presentation/UnityCliLoopSettingsSkillsPresenter.cs
index 23a05522c..5b7e96250 100644
--- a/Packages/src/Editor/Presentation/UnityCliLoopSettingsSkillsPresenter.cs
+++ b/Packages/src/Editor/Presentation/UnityCliLoopSettingsSkillsPresenter.cs
@@ -21,18 +21,21 @@ internal UnityCliLoopSettingsSkillsSnapshot(
             bool installSkillsFlat,
             SkillInstallState selectedTargetInstallState,
             SkillsTarget skillsTarget,
-            bool isInstallingSkills)
+            bool isInstallingSkills,
+            IReadOnlyList<SkillSetupTargetInfo> installableSkillTargets)
         {
             InstallSkillsFlat = installSkillsFlat;
             SelectedTargetInstallState = selectedTargetInstallState;
             SkillsTarget = skillsTarget;
             IsInstallingSkills = isInstallingSkills;
+            InstallableSkillTargets = installableSkillTargets;
         }
 
         internal bool InstallSkillsFlat { get; }
         internal SkillInstallState SelectedTargetInstallState { get; }
         internal SkillsTarget SkillsTarget { get; }
         internal bool IsInstallingSkills { get; }
+        internal IReadOnlyList<SkillSetupTargetInfo> InstallableSkillTargets { get; }
     }
 
     /// <summary>
@@ -53,6 +56,7 @@ internal sealed class UnityCliLoopSettingsSkillsPresenter
         private bool _installSkillsFlat = ForceFlatSkillInstall;
         private bool _isInstallingSkills;
         private SkillInstallState _selectedTargetInstallState = SkillInstallState.Missing;
+        private List<SkillSetupTargetInfo> _installableTargets = new();
         private CancellationTokenSource _skillInstallStateRefreshCts;
 
         internal UnityCliLoopSettingsSkillsPresenter(
@@ -91,7 +95,8 @@ internal UnityCliLoopSettingsSkillsSnapshot GetSnapshot()
                 _installSkillsFlat,
                 _selectedTargetInstallState,
                 _skillsTarget,
-                _isInstallingSkills);
+                _isInstallingSkills,
+                _installableTargets);
         }
 
         internal void MarkSelectedTargetInstallStateChecking()
@@ -143,11 +148,17 @@ internal void RefreshSelectedTargetInstallStateFast()
             if (!_cliSetupApplicationService.IsCliInstalled())
             {
                 _selectedTargetInstallState = SkillInstallState.Missing;
+                _installableTargets = new List<SkillSetupTargetInfo>();
                 RefreshCliSetupSection();
                 return;
             }
 
-            _selectedTargetInstallState = GetSelectedTargetInstallStateForCurrentProject(includeFreshnessCheck: false);
+            (SkillSetupTargetInfo selectedTargetInfo, List<SkillSetupTargetInfo> allTargets) =
+                GetSelectedTargetInfo(UnityCliLoopPathResolver.GetProjectRoot(), includeFreshnessCheck: false);
+            _selectedTargetInstallState = string.IsNullOrEmpty(selectedTargetInfo.DirName)
+                ? SkillInstallState.Missing
+                : selectedTargetInfo.InstallState;
+            _installableTargets = SkillsSetupPanelView.FilterInstallableSkillTargets(allTargets);
             RefreshCliSetupSection();
         }
 
@@ -190,7 +201,7 @@ internal async Task HandleInstallSkills()
             }
 
             string projectRoot = UnityCliLoopPathResolver.GetProjectRoot();
-            SkillSetupTargetInfo selectedTargetInfo =
+            (SkillSetupTargetInfo selectedTargetInfo, List<SkillSetupTargetInfo> _) =
                 GetSelectedTargetInfo(projectRoot, includeFreshnessCheck: true);
             bool shouldShowSkillsInstalledDialog =
                 SkillInstallDialogPolicy.ShouldShowForSelectedTarget(selectedTargetInfo);
@@ -229,6 +240,67 @@ await _skillSetupUseCase.InstallSkillFilesAsync(
             }
         }
 
+        internal async Task HandleInstallAllSkills(CancellationToken ct)
+        {
+            if (_isInstallingSkills)
+            {
+                return;
+            }
+
+            if (!_cliSetupApplicationService.IsCliInstalled())
+            {
+                EditorUtility.DisplayDialog(
+                    "CLI Not Found",
+                    "uloop CLI is not installed. Please install the CLI first.",
+                    "OK");
+                return;
+            }
+
+            // Latch before the first await so a second Install click cannot start a parallel install.
+            _isInstallingSkills = true;
+            CancelSkillInstallStateRefresh();
+            RefreshCliSetupSection();
+
+            try
+            {
+                string projectRoot = UnityCliLoopPathResolver.GetProjectRoot();
+                List<SkillSetupTargetInfo> targets = await Task.Run(
+                    () => _skillSetupUseCase.DetectSkillTargetsForLayoutAtProjectRoot(
+                        projectRoot,
+                        !_installSkillsFlat));
+                if (ct.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                List<SkillSetupTargetInfo> installable =
+                    SkillsSetupPanelView.FilterInstallableSkillTargets(targets);
+                if (installable.Count == 0)
+                {
+                    return;
+                }
+
+                bool shouldShowSkillsInstalledDialog =
+                    SkillInstallDialogPolicy.ShouldShowForInstallableTargets(installable);
+
+                await _skillSetupUseCase.InstallSkillFilesAsync(
+                    installable,
+                    !_installSkillsFlat,
+                    ct);
+                if (shouldShowSkillsInstalledDialog)
+                {
+                    EditorDialogHelper.ShowSkillsInstalledDialog();
+                }
+            }
+            finally
+            {
+                _isInstallingSkills = false;
+                RefreshSelectedTargetInstallStateFast();
+                RefreshSelectedTargetInstallStateInBackground(allowDuringCliRefresh: true);
+                RefreshCliSetupSection();
+            }
+        }
+
         internal async Task ApplyToolToggleSideEffects(string toolName, bool enabled)
         {
             if (!enabled)
@@ -256,34 +328,21 @@ await _skillSetupUseCase.InstallSkillFilesForToolAsync(
         private async Task RefreshSelectedTargetInstallStateAsync(CancellationToken ct)
         {
             string projectRoot = UnityCliLoopPathResolver.GetProjectRoot();
-            SkillInstallState installState = await Task.Run(
-                () => GetSelectedTargetInstallStateAtProjectRoot(projectRoot, includeFreshnessCheck: true));
+            (SkillSetupTargetInfo selectedTargetInfo, List<SkillSetupTargetInfo> allTargets) =
+                await Task.Run(() => GetSelectedTargetInfo(projectRoot, includeFreshnessCheck: true));
             if (ct.IsCancellationRequested)
             {
                 return;
             }
 
-            _selectedTargetInstallState = installState;
-            RefreshCliSetupSection();
-        }
-
-        private SkillInstallState GetSelectedTargetInstallStateForCurrentProject(bool includeFreshnessCheck)
-        {
-            string projectRoot = UnityCliLoopPathResolver.GetProjectRoot();
-            return GetSelectedTargetInstallStateAtProjectRoot(projectRoot, includeFreshnessCheck);
-        }
-
-        private SkillInstallState GetSelectedTargetInstallStateAtProjectRoot(
-            string projectRoot,
-            bool includeFreshnessCheck)
-        {
-            SkillSetupTargetInfo targetInfo = GetSelectedTargetInfo(projectRoot, includeFreshnessCheck);
-            return string.IsNullOrEmpty(targetInfo.DirName)
+            _selectedTargetInstallState = string.IsNullOrEmpty(selectedTargetInfo.DirName)
                 ? SkillInstallState.Missing
-                : targetInfo.InstallState;
+                : selectedTargetInfo.InstallState;
+            _installableTargets = SkillsSetupPanelView.FilterInstallableSkillTargets(allTargets);
+            RefreshCliSetupSection();
         }
 
-        private SkillSetupTargetInfo GetSelectedTargetInfo(
+        private (SkillSetupTargetInfo selectedInfo, List<SkillSetupTargetInfo> allTargets) GetSelectedTargetInfo(
             string projectRoot,
             bool includeFreshnessCheck)
         {
@@ -296,7 +355,7 @@ private SkillSetupTargetInfo GetSelectedTargetInfo(
             SkillSetupTargetInfo targetInfo = targets
                 .FirstOrDefault(target => target.DirName == selection.DirectoryName);
 
-            return targetInfo;
+            return (targetInfo, targets);
         }
 
         private void RefreshCliSetupSection(bool includeSkillDirectoryChecks = true)
diff --git a/Packages/src/Editor/Presentation/UnityCliLoopSettingsWindow.cs b/Packages/src/Editor/Presentation/UnityCliLoopSettingsWindow.cs
index d3015a86e..3da43fbfc 100644
--- a/Packages/src/Editor/Presentation/UnityCliLoopSettingsWindow.cs
+++ b/Packages/src/Editor/Presentation/UnityCliLoopSettingsWindow.cs
@@ -1,5 +1,6 @@
 using UnityEditor;
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 
 using io.github.hatayama.UnityCliLoop.Application;
@@ -169,6 +170,7 @@ private void SetupViewCallbacks()
             _view.OnRefreshCliVersion += () => _cliSetupPresenter.HandleRefreshCliVersion().Forget();
             _view.OnInstallCli += () => _cliSetupPresenter.HandleInstallCli().Forget();
             _view.OnInstallSkills += () => _skillsPresenter.HandleInstallSkills().Forget();
+            _view.OnInstallAllSkills += () => _skillsPresenter.HandleInstallAllSkills(CancellationToken.None).Forget();
             _view.OnRefreshSkillsState += _skillsPresenter.HandleRefreshSkillsState;
             _view.OnSkillsTargetChanged += _skillsPresenter.HandleSkillsTargetChanged;
             _view.OnGroupSkillsChanged += _skillsPresenter.HandleGroupSkillsChanged;
diff --git a/Packages/src/Editor/Presentation/UnityCliLoopSettingsWindowViewData.cs b/Packages/src/Editor/Presentation/UnityCliLoopSettingsWindowViewData.cs
index 42cba4f06..b68a0b587 100644
--- a/Packages/src/Editor/Presentation/UnityCliLoopSettingsWindowViewData.cs
+++ b/Packages/src/Editor/Presentation/UnityCliLoopSettingsWindowViewData.cs
@@ -98,6 +98,7 @@ public record CliSetupData
         public readonly SkillsTarget SelectedTarget;
         public readonly bool GroupSkillsUnderUnityCliLoop;
         public readonly bool IsInstallingSkills;
+        public readonly System.Collections.Generic.IReadOnlyList<SkillSetupTargetInfo> InstallableSkillTargets;
 
         public CliSetupData(
             bool isCliInstalled,
@@ -117,7 +118,8 @@ public CliSetupData(
             SkillInstallState selectedTargetInstallState,
             SkillsTarget selectedTarget,
             bool groupSkillsUnderUnityCliLoop,
-            bool isInstallingSkills)
+            bool isInstallingSkills,
+            System.Collections.Generic.IReadOnlyList<SkillSetupTargetInfo> installableSkillTargets)
         {
             IsCliInstalled = isCliInstalled;
             CliVersion = cliVersion;
@@ -137,6 +139,7 @@ public CliSetupData(
             SelectedTarget = selectedTarget;
             GroupSkillsUnderUnityCliLoop = groupSkillsUnderUnityCliLoop;
             IsInstallingSkills = isInstallingSkills;
+            InstallableSkillTargets = installableSkillTargets;
         }
     }