fix(core): give plugins from the same repository distinct extension ids

packages/core/src/extension/extension-store.test.ts

@@ -102,6 +102,80 @@ describe('ExtensionStore', () => {
     ).toMatchObject({ effective: 'enabled', source: 'workspace_override' });
   });
 
+  it('re-keys a policy to a new id for the same name after an id-formula change', async () => {
+    const store = makeStore();
+    const oldId = 'a'.repeat(64);
+    const newId = 'b'.repeat(64);
+    await store.ensureInitialized([{ id: oldId, name: 'dotnet' }]);
+    await store.setDefaultActivation({ id: oldId, name: 'dotnet' }, 'disabled');
+    await store.setWorkspaceActivation(
+      { id: oldId, name: 'dotnet' },
+      '/workspace/a',
+      'enabled',
+    );
+
+    const snapshot = await store.ensureInitialized([
+      { id: newId, name: 'dotnet' },
+    ]);
+
+    expect(snapshot.extensions[oldId]).toBeUndefined();
+    expect(snapshot.extensions[newId]).toMatchObject({
+      name: 'dotnet',
+      defaultActivation: 'disabled',
+      workspaceOverrides: { '/workspace/a': 'enabled' },
+    });
+  });
+
+  it('re-keys across a case mismatch and normalizes the stored name', async () => {
+    const store = makeStore();
+    const oldId = 'a'.repeat(64);
+    const newId = 'b'.repeat(64);
+    await store.ensureInitialized([{ id: oldId, name: 'DotNet' }]);
+    await store.setDefaultActivation({ id: oldId, name: 'DotNet' }, 'disabled');
+
+    const snapshot = await store.ensureInitialized([
+      { id: newId, name: 'dotnet' },
+    ]);
+
+    expect(snapshot.extensions[oldId]).toBeUndefined();
+    expect(snapshot.extensions[newId]).toMatchObject({
+      name: 'dotnet',
+      defaultActivation: 'disabled',
+    });
+  });
+
+  it('re-keys only the orphaned policy when a sibling plugin installs fresh', async () => {
+    const store = makeStore();
+    const repoOnlyId = 'a'.repeat(64);
+    const dotnetId = 'b'.repeat(64);
+    const dotnetTestId = 'c'.repeat(64);
+    await store.ensureInitialized([{ id: repoOnlyId, name: 'dotnet' }]);
+
+    const snapshot = await store.ensureInitialized([
+      { id: dotnetId, name: 'dotnet' },
+      { id: dotnetTestId, name: 'dotnet-test' },
+    ]);
+
+    expect(snapshot.extensions[repoOnlyId]).toBeUndefined();
+    expect(snapshot.extensions[dotnetId]?.name).toBe('dotnet');
+    expect(snapshot.extensions[dotnetTestId]?.name).toBe('dotnet-test');
+  });
+
+  it('does not re-key a policy still owned by another loaded extension', async () => {
+    const store = makeStore();
+    const demoId = 'a'.repeat(64);
+    const otherId = 'b'.repeat(64);
+    await store.ensureInitialized([{ id: demoId, name: 'demo' }]);
+
+    const snapshot = await store.ensureInitialized([
+      { id: demoId, name: 'demo' },
+      { id: otherId, name: 'other' },
+    ]);
+
+    expect(snapshot.extensions[demoId]?.name).toBe('demo');
+    expect(snapshot.extensions[otherId]?.name).toBe('other');
+  });
+
   it('uses an inherit mask when clearing an override matched by a legacy rule', async () => {
     await fsp.writeFile(
       enablementPath,

packages/core/src/extension/extension-store.ts

@@ -273,6 +273,32 @@ export class ExtensionStore {
     const legacy = await this.readLegacyProjection();
     if (existing) {
       let changed = false;
+      // An id-formula change (e.g. #7568 added the plugin name to the hash)
+      // leaves installed extensions pointing at ids the store has never
+      // seen. Without this re-key, the blocks below would mint a fresh
+      // default policy under the new id — resetting activation state — and
+      // strand the old policy as an orphan that later trips the
+      // name-conflict guard on update/uninstall. Names are unique in the
+      // store (enforced case-insensitively on every commit), so a loaded
+      // identity whose id is unknown safely claims the policy stored under
+      // its name, provided no loaded extension still owns that entry.
+      const loadedIds = new Set(extensions.map((identity) => identity.id));
+      for (const identity of extensions) {
+        assertIdentity(identity);
+        if (existing.extensions[identity.id]) continue;
+        const staleEntry = Object.entries(existing.extensions).find(
+          ([id, policy]) =>
+            !loadedIds.has(id) &&
+            policy.name.toLowerCase() === identity.name.toLowerCase(),
+        );
+        if (staleEntry) {
+          const [staleId, policy] = staleEntry;
+          delete existing.extensions[staleId];
+          policy.name = identity.name;
+          existing.extensions[identity.id] = policy;
+          changed = true;
+        }
+      }
       if (existing.legacyProjectionHash !== projectionHash(legacy)) {
         if (!(await this.legacyProjectionIsNewerThanState())) {
           try {

packages/core/src/extension/extensionManager.test.ts

@@ -2780,6 +2780,41 @@ describe('extension tests', () => {
           hashValue('https://gitlab.company.com/team/extension-repo'),
         );
       });
+
+      it('gives plugins from the same repository distinct ids (#7568)', () => {
+        const metadataFor = (pluginName: string) => ({
+          type: 'git' as const,
+          source: 'https://github.com/dotnet/skills',
+          pluginName,
+        });
+        const dotnetId = getExtensionId(
+          { name: 'dotnet', version: '1.0.0' },
+          metadataFor('dotnet'),
+        );
+        const dotnetTestId = getExtensionId(
+          { name: 'dotnet-test', version: '1.0.0' },
+          metadataFor('dotnet-test'),
+        );
+
+        expect(dotnetId).toBe(
+          hashValue('https://github.com/dotnet/skills:dotnet'),
+        );
+        expect(dotnetTestId).toBe(
+          hashValue('https://github.com/dotnet/skills:dotnet-test'),
+        );
+        expect(dotnetId).not.toBe(dotnetTestId);
+      });
+
+      it('keeps the repo-only id when no plugin name is recorded', () => {
+        const config: ExtensionConfig = { name: 'solo-ext', version: '1.0.0' };
+        const metadata = {
+          type: 'git' as const,
+          source: 'https://github.com/owner/solo',
+        };
+        expect(getExtensionId(config, metadata)).toBe(
+          hashValue('https://github.com/owner/solo'),
+        );
+      });
     });
   });
 

packages/core/src/extension/extensionManager.ts

@@ -2624,6 +2624,14 @@ export function getExtensionId(
   } else {
     idValue = installMetadata?.source ?? config.name;
   }
+  // A marketplace repo can host several plugins; hashing only the repo URL
+  // collapses them into one id and the second install trips the store's
+  // id-ownership check (#7568). Suffix the plugin name so each plugin from
+  // the same source gets its own id. Installs recorded under the old
+  // repo-only id are re-keyed by ExtensionStore.ensureInitialized.
+  if (installMetadata?.pluginName) {
+    idValue += `:${installMetadata.pluginName}`;
+  }
   return hashValue(idValue);
 }