fix: address second round of Copilot PR review feedback

- Fix 'preset resolve' CLI to derive display from _collect_all_layers()
  instead of resolve_with_source(), showing top layer path and noting
  when final output is composed from multiple layers
- Add _reconcile_composed_commands() for stack-level command reconciliation:
  after install or remove, recompute effective command content from the full
  priority stack so command files always reflect the current state
- Call reconciliation after preset remove so the next layer takes effect
  instead of leaving stale/missing command files
- Persist registry incrementally: save registered_commands immediately after
  command registration, then registered_skills after skill registration,
  so interrupted installs can be cleaned up properly

Author: mnriem

src/specify_cli/__init__.py

@@ -2596,22 +2596,28 @@ def preset_resolve(
         raise typer.Exit(1)
 
     resolver = PresetResolver(project_root)
+    layers = resolver._collect_all_layers(template_name)
     result = resolver.resolve_with_source(template_name)
 
-    if result:
-        console.print(f"  [bold]{template_name}[/bold]: {result['path']}")
-        console.print(f"    [dim](from: {result['source']})[/dim]")
+    if layers:
+        # Use the highest-priority layer for display because the final output
+        # may be composed and may not map to resolve_with_source()'s single path.
+        display_layer = layers[0]
+        console.print(f"  [bold]{template_name}[/bold]: {display_layer['path']}")
+        console.print(f"    [dim](top layer from: {display_layer['source']})[/dim]")
 
-        # Show composition chain if any layers use non-replace strategies
-        layers = resolver._collect_all_layers(template_name)
-        has_composition = any(layer["strategy"] != "replace" for layer in layers)
+        has_composition = len(layers) > 1 or 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]")
             for i, layer in enumerate(reversed(layers)):
                 strategy_label = layer["strategy"]
                 if strategy_label == "replace":
                     strategy_label = "base"
                 console.print(f"    {i + 1}. [{strategy_label}] {layer['source']} → {layer['path']}")
+    elif result:
+        console.print(f"  [bold]{template_name}[/bold]: {result['path']}")
+        console.print(f"    [dim](from: {result['source']})[/dim]")
     else:
         console.print(f"  [yellow]{template_name}[/yellow]: not found")
         console.print("    [dim]No template with this name exists in the resolution stack[/dim]")

src/specify_cli/presets.py

@@ -600,6 +600,88 @@ def _unregister_commands(self, registered_commands: Dict[str, List[str]]) -> Non
         registrar = CommandRegistrar()
         registrar.unregister_commands(registered_commands, self.project_root)
 
+    def _reconcile_composed_commands(self, command_names: List[str]) -> None:
+        """Re-resolve and re-register composed commands from the full stack.
+
+        After install or remove, recompute the effective content for each
+        command name that participates in composition, and write the winning
+        content to the agent directories. This ensures command files always
+        reflect the current priority stack rather than depending on
+        install/remove order.
+
+        Args:
+            command_names: List of command names to reconcile
+        """
+        if not command_names:
+            return
+
+        try:
+            from .agents import CommandRegistrar
+        except ImportError:
+            return
+
+        resolver = PresetResolver(self.project_root)
+        registrar = CommandRegistrar()
+
+        for cmd_name in command_names:
+            layers = resolver._collect_all_layers(cmd_name, "command")
+            if not layers:
+                continue
+
+            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.
+                top_layer = layers[0]
+                top_path = top_layer["path"]
+                # Find the preset that owns this layer
+                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)):
+                        manifest_path = pack_dir / "preset.yml"
+                        if manifest_path.exists():
+                            try:
+                                manifest = PresetManifest(manifest_path)
+                            except PresetValidationError:
+                                continue
+                            for tmpl in manifest.templates:
+                                if tmpl.get("name") == cmd_name and tmpl.get("type") == "command":
+                                    registrar.register_commands_for_all_agents(
+                                        [tmpl], manifest.id, pack_dir, self.project_root
+                                    )
+                                    break
+                        break
+            else:
+                # Composed command — resolve from full stack
+                composed = resolver.resolve_content(cmd_name, "command")
+                if not composed:
+                    continue
+
+                # Write to the highest-priority preset's .composed dir
+                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"
+                    if not manifest_path.exists():
+                        continue
+                    try:
+                        manifest = PresetManifest(manifest_path)
+                    except PresetValidationError:
+                        continue
+                    for tmpl in manifest.templates:
+                        if tmpl.get("name") == cmd_name and tmpl.get("type") == "command":
+                            composed_dir = pack_dir / ".composed"
+                            composed_dir.mkdir(parents=True, exist_ok=True)
+                            composed_file = composed_dir / f"{cmd_name}.md"
+                            composed_file.write_text(composed, encoding="utf-8")
+                            registrar.register_commands_for_all_agents(
+                                [{**tmpl, "file": f".composed/{cmd_name}.md"}],
+                                manifest.id, pack_dir, self.project_root,
+                            )
+                            break
+                    else:
+                        continue
+                    break
+
     def _get_skills_dir(self) -> Optional[Path]:
         """Return the active skills directory for preset skill overrides.
 
@@ -1032,21 +1114,25 @@ def install_from_directory(
         })
 
         try:
-            # Register command overrides with AI agents
+            # Register command overrides with AI agents and persist the result
+            # immediately so cleanup can recover even if installation stops
+            # before later phases complete.
             registered_commands = self._register_commands(manifest, dest_dir)
+            self.registry.update(manifest.id, {
+                "registered_commands": registered_commands,
+            })
 
             # Update corresponding skills when --ai-skills was previously used
+            # and persist that result as well.
             registered_skills = self._register_skills(manifest, dest_dir)
+            self.registry.update(manifest.id, {
+                "registered_skills": registered_skills,
+            })
         except Exception:
             # Roll back registry entry on failure
             self.registry.remove(manifest.id)
             raise
 
-        self.registry.update(manifest.id, {
-            "registered_commands": registered_commands,
-            "registered_skills": registered_skills,
-        })
-
         return manifest
 
     def install_from_zip(
@@ -1136,13 +1222,23 @@ def remove(self, pack_id: str) -> bool:
                 }
 
         # Unregister non-skill command files from AI agents.
+        # Collect all command names for post-removal reconciliation.
+        removed_cmd_names = set()
+        for cmd_names in registered_commands.values():
+            removed_cmd_names.update(cmd_names)
         if registered_commands:
             self._unregister_commands(registered_commands)
 
         if pack_dir.exists():
             shutil.rmtree(pack_dir)
 
         self.registry.remove(pack_id)
+
+        # Reconcile: if other presets still provide these commands,
+        # re-resolve from the remaining stack so the next layer takes effect.
+        if removed_cmd_names:
+            self._reconcile_composed_commands(list(removed_cmd_names))
+
         return True
 
     def list_installed(self) -> List[Dict[str, Any]]: