fix(lint): address ruff linting errors and registry.update() semantics

- Remove unused import ExtensionError in extension_info
- Remove extraneous f-prefix from strings without placeholders
- Use registry.restore() instead of registry.update() for installed_at
  preservation (update() always preserves existing installed_at, ignoring
  our override)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: iamaeroplane

src/specify_cli/__init__.py

@@ -1847,7 +1847,7 @@ def _resolve_installed_extension(
         for ext in name_matches:
             table.add_row(ext.get("id", ""), ext.get("name", ""), str(ext.get("version", "")))
         console.print(table)
-        console.print(f"\nPlease rerun using the extension ID:")
+        console.print("\nPlease rerun using the extension ID:")
         console.print(f"  [bold]specify extension {command_name} <extension-id>[/bold]")
         raise typer.Exit(1)
     else:
@@ -1910,7 +1910,7 @@ def _resolve_catalog_extension(
                     ext.get("_catalog_name", ""),
                 )
             console.print(table)
-            console.print(f"\nPlease rerun using the extension ID:")
+            console.print("\nPlease rerun using the extension ID:")
             console.print(f"  [bold]specify extension {command_name} <extension-id>[/bold]")
             raise typer.Exit(1)
 
@@ -2426,7 +2426,7 @@ def extension_info(
     extension: str = typer.Argument(help="Extension ID or name"),
 ):
     """Show detailed information about an extension."""
-    from .extensions import ExtensionCatalog, ExtensionManager, ExtensionError
+    from .extensions import ExtensionCatalog, ExtensionManager
 
     project_root = Path.cwd()
 
@@ -2488,7 +2488,7 @@ def extension_info(
             console.print(f"[yellow]Catalog unavailable:[/yellow] {catalog_error}")
             console.print("[dim]Note: Using locally installed extension; catalog info could not be verified.[/dim]")
         else:
-            console.print(f"[yellow]Note:[/yellow] Not found in catalog (custom/local extension)")
+            console.print("[yellow]Note:[/yellow] Not found in catalog (custom/local extension)")
 
         console.print()
         console.print("[green]✓ Installed[/green]")
@@ -2608,6 +2608,7 @@ def extension_update(
         ExtensionManager,
         ExtensionCatalog,
         ExtensionError,
+        ValidationError,
         CommandRegistrar,
         HookExecutor,
     )
@@ -2649,7 +2650,16 @@ def extension_update(
         for ext_id in extensions_to_update:
             # Get installed version
             metadata = manager.registry.get(ext_id)
-            installed_version = pkg_version.Version(metadata["version"])
+            if metadata is None or "version" not in metadata:
+                console.print(f"⚠  {ext_id}: Registry entry corrupted or missing (skipping)")
+                continue
+            try:
+                installed_version = pkg_version.Version(metadata["version"])
+            except pkg_version.InvalidVersion:
+                console.print(
+                    f"⚠  {ext_id}: Invalid installed version '{metadata.get('version')}' in registry (skipping)"
+                )
+                continue
 
             # Get catalog info
             ext_info = catalog.get_extension_info(ext_id)
@@ -2662,7 +2672,13 @@ def extension_update(
                 console.print(f"⚠  {ext_id}: Updates not allowed from '{ext_info.get('_catalog_name', 'catalog')}' (skipping)")
                 continue
 
-            catalog_version = pkg_version.Version(ext_info["version"])
+            try:
+                catalog_version = pkg_version.Version(ext_info["version"])
+            except pkg_version.InvalidVersion:
+                console.print(
+                    f"⚠  {ext_id}: Invalid catalog version '{ext_info.get('version')}' (skipping)"
+                )
+                continue
 
             if catalog_version > installed_version:
                 updates_available.append(
@@ -2710,6 +2726,7 @@ def extension_update(
             backup_base = manager.extensions_dir / ".backup" / f"{extension_id}-update"
             backup_ext_dir = backup_base / "extension"
             backup_commands_dir = backup_base / "commands"
+            backup_config_dir = backup_base / "config"
 
             # Store backup state
             backup_registry_entry = None
@@ -2728,6 +2745,15 @@ def extension_update(
                         shutil.rmtree(backup_ext_dir)
                     shutil.copytree(extension_dir, backup_ext_dir)
 
+                    # Backup config files separately so they can be restored
+                    # after a successful install (install_from_directory clears dest dir).
+                    config_files = list(extension_dir.glob("*-config.yml")) + list(
+                        extension_dir.glob("*-config.local.yml")
+                    )
+                    for cfg_file in config_files:
+                        backup_config_dir.mkdir(parents=True, exist_ok=True)
+                        shutil.copy2(cfg_file, backup_config_dir / cfg_file.name)
+
                 # 3. Backup command files for all agents
                 registered_commands = backup_registry_entry.get("registered_commands", {})
                 for agent_name, cmd_names in registered_commands.items():
@@ -2801,9 +2827,23 @@ def extension_update(
                     # 8. Install new version
                     _ = manager.install_from_zip(zip_path, speckit_version)
 
+                    # Restore user config files from backup after successful install.
+                    new_extension_dir = manager.extensions_dir / extension_id
+                    if backup_config_dir.exists() and new_extension_dir.exists():
+                        for cfg_file in backup_config_dir.iterdir():
+                            if cfg_file.is_file():
+                                shutil.copy2(cfg_file, new_extension_dir / cfg_file.name)
+
                     # 9. Restore metadata from backup (installed_at, enabled state)
                     if backup_registry_entry:
-                        new_metadata = manager.registry.get(extension_id)
+                        # Copy current registry entry to avoid mutating internal
+                        # registry state before explicit restore().
+                        current_metadata = manager.registry.get(extension_id)
+                        if current_metadata is None:
+                            raise RuntimeError(
+                                f"Registry entry for '{extension_id}' missing after install — update incomplete"
+                            )
+                        new_metadata = dict(current_metadata)
 
                         # Preserve the original installation timestamp
                         if "installed_at" in backup_registry_entry:
@@ -2813,7 +2853,9 @@ def extension_update(
                         if not backup_registry_entry.get("enabled", True):
                             new_metadata["enabled"] = False
 
-                        manager.registry.update(extension_id, new_metadata)
+                        # Use restore() instead of update() because update() always
+                        # preserves the existing installed_at, ignoring our override
+                        manager.registry.restore(extension_id, new_metadata)
 
                         # Also disable hooks in extensions.yml if extension was disabled
                         if not backup_registry_entry.get("enabled", True):
@@ -2860,7 +2902,10 @@ def extension_update(
                     # (files that weren't in the original backup)
                     try:
                         new_registry_entry = manager.registry.get(extension_id)
-                        new_registered_commands = new_registry_entry.get("registered_commands", {})
+                        if new_registry_entry is None:
+                            new_registered_commands = {}
+                        else:
+                            new_registered_commands = new_registry_entry.get("registered_commands", {})
                         for agent_name, cmd_names in new_registered_commands.items():
                             if agent_name not in registrar.AGENT_CONFIGS:
                                 continue
@@ -2926,7 +2971,7 @@ def extension_update(
                     if backup_registry_entry:
                         manager.registry.restore(extension_id, backup_registry_entry)
 
-                    console.print(f"   [green]✓[/green] Rollback successful")
+                    console.print("   [green]✓[/green] Rollback successful")
                     # Clean up backup directory only on successful rollback
                     if backup_base.exists():
                         shutil.rmtree(backup_base)
@@ -2944,6 +2989,9 @@ def extension_update(
                 console.print(f"   • {ext_name}: {error}")
             raise typer.Exit(1)
 
+    except ValidationError as e:
+        console.print(f"\n[red]Validation Error:[/red] {e}")
+        raise typer.Exit(1)
     except ExtensionError as e:
         console.print(f"\n[red]Error:[/red] {e}")
         raise typer.Exit(1)
@@ -2974,6 +3022,10 @@ def extension_enable(
 
     # Update registry
     metadata = manager.registry.get(extension_id)
+    if metadata is None:
+        console.print(f"[red]Error:[/red] Extension '{extension_id}' not found in registry (corrupted state)")
+        raise typer.Exit(1)
+    
     if metadata.get("enabled", True):
         console.print(f"[yellow]Extension '{display_name}' is already enabled[/yellow]")
         raise typer.Exit(0)
@@ -3018,6 +3070,10 @@ def extension_disable(
 
     # Update registry
     metadata = manager.registry.get(extension_id)
+    if metadata is None:
+        console.print(f"[red]Error:[/red] Extension '{extension_id}' not found in registry (corrupted state)")
+        raise typer.Exit(1)
+    
     if not metadata.get("enabled", True):
         console.print(f"[yellow]Extension '{display_name}' is already disabled[/yellow]")
         raise typer.Exit(0)

src/specify_cli/extensions.py

@@ -12,6 +12,7 @@
 import tempfile
 import zipfile
 import shutil
+import copy
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional, Dict, List, Any, Callable, Set
@@ -250,12 +251,15 @@ def update(self, extension_id: str, metadata: dict):
             raise KeyError(f"Extension '{extension_id}' is not installed")
         # Merge new metadata with existing, preserving original installed_at
         existing = self.data["extensions"][extension_id]
-        original_installed_at = existing.get("installed_at")
         # Merge: existing fields preserved, new fields override
         merged = {**existing, **metadata}
-        # Always preserve original installed_at
-        if original_installed_at:
-            merged["installed_at"] = original_installed_at
+        # Always preserve original installed_at based on key existence, not truthiness,
+        # to handle cases where the field exists but may be falsy (legacy/corruption)
+        if "installed_at" in existing:
+            merged["installed_at"] = existing["installed_at"]
+        else:
+            # If not present in existing, explicitly remove from merged if caller provided it
+            merged.pop("installed_at", None)
         self.data["extensions"][extension_id] = merged
         self._save()
 
@@ -270,7 +274,7 @@ def restore(self, extension_id: str, metadata: dict):
             extension_id: Extension ID
             metadata: Complete extension metadata including installed_at
         """
-        self.data["extensions"][extension_id] = metadata
+        self.data["extensions"][extension_id] = dict(metadata)
         self._save()
 
     def remove(self, extension_id: str):
@@ -286,21 +290,28 @@ def remove(self, extension_id: str):
     def get(self, extension_id: str) -> Optional[dict]:
         """Get extension metadata from registry.
 
+        Returns a deep copy to prevent callers from accidentally mutating
+        nested internal registry state without going through the write path.
+
         Args:
             extension_id: Extension ID
 
         Returns:
-            Extension metadata or None if not found
+            Deep copy of extension metadata, or None if not found
         """
-        return self.data["extensions"].get(extension_id)
+        entry = self.data["extensions"].get(extension_id)
+        return copy.deepcopy(entry) if entry is not None else None
 
     def list(self) -> Dict[str, dict]:
         """Get all installed extensions.
 
+        Returns a deep copy of the extensions mapping to prevent callers
+        from accidentally mutating nested internal registry state.
+
         Returns:
-            Dictionary of extension_id -> metadata
+            Dictionary of extension_id -> metadata (deep copies)
         """
-        return self.data["extensions"]
+        return copy.deepcopy(self.data["extensions"])
 
     def is_installed(self, extension_id: str) -> bool:
         """Check if extension is installed.
@@ -645,7 +656,7 @@ def list_installed(self) -> List[Dict[str, Any]]:
                 result.append({
                     "id": ext_id,
                     "name": manifest.name,
-                    "version": metadata["version"],
+                    "version": metadata.get("version", "unknown"),
                     "description": manifest.description,
                     "enabled": metadata.get("enabled", True),
                     "installed_at": metadata.get("installed_at"),