Fix metadata unregister and rollback functionality

Fixed multiple issues with metadata management:

1. rollback(): Now updates in-memory registry after restoring from history
2. unregister(): Now deletes from both in-memory registry AND all loaders
3. unregisterPackage(): Now uses unregister() to ensure proper cleanup
4. Added delete() methods to MemoryLoader and DatabaseLoader

These changes ensure that unregister operations properly remove metadata
from all storage locations, and rollback operations update the in-memory
state correctly.

Fixes:
- packages/metadata/src/metadata-manager.ts:1354-1358 (rollback registry update)
- packages/metadata/src/metadata-manager.ts:223-244 (unregister loader cleanup)
- packages/metadata/src/metadata-manager.ts:344-361 (unregisterPackage refactor)
- packages/metadata/src/loaders/memory-loader.ts:104-115 (delete method)
- packages/metadata/src/loaders/database-loader.ts:594-616 (delete method)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Claude

packages/metadata/src/loaders/database-loader.ts

@@ -590,6 +590,30 @@ export class DatabaseLoader implements MetadataLoader {
       );
     }
   }
+
+  /**
+   * Delete a metadata item from the database
+   */
+  async delete(type: string, name: string): Promise<void> {
+    await this.ensureSchema();
+
+    // Find the existing record to get its ID
+    const existing = await this.driver.findOne(this.tableName, {
+      object: this.tableName,
+      where: this.baseFilter(type, name),
+    });
+
+    if (!existing) {
+      // Item doesn't exist, nothing to delete
+      return;
+    }
+
+    // Delete from the main metadata table
+    await this.driver.delete(this.tableName, {
+      object: this.tableName,
+      where: this.baseFilter(type, name),
+    });
+  }
 }
 
 /**

packages/metadata/src/loaders/memory-loader.ts

@@ -91,7 +91,7 @@ export class MemoryLoader implements MetadataLoader {
     if (!this.storage.has(type)) {
       this.storage.set(type, new Map());
     }
-    
+
     this.storage.get(type)!.set(name, data);
 
     return {
@@ -100,4 +100,17 @@ export class MemoryLoader implements MetadataLoader {
       saveTime: 0,
     };
   }
+
+  /**
+   * Delete a metadata item from memory storage
+   */
+  async delete(type: string, name: string): Promise<void> {
+    const typeStore = this.storage.get(type);
+    if (typeStore) {
+      typeStore.delete(name);
+      if (typeStore.size === 0) {
+        this.storage.delete(type);
+      }
+    }
+  }
 }

packages/metadata/src/metadata-manager.ts

@@ -221,13 +221,26 @@ export class MetadataManager implements IMetadataService {
    * Unregister/remove a metadata item by type and name
    */
   async unregister(type: string, name: string): Promise<void> {
+    // Remove from in-memory registry
     const typeStore = this.registry.get(type);
     if (typeStore) {
       typeStore.delete(name);
       if (typeStore.size === 0) {
         this.registry.delete(type);
       }
     }
+
+    // Also delete from all loaders that support deletion
+    for (const loader of this.loaders.values()) {
+      // Check if the loader has a delete method
+      if (typeof (loader as any).delete === 'function') {
+        try {
+          await (loader as any).delete(type, name);
+        } catch (error) {
+          this.logger.warn(`Failed to delete ${type}/${name} from loader ${loader.contract.name}`, { error });
+        }
+      }
+    }
   }
 
   /**
@@ -329,20 +342,21 @@ export class MetadataManager implements IMetadataService {
    * Unregister all metadata items from a specific package
    */
   async unregisterPackage(packageName: string): Promise<void> {
+    // Collect all items to delete (type and name pairs)
+    const itemsToDelete: Array<{ type: string; name: string }> = [];
+
     for (const [type, typeStore] of this.registry) {
-      const toDelete: string[] = [];
       for (const [name, data] of typeStore) {
         const meta = data as any;
         if (meta?.packageId === packageName || meta?.package === packageName) {
-          toDelete.push(name);
+          itemsToDelete.push({ type, name });
         }
       }
-      for (const name of toDelete) {
-        typeStore.delete(name);
-      }
-      if (typeStore.size === 0) {
-        this.registry.delete(type);
-      }
+    }
+
+    // Delete each item using unregister() to ensure deletion from both registry and loaders
+    for (const { type, name } of itemsToDelete) {
+      await this.unregister(type, name);
     }
   }
 
@@ -1351,6 +1365,12 @@ export class MetadataManager implements IMetadataService {
       options?.recordedBy
     );
 
+    // Update in-memory registry with the restored metadata
+    if (!this.registry.has(type)) {
+      this.registry.set(type, new Map());
+    }
+    this.registry.get(type)!.set(name, restoredMetadata);
+
     return restoredMetadata;
   }