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

package/src/shared/__tests__/join-request.test.ts

@@ -1,19 +1,19 @@
 import { describe, it, expect } from 'vitest';
-import { isJoinBranchFor, joinBranchFor, kebabGroupName } from '@bevel-software/platform-shared';
+import { isJoinBranchFor, joinBranchFor, kebabPluginName } from '@bevel-software/platform-shared';
 import { assertValidBranchName } from '../../modules/workflow/git/branch-name.js';
 
 /**
  * The join-branch convention. Two properties matter, and they pull in
  * different directions:
  *
- *  - UNIQUENESS (the write side): distinct requesters and distinct groups must
+ *  - UNIQUENESS (the write side): distinct requesters and distinct plugins must
  *    never share a branch, or one person's commit lands on another's request.
  *    Both inputs the name is built from are lossy; the requester tag fixes it.
- *  - EXACT GROUP IDENTITY (the read side): the settle decision is "the diff
- *    is empty", so matching a branch to the WRONG group reads an unchanged
+ *  - EXACT PLUGIN IDENTITY (the read side): the settle decision is "the diff
+ *    is empty", so matching a branch to the WRONG plugin reads an unchanged
  *    file, sees an empty diff, and destroys somebody else's request. The
- *    group tag is recomputed from the exact name so shape-matching can never
- *    cross groups; only the requester half matches by shape (the reader has
+ *    plugin tag is recomputed from the exact name so shape-matching can never
+ *    cross plugins; only the requester half matches by shape (the reader has
  *    no email to recompute it from).
  */
 const TAG = '[0-9a-z]{7}';
@@ -37,19 +37,19 @@ describe('joinBranchFor', () => {
     );
   });
 
-  it('separates groups whose names kebab to the same slug', () => {
+  it('separates plugins whose names kebab to the same slug', () => {
     expect(joinBranchFor('ali@bevel.software', 'Finance!')).not.toBe(
       joinBranchFor('ali@bevel.software', 'Finance'),
     );
-    // Case is part of a group's identity (the folder name is case-sensitive).
+    // Case is part of a plugin's identity (the folder name is case-sensitive).
     expect(joinBranchFor('ali@bevel.software', 'finance')).not.toBe(
       joinBranchFor('ali@bevel.software', 'Finance'),
     );
   });
 
-  it('still yields a valid, matchable branch for a group with no alphanumerics', () => {
+  it('still yields a valid, matchable branch for a plugin with no alphanumerics', () => {
     const branch = joinBranchFor('ali@bevel.software', '!!!');
-    expect(kebabGroupName('!!!')).toBe('');
+    expect(kebabPluginName('!!!')).toBe('');
     expect(branch).toMatch(new RegExp(`^ali/join-${TAG}-${TAG}$`));
     expect(() => assertValidBranchName(branch)).not.toThrow();
     expect(isJoinBranchFor(branch, '!!!')).toBe(true);
@@ -62,16 +62,16 @@ describe('isJoinBranchFor', () => {
     expect(isJoinBranchFor(joinBranchFor('ali@other.com', 'GTM'), 'GTM')).toBe(true);
   });
 
-  it('rejects a branch for a different group', () => {
+  it('rejects a branch for a different plugin', () => {
     expect(isJoinBranchFor(joinBranchFor('ali@bevel.software', 'Finance'), 'GTM')).toBe(false);
   });
 
-  it('NEVER crosses slug-colliding groups — the destructive-settle regression', () => {
+  it('NEVER crosses slug-colliding plugins — the destructive-settle regression', () => {
     // `Finance!`, `finance` and `Finance` all slug to `finance`. A listing
     // for one that matched another's branch would read that branch's copy of
     // ITS OWN access.md (unchanged there), see an empty diff, and settle —
     // closing a change request and deleting a branch belonging to a
-    // different group. The recomputed group tag is what forbids the match.
+    // different plugin. The recomputed plugin tag is what forbids the match.
     const forBang = joinBranchFor('ali@bevel.software', 'Finance!');
     expect(isJoinBranchFor(forBang, 'finance')).toBe(false);
     expect(isJoinBranchFor(forBang, 'Finance')).toBe(false);

package/src/shared/__tests__/kb-layout.plugin.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from 'vitest';
+import { pluginOfPath, PLUGINS_DIR } from '@bevel-software/platform-shared';
+
+/**
+ * `pluginOfPath` is the whole of the grouping contract — the sidebar, the
+ * catalog buckets and the access story all read a plugin off a path with it.
+ * The cases that matter are the ones where "has a plugin" and "is under the
+ * plugin root" come apart.
+ */
+describe('pluginOfPath', () => {
+  it('reads the plugin from the Plugins root', () => {
+    expect(pluginOfPath(`${PLUGINS_DIR}/GTM/heyreach-campaign/SKILL.md`)).toBe('GTM');
+    expect(pluginOfPath(`${PLUGINS_DIR}/GTM/heyreach.tool`)).toBe('GTM');
+    expect(pluginOfPath(`${PLUGINS_DIR}/Engineering/review/architecture-review`)).toBe(
+      'Engineering',
+    );
+  });
+
+  it('returns null for content directly under the root — it has no plugin folder', () => {
+    // The regression this guards: `Plugins/slack.tool` must NOT report a plugin
+    // called "slack.tool", and `Plugins/GTM` must not report itself.
+    expect(pluginOfPath(`${PLUGINS_DIR}/slack.tool`)).toBeNull();
+    expect(pluginOfPath(`${PLUGINS_DIR}/GTM`)).toBeNull();
+    expect(pluginOfPath(PLUGINS_DIR)).toBeNull();
+  });
+
+  it('returns null outside the plugin root', () => {
+    expect(pluginOfPath('KnowledgeBase/Product/Knowledge/Foo.md')).toBeNull();
+    expect(pluginOfPath('Data/Engineering/Knowledge/Bar.md')).toBeNull();
+    // The retired pre-merge roots are ordinary non-plugin folders now.
+    expect(pluginOfPath('Skills/GTM/heyreach-campaign')).toBeNull();
+    expect(pluginOfPath('Tools/NewsAgent/serper.tool')).toBeNull();
+    expect(pluginOfPath('access.md')).toBeNull();
+    expect(pluginOfPath('')).toBeNull();
+  });
+
+  it('is not fooled by a prefix match on the root name', () => {
+    expect(pluginOfPath('PluginsOld/GTM/x')).toBeNull();
+  });
+
+  it('tolerates leading and doubled separators', () => {
+    expect(pluginOfPath(`/${PLUGINS_DIR}/GTM/x`)).toBe('GTM');
+    expect(pluginOfPath(`${PLUGINS_DIR}//GTM//x`)).toBe('GTM');
+  });
+});

package/src/shared/kb-layout.test.ts

@@ -17,7 +17,7 @@ describe('ontologyOf', () => {
   });
 
   it('treats a nested ontology directory as the full prefix before the marker', () => {
-    expect(ontologyOf('KnowledgeBase/Group/Sub/Knowledge/x.md')).toBe('KnowledgeBase/Group/Sub');
+    expect(ontologyOf('KnowledgeBase/Plugin/Sub/Knowledge/x.md')).toBe('KnowledgeBase/Plugin/Sub');
   });
 
   it('returns null when the marker sits directly under KnowledgeBase/', () => {
@@ -41,8 +41,8 @@ describe('ontologyOf', () => {
     expect(ontologyOf('KnowledgeBase/Ops/Knowledge/x.md')).toBe('KnowledgeBase/Ops');
   });
 
-  it('returns null for Groups and root config (neutral)', () => {
-    expect(ontologyOf('Groups/some-skill/SKILL.md')).toBeNull();
+  it('returns null for Plugins and root config (neutral)', () => {
+    expect(ontologyOf('Plugins/some-skill/SKILL.md')).toBeNull();
     expect(ontologyOf('access.md')).toBeNull();
     expect(ontologyOf('roles.yaml')).toBeNull();
   });

package/src/shared/utcp-namespace.ts

@@ -1,21 +1,15 @@
 /**
- * The key UTCP uses to look up a manual's `${VAR}`. `@utcp/sdk` first SANITIZES
- * the manual name — every non-word char (`-`, `.`, spaces, …) becomes `_`
- * (`manualCallTemplate.name.replace(/[^\w]/g, "_")` at registration) — and then
- * namespaces variables under `<namespace>_<VAR>` where every `_` in the
- * sanitized namespace is DOUBLED (the variable substitutor), so `my_tool` + `KEY`
- * → `my__tool_KEY` and `my-tool` + `KEY` → the very same `my__tool_KEY`. Our
- * secret storage AND scope resolution must derive the exact same key. For an
- * alphanumeric name (no `_`, no punctuation) this reduces to `<name>_<VAR>`,
- * so plain tool names are unaffected.
+ * UTCP namespacing and the Bevel-hosted seeding rule now live in
+ * `@bevel-software/platform-mcp-core`: the local MCP server has to make the
+ * SAME bearer-leak decision this file documents, and a security rule that
+ * exists in two copies is a security rule that will eventually differ.
+ * Re-exported here because this is the path the rest of the package imports.
  */
-export function utcpNamespacePrefix(manualName: string): string {
-  return `${manualName.replace(/[^\w]/g, '_').replace(/_/g, '__')}_`;
-}
-
-export function utcpNamespacedKey(manualName: string, varName: string): string {
-  return `${utcpNamespacePrefix(manualName)}${varName}`;
-}
+export {
+  utcpNamespacePrefix,
+  utcpNamespacedKey,
+  seedBevelHostedManualVars,
+} from '@bevel-software/platform-mcp-core';
 
 /**
  * The synthetic per-user variable MCP OAuth auto-discovery hangs a remote
@@ -34,55 +28,3 @@ export const MCP_OAUTH_VAR = 'MCP_OAUTH';
  * connector creds under the shared namespace) can't drift.
  */
 export const INTERNAL_MANUAL_NAME = 'Bevel';
-
-/**
- * The origin template WE mint for every Bevel-hosted manual's discovery URL
- * (`${API_URL}/api/…`). `${API_URL}` expands to the loopback origin, so a
- * Bevel-hosted URL always has this exact string as its scheme+authority.
- */
-const LOOPBACK_ORIGIN_TEMPLATE = '${API_URL}';
-
-/**
- * True only when `${API_URL}` is the URL's ORIGIN (scheme+authority) — the shape
- * we ourselves produce for a Bevel-hosted manual. A third-party `.tool` author
- * can embed the literal `${API_URL}` anywhere in a path or query
- * (`http://evil.example/?x=${API_URL}`) but can NOT make it the authority without
- * pointing the request back at our own loopback, so anchoring the trust decision
- * to the origin is what a user `.tool`'s URL text cannot forge.
- */
-function isBevelHostedUrl(url: string): boolean {
-  if (!url.startsWith(LOOPBACK_ORIGIN_TEMPLATE)) return false;
-  // The char right after the origin must delimit the authority; anything else
-  // (`${API_URL}.evil.com`, `${API_URL}evil`) is a different, untrusted host.
-  const next = url.charAt(LOOPBACK_ORIGIN_TEMPLATE.length);
-  return next === '' || next === '/' || next === '?' || next === '#';
-}
-
-/**
- * Seed the loopback discovery vars (`<ns>_API_URL` + `<ns>_CONNECTION_KEY`) for
- * every Bevel-HOSTED manual in `manuals` — one whose discovery `url` targets our
- * own backend with `${API_URL}` as its ORIGIN (the KB manual and inline `.tool`
- * sub-manuals). A third-party http/mcp `.tool` points at an arbitrary URL, so it
- * is deliberately NOT seeded: handing it `connectionKey` would leak the bearer to
- * that endpoint. Keying off the origin (not a bare `includes('${API_URL}')`) is
- * deliberate — an `http` `.tool`'s URL is author-controlled, so a substring match
- * would let `http://attacker/?x=${API_URL}` be seeded the bearer and exfiltrate
- * it. This is the exfiltration-safe seeding rule shared by the external MCP proxy
- * and the in-process agent factory, so the bearer-leak decision is written ONCE.
- */
-export function seedBevelHostedManualVars(
-  manuals: readonly { name?: unknown; url?: unknown }[],
-  loopbackBaseUrl: string,
-  connectionKey: string,
-): Record<string, string> {
-  const variables: Record<string, string> = {};
-  for (const m of manuals) {
-    const name = typeof m.name === 'string' ? m.name : '';
-    if (!name) continue;
-    const url = (m as { url?: unknown }).url;
-    if (typeof url !== 'string' || !isBevelHostedUrl(url)) continue;
-    variables[utcpNamespacedKey(name, 'API_URL')] = loopbackBaseUrl;
-    variables[utcpNamespacedKey(name, 'CONNECTION_KEY')] = connectionKey;
-  }
-  return variables;
-}

package/src/shared/variable-refs.ts

@@ -0,0 +1,64 @@
+/**
+ * The ONE variable-reference grammar, shared by every boundary that has to
+ * decide "would the substitutor expand this?" — `.tool` parsing, `mcp.json`
+ * discovery, the server editor's header split, and the Groups→Plugins
+ * migration. The decision has credential stakes on both sides (a reference
+ * mis-read as prose is a `${VAR}` written into portable, world-readable
+ * `mcp.json`; prose mis-read as a reference is a header that stops working),
+ * so the classifiers must not each keep their own approximation of it.
+ */
+
+/**
+ * The SDK substitutor's reference grammar, exactly: `${VAR}` or `$VAR`, names
+ * `[a-zA-Z0-9_]+`. Note a LEADING DIGIT is legal — `$5TOKEN` (and `$5` in
+ * prose) is a reference as far as substitution is concerned, and classifying
+ * it as anything else here would diverge from what actually expands.
+ */
+export const VARIABLE_REFERENCE_RE = /\$\{([a-zA-Z0-9_]+)\}|\$([a-zA-Z0-9_]+)/g;
+
+// `.test()` on a global regex is stateful (lastIndex persists across calls) —
+// the predicate gets its own non-global compilation of the same source.
+const VARIABLE_REFERENCE_ONCE = new RegExp(VARIABLE_REFERENCE_RE.source);
+
+/** True when any substring of `text` is a substitutor reference. */
+export function containsVariableReference(text: string): boolean {
+  return VARIABLE_REFERENCE_ONCE.test(text);
+}
+
+/**
+ * Variable names the platform seeds for its own (Bevel-hosted) manuals:
+ * `<ns>_API_URL` points a manual at the backend and `<ns>_CONNECTION_KEY`
+ * carries the platform bearer. User-declared variables may not take these
+ * names, and user content may not reference them (bare or namespaced).
+ */
+export const RESERVED_VARIABLE_NAMES: readonly string[] = ['API_URL', 'CONNECTION_KEY'];
+
+/**
+ * A NAME is reserved by SUFFIX, not by exact match: the substitutor looks a
+ * variable up under the manual's UTCP namespace first, so `${<ns>_CONNECTION_KEY}`
+ * resolves the very same seeded value the bare `${CONNECTION_KEY}` does.
+ * Suffix matching also refuses harmless-looking near-misses (`MY_API_URL`) —
+ * deliberately fail-closed.
+ */
+export function isReservedVariableName(varName: string): boolean {
+  return RESERVED_VARIABLE_NAMES.some((reserved) => varName.endsWith(reserved));
+}
+
+/**
+ * The first reserved REFERENCE anywhere in `doc` (scanned as JSON text), or
+ * null. Built on the shared grammar above, so what counts as a reference here
+ * is exactly what counts everywhere else — `${ API_URL }` with spaces is not
+ * expandable, so it is a literal to every boundary, not reserved to one and
+ * portable to another.
+ */
+export function findReservedVariableRef(doc: unknown): string | null {
+  const text = JSON.stringify(doc) ?? '';
+  // A fresh instance per scan: `matchAll` COPIES the source regex's
+  // `lastIndex` (spec), and the exported one is mutable module state — any
+  // future `.exec`/`.test` on it would make this scan start mid-string.
+  for (const match of text.matchAll(new RegExp(VARIABLE_REFERENCE_RE.source, VARIABLE_REFERENCE_RE.flags))) {
+    const varName = match[1] ?? match[2] ?? '';
+    if (isReservedVariableName(varName)) return match[0];
+  }
+  return null;
+}

package/src/modules/groups/__tests__/group-provision.service.test.ts

@@ -1,247 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { DEFAULT_BRANCH, personalGroupFolderName } from '@bevel-software/platform-shared';
-import type { AuthUser } from '@bevel-software/platform-shared';
-import type { WorkspaceService } from '../../workspace/workspace.service.js';
-import type { IAccessControl } from '../../access/access-control.interface.js';
-import {
-  GroupProvisionError,
-  GroupProvisionService,
-  groupAccessMd,
-  personalAccessMd,
-} from '../group-provision.service.js';
-
-const KB = 'knowledge-base';
-const USER: AuthUser = { id: 'u1-abcd', email: 'ali@example.com', name: 'Ali Vega' } as AuthUser;
-
-/**
- * The service is exercised against a REAL temp directory (the existence
- * check and the rollback are filesystem semantics, not mockable branches),
- * with the workspace, commit and access dependencies stubbed at their seams.
- */
-async function makeHarness() {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'bevel-provision-'));
-  const writeFile = vi.fn(
-    async (_id: string, rel: string, content: string, opts?: { failIfExists?: boolean }) => {
-      const abs = path.join(dir, rel);
-      await fs.mkdir(path.dirname(abs), { recursive: true });
-      try {
-        await fs.writeFile(abs, content, { encoding: 'utf-8', flag: opts?.failIfExists ? 'wx' : 'w' });
-      } catch (err) {
-        if ((err as NodeJS.ErrnoException).code === 'EEXIST') {
-          const conflict: Error & { status?: number } = new Error(`"${rel}" already exists.`);
-          conflict.status = 409;
-          throw conflict;
-        }
-        throw err;
-      }
-    },
-  );
-  const workspaceService = {
-    getOrCreateForBranch: vi.fn(async () => ({ id: 'ws-main' })),
-    getWorkspacePath: vi.fn(async () => dir),
-    writeFile,
-  } as unknown as WorkspaceService;
-  const commits = { runPendingCommit: vi.fn(async () => undefined) };
-  const accessControl = { invalidate: vi.fn() } as unknown as IAccessControl;
-  const events = { emit: vi.fn() };
-  const svc = new GroupProvisionService(workspaceService, commits, accessControl, KB, events);
-  return { svc, dir, commits, accessControl, events, writeFile };
-}
-
-describe('GroupProvisionService.createGroup', () => {
-  let h: Awaited<ReturnType<typeof makeHarness>>;
-  beforeEach(async () => {
-    h = await makeHarness();
-  });
-
-  it('writes the discoverable template, commits it inline, and drops the access cache', async () => {
-    const result = await h.svc.createGroup(USER, 'GTM');
-    expect(result).toEqual({ folder: 'GTM', created: true });
-
-    const accessMd = await fs.readFile(path.join(h.dir, KB, 'Groups/GTM/access.md'), 'utf-8');
-    // Discoverable FILE (frontmatter read: everyone), creator-run FOLDER
-    // (body names the creator under all three verbs).
-    expect(accessMd.startsWith('---\nread:\n  - everyone\n---\n')).toBe(true);
-    const body = accessMd.slice(accessMd.indexOf('---\n', 4) + 4);
-    for (const verb of ['read', 'write', 'owner']) {
-      expect(body).toMatch(new RegExp(`${verb}:[\\s\\S]*Ali Vega <ali@example.com>`));
-    }
-
-    // The commit ran INLINE — the gate reads at HEAD, so an async commit
-    // would 403 the creator's very next write into the folder.
-    // `systemAuthorized`: the endpoint is the authorization — without it the
-    // push gate reads origin (where the folder does not exist) and refuses
-    // every non-admin the product promised a group to.
-    expect(h.commits.runPendingCommit).toHaveBeenCalledWith(
-      'ws-main',
-      DEFAULT_BRANCH,
-      `${KB}/Groups/GTM/access.md`,
-      USER,
-      { systemAuthorized: true },
-    );
-    expect(h.accessControl.invalidate).toHaveBeenCalledWith('ws-main');
-  });
-
-  it('refuses a taken name case-insensitively with 409', async () => {
-    await h.svc.createGroup(USER, 'GTM');
-    await expect(h.svc.createGroup(USER, 'gtm')).rejects.toMatchObject({ status: 409 });
-  });
-
-  it('refuses names the filesystem or the model cannot carry with 422', async () => {
-    for (const bad of ['', '  ', 'a/b', 'a\\b', '.', '..', '.hidden', 'personal-anything', 'a\u0000b', 'a\tb']) {
-      await expect(h.svc.createGroup(USER, bad)).rejects.toBeInstanceOf(GroupProvisionError);
-      await expect(h.svc.createGroup(USER, bad)).rejects.toMatchObject({ status: 422 });
-    }
-    // Nothing landed on disk for any of them.
-    await expect(fs.readdir(path.join(h.dir, KB, 'Groups'))).rejects.toThrow();
-  });
-
-  it('serialises concurrent creations of one name in different casings — exactly one lands', async () => {
-    // On a case-sensitive filesystem `GTM` and `gtm` are different paths, so
-    // the wx writes alone would BOTH succeed; the per-name lock is what makes
-    // the case-insensitive uniqueness hold under concurrency.
-    const results = await Promise.allSettled([
-      h.svc.createGroup(USER, 'GTM'),
-      h.svc.createGroup(USER, 'gtm'),
-    ]);
-    const ok = results.filter((r) => r.status === 'fulfilled');
-    const refused = results.filter(
-      (r) => r.status === 'rejected' && (r.reason as GroupProvisionError).status === 409,
-    );
-    expect(ok).toHaveLength(1);
-    expect(refused).toHaveLength(1);
-    expect(await fs.readdir(path.join(h.dir, KB, 'Groups'))).toHaveLength(1);
-  });
-
-  it('rolls the seeded file back when the commit fails, so a retry is not told "already exists"', async () => {
-    h.commits.runPendingCommit.mockRejectedValueOnce(new Error('push refused'));
-    await expect(h.svc.createGroup(USER, 'GTM')).rejects.toThrow('push refused');
-    // The folder is gone again — the next attempt starts clean.
-    await expect(fs.stat(path.join(h.dir, KB, 'Groups/GTM'))).rejects.toThrow();
-    await expect(h.svc.createGroup(USER, 'GTM')).resolves.toEqual({ folder: 'GTM', created: true });
-  });
-});
-
-describe('GroupProvisionService.deleteGroup', () => {
-  let h: Awaited<ReturnType<typeof makeHarness>>;
-  beforeEach(async () => {
-    h = await makeHarness();
-  });
-
-  it('removes the whole folder in ONE folder-scoped commit, and drops the access cache', async () => {
-    await h.svc.createGroup(USER, 'GTM');
-    // A group with content — the delete takes the skills with the folder.
-    await fs.mkdir(path.join(h.dir, KB, 'Groups/GTM/outreach'), { recursive: true });
-    await fs.writeFile(path.join(h.dir, KB, 'Groups/GTM/outreach/SKILL.md'), '# outreach\n');
-    h.commits.runPendingCommit.mockClear();
-    (h.accessControl.invalidate as ReturnType<typeof vi.fn>).mockClear();
-
-    await h.svc.deleteGroup(USER, 'GTM');
-
-    await expect(fs.stat(path.join(h.dir, KB, 'Groups/GTM'))).rejects.toThrow();
-    // No parked remnant either — the commit landed, so the bytes may go.
-    expect(await fs.readdir(path.join(h.dir, KB, 'Groups'))).toEqual([]);
-    // FOLDER-scoped (`git add -- <folder>` stages every deletion under it),
-    // inline, and `systemAuthorized` — the endpoint already authorized the
-    // delete (owner verdict), and the per-user push gate would re-read the
-    // very access.md this commit removes.
-    expect(h.commits.runPendingCommit).toHaveBeenCalledWith(
-      'ws-main',
-      DEFAULT_BRANCH,
-      `${KB}/Groups/GTM`,
-      USER,
-      { systemAuthorized: true },
-    );
-    expect(h.accessControl.invalidate).toHaveBeenCalledWith('ws-main');
-    expect(h.events.emit).toHaveBeenCalledWith(
-      expect.objectContaining({ kind: 'fs-tree-changed' }),
-    );
-  });
-
-  it('refuses an unknown name — and a casing mismatch, which is the same thing — with 404', async () => {
-    await h.svc.createGroup(USER, 'GTM');
-    for (const name of ['Nope', 'gtm']) {
-      await expect(h.svc.deleteGroup(USER, name)).rejects.toMatchObject({ status: 404 });
-    }
-    expect(await fs.readdir(path.join(h.dir, KB, 'Groups'))).toEqual(['GTM']);
-  });
-
-  it('never deletes a personal folder through the group door', async () => {
-    await h.svc.ensurePersonalGroup(USER);
-    const folder = personalGroupFolderName(USER.id);
-    await expect(h.svc.deleteGroup(USER, folder)).rejects.toMatchObject({ status: 404 });
-    await expect(fs.stat(path.join(h.dir, KB, 'Groups', folder))).resolves.toBeDefined();
-  });
-
-  it('puts the folder back, content intact, when the commit is refused', async () => {
-    await h.svc.createGroup(USER, 'GTM');
-    await fs.mkdir(path.join(h.dir, KB, 'Groups/GTM/outreach'), { recursive: true });
-    await fs.writeFile(path.join(h.dir, KB, 'Groups/GTM/outreach/SKILL.md'), '# outreach\n');
-    h.commits.runPendingCommit.mockRejectedValueOnce(new Error('push refused'));
-
-    await expect(h.svc.deleteGroup(USER, 'GTM')).rejects.toThrow('push refused');
-
-    // A failed delete is a NO-OP: origin still carries the group, so the
-    // working tree must too — bytes included, not just the folder shell.
-    expect(
-      await fs.readFile(path.join(h.dir, KB, 'Groups/GTM/outreach/SKILL.md'), 'utf-8'),
-    ).toBe('# outreach\n');
-    // And the retry goes through.
-    await expect(h.svc.deleteGroup(USER, 'GTM')).resolves.toBeUndefined();
-    await expect(fs.stat(path.join(h.dir, KB, 'Groups/GTM'))).rejects.toThrow();
-  });
-});
-
-describe('GroupProvisionService.ensurePersonalGroup', () => {
-  it('creates the private personal folder once, then reports it as existing', async () => {
-    const h = await makeHarness();
-    const folder = personalGroupFolderName(USER.id);
-
-    const first = await h.svc.ensurePersonalGroup(USER);
-    expect(first).toEqual({ folder, created: true });
-    const accessMd = await fs.readFile(
-      path.join(h.dir, KB, 'Groups', folder, 'access.md'),
-      'utf-8',
-    );
-    // PRIVATE: no `everyone` self-grant anywhere — the file follows the
-    // folder chain, and the rules close that chain to the owner alone.
-    expect(accessMd).not.toContain('everyone');
-    for (const verb of ['read', 'write', 'owner']) {
-      expect(accessMd).toMatch(new RegExp(`${verb}:[\\s\\S]*Ali Vega <ali@example.com>`));
-    }
-
-    const second = await h.svc.ensurePersonalGroup(USER);
-    expect(second).toEqual({ folder, created: false });
-    // Idempotent for real: one write, one commit.
-    expect(h.writeFile).toHaveBeenCalledTimes(1);
-    expect(h.commits.runPendingCommit).toHaveBeenCalledTimes(1);
-  });
-
-  it('two concurrent ensures both succeed — one creates, the other reports existing', async () => {
-    const h = await makeHarness();
-    const folder = personalGroupFolderName(USER.id);
-    const [a, b] = await Promise.all([
-      h.svc.ensurePersonalGroup(USER),
-      h.svc.ensurePersonalGroup(USER),
-    ]);
-    expect([a.created, b.created].sort()).toEqual([false, true]);
-    expect(a.folder).toBe(folder);
-    expect(b.folder).toBe(folder);
-    expect(h.commits.runPendingCommit).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe('access.md templates', () => {
-  it('group template is discoverable, personal template is not — same creator grants in both', () => {
-    const group = groupAccessMd(USER);
-    const personal = personalAccessMd(USER);
-    expect(group).toContain('everyone');
-    expect(personal).not.toContain('everyone');
-    for (const text of [group, personal]) {
-      expect(text).toContain('Ali Vega <ali@example.com>');
-    }
-  });
-});

package/src/modules/groups/index.ts

@@ -1,17 +0,0 @@
-export { GroupIndexService, groupsWorkspaceId } from './groups.service.js';
-export {
-  GroupProvisionService,
-  GroupProvisionError,
-  groupAccessMd,
-  personalAccessMd,
-} from './group-provision.service.js';
-export { JoinRequestsService, type JoinRequest } from './join-requests.service.js';
-export { pendingProposals, type JoinProposal } from './join-proposals.js';
-export { createGroupsRoutes } from './groups.routes.js';
-export type {
-  IGroupIndexService,
-  GroupCatalogEntry,
-  GroupSummary,
-  ResolvedPrincipals,
-  ResolvedReaders,
-} from './groups.contract.js';

package/src/shared/__tests__/kb-layout.group.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { groupOfPath, GROUPS_DIR } from '@bevel-software/platform-shared';
-
-/**
- * `groupOfPath` is the whole of the grouping contract — the sidebar, the
- * catalog buckets and the access story all read a group off a path with it.
- * The cases that matter are the ones where "has a group" and "is under the
- * group root" come apart.
- */
-describe('groupOfPath', () => {
-  it('reads the group from the Groups root', () => {
-    expect(groupOfPath(`${GROUPS_DIR}/GTM/heyreach-campaign/SKILL.md`)).toBe('GTM');
-    expect(groupOfPath(`${GROUPS_DIR}/GTM/heyreach.tool`)).toBe('GTM');
-    expect(groupOfPath(`${GROUPS_DIR}/Engineering/review/architecture-review`)).toBe(
-      'Engineering',
-    );
-  });
-
-  it('returns null for content directly under the root — it has no group folder', () => {
-    // The regression this guards: `Groups/slack.tool` must NOT report a group
-    // called "slack.tool", and `Groups/GTM` must not report itself.
-    expect(groupOfPath(`${GROUPS_DIR}/slack.tool`)).toBeNull();
-    expect(groupOfPath(`${GROUPS_DIR}/GTM`)).toBeNull();
-    expect(groupOfPath(GROUPS_DIR)).toBeNull();
-  });
-
-  it('returns null outside the group root', () => {
-    expect(groupOfPath('KnowledgeBase/Product/Knowledge/Foo.md')).toBeNull();
-    expect(groupOfPath('Data/Engineering/Knowledge/Bar.md')).toBeNull();
-    // The retired pre-merge roots are ordinary non-group folders now.
-    expect(groupOfPath('Skills/GTM/heyreach-campaign')).toBeNull();
-    expect(groupOfPath('Tools/NewsAgent/serper.tool')).toBeNull();
-    expect(groupOfPath('access.md')).toBeNull();
-    expect(groupOfPath('')).toBeNull();
-  });
-
-  it('is not fooled by a prefix match on the root name', () => {
-    expect(groupOfPath('GroupsOld/GTM/x')).toBeNull();
-  });
-
-  it('tolerates leading and doubled separators', () => {
-    expect(groupOfPath(`/${GROUPS_DIR}/GTM/x`)).toBe('GTM');
-    expect(groupOfPath(`${GROUPS_DIR}//GTM//x`)).toBe('GTM');
-  });
-});