@bevel-software/platform-core-backend 0.7.5 → 0.9.0

package/src/modules/{groups/__tests__/groups.routes.test.ts → plugins/__tests__/plugins.routes.test.ts}

@@ -13,18 +13,18 @@ import type { WorkspaceService } from '../../workspace/workspace.service.js';
 import type { IAccessControl } from '../../access/access-control.interface.js';
 import type { ISkillService, SkillSummary } from '../../skills/skills.contract.js';
 import type { IToolManualService, ToolManualSummary } from '../../tool-manuals/tool-manuals.contract.js';
-import { GroupIndexService } from '../groups.service.js';
-import { createGroupsRoutes } from '../groups.routes.js';
+import { PluginIndexService } from '../plugins.service.js';
+import { createPluginsRoutes } from '../plugins.routes.js';
 import type { JoinRequestsService } from '../join-requests.service.js';
-import type { GroupSummary, IGroupIndexService } from '../groups.contract.js';
+import type { PluginSummary, IPluginIndexService } from '../plugins.contract.js';
 
 /**
- * HTTP-level contract for the group routes: the auth gate, the three-tier
+ * HTTP-level contract for the plugin routes: the auth gate, the three-tier
  * enumeration (member / manager / discoverable — all ordinary access
- * verdicts), the fail-closed omission of groups with no verdict at all, and
+ * verdicts), the fail-closed omission of plugins with no verdict at all, and
  * the join flow that rides on plain change requests.
  *
- * The group index is REAL over a temp KB; access control and the workflow are
+ * The plugin index is REAL over a temp KB; access control and the workflow are
  * stubs, because what's under test here is the route's use of them.
  */
 
@@ -38,18 +38,18 @@ const tmpDirs: string[] = [];
 
 interface HarnessOpts {
   /**
-   * Paths (`Groups/GTM` for the folder/member verdict, `Groups/GTM/access.md`
+   * Paths (`Plugins/GTM` for the folder/member verdict, `Plugins/GTM/access.md`
    * for the discover verdict) the given email may read.
    */
   readable?: Record<string, string[]>;
   /** Paths the given email may write. */
   writable?: Record<string, string[]>;
-  /** Paths (the FOLDER, e.g. `Groups/GTM`) the given email OWNS. */
+  /** Paths (the FOLDER, e.g. `Plugins/GTM`) the given email OWNS. */
   owner?: Record<string, string[]>;
   /** Open CRs `listChangeRequestsAuthoredBy` returns for any caller. */
   authoredCrs?: ChangeRequest[];
   /** Override the whole index (used to force the 500 path). */
-  index?: IGroupIndexService;
+  index?: IPluginIndexService;
   email?: string | null;
   skills?: SkillSummary[];
   tools?: ToolManualSummary[];
@@ -72,18 +72,18 @@ function cr(over: Partial<ChangeRequest>): ChangeRequest {
 }
 
 async function makeHarness(opts: HarnessOpts = {}) {
-  const workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), 'bevel-groups-routes-'));
+  const workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), 'bevel-plugins-routes-'));
   tmpDirs.push(workspaceDir);
   const kbRoot = path.join(workspaceDir, KB);
-  // Both carry the access.md that makes a folder a group at all.
-  await fs.mkdir(path.join(kbRoot, 'Groups', 'GTM'), { recursive: true });
+  // Both carry the access.md that makes a folder a plugin at all.
+  await fs.mkdir(path.join(kbRoot, 'Plugins', 'GTM'), { recursive: true });
   await fs.writeFile(
-    path.join(kbRoot, 'Groups', 'GTM', 'access.md'),
+    path.join(kbRoot, 'Plugins', 'GTM', 'access.md'),
     '---\nread:\n  - everyone\n---\nread: []\n',
   );
-  await fs.mkdir(path.join(kbRoot, 'Groups', 'Finance'), { recursive: true });
+  await fs.mkdir(path.join(kbRoot, 'Plugins', 'Finance'), { recursive: true });
   await fs.writeFile(
-    path.join(kbRoot, 'Groups', 'Finance', 'access.md'),
+    path.join(kbRoot, 'Plugins', 'Finance', 'access.md'),
     '---\nread:\n  - everyone\n---\nread: []\n',
   );
 
@@ -133,7 +133,7 @@ async function makeHarness(opts: HarnessOpts = {}) {
 
   const index =
     opts.index ??
-    new GroupIndexService(workspaceService, accessControl, skillService, toolService, KB);
+    new PluginIndexService(workspaceService, accessControl, skillService, toolService, KB);
 
   const email = opts.email === undefined ? ALI : opts.email;
   const app = express();
@@ -153,13 +153,13 @@ async function makeHarness(opts: HarnessOpts = {}) {
   // Provisioning MECHANISM is exercised by its own service tests; the routes
   // here only need to prove what they hand it and when they refuse to.
   const provision = {
-    createGroup: vi.fn(async () => ({ folder: 'GTM', created: true })),
-    deleteGroup: vi.fn(async () => undefined),
+    createPlugin: vi.fn(async () => ({ folder: 'GTM', created: true })),
+    deletePlugin: vi.fn(async () => undefined),
   };
 
   app.use(
     '/api',
-    createGroupsRoutes(
+    createPluginsRoutes(
       index,
       accessControl,
       workflow,
@@ -191,10 +191,10 @@ function close(s: Server): Promise<void> {
 }
 
 const MEMBER_OF_BOTH = {
-  [ALI]: ['Groups/GTM', 'Groups/GTM/access.md', 'Groups/Finance', 'Groups/Finance/access.md'],
+  [ALI]: ['Plugins/GTM', 'Plugins/GTM/access.md', 'Plugins/Finance', 'Plugins/Finance/access.md'],
 };
 
-describe('/api/groups routes', () => {
+describe('/api/plugins routes', () => {
   let server: Server | null = null;
   afterEach(async () => {
     if (server) await close(server);
@@ -202,51 +202,51 @@ describe('/api/groups routes', () => {
     await Promise.all(tmpDirs.splice(0).map((d) => fs.rm(d, { recursive: true, force: true })));
   });
 
-  const listGroups = async (baseUrl: string) => {
-    const res = await fetch(`${baseUrl}/api/groups`);
-    const body = (await res.json()) as { groups: GroupSummary[] };
-    return { status: res.status, groups: body.groups, raw: JSON.stringify(body) };
+  const listPlugins = async (baseUrl: string) => {
+    const res = await fetch(`${baseUrl}/api/plugins`);
+    const body = (await res.json()) as { plugins: PluginSummary[] };
+    return { status: res.status, plugins: body.plugins, raw: JSON.stringify(body) };
   };
 
   it('401s both endpoints when req.userEmail is absent', async () => {
     const h = await makeHarness({ email: null });
     server = h.server;
     for (const [method, url] of [
-      ['GET', '/api/groups'],
-      ['POST', '/api/groups/GTM/join-request'],
-      ['DELETE', '/api/groups/GTM'],
+      ['GET', '/api/plugins'],
+      ['POST', '/api/plugins/GTM/join-request'],
+      ['DELETE', '/api/plugins/GTM'],
     ] as const) {
       const res = await fetch(`${h.baseUrl}${url}`, { method });
       expect(res.status, `${method} ${url}`).toBe(401);
     }
   });
 
-  it('lists member groups sorted, counting by groupOfPath', async () => {
+  it('lists member plugins sorted, counting by pluginOfPath', async () => {
     const h = await makeHarness({
       readable: MEMBER_OF_BOTH,
-      skills: [{ name: 'outreach', description: '', path: 'Groups/GTM/outreach' }],
+      skills: [{ name: 'outreach', description: '', path: 'Plugins/GTM/outreach' }],
       tools: [
-        { slug: 'ledger', name: 'ledger', path: 'Groups/Finance/ledger.tool', type: 'inline' },
-        { slug: 'slack', name: 'slack', path: 'Groups/slack.tool', type: 'inline' },
+        { slug: 'ledger', name: 'ledger', path: 'Plugins/Finance/ledger.tool', type: 'inline' },
+        { slug: 'slack', name: 'slack', path: 'Plugins/slack.tool', type: 'inline' },
       ],
     });
     server = h.server;
-    const { status, groups } = await listGroups(h.baseUrl);
+    const { status, plugins } = await listPlugins(h.baseUrl);
     expect(status).toBe(200);
-    expect(groups.map((g) => g.name)).toEqual(['Finance', 'GTM']);
-    expect(groups[0]).toMatchObject({ canRead: true, skillCount: 0, toolCount: 1 });
-    expect(groups[1]).toMatchObject({ canRead: true, skillCount: 1, toolCount: 0 });
+    expect(plugins.map((g) => g.name)).toEqual(['Finance', 'GTM']);
+    expect(plugins[0]).toMatchObject({ canRead: true, skillCount: 0, toolCount: 1 });
+    expect(plugins[1]).toMatchObject({ canRead: true, skillCount: 1, toolCount: 0 });
   });
 
-  it('a DISCOVERABLE group (access.md readable, folder not) lists locked with hasRequested from the join CR', async () => {
+  it('a DISCOVERABLE plugin (access.md readable, folder not) lists locked with hasRequested from the join CR', async () => {
     const h = await makeHarness({
-      readable: { [ALI]: ['Groups/Finance/access.md'] },
+      readable: { [ALI]: ['Plugins/Finance/access.md'] },
       authoredCrs: [cr({ branch: joinBranchFor(ALI, 'Finance'), number: 9 })],
     });
     server = h.server;
-    const { groups } = await listGroups(h.baseUrl);
-    expect(groups.map((g) => g.name)).toEqual(['Finance']);
-    expect(groups[0]).toMatchObject({
+    const { plugins } = await listPlugins(h.baseUrl);
+    expect(plugins.map((g) => g.name)).toEqual(['Finance']);
+    expect(plugins[0]).toMatchObject({
       canRead: false,
       canWrite: false,
       hasRequested: true,
@@ -254,91 +254,91 @@ describe('/api/groups routes', () => {
     });
   });
 
-  it('OMITS a group with NO verdict at all — nothing about it leaves the backend', async () => {
-    const h = await makeHarness({ readable: { [ALI]: ['Groups/Finance/access.md'] } });
+  it('OMITS a plugin with NO verdict at all — nothing about it leaves the backend', async () => {
+    const h = await makeHarness({ readable: { [ALI]: ['Plugins/Finance/access.md'] } });
     server = h.server;
-    const { groups, raw } = await listGroups(h.baseUrl);
-    expect(groups.map((g) => g.name)).toEqual(['Finance']);
+    const { plugins, raw } = await listPlugins(h.baseUrl);
+    expect(plugins.map((g) => g.name)).toEqual(['Finance']);
     expect(raw).not.toContain('"name":"GTM"');
-    expect(raw).not.toContain('Groups/GTM');
+    expect(raw).not.toContain('Plugins/GTM');
   });
 
-  it("keeps a locked-out folder-writer's group listed with canWrite: true (admin-rescue)", async () => {
-    const h = await makeHarness({ writable: { [ALI]: ['Groups/GTM/access.md'] } });
+  it("keeps a locked-out folder-writer's plugin listed with canWrite: true (admin-rescue)", async () => {
+    const h = await makeHarness({ writable: { [ALI]: ['Plugins/GTM/access.md'] } });
     server = h.server;
-    const { groups } = await listGroups(h.baseUrl);
-    expect(groups.map((g) => g.name)).toEqual(['GTM']);
-    expect(groups[0]).toMatchObject({ canRead: false, canWrite: true });
+    const { plugins } = await listPlugins(h.baseUrl);
+    expect(plugins.map((g) => g.name)).toEqual(['GTM']);
+    expect(plugins[0]).toMatchObject({ canRead: false, canWrite: true });
   });
 
   it('a member never reports hasRequested (their stale join CR is ignored)', async () => {
     const h = await makeHarness({
-      readable: { [ALI]: ['Groups/GTM', 'Groups/GTM/access.md'] },
+      readable: { [ALI]: ['Plugins/GTM', 'Plugins/GTM/access.md'] },
       authoredCrs: [cr({})],
     });
     server = h.server;
-    const { groups } = await listGroups(h.baseUrl);
-    expect(groups[0]).toMatchObject({ name: 'GTM', canRead: true, hasRequested: false });
+    const { plugins } = await listPlugins(h.baseUrl);
+    expect(plugins[0]).toMatchObject({ name: 'GTM', canRead: true, hasRequested: false });
   });
 
   it('lists the owner verdict per caller — the folder verdict, not the manager one', async () => {
     const h = await makeHarness({
       readable: MEMBER_OF_BOTH,
-      owner: { [ALI]: ['Groups/GTM'] },
+      owner: { [ALI]: ['Plugins/GTM'] },
     });
     server = h.server;
-    const { groups } = await listGroups(h.baseUrl);
-    expect(groups.find((g) => g.name === 'GTM')).toMatchObject({ isOwner: true });
-    expect(groups.find((g) => g.name === 'Finance')).toMatchObject({ isOwner: false });
+    const { plugins } = await listPlugins(h.baseUrl);
+    expect(plugins.find((g) => g.name === 'GTM')).toMatchObject({ isOwner: true });
+    expect(plugins.find((g) => g.name === 'Finance')).toMatchObject({ isOwner: false });
   });
 
   it('delete: 404 for unknown AND for a non-owner — a manager included (identical, fail-closed)', async () => {
     // A MANAGER (write on the access.md) and a MEMBER, but not an owner:
     // deletion is the owner's verb, and the refusal must not confirm the
-    // group exists.
+    // plugin exists.
     const h = await makeHarness({
       readable: MEMBER_OF_BOTH,
-      writable: { [ALI]: ['Groups/GTM/access.md'] },
+      writable: { [ALI]: ['Plugins/GTM/access.md'] },
     });
     server = h.server;
     for (const name of ['Nope', 'GTM']) {
-      const res = await fetch(`${h.baseUrl}/api/groups/${name}`, { method: 'DELETE' });
+      const res = await fetch(`${h.baseUrl}/api/plugins/${name}`, { method: 'DELETE' });
       expect(res.status, name).toBe(404);
-      expect(await res.json()).toEqual({ error: 'Unknown group', kind: 'unknown-group' });
+      expect(await res.json()).toEqual({ error: 'Unknown plugin', kind: 'unknown-plugin' });
     }
-    expect(h.provision.deleteGroup).not.toHaveBeenCalled();
+    expect(h.provision.deletePlugin).not.toHaveBeenCalled();
   });
 
   it('delete: an OWNER deletes through the provision door, by the catalog name', async () => {
-    const h = await makeHarness({ owner: { [ALI]: ['Groups/GTM'] } });
+    const h = await makeHarness({ owner: { [ALI]: ['Plugins/GTM'] } });
     server = h.server;
-    const res = await fetch(`${h.baseUrl}/api/groups/GTM`, { method: 'DELETE' });
+    const res = await fetch(`${h.baseUrl}/api/plugins/GTM`, { method: 'DELETE' });
     expect(res.status).toBe(200);
     expect(await res.json()).toEqual({ ok: true });
-    expect(h.provision.deleteGroup).toHaveBeenCalledWith(
+    expect(h.provision.deletePlugin).toHaveBeenCalledWith(
       expect.objectContaining({ email: ALI }),
       'GTM',
     );
   });
 
   it("delete: passes a provision refusal through with the service's own status and words", async () => {
-    const h = await makeHarness({ owner: { [ALI]: ['Groups/GTM'] } });
-    const { GroupProvisionError } = await import('../group-provision.service.js');
-    h.provision.deleteGroup.mockRejectedValueOnce(new GroupProvisionError('Unknown group', 404));
+    const h = await makeHarness({ owner: { [ALI]: ['Plugins/GTM'] } });
+    const { PluginProvisionError } = await import('../plugin-provision.service.js');
+    h.provision.deletePlugin.mockRejectedValueOnce(new PluginProvisionError('Unknown plugin', 404));
     server = h.server;
-    const res = await fetch(`${h.baseUrl}/api/groups/GTM`, { method: 'DELETE' });
+    const res = await fetch(`${h.baseUrl}/api/plugins/GTM`, { method: 'DELETE' });
     expect(res.status).toBe(404);
-    expect(await res.json()).toEqual({ error: 'Unknown group' });
+    expect(await res.json()).toEqual({ error: 'Unknown plugin' });
   });
 
   it('delete: 500s with its own words when the mechanism fails', async () => {
     const error = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const h = await makeHarness({ owner: { [ALI]: ['Groups/GTM'] } });
-    h.provision.deleteGroup.mockRejectedValueOnce(new Error('push refused'));
+    const h = await makeHarness({ owner: { [ALI]: ['Plugins/GTM'] } });
+    h.provision.deletePlugin.mockRejectedValueOnce(new Error('push refused'));
     server = h.server;
-    const res = await fetch(`${h.baseUrl}/api/groups/GTM`, { method: 'DELETE' });
+    const res = await fetch(`${h.baseUrl}/api/plugins/GTM`, { method: 'DELETE' });
     expect(res.status).toBe(500);
-    expect(await res.json()).toEqual({ error: 'Failed to delete the group' });
+    expect(await res.json()).toEqual({ error: 'Failed to delete the plugin' });
     error.mockRestore();
   });
 
@@ -346,33 +346,33 @@ describe('/api/groups routes', () => {
     const h = await makeHarness({});
     server = h.server;
     for (const name of ['Nope', 'GTM']) {
-      const res = await fetch(`${h.baseUrl}/api/groups/${name}/join-request`, { method: 'POST' });
+      const res = await fetch(`${h.baseUrl}/api/plugins/${name}/join-request`, { method: 'POST' });
       expect(res.status, name).toBe(404);
-      expect(await res.json()).toEqual({ error: 'Unknown group', kind: 'unknown-group' });
+      expect(await res.json()).toEqual({ error: 'Unknown plugin', kind: 'unknown-plugin' });
     }
   });
 
   it('join-request: 409 when the caller can already read the folder', async () => {
     const h = await makeHarness({ readable: MEMBER_OF_BOTH });
     server = h.server;
-    const res = await fetch(`${h.baseUrl}/api/groups/Finance/join-request`, { method: 'POST' });
+    const res = await fetch(`${h.baseUrl}/api/plugins/Finance/join-request`, { method: 'POST' });
     expect(res.status).toBe(409);
     expect((await res.json()).kind).toBe('already-readable');
   });
 
   it('join-request: branch + splice + commit + CR, on the deterministic join branch', async () => {
-    const h = await makeHarness({ readable: { [ALI]: ['Groups/Finance/access.md'] } });
+    const h = await makeHarness({ readable: { [ALI]: ['Plugins/Finance/access.md'] } });
     server = h.server;
-    const res = await fetch(`${h.baseUrl}/api/groups/Finance/join-request`, { method: 'POST' });
+    const res = await fetch(`${h.baseUrl}/api/plugins/Finance/join-request`, { method: 'POST' });
     expect(res.status).toBe(200);
     expect(await res.json()).toEqual({ ok: true, number: 42 });
 
     const branch = joinBranchFor(ALI, 'Finance');
     expect(h.workflow.createBranch).toHaveBeenCalledWith(wsId, branch, DEFAULT_BRANCH);
-    // The write went to the group's access.md and added the caller to the
+    // The write went to the plugin's access.md and added the caller to the
     // BODY's read list (folder rules), leaving the discovery frontmatter alone.
     const write = (h.workspaceService.writeFile as ReturnType<typeof vi.fn>).mock.calls[0];
-    expect(write[1]).toBe(`${KB}/Groups/Finance/access.md`);
+    expect(write[1]).toBe(`${KB}/Plugins/Finance/access.md`);
     expect(write[2]).toContain('Ali Baba <ali@bevel.software>');
     expect((write[2] as string).indexOf('everyone')).toBeLessThan(
       (write[2] as string).indexOf('Ali Baba'),
@@ -391,11 +391,11 @@ describe('/api/groups routes', () => {
 
   it('join-request is idempotent: an existing open join CR is returned, nothing new is created', async () => {
     const h = await makeHarness({
-      readable: { [ALI]: ['Groups/Finance/access.md'] },
+      readable: { [ALI]: ['Plugins/Finance/access.md'] },
       authoredCrs: [cr({ branch: joinBranchFor(ALI, 'Finance'), number: 9 })],
     });
     server = h.server;
-    const res = await fetch(`${h.baseUrl}/api/groups/Finance/join-request`, { method: 'POST' });
+    const res = await fetch(`${h.baseUrl}/api/plugins/Finance/join-request`, { method: 'POST' });
     expect(res.status).toBe(200);
     expect(await res.json()).toEqual({ ok: true, number: 9 });
     expect(h.workflow.createBranch).not.toHaveBeenCalled();
@@ -403,27 +403,27 @@ describe('/api/groups routes', () => {
   });
 
   it('degrades hasRequested to false when the CR lookup throws', async () => {
-    const h = await makeHarness({ readable: { [ALI]: ['Groups/Finance/access.md'] } });
+    const h = await makeHarness({ readable: { [ALI]: ['Plugins/Finance/access.md'] } });
     (h.workflow.listChangeRequestsAuthoredBy as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
       new Error('gh down'),
     );
     const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
     server = h.server;
-    const { status, groups } = await listGroups(h.baseUrl);
+    const { status, plugins } = await listPlugins(h.baseUrl);
     expect(status).toBe(200);
-    expect(groups[0]).toMatchObject({ hasRequested: false });
+    expect(plugins[0]).toMatchObject({ hasRequested: false });
     warn.mockRestore();
   });
 
-  it('join-requests: a MANAGER gets the service\'s list for the group', async () => {
-    const h = await makeHarness({ writable: { [ALI]: ['Groups/GTM/access.md'] } });
+  it('join-requests: a MANAGER gets the service\'s list for the plugin', async () => {
+    const h = await makeHarness({ writable: { [ALI]: ['Plugins/GTM/access.md'] } });
     server = h.server;
-    const res = await fetch(`${h.baseUrl}/api/groups/GTM/join-requests`);
+    const res = await fetch(`${h.baseUrl}/api/plugins/GTM/join-requests`);
     expect(res.status).toBe(200);
     expect(await res.json()).toEqual({ requests: [] });
     expect(h.joinRequests.list).toHaveBeenCalledWith(
       'GTM',
-      'Groups/GTM',
+      'Plugins/GTM',
       expect.anything(),
       expect.objectContaining({ email: ALI }),
     );
@@ -434,7 +434,7 @@ describe('/api/groups routes', () => {
     // question only the server answers.
     const h = await makeHarness({ readable: MEMBER_OF_BOTH });
     server = h.server;
-    const res = await fetch(`${h.baseUrl}/api/groups/GTM/join-requests`);
+    const res = await fetch(`${h.baseUrl}/api/plugins/GTM/join-requests`);
     expect(res.status).toBe(200);
     expect(await res.json()).toEqual({ requests: [] });
     expect(h.joinRequests.list).not.toHaveBeenCalled();
@@ -443,7 +443,7 @@ describe('/api/groups routes', () => {
   it('reconcile: 404 for a non-manager — indistinguishable from a missing request', async () => {
     const h = await makeHarness({ readable: MEMBER_OF_BOTH, authoredCrs: [cr({ number: 7 })] });
     server = h.server;
-    const denied = await fetch(`${h.baseUrl}/api/groups/GTM/join-requests/7/reconcile`, {
+    const denied = await fetch(`${h.baseUrl}/api/plugins/GTM/join-requests/7/reconcile`, {
       method: 'POST',
     });
     expect(denied.status).toBe(404);
@@ -451,9 +451,9 @@ describe('/api/groups routes', () => {
   });
 
   it('reconcile: 404 for a manager when the change request does not exist', async () => {
-    const h = await makeHarness({ writable: { [ALI]: ['Groups/GTM/access.md'] } });
+    const h = await makeHarness({ writable: { [ALI]: ['Plugins/GTM/access.md'] } });
     server = h.server;
-    const missing = await fetch(`${h.baseUrl}/api/groups/GTM/join-requests/999/reconcile`, {
+    const missing = await fetch(`${h.baseUrl}/api/plugins/GTM/join-requests/999/reconcile`, {
       method: 'POST',
     });
     expect(missing.status).toBe(404);
@@ -462,19 +462,19 @@ describe('/api/groups routes', () => {
 
   it('reconcile: a manager settles an open request through the service', async () => {
     const h = await makeHarness({
-      writable: { [ALI]: ['Groups/GTM/access.md'] },
+      writable: { [ALI]: ['Plugins/GTM/access.md'] },
       authoredCrs: [cr({ number: 7 })],
     });
     (h.joinRequests.reconcile as ReturnType<typeof vi.fn>).mockResolvedValue(true);
     server = h.server;
-    const res = await fetch(`${h.baseUrl}/api/groups/GTM/join-requests/7/reconcile`, {
+    const res = await fetch(`${h.baseUrl}/api/plugins/GTM/join-requests/7/reconcile`, {
       method: 'POST',
     });
     expect(res.status).toBe(200);
     expect(await res.json()).toEqual({ closed: true });
   });
 
-  it('500s with { error: "Failed to list groups" } when the index throws', async () => {
+  it('500s with { error: "Failed to list plugins" } when the index throws', async () => {
     const error = vi.spyOn(console, 'error').mockImplementation(() => {});
     const h = await makeHarness({
       index: {
@@ -485,9 +485,9 @@ describe('/api/groups routes', () => {
       },
     });
     server = h.server;
-    const res = await fetch(`${h.baseUrl}/api/groups`);
+    const res = await fetch(`${h.baseUrl}/api/plugins`);
     expect(res.status).toBe(500);
-    expect(await res.json()).toEqual({ error: 'Failed to list groups' });
+    expect(await res.json()).toEqual({ error: 'Failed to list plugins' });
     error.mockRestore();
   });
 });

package/src/modules/plugins/index.ts

@@ -0,0 +1,17 @@
+export { PluginIndexService, pluginsWorkspaceId } from './plugins.service.js';
+export {
+  PluginProvisionService,
+  PluginProvisionError,
+  pluginAccessMd,
+  personalAccessMd,
+} from './plugin-provision.service.js';
+export { JoinRequestsService, type JoinRequest } from './join-requests.service.js';
+export { pendingProposals, type JoinProposal } from './join-proposals.js';
+export { createPluginsRoutes } from './plugins.routes.js';
+export type {
+  IPluginIndexService,
+  PluginCatalogEntry,
+  PluginSummary,
+  ResolvedPrincipals,
+  ResolvedReaders,
+} from './plugins.contract.js';

package/src/modules/{groups → plugins}/join-proposals.ts

@@ -8,9 +8,9 @@ import {
 /**
  * What a join branch is PROPOSING, relative to the default branch.
  *
- * A join request is a change request whose branch edits one group's
+ * A join request is a change request whose branch edits one plugin's
  * `access.md`. Rather than treating that change request as an all-or-nothing
- * merge, the group's managers see its individual proposals — "grant Ali read",
+ * merge, the plugin's managers see its individual proposals — "grant Ali read",
  * "grant GTM Team write" — and answer them one at a time. Approving a proposal
  * writes THAT ONE grant onto the default branch through the ordinary access
  * mutation path; the branch is never merged, so nothing else it happens to

package/src/modules/{groups → plugins}/join-requests.service.ts

@@ -45,15 +45,15 @@ export class JoinRequestsService {
   ) {}
 
   /**
-   * Open join requests for `group`, each carrying only its still-pending
+   * Open join requests for `plugin`, each carrying only its still-pending
    * proposals. Requests with none left are reconciled away (rejected, branch
    * deleted) and omitted.
    *
-   * `actor` is who the reconciliation acts as — a manager of the group, since
+   * `actor` is who the reconciliation acts as — a manager of the plugin, since
    * rejecting a change request requires write on everything it touches.
    */
   async list(
-    group: string,
+    plugin: string,
     folder: string,
     crs: ChangeRequest[],
     actor: AuthUser,
@@ -63,7 +63,7 @@ export class JoinRequestsService {
     const baseText = await this.readAt(DEFAULT_BRANCH, accessPath);
     const out: JoinRequest[] = [];
     for (const cr of crs) {
-      if (cr.state !== 'open' || !isJoinBranchFor(cr.branch, group)) continue;
+      if (cr.state !== 'open' || !isJoinBranchFor(cr.branch, plugin)) continue;
       const proposals = pendingProposals(
         await this.readAt(cr.branch, accessPath),
         baseText,
@@ -90,12 +90,12 @@ export class JoinRequestsService {
    * same round-trip instead of waiting for the next listing.
    */
   async reconcile(
-    group: string,
+    plugin: string,
     folder: string,
     cr: ChangeRequest,
     actor: AuthUser,
   ): Promise<boolean> {
-    if (cr.state !== 'open' || !isJoinBranchFor(cr.branch, group)) return false;
+    if (cr.state !== 'open' || !isJoinBranchFor(cr.branch, plugin)) return false;
     await this.refresh();
     const accessPath = `${folder}/access.md`;
     const proposals = pendingProposals(
@@ -133,7 +133,7 @@ export class JoinRequestsService {
       );
     } catch (err) {
       console.warn(
-        `[groups] could not close settled join request #${cr.number}: ${
+        `[plugins] could not close settled join request #${cr.number}: ${
           err instanceof Error ? err.message : String(err)
         }`,
       );
@@ -145,7 +145,7 @@ export class JoinRequestsService {
       // The request is closed either way; a leftover branch is cosmetic and
       // the author can still delete it themselves.
       console.warn(
-        `[groups] closed join request #${cr.number} but could not delete "${cr.branch}": ${
+        `[plugins] closed join request #${cr.number} but could not delete "${cr.branch}": ${
           err instanceof Error ? err.message : String(err)
         }`,
       );