@bevel-software/platform-core-backend 0.15.1 → 0.20.0

package/src/modules/plugins/__tests__/plugin-provision.service.test.ts

@@ -1,4 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { NodeFs } from '../../kb-fs/node-fs.js';
+import { KbPluginSource } from '../discovery/kb-plugin-source.js';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
@@ -6,6 +8,7 @@ import { DEFAULT_BRANCH, personalPluginFolderName } from '@bevel-software/platfo
 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 { isPrivateAccessMd } from '../../access-model/access-grammar.js';
 import {
   PluginProvisionError,
   PluginProvisionService,
@@ -47,7 +50,7 @@ async function makeHarness() {
   const commits = { runPendingCommit: vi.fn(async () => undefined) };
   const accessControl = { invalidate: vi.fn() } as unknown as IAccessControl;
   const events = { emit: vi.fn() };
-  const svc = new PluginProvisionService(workspaceService, commits, accessControl, KB, events);
+  const svc = new PluginProvisionService(workspaceService, commits, accessControl, KB, events, new KbPluginSource(new NodeFs()), new NodeFs());
   return { svc, dir, commits, accessControl, events, writeFile };
 }
 
@@ -75,13 +78,30 @@ describe('PluginProvisionService.createPlugin', () => {
     const result = await h.svc.createPlugin(USER, 'GTM');
     // The folder is where it lives; the name is what it IS (the identity the
     // page navigates to and the grants spell).
-    expect(result).toEqual({ folder: 'GTM', name: 'gtm', created: true });
+    expect(result).toEqual({
+      folder: 'GTM',
+      path: 'Plugins/GTM',
+      skillsDir: 'Plugins/GTM/skills',
+      name: 'gtm',
+      // The name its creator typed, trimmed — persisted, and reported back
+      // exactly as persisted.
+      displayName: 'GTM',
+      created: true,
+    });
 
     const accessMd = await fs.readFile(path.join(h.dir, KB, 'Plugins/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);
+    // (body names the creator under all three verbs) — each block saying,
+    // in its own comments, what it governs and how to admit people.
+    expect(accessMd.startsWith('---\n')).toBe(true);
+    const close = accessMd.indexOf('\n---\n', 4);
+    const frontmatter = accessMd.slice(4, close);
+    const body = accessMd.slice(close + 5);
+    expect(frontmatter).toMatch(/read:\n\s+- everyone/);
+    expect(frontmatter).not.toContain('Ali Vega');
+    expect(frontmatter).toMatch(/governs this access\.md FILE only/);
+    expect(body).toMatch(/governs the PLUGIN FOLDER/);
+    expect(body).toMatch(/To admit people/);
     for (const verb of ['read', 'write', 'owner']) {
       expect(body).toMatch(new RegExp(`${verb}:[\\s\\S]*Ali Vega <ali@example.com>`));
     }
@@ -103,6 +123,57 @@ describe('PluginProvisionService.createPlugin', () => {
     expect(h.accessControl.invalidate).toHaveBeenCalledWith('ws-main');
   });
 
+  it('makes a plugin INSIDE a grouping folder when one is named — the folder path is where it lives, the leaf is what it is', async () => {
+    await fs.mkdir(path.join(h.dir, KB, 'Plugins/Teams/EU'), { recursive: true });
+    const result = await h.svc.createPlugin(USER, 'Sales', 'Teams/EU');
+    expect(result).toEqual({
+      folder: 'Teams/EU/Sales',
+      path: 'Plugins/Teams/EU/Sales',
+      skillsDir: 'Plugins/Teams/EU/Sales/skills',
+      name: 'sales',
+      displayName: 'Sales',
+      created: true,
+    });
+    const manifest = JSON.parse(await fs.readFile(path.join(h.dir, KB, 'Plugins/Teams/EU/Sales/plugin.json'), 'utf-8'));
+    expect(manifest.name).toBe('sales');
+    expect(await fs.readFile(path.join(h.dir, KB, 'Plugins/Teams/EU/Sales/access.md'), 'utf-8')).toContain('Ali Vega');
+    // One folder-scoped commit, at the nested path.
+    expect(h.commits.runPendingCommit).toHaveBeenCalledWith('ws-main', DEFAULT_BRANCH, `${KB}/Plugins/Teams/EU/Sales`, USER, {
+      systemAuthorized: true,
+    });
+    // Taken is judged by IDENTITY, which is global: the slug a nested plugin
+    // publishes is the one a client keys it by, so the same name is taken in
+    // that folder and at the root alike.
+    await expect(h.svc.createPlugin(USER, 'sales', 'Teams/EU')).rejects.toMatchObject({ status: 409 });
+    await expect(h.svc.createPlugin(USER, 'sales')).rejects.toMatchObject({ status: 409 });
+  });
+
+  it('refuses a parent that is not there (404), not a folder name (422), a personal space, or a plugin — a plugin cannot hold another', async () => {
+    await expect(h.svc.createPlugin(USER, 'X', 'Nope')).rejects.toMatchObject({ status: 404 });
+    // The NAME is judged first: a name that can never be created is refused
+    // as such, whatever the parent — not as a missing folder.
+    await expect(h.svc.createPlugin(USER, 'a/b', 'Nope')).rejects.toMatchObject({ status: 422 });
+    await expect(h.svc.createPlugin(USER, 'X', 'a/../b')).rejects.toMatchObject({ status: 422 });
+    await expect(h.svc.createPlugin(USER, 'X', '.hidden')).rejects.toMatchObject({ status: 422 });
+    await expect(h.svc.createPlugin(USER, 'X', personalPluginFolderName(USER.id))).rejects.toMatchObject({ status: 422 });
+    // Discovery says GTM is a plugin: nothing may be made inside it, at any depth.
+    await h.svc.createPlugin(USER, 'GTM');
+    await fs.mkdir(path.join(h.dir, KB, 'Plugins/GTM/skills'), { recursive: true });
+    await expect(h.svc.createPlugin(USER, 'X', 'GTM')).rejects.toMatchObject({ status: 422 });
+    await expect(h.svc.createPlugin(USER, 'X', 'GTM/skills')).rejects.toMatchObject({ status: 422 });
+    // A TWIN of GTM — same slug, so discovery lists it under no catalog —
+    // still claims its subtree: a plugin made inside it would be invisible.
+    await fs.mkdir(path.join(h.dir, KB, 'Plugins/Teams/GTM/sub'), { recursive: true });
+    await fs.writeFile(path.join(h.dir, KB, 'Plugins/Teams/GTM/plugin.json'), '{"name":"gtm"}');
+    await expect(h.svc.createPlugin(USER, 'X', 'Teams/GTM')).rejects.toMatchObject({ status: 422 });
+    await expect(h.svc.createPlugin(USER, 'X', 'Teams/GTM/sub')).rejects.toMatchObject({ status: 422 });
+    // A padded spelling names no folder: refused, never trimmed into one.
+    await fs.mkdir(path.join(h.dir, KB, 'Plugins/Teams'), { recursive: true });
+    await expect(h.svc.createPlugin(USER, 'X', 'Teams ')).rejects.toMatchObject({ status: 422 });
+    // The root, spelled as absence or as the empty string, is still the root.
+    expect((await h.svc.createPlugin(USER, 'Root', '')).folder).toBe('Root');
+  });
+
   it('writes a conformant plugin.json: the identifier in slug form, the typed name as the display name', async () => {
     await h.svc.createPlugin(USER, 'GTM');
     const manifest = JSON.parse(
@@ -133,7 +204,7 @@ describe('PluginProvisionService.createPlugin', () => {
     // Only the first folder landed.
     expect(await fs.readdir(path.join(h.dir, KB, 'Plugins'))).toEqual(['Sales Team']);
     // A genuinely distinct slug still goes through.
-    await expect(h.svc.createPlugin(USER, 'Sales Ops')).resolves.toEqual({
+    await expect(h.svc.createPlugin(USER, 'Sales Ops')).resolves.toMatchObject({
       folder: 'Sales Ops',
       name: 'sales-ops',
       created: true,
@@ -161,7 +232,7 @@ describe('PluginProvisionService.createPlugin', () => {
     // plugin FOLDER publishes a manifest identity.
     await fs.mkdir(path.join(h.dir, KB, 'Plugins'), { recursive: true });
     await fs.writeFile(path.join(h.dir, KB, 'Plugins', 'slack.tool'), 'id: slack\n', 'utf-8');
-    await expect(h.svc.createPlugin(USER, 'Slack Tool')).resolves.toEqual({
+    await expect(h.svc.createPlugin(USER, 'Slack Tool')).resolves.toMatchObject({
       folder: 'Slack Tool',
       name: 'slack-tool',
       created: true,
@@ -199,7 +270,7 @@ describe('PluginProvisionService.createPlugin', () => {
     await expect(h.svc.createPlugin(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, 'Plugins/GTM'))).rejects.toThrow();
-    await expect(h.svc.createPlugin(USER, 'GTM')).resolves.toEqual({ folder: 'GTM', name: 'gtm', created: true });
+    await expect(h.svc.createPlugin(USER, 'GTM')).resolves.toMatchObject({ folder: 'GTM', name: 'gtm', created: true });
   });
 });
 
@@ -460,20 +531,35 @@ describe('PluginProvisionService.ensurePersonalPlugin', () => {
     const folder = personalPluginFolderName(USER.id);
 
     const first = await h.svc.ensurePersonalPlugin(USER);
-    expect(first).toEqual({ folder, name: folder, created: true });
+    expect(first).toEqual({
+      folder,
+      path: `Plugins/${folder}`,
+      skillsDir: `Plugins/${folder}/skills`,
+      name: folder,
+      displayName: folder,
+      created: true,
+    });
     const accessMd = await fs.readFile(
       path.join(h.dir, KB, 'Plugins', 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>`));
+    // PRIVATE, in both blocks: the frontmatter denies `everyone` and names the
+    // owner (the space is listed for no one else, and the file says so), and
+    // the body denies `everyone` — so a root-level `read: everyone` an admin
+    // adds later cannot open it — naming the owner and nobody else, Admin
+    // included.
+    const close = accessMd.indexOf('\n---\n', 4);
+    const frontmatter = accessMd.slice(4, close);
+    const body = accessMd.slice(close + 5);
+    expect(frontmatter).toMatch(/read:\n(?:\s+#.*\n)*\s+- deny everyone\n\s+- Ali Vega <ali@example.com>$/);
+    expect(body).toMatch(/read:\n(?:\s+#.*\n)*\s+- deny everyone\n/);
+    expect(body).not.toMatch(/^\s+- Admin/m);
+    for (const verb of ['read', 'write', 'owner'] as const) {
+      expect(verbBlock(body, verb)).toContain('Ali Vega <ali@example.com>');
     }
 
     const second = await h.svc.ensurePersonalPlugin(USER);
-    expect(second).toEqual({ folder, name: folder, created: false });
+    expect(second).toMatchObject({ folder, path: `Plugins/${folder}`, created: false });
     // Idempotent for real: one provision (access.md + plugin.json), one commit.
     expect(h.writeFile).toHaveBeenCalledTimes(2);
     expect(h.commits.runPendingCommit).toHaveBeenCalledTimes(1);
@@ -499,14 +585,38 @@ describe('PluginProvisionService.ensurePersonalPlugin', () => {
   });
 });
 
+/**
+ * One verb's block of an access.md region — from `<verb>:` up to the next
+ * verb key or the end — so an assertion about a grant under `write:` cannot
+ * be satisfied by the same line under `owner:`.
+ */
+function verbBlock(region: string, verb: 'read' | 'write' | 'owner'): string {
+  const match = region.match(new RegExp(`(?:^|\\n)${verb}:[\\s\\S]*?(?=\\n(?:read|write|download|owner):|$)`));
+  if (!match) throw new Error(`no ${verb}: block in\n${region}`);
+  return match[0];
+}
+
 describe('access.md templates', () => {
-  it('plugin template is discoverable, personal template is not — same creator grants in both', () => {
+  it('plugin template is discoverable, personal template denies everyone in both blocks — same creator grants in both bodies', () => {
     const plugin = pluginAccessMd(USER);
     const personal = personalAccessMd(USER);
-    expect(plugin).toContain('everyone');
-    expect(personal).not.toContain('everyone');
+    const split = (text: string) => {
+      const close = text.indexOf('\n---\n', 4);
+      return { frontmatter: text.slice(4, close), body: text.slice(close + 5) };
+    };
+    expect(split(plugin).frontmatter).toMatch(/read:\n\s+- everyone/);
+    expect(split(plugin).frontmatter).not.toContain('Ali Vega');
+    // The personal file's own block is the private shape the Library marks:
+    // the denial, then the owner, nobody else.
+    expect(split(personal).frontmatter).toMatch(/read:\n(?:\s+#.*\n)*\s+- deny everyone\n\s+- Ali Vega <ali@example.com>$/);
+    expect(isPrivateAccessMd(personal)).toBe(true);
+    expect(isPrivateAccessMd(plugin)).toBe(false);
+    expect(split(personal).body).toMatch(/- deny everyone\n/);
+    expect(split(personal).body).not.toMatch(/^\s+- Admin/m);
     for (const text of [plugin, personal]) {
-      expect(text).toContain('Ali Vega <ali@example.com>');
+      for (const verb of ['read', 'write', 'owner'] as const) {
+        expect(verbBlock(split(text).body, verb)).toContain('Ali Vega <ali@example.com>');
+      }
     }
   });
 });

package/src/modules/plugins/__tests__/plugin-rename.service.test.ts

@@ -1,8 +1,10 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { NodeFs } from '../../kb-fs/node-fs.js';
+import type { TreeWalkOptions, WalkListener, WalkResult } from '../../../shared/fs.contract.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
-import { DEFAULT_BRANCH, type AuthUser } from '@bevel-software/platform-shared';
+import { DEFAULT_BRANCH, pluginDisplayNameOf, type AuthUser } from '@bevel-software/platform-shared';
 
 import type { WorkspaceService } from '../../workspace/workspace.service.js';
 import { AccessControlService } from '../../access/access-control.service.js';
@@ -12,23 +14,24 @@ import { KbPluginSource } from '../discovery/kb-plugin-source.js';
 import { PluginRenameError, PluginRenameService, renamePluginPrincipalInText } from '../plugin-rename.service.js';
 
 // The one walk of the checkout, with a switch that makes it report a hole —
-// the way a folder it cannot list would — to every listener on it.
-const walkMock = vi.hoisted(() => ({ holeInTheWalk: false }));
-vi.mock('../../../shared/kb-walk.js', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('../../../shared/kb-walk.js')>();
-  return {
-    ...actual,
-    walkKb: async (root: string, listeners: readonly import('../../../shared/kb-walk.js').KbWalkListener[]) => {
-      const result = await actual.walkKb(root, listeners);
-      if (walkMock.holeInTheWalk) {
-        const err = Object.assign(new Error('EACCES: permission denied'), { code: 'EACCES' });
-        for (const l of listeners) await l.onHole?.('KnowledgeBase/Notes', err);
-        result.holes.push('KnowledgeBase/Notes');
-      }
-      return result;
-    },
-  };
-});
+// the way a folder it cannot list would — to every listener on it. The
+// walk is injected, so the switch is a disk that lies, not a module mock.
+const walkMock = { holeInTheWalk: false };
+class HoledFs extends NodeFs {
+  override async walkKb(
+    root: string,
+    listeners: readonly WalkListener[],
+    options?: Omit<TreeWalkOptions, 'skip'>,
+  ): Promise<WalkResult> {
+    const result = await super.walkKb(root, listeners, options);
+    if (walkMock.holeInTheWalk) {
+      const err = Object.assign(new Error('EACCES: permission denied'), { code: 'EACCES' });
+      for (const l of listeners) await l.onHole?.('KnowledgeBase/Notes', err);
+      result.holes.push('KnowledgeBase/Notes');
+    }
+    return result;
+  }
+}
 
 /**
  * Renaming over a real tree: the real resolver decides who may rename and
@@ -110,8 +113,9 @@ describe('PluginRenameService', () => {
     await write('Skills/Eng/deploy/access.md', DEPLOY_RULES);
     await write('Skills/Eng/deploy/SKILL.md', '---\ndescription: Ship it.\n---\n');
 
-    access = new AccessControlService(workspaceService, KB_DIR);
-    svc = new PluginRenameService(workspaceService, driver, access, new KbPluginSource(), KB_DIR, undefined, () => {
+    access = new AccessControlService(workspaceService, KB_DIR, new NodeFs());
+    const disk = new HoledFs();
+    svc = new PluginRenameService(workspaceService, driver, access, new KbPluginSource(disk), disk, KB_DIR, undefined, () => {
       invalidated += 1;
     });
   });
@@ -120,7 +124,7 @@ describe('PluginRenameService', () => {
   it('refuses to claim a name against a listing with a hole in it — an unreadable folder may hold that very plugin', async () => {
     // Discovery as the walker reports it when a folder exists but could not
     // be read: the plugins it did see, plus the hole.
-    const real = new KbPluginSource();
+    const real = new KbPluginSource(new NodeFs());
     const holed = {
       dialect: 'kb',
       discover: async (root: string) => ({ ...(await real.discover(root)), unreadable: ['Plugins/Hidden'] }),
@@ -130,6 +134,7 @@ describe('PluginRenameService', () => {
       { commitChanges: async () => { throw new Error('must not commit'); } },
       access,
       holed,
+      new NodeFs(),
       KB_DIR,
     );
     await expect(svcOverHole.rename(manager, 'gtm', { name: 'go-to-market' })).rejects.toMatchObject({
@@ -150,7 +155,7 @@ describe('PluginRenameService', () => {
   });
 
   it('tells a NON-manager nothing about the tree — a holed discovery is still just "unknown plugin" to them', async () => {
-    const real = new KbPluginSource();
+    const real = new KbPluginSource(new NodeFs());
     const holed = {
       dialect: 'kb',
       discover: async (root: string) => ({ ...(await real.discover(root)), unreadable: ['Plugins/Hidden'] }),
@@ -160,6 +165,7 @@ describe('PluginRenameService', () => {
       { commitChanges: async () => { throw new Error('must not commit'); } },
       access,
       holed,
+      new NodeFs(),
       KB_DIR,
     );
     const refusal = await svcOverHole.rename(member, 'gtm', { name: 'go-to-market' }).catch((e: unknown) => e);
@@ -192,10 +198,21 @@ describe('PluginRenameService', () => {
     expect(await access.canRead(wsId, member.email, 'Skills/Eng/deploy/SKILL.md')).toBe(true);
 
     const result = await svc.rename(manager, 'gtm', { name: 'go-to-market' });
-    expect(result).toEqual({ name: 'go-to-market', displayName: 'GTM', rewritten: ['Skills/Eng/deploy/access.md'] });
+    // The fixture's manifest carries no `displayName`: it predates the boot
+    // backfill, which would not have left it this way either — the folder
+    // `GTM` and the identifier `gtm` differ, so the step would have recorded
+    // the folder's spelling. With the field absent, the plugin is called by
+    // its identifier, and the new identifier is what it is now called.
+    // Nothing here reads `Plugins/GTM`.
+    expect(result).toEqual({
+      name: 'go-to-market',
+      displayName: 'go-to-market',
+      rewritten: ['Skills/Eng/deploy/access.md'],
+    });
 
-    // The manifest keeps everything else it had.
-    expect(await manifest()).toEqual({ name: 'go-to-market', version: '1.0.0' });
+    // The manifest keeps everything else it had, and gains the field every
+    // write path persists.
+    expect(await manifest()).toEqual({ name: 'go-to-market', version: '1.0.0', displayName: 'go-to-market' });
     // Both spellings became the one new one; the file's shape is otherwise untouched.
     expect(await read('Skills/Eng/deploy/access.md')).toBe(
       '---\n---\nread:\n  - plugin/go-to-market/read\nwrite:\n  - plugin/go-to-market/write\n',
@@ -216,15 +233,60 @@ describe('PluginRenameService', () => {
     expect(await access.canRead(wsId, member.email, 'Skills/Eng/deploy/SKILL.md')).toBe(false);
   });
 
-  it('changes the display name without touching a single grant, and stores none that equals the folder', async () => {
+  it('changes the display name without touching a single grant, and stores it whatever it equals', async () => {
     await svc.rename(manager, 'gtm', { displayName: '  Go To Market ' });
     expect(await manifest()).toEqual({ name: 'gtm', version: '1.0.0', displayName: 'Go To Market' });
     expect(await read('Skills/Eng/deploy/access.md')).toBe(DEPLOY_RULES);
     expect(commits).toEqual([{ summary: 'Rename plugin gtm: display name', paths: [`${KB_DIR}/Plugins/GTM/plugin.json`] }]);
 
-    // The folder name is the default label — writing it down would only be noise.
-    await svc.rename(manager, 'gtm', { displayName: 'GTM' });
-    expect(await manifest()).toEqual({ name: 'gtm', version: '1.0.0' });
+    // Equal to the FOLDER's spelling: stored all the same. The field used to
+    // be deleted here, which handed the folder's spelling back the job of
+    // saying what the plugin is called.
+    const toFolder = await svc.rename(manager, 'gtm', { displayName: 'GTM' });
+    expect(await manifest()).toEqual({ name: 'gtm', version: '1.0.0', displayName: 'GTM' });
+    expect(toFolder).toMatchObject({ name: 'gtm', displayName: 'GTM' });
+
+    // Equal to the IDENTIFIER: stored too, and the identifier is untouched.
+    const toIdentifier = await svc.rename(manager, 'gtm', { displayName: 'gtm' });
+    expect(await manifest()).toEqual({ name: 'gtm', version: '1.0.0', displayName: 'gtm' });
+    expect(toIdentifier).toMatchObject({ name: 'gtm', displayName: 'gtm' });
+
+    // Blanked: the field is never DELETED — it falls back to the identifier,
+    // which is what the plugin is then called, and every reader sees the same.
+    const blanked = await svc.rename(manager, 'gtm', { displayName: '   ' });
+    expect(await manifest()).toEqual({ name: 'gtm', version: '1.0.0', displayName: 'gtm' });
+    expect(blanked).toMatchObject({ name: 'gtm', displayName: 'gtm' });
+  });
+
+  it('round-trips a display name: what comes back is what the file holds, and what every reader then says', async () => {
+    for (const typed of ['Go To Market', 'GTM', 'gtm', '  Sales & Marketing  ']) {
+      const result = await svc.rename(manager, 'gtm', { displayName: typed });
+      expect(result.displayName).toBe(typed.trim());
+      expect((await manifest()).displayName).toBe(typed.trim());
+      // The identifier never moves with a display-name edit, and no grant does.
+      expect(result.name).toBe('gtm');
+      expect(result.rewritten).toEqual([]);
+      expect(await read('Skills/Eng/deploy/access.md')).toBe(DEPLOY_RULES);
+      // The three answers that must never diverge: the rename's, the
+      // discovery source's, and the shared reader's over the file itself.
+      const { plugins } = await new KbPluginSource(new NodeFs()).discover(repo);
+      const found = plugins.find((p) => p.folder === 'Plugins/GTM')!;
+      expect([found.name, found.displayName]).toEqual([result.name, result.displayName]);
+      expect(pluginDisplayNameOf(JSON.parse(await read('Plugins/GTM/plugin.json')))).toBe(result.displayName);
+    }
+  });
+
+  it('carries a stored display name through an identifier change, and never the identifier it stopped being', async () => {
+    await svc.rename(manager, 'gtm', { displayName: 'Go To Market' });
+    const result = await svc.rename(manager, 'gtm', { name: 'go-to-market' });
+    expect(result).toMatchObject({ name: 'go-to-market', displayName: 'Go To Market' });
+    expect(await manifest()).toEqual({ name: 'go-to-market', version: '1.0.0', displayName: 'Go To Market' });
+  });
+
+  it('changes both at once, and the answer is what the file holds', async () => {
+    const result = await svc.rename(manager, 'gtm', { name: 'go-to-market', displayName: '  Go To Market  ' });
+    expect(result).toMatchObject({ name: 'go-to-market', displayName: 'Go To Market' });
+    expect(await manifest()).toEqual({ name: 'go-to-market', version: '1.0.0', displayName: 'Go To Market' });
   });
 
   it('judges only a NEW identifier: a plugin whose manifest already wears the reserved prefix can still change its display name', async () => {