fix: address third round of Copilot PR review feedback

- Fix empty composed content check: use 'is not None' instead of
  truthiness so intentionally blank overrides aren't skipped
- Handle non-preset sources in _reconcile_composed_commands(): when the
  winning layer after removal is an extension, core, or project override,
  re-register from that path instead of silently leaving command absent
- Fix has_composition in 'preset resolve' CLI: only show composition
  chain when non-replace strategies are present, not for simple multi-
  preset replace stacks
- Fix PowerShell fallback scan: use if/else structure matching
  Resolve-Template so directory scan runs when registry is missing
- Add test: removing a high-priority preset preserves lower-priority
  preset's command in the resolution stack

Author: mnriem

scripts/powershell/common.ps1

@@ -395,15 +395,16 @@ function Resolve-TemplateContent {
             }
         }
 
-        foreach ($presetId in $sortedPresets) {
-            # Read strategy and file path from preset manifest
-            $strategy = 'replace'
-            $manifestFilePath = ''
-            $manifest = Join-Path $presetsDir "$presetId/preset.yml"
-            if (Test-Path $manifest) {
-                try {
-                    # Use python3 to parse YAML manifest for strategy and file path
-                    $stratResult = & python3 -c @"
+        if ($sortedPresets.Count -gt 0) {
+            foreach ($presetId in $sortedPresets) {
+                # Read strategy and file path from preset manifest
+                $strategy = 'replace'
+                $manifestFilePath = ''
+                $manifest = Join-Path $presetsDir "$presetId/preset.yml"
+                if (Test-Path $manifest) {
+                    try {
+                        # Use python3 to parse YAML manifest for strategy and file path
+                        $stratResult = & python3 -c @"
 import yaml, sys
 try:
     with open(sys.argv[1]) as f:
@@ -416,32 +417,32 @@ try:
 except Exception:
     print('replace\t')
 "@ $manifest $TemplateName 2>$null
-                    if ($stratResult) {
-                        $parts = $stratResult.Trim() -split "`t", 2
-                        $strategy = $parts[0]
-                        if ($parts.Count -gt 1 -and $parts[1]) { $manifestFilePath = $parts[1] }
+                        if ($stratResult) {
+                            $parts = $stratResult.Trim() -split "`t", 2
+                            $strategy = $parts[0]
+                            if ($parts.Count -gt 1 -and $parts[1]) { $manifestFilePath = $parts[1] }
+                        }
+                    } catch {
+                        $strategy = 'replace'
                     }
-                } catch {
-                    $strategy = 'replace'
+                }
+                # Try manifest file path first, then convention path
+                $candidate = $null
+                if ($manifestFilePath) {
+                    $mf = Join-Path $presetsDir "$presetId/$manifestFilePath"
+                    if (Test-Path $mf) { $candidate = $mf }
+                }
+                if (-not $candidate) {
+                    $cf = Join-Path $presetsDir "$presetId/templates/$TemplateName.md"
+                    if (Test-Path $cf) { $candidate = $cf }
+                }
+                if ($candidate) {
+                    $layerPaths += $candidate
+                    $layerStrategies += $strategy
                 }
             }
-            # Try manifest file path first, then convention path
-            $candidate = $null
-            if ($manifestFilePath) {
-                $mf = Join-Path $presetsDir "$presetId/$manifestFilePath"
-                if (Test-Path $mf) { $candidate = $mf }
-            }
-            if (-not $candidate) {
-                $cf = Join-Path $presetsDir "$presetId/templates/$TemplateName.md"
-                if (Test-Path $cf) { $candidate = $cf }
-            }
-            if ($candidate) {
-                $layerPaths += $candidate
-                $layerStrategies += $strategy
-            }
-        }
-
-        if ($sortedPresets.Count -eq 0) {
+        } else {
+            # Fallback: alphabetical directory order (no registry or parse failure)
             foreach ($preset in Get-ChildItem -Path $presetsDir -Directory -ErrorAction SilentlyContinue | Where-Object { $_.Name -notlike '.*' }) {
                 $candidate = Join-Path $preset.FullName "templates/$TemplateName.md"
                 if (Test-Path $candidate) {

src/specify_cli/__init__.py

@@ -2606,7 +2606,7 @@ def preset_resolve(
         console.print(f"  [bold]{template_name}[/bold]: {display_layer['path']}")
         console.print(f"    [dim](top layer from: {display_layer['source']})[/dim]")
 
-        has_composition = len(layers) > 1 or any(layer["strategy"] != "replace" for layer in layers)
+        has_composition = any(layer["strategy"] != "replace" for layer in layers)
         if has_composition:
             console.print("    [dim]Final output is composed from multiple preset layers; the path above is the highest-priority contributing layer.[/dim]")
             console.print("\n  [bold]Composition chain:[/bold]")

src/specify_cli/presets.py

@@ -560,7 +560,7 @@ def _register_commands(
             if strategy != "replace":
                 # Resolve composed content using the full priority stack
                 composed = resolver.resolve_content(cmd["name"], "command")
-                if composed:
+                if composed is not None:
                     # Write composed content to a temporary subdirectory
                     if composed_dir is None:
                         composed_dir = preset_dir / ".composed"
@@ -630,11 +630,11 @@ def _reconcile_composed_commands(self, command_names: List[str]) -> None:
 
             has_composition = any(l["strategy"] != "replace" for l in layers)
             if not has_composition:
-                # Pure replace — the top layer wins. Find which preset owns it
-                # and re-register from that preset's file.
+                # Pure replace — the top layer wins.
                 top_layer = layers[0]
                 top_path = top_layer["path"]
-                # Find the preset that owns this layer
+                # Try to find which preset owns this layer
+                registered = False
                 for pack_id, _meta in PresetRegistry(self.presets_dir).list_by_priority():
                     pack_dir = self.presets_dir / pack_id
                     if str(top_path).startswith(str(pack_dir)):
@@ -649,15 +649,23 @@ def _reconcile_composed_commands(self, command_names: List[str]) -> None:
                                     registrar.register_commands_for_all_agents(
                                         [tmpl], manifest.id, pack_dir, self.project_root
                                     )
+                                    registered = True
                                     break
                         break
+                if not registered:
+                    # Top layer is a non-preset source (extension, core, or
+                    # project override). Register directly from the layer path.
+                    self._register_command_from_path(
+                        registrar, cmd_name, top_path
+                    )
             else:
                 # Composed command — resolve from full stack
                 composed = resolver.resolve_content(cmd_name, "command")
-                if not composed:
+                if composed is None:
                     continue
 
                 # Write to the highest-priority preset's .composed dir
+                registered = False
                 for pack_id, _meta in PresetRegistry(self.presets_dir).list_by_priority():
                     pack_dir = self.presets_dir / pack_id
                     manifest_path = pack_dir / "preset.yml"
@@ -677,10 +685,43 @@ def _reconcile_composed_commands(self, command_names: List[str]) -> None:
                                 [{**tmpl, "file": f".composed/{cmd_name}.md"}],
                                 manifest.id, pack_dir, self.project_root,
                             )
+                            registered = True
                             break
                     else:
                         continue
                     break
+                if not registered:
+                    # No preset owns this composed command — write to a
+                    # shared .composed dir and register from the top layer.
+                    shared_composed = self.presets_dir / ".composed"
+                    shared_composed.mkdir(parents=True, exist_ok=True)
+                    composed_file = shared_composed / f"{cmd_name}.md"
+                    composed_file.write_text(composed, encoding="utf-8")
+                    self._register_command_from_path(
+                        registrar, cmd_name, composed_file
+                    )
+
+    def _register_command_from_path(
+        self,
+        registrar: Any,
+        cmd_name: str,
+        cmd_path: Path,
+    ) -> None:
+        """Register a single command from a file path (non-preset source).
+
+        Used by reconciliation when the winning layer is an extension,
+        core template, or project override rather than a preset.
+        """
+        if not cmd_path.exists():
+            return
+        cmd_tmpl = {
+            "name": cmd_name,
+            "type": "command",
+            "file": cmd_path.name,
+        }
+        registrar.register_commands_for_all_agents(
+            [cmd_tmpl], "reconciled", cmd_path.parent, self.project_root
+        )
 
     def _get_skills_dir(self) -> Optional[Path]:
         """Return the active skills directory for preset skill overrides.

tests/test_presets.py

@@ -3564,6 +3564,75 @@ def test_layers_read_strategy_from_manifest(self, project_dir, temp_dir, valid_p
         assert layers[1]["strategy"] == "replace"
 
 
+class TestRemoveReconciliation:
+    """Test that removing a preset re-registers the next layer's command."""
+
+    def test_remove_restores_lower_priority_command(
+        self, project_dir, temp_dir, valid_pack_data
+    ):
+        """After removing the top-priority preset, the next preset's command
+        should be re-registered in agent directories."""
+        manager = PresetManager(project_dir)
+
+        # Install a low-priority preset with a command
+        lo_data = {**valid_pack_data}
+        lo_data["preset"] = {
+            **valid_pack_data["preset"],
+            "id": "lo-preset",
+            "name": "Lo",
+        }
+        lo_data["provides"] = {
+            "templates": [{
+                "type": "command",
+                "name": "speckit.specify",
+                "file": "commands/speckit.specify.md",
+            }]
+        }
+        lo_dir = temp_dir / "lo-preset"
+        lo_dir.mkdir()
+        with open(lo_dir / "preset.yml", "w") as f:
+            yaml.dump(lo_data, f)
+        (lo_dir / "commands").mkdir()
+        (lo_dir / "commands" / "speckit.specify.md").write_text(
+            "---\ndescription: lo\n---\nLo content\n"
+        )
+        manager.install_from_directory(lo_dir, "0.1.5", priority=10)
+
+        # Install a high-priority preset overriding the same command
+        hi_data = {**valid_pack_data}
+        hi_data["preset"] = {
+            **valid_pack_data["preset"],
+            "id": "hi-preset",
+            "name": "Hi",
+        }
+        hi_data["provides"] = {
+            "templates": [{
+                "type": "command",
+                "name": "speckit.specify",
+                "file": "commands/speckit.specify.md",
+            }]
+        }
+        hi_dir = temp_dir / "hi-preset"
+        hi_dir.mkdir()
+        with open(hi_dir / "preset.yml", "w") as f:
+            yaml.dump(hi_data, f)
+        (hi_dir / "commands").mkdir()
+        (hi_dir / "commands" / "speckit.specify.md").write_text(
+            "---\ndescription: hi\n---\nHi content\n"
+        )
+        manager.install_from_directory(hi_dir, "0.1.5", priority=1)
+
+        # Remove the high-priority preset
+        manager.remove("hi-preset")
+
+        # The low-priority preset's command should still be present
+        # in the resolution stack
+        resolver = PresetResolver(project_dir)
+        layers = resolver._collect_all_layers("speckit.specify", "command")
+        assert len(layers) >= 1
+        assert "lo-preset" in layers[0]["source"]
+
+
 def _create_pack(temp_dir, valid_pack_data, pack_id, content,
                  strategy="replace", template_type="template",
                  template_name="spec-template"):