fix(store): realign git install_meta stamped from a since-corrected source

The scanner now resolves the real source from install manifests, but the
git-source backfill only writes install_meta when install_type IS NULL, so a
row stamped in an earlier sync (e.g. a plugin first attributed to the
enclosing dotfiles repo) keeps its stale install_url. deriveExtensionUrl
prefers install_url, so the corrected source_json.url stayed shadowed and the
extension lingered in the wrong group.

Add refresh_stale_git_install_meta: for install_type='git' rows whose
install_url disagrees with the authoritative source_json.url, realign
install_url/revision and clear pack so backfill_packs re-derives it. Rows
already in agreement and non-git installs are untouched. Runs in both sync
paths after the symlink heal, before backfill_packs. This is the store half of
the manifest source-resolution fix (parallel to the RealZST#88 self-heal).

Author: SherlockSalvatore

crates/hk-core/src/store.rs

@@ -1065,6 +1065,11 @@ impl Store {
         // pack backfill so the cleared rows don't re-acquire a pack.
         Self::heal_symlinked_git_install_meta(&tx, extensions)?;
 
+        // Realign git install_meta the backfill stamped from a since-corrected
+        // source (e.g. plugins re-attributed to their marketplace repo). Run
+        // before pack backfill so pack re-derives from the refreshed URL.
+        Self::refresh_stale_git_install_meta(&tx)?;
+
         // Backfill pack from install_url or source_json URL for deployed extensions
         // that lost their git context after being copied to agent directories
         Self::backfill_packs(&tx)?;
@@ -1171,6 +1176,8 @@ impl Store {
 
         Self::heal_symlinked_git_install_meta(&tx, extensions)?;
 
+        Self::refresh_stale_git_install_meta(&tx)?;
+
         Self::backfill_packs(&tx)?;
 
         tx.commit()?;
@@ -1214,6 +1221,30 @@ impl Store {
         Ok(())
     }
 
+    /// Refresh `git` install_meta that the source backfill stamped from a now-
+    /// corrected source. The backfill (above) only fires on `install_type IS
+    /// NULL`, so a row stamped in an earlier sync keeps its old `install_url`
+    /// even after the scanner learns the real source (e.g. a plugin first seen
+    /// as the enclosing dotfiles repo, now resolved to its marketplace repo via
+    /// the install manifest). `deriveExtensionUrl` prefers `install_url`, so the
+    /// stale value would keep the extension in the wrong group. Realign
+    /// `install_url`/revision to the authoritative `source_json.url` and clear
+    /// `pack` so `backfill_packs` re-derives it. Rows already in agreement, and
+    /// non-git installs (marketplace/manual/cli), are untouched.
+    fn refresh_stale_git_install_meta(conn: &rusqlite::Connection) -> Result<(), HkError> {
+        conn.execute_batch(
+            "UPDATE extensions
+             SET install_url = json_extract(source_json, '$.url'),
+                 install_url_resolved = NULL,
+                 install_revision = json_extract(source_json, '$.commit_hash'),
+                 remote_revision = NULL, checked_at = NULL, check_error = NULL, pack = NULL
+             WHERE install_type = 'git'
+               AND json_extract(source_json, '$.url') IS NOT NULL
+               AND install_url IS NOT json_extract(source_json, '$.url')",
+        )?;
+        Ok(())
+    }
+
     /// Backfill `pack` from install_url, source_json URL, or child extensions.
     /// Deployed skills lose their git context after being copied to agent directories,
     /// but install_url retains the repo URL. CLI parent extensions inherit pack from children.
@@ -2736,6 +2767,94 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_sync_refreshes_stale_git_install_meta() {
+        // Regression: a plugin first scanned as the enclosing dotfiles repo got
+        // install_type='git' + install_url/pack of that repo. After the scanner
+        // learns the real marketplace source, the backfill (install_type IS
+        // NULL only) can't update it, so the stale install_url kept the plugin
+        // in the dotfiles group. Sync must realign install_url + pack to the
+        // corrected source; a git row already in agreement stays untouched.
+        let (store, _dir) = test_store();
+
+        // Polluted plugin: stale dotfiles install_meta, but the scan now reports
+        // the real marketplace source.
+        let mut polluted = sample_extension();
+        polluted.id = "plugin-cr".into();
+        polluted.kind = ExtensionKind::Plugin;
+        polluted.name = "code-review".into();
+        polluted.source.origin = SourceOrigin::Git;
+        polluted.source.url = Some("https://github.com/anthropics/claude-plugins-official".into());
+        store.insert_extension(&polluted).unwrap();
+        store
+            .set_install_meta(
+                "plugin-cr",
+                &InstallMeta {
+                    install_type: "git".into(),
+                    url: Some("https://github.com/octo/dotfiles".into()),
+                    url_resolved: None,
+                    branch: None,
+                    subpath: None,
+                    revision: None,
+                    remote_revision: None,
+                    checked_at: None,
+                    check_error: None,
+                },
+            )
+            .unwrap();
+        store.update_pack("plugin-cr", Some("octo/dotfiles")).unwrap();
+
+        // Consistent git install: install_url already matches its source.
+        let mut consistent = sample_extension();
+        consistent.id = "plugin-ok".into();
+        consistent.kind = ExtensionKind::Plugin;
+        consistent.name = "ok".into();
+        consistent.source.origin = SourceOrigin::Git;
+        consistent.source.url = Some("https://github.com/real/repo".into());
+        store.insert_extension(&consistent).unwrap();
+        store
+            .set_install_meta(
+                "plugin-ok",
+                &InstallMeta {
+                    install_type: "git".into(),
+                    url: Some("https://github.com/real/repo".into()),
+                    url_resolved: None,
+                    branch: None,
+                    subpath: None,
+                    revision: None,
+                    remote_revision: None,
+                    checked_at: None,
+                    check_error: None,
+                },
+            )
+            .unwrap();
+        store.update_pack("plugin-ok", Some("real/repo")).unwrap();
+
+        // Re-sync as the scanner now reports them (install_meta carried in DB).
+        let mut s_polluted = polluted.clone();
+        s_polluted.install_meta = None;
+        s_polluted.pack = None;
+        let mut s_consistent = consistent.clone();
+        s_consistent.install_meta = None;
+        s_consistent.pack = None;
+        store.sync_extensions(&[s_polluted, s_consistent]).unwrap();
+
+        let fixed = store.get_extension("plugin-cr").unwrap().unwrap();
+        assert_eq!(
+            fixed.install_meta.expect("install_meta kept").url.as_deref(),
+            Some("https://github.com/anthropics/claude-plugins-official"),
+            "stale install_url must be realigned to the corrected source"
+        );
+        assert_eq!(
+            fixed.pack.as_deref(),
+            Some("anthropics/claude-plugins-official"),
+            "pack must re-derive from the corrected source"
+        );
+
+        let kept = store.get_extension("plugin-ok").unwrap().unwrap();
+        assert_eq!(kept.pack.as_deref(), Some("real/repo"), "consistent git row untouched");
+    }
+
     #[test]
     fn test_stale_row_should_prune_decision() {
         let cli = ExtensionKind::Cli.as_str();