@bevel-software/platform-core-backend 0.23.0 → 0.25.0

package/src/modules/workspace/__tests__/escape-sequences.routes.test.ts

@@ -21,6 +21,7 @@ import type { IAccessControl } from '../../access/access-control.interface.js';
 import { createMcpRoutes } from '../../mcp/mcp.routes.js';
 import { McpService } from '../../mcp/mcp.service.js';
 import { testKbContext } from '../../../__tests__/kb-context.js';
+import { sharedFileRules, sharedFileRulesSection, sharedRulesPointer } from '../../agent-instructions/shared-file-rules.js';
 
 /**
  * Who decodes escape sequences in written content a second time — settled on
@@ -361,24 +362,33 @@ describe('escape sequences survive a write — call_tool_chain', () => {
 });
 
 describe('what the write tools tell an agent about escape sequences', () => {
-  it('warns on write_file, write_files and edit_file, and names the upload route', async () => {
+  it('states the warning once, in the shared rules, and in no description', async () => {
     const { descriptions } = await startPlatform();
     const served = await descriptions();
+    // It applies to the three tools that take content as a JSON string, so it is
+    // a SHARED rule: stated in the handshake instructions and in the managed
+    // agent guide, and repeated in no tool description — a description that
+    // carried it was long enough for a client to cut the end off.
+    const rule = sharedFileRules(testKbContext().layout).find((r) => r.id === 'escape-sequences')!;
+    expect(rule.body).toContain('some clients decode escape sequences in arguments before sending');
+    // The way out is the upload route, which the rule after it spells out by
+    // the names of the tools this deployment serves.
+    expect(rule.body).toContain('by upload (see below), which lands it unchanged');
+    const upload = sharedFileRules(testKbContext().layout).find((r) => r.id === 'upload-route')!;
+    expect(upload.body).toContain('`request_file_upload`');
+    expect(upload.body).toContain('`apply_file_upload`');
+    // It names the three tools it is about, so an agent reading the section
+    // knows where it applies.
+    for (const name of ['write_file', 'write_files', 'edit_file']) expect(rule.body, name).toContain(name);
+    expect(sharedFileRulesSection(testKbContext().layout)).toContain(rule.body);
 
+    const carrying = Object.entries(served)
+      .filter(([, d]) => d.includes('decode escape sequences in arguments before sending') || d.includes('some clients decode them in arguments'))
+      .map(([n]) => n);
+    expect(carrying).toEqual([]);
+    // Each of the three still points at where the warning is.
     for (const name of ['write_file', 'write_files', 'edit_file']) {
-      const d = served[name];
-      expect(d, name).toBeDefined();
-      // Some clients decode before sending …
-      expect(d, name).toContain('some clients decode them in arguments before sending');
-      // … and the route that lands such content unchanged.
-      expect(d, name).toContain('request_upload_token');
-      expect(d, name).toContain('lands it unchanged');
+      expect(served[name], name).toContain(sharedRulesPointer(testKbContext().layout).trim());
     }
-    // Said on the three tools that take content as a JSON string, and nowhere else.
-    const carrying = Object.entries(served)
-      .filter(([, d]) => d.includes('some clients decode them in arguments before sending'))
-      .map(([n]) => n)
-      .sort();
-    expect(carrying).toEqual(['edit_file', 'write_file', 'write_files']);
   });
 });

package/src/modules/workspace/__tests__/workspace.service.any-workspace-credentials.test.ts

@@ -0,0 +1,156 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { testKbContext } from '../../../__tests__/kb-context.js';
+import { NodeFs } from '../../kb-fs/node-fs.js';
+import { WorkspaceService } from '../workspace.service.js';
+import { NodeGitRunner } from '../../workflow/git/node-git-runner.js';
+import { gitCredentials } from '../../../shared/git.contract.js';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * The working copy a repo-global operation is handed.
+ *
+ * Listing change requests, reading one by number, listing branches: none of
+ * them is about a particular draft, so they run in whichever clone is already
+ * on disk (`findAnyWorkspaceId`). That clone is one this process may never have
+ * opened — and a clone gets its credential helper when its branch is opened.
+ *
+ * A deployment's oldest clone had none: it predated the helper being persisted.
+ * It sorted first on disk, so every repo-global fetch ran in it, failed with
+ * "could not read Username", was swallowed, and came back as `unknown branch`
+ * for each open change request — thirty-four of them, on every list, while all
+ * thirty-four branches were on the remote. Opening that one branch in the app
+ * stamped the helper and the errors stopped.
+ */
+
+const BRANCH = 'main';
+const OLD_DRAFT = 'someone/an-old-draft';
+const KB_DIR = 'knowledge-base';
+
+async function git(cwd: string, args: string[]): Promise<string> {
+  const { stdout } = await execFileAsync('git', args, {
+    cwd,
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: 'Test', GIT_AUTHOR_EMAIL: 't@x.com',
+      GIT_COMMITTER_NAME: 'Test', GIT_COMMITTER_EMAIL: 't@x.com',
+    },
+  });
+  return stdout.toString();
+}
+
+/** The credential helpers a clone's own config carries; none is the empty list. */
+async function helpersOf(repoDir: string): Promise<string[]> {
+  return git(repoDir, ['config', '--local', '--get-all', 'credential.helper']).then(
+    (out) => out.split('\n').filter((line) => line.trim() !== ''),
+    () => [],
+  );
+}
+
+let root: string;
+let workspacesRoot: string;
+let upstream: string;
+
+beforeEach(async () => {
+  root = await fs.mkdtemp(path.join(os.tmpdir(), 'ws-any-creds-'));
+  workspacesRoot = path.join(root, 'workspaces');
+  await fs.mkdir(workspacesRoot, { recursive: true });
+  upstream = path.join(root, 'upstream.git');
+  await git(root, ['init', '--bare', '-b', BRANCH, upstream]);
+  const seed = path.join(root, '.seed');
+  await fs.mkdir(seed);
+  await git(seed, ['init', '-b', BRANCH]);
+  await fs.writeFile(path.join(seed, 'README.md'), 'seed\n', 'utf8');
+  await git(seed, ['add', '-A']);
+  await git(seed, ['commit', '-m', 'init']);
+  await git(seed, ['remote', 'add', 'origin', upstream]);
+  await git(seed, ['push', 'origin', BRANCH]);
+  await git(seed, ['push', 'origin', `${BRANCH}:refs/heads/${OLD_DRAFT}`]);
+});
+
+afterEach(async () => {
+  await fs.rm(root, { recursive: true, force: true });
+});
+
+/** A clone as an older build left it: on disk, complete, and with no helper of ours. */
+async function anOldCloneWithNoHelper(branch: string): Promise<string> {
+  const repoDir = path.join(workspacesRoot, encodeURIComponent(branch), KB_DIR);
+  await fs.mkdir(path.dirname(repoDir), { recursive: true });
+  await git(root, ['clone', '-b', branch, upstream, repoDir]);
+  expect(await helpersOf(repoDir)).toEqual([]);
+  return repoDir;
+}
+
+function service(token: string | null) {
+  return new WorkspaceService(
+    workspacesRoot,
+    () => upstream,
+    testKbContext({ kbDirName: KB_DIR, branchModel: { defaultBranch: BRANCH, protectedBranches: [BRANCH] } }),
+    new NodeFs(),
+    new NodeGitRunner(undefined, gitCredentials('x-access-token', token)),
+  );
+}
+
+describe('the working copy a repo-global operation runs in', () => {
+  it('is given the deployment’s credential helper before it is handed out', async () => {
+    const repoDir = await anOldCloneWithNoHelper(OLD_DRAFT);
+
+    const id = await service('a-token').findAnyWorkspaceId();
+
+    expect(id).toBe(encodeURIComponent(OLD_DRAFT));
+    // One helper, ours: the one that reads the token from the environment the
+    // runner hands each git call. The token itself is never written down.
+    const helpers = await helpersOf(repoDir);
+    expect(helpers).toHaveLength(1);
+    expect(helpers[0]).toContain('GITHUB_TOKEN');
+    expect(helpers[0]).not.toContain('a-token');
+  });
+
+  it('is the same clone it always picked: the first on disk', async () => {
+    await anOldCloneWithNoHelper(OLD_DRAFT);
+    await anOldCloneWithNoHelper(BRANCH);
+    const svc = service('a-token');
+    const entries = (await fs.readdir(workspacesRoot)).filter((name) => !name.startsWith('.'));
+    expect(await svc.findAnyWorkspaceId()).toBe(entries[0]);
+  });
+
+  it('keeps a helper an operator wrote themselves, beside ours', async () => {
+    const repoDir = await anOldCloneWithNoHelper(OLD_DRAFT);
+    await git(repoDir, ['config', '--add', 'credential.helper', 'store']);
+
+    await service('a-token').findAnyWorkspaceId();
+
+    const helpers = await helpersOf(repoDir);
+    expect(helpers).toContain('store');
+    expect(helpers.some((h) => h.includes('GITHUB_TOKEN'))).toBe(true);
+  });
+
+  it('writes the helper once, not on every call', async () => {
+    const repoDir = await anOldCloneWithNoHelper(OLD_DRAFT);
+    const svc = service('a-token');
+    await svc.findAnyWorkspaceId();
+    const config = path.join(repoDir, '.git', 'config');
+    const stampedAt = (await fs.stat(config)).mtimeMs;
+    await new Promise((resolve) => setTimeout(resolve, 20));
+
+    await svc.findAnyWorkspaceId();
+    await svc.findAnyWorkspaceId();
+
+    expect((await fs.stat(config)).mtimeMs).toBe(stampedAt);
+  });
+
+  it('stamps nothing on a deployment that has no token', async () => {
+    const repoDir = await anOldCloneWithNoHelper(OLD_DRAFT);
+    expect(await service(null).findAnyWorkspaceId()).toBe(encodeURIComponent(OLD_DRAFT));
+    expect(await helpersOf(repoDir)).toEqual([]);
+  });
+
+  it('still answers null when nothing is cloned', async () => {
+    expect(await service('a-token').findAnyWorkspaceId()).toBeNull();
+  });
+});

package/src/modules/workspace/__tests__/workspace.service.replaced-repository.test.ts

@@ -75,18 +75,58 @@ function service(
   kbRepoUrl: () => string,
   setAsideRoot?: string,
   aroundSetAside?: (workspaceId: string, move: () => Promise<void>) => Promise<void>,
+  gitRunner: NodeGitRunner = new NodeGitRunner(),
 ) {
   return new WorkspaceService(
     workspacesRoot,
     kbRepoUrl,
     testKbContext({ branchModel: { defaultBranch: BRANCH, protectedBranches: [BRANCH] } }),
     new NodeFs(),
-    new NodeGitRunner(),
+    gitRunner,
     setAsideRoot,
     aroundSetAside,
   );
 }
 
+/**
+ * A git runner that puts two callers' reads of a working copy's address in ONE
+ * order, the one that matters: both read the copy that is there, and the
+ * second is handed its answer only once `afterTheFirstMove` has come.
+ *
+ * Two holds, because holding the second answer back is only half of it. The
+ * FIRST answer is held until the second read has happened, so the first caller
+ * cannot move the copy before the second has looked at it — otherwise the
+ * second would read whatever replaced it, and the stale answer this is about
+ * would never exist. Then the second answer is held until the first move has
+ * ended. Neither can wait on the other forever: the first caller is held in its
+ * read, so no move is in flight for the second to wait on, and it always reads.
+ * Everything else runs as it is.
+ */
+function withTheSecondAddressReadHeldPastTheMove(afterTheFirstMove: Promise<void>): NodeGitRunner {
+  let reads = 0;
+  let secondHasRead!: () => void;
+  const onceTheSecondHasRead = new Promise<void>((resolve) => {
+    secondHasRead = resolve;
+  });
+  return new Proxy(new NodeGitRunner(), {
+    get(target, prop, receiver) {
+      if (prop !== 'run') return Reflect.get(target, prop, receiver);
+      return async (cwd: string, args: string[], opts?: never) => {
+        const answer = await target.run(cwd, args, opts);
+        const readsTheAddress = args[0] === 'config' && args.includes('--get') && args.includes('remote.origin.url');
+        if (!readsTheAddress) return answer;
+        const mine = ++reads;
+        if (mine === 1) await onceTheSecondHasRead;
+        if (mine === 2) {
+          secondHasRead();
+          await afterTheFirstMove;
+        }
+        return answer;
+      };
+    },
+  });
+}
+
 const cloneDir = () => path.join(workspacesRoot, encodeURIComponent(BRANCH), 'knowledge-base');
 
 /** Every working copy under a set-aside root, as repo directories. */
@@ -307,6 +347,42 @@ describe('what surrounds the setting aside of one working copy', () => {
     expect(await setAside()).toHaveLength(1);
     expect(await fs.readFile(path.join(cloneDir(), 'marker.txt'), 'utf8')).toBe('new repository');
   });
+
+  /**
+   * The same two callers, in the order the test above only sometimes got. The
+   * second reads the old copy's address, and is handed the answer after the
+   * first has finished moving that copy — when nothing says a move is in
+   * flight any more, and what sits at the path is the fresh clone the first is
+   * making. It moved that too: a second set-aside, of a working copy of the
+   * RIGHT repository, taken from under the clone that was writing it.
+   */
+  it('moves it once when the second caller comes back with the old address after the move has ended', async () => {
+    const { replacement } = await onTheOldRepository();
+    let moves = 0;
+    let firstMoveEnded!: () => void;
+    const afterTheFirstMove = new Promise<void>((resolve) => {
+      firstMoveEnded = resolve;
+    });
+    const svc = service(
+      () => replacement,
+      undefined,
+      async (_workspaceId, move) => {
+        moves += 1;
+        await move();
+        firstMoveEnded();
+      },
+      withTheSecondAddressReadHeldPastTheMove(afterTheFirstMove),
+    );
+
+    const [first, second] = await Promise.all([svc.getOrCreateForBranch(BRANCH), svc.getOrCreateForBranch(BRANCH)]);
+
+    expect(moves).toBe(1);
+    expect(first.repoDir).toBe(second.repoDir);
+    expect(await setAside()).toHaveLength(1);
+    expect(await fs.readFile(path.join(cloneDir(), 'marker.txt'), 'utf8')).toBe('new repository');
+    // And the clone both were served is whole: its address is the new one.
+    expect((await git(cloneDir(), ['config', '--get', 'remote.origin.url'])).trim()).toBe(replacement);
+  });
 });
 
 describe('forgetClone', () => {

package/src/modules/workspace/__tests__/workspace.service.test.ts

@@ -1181,6 +1181,63 @@ describe('WorkspaceService.unzipFile — per-entry write guard', () => {
     await expect(fs.stat(path.join(repoDir, 'out', 'blocked-dir'))).rejects.toThrow();
   });
 
+  /**
+   * An archive reader caps the inflation at the size the header DECLARES, but
+   * only when that size is above zero: an entry declaring zero is inflated with
+   * no cap. So "check the declared size, then read" let a few kilobytes expand
+   * to whatever memory there was. Both headers are patched to say "empty" here,
+   * over four megabytes that deflate to four kilobytes.
+   */
+  it('refuses an entry whose header says it is empty and whose stream is not, and extracts the rest', async () => {
+    const { default: AdmZip } = await import('adm-zip');
+    const zip = new AdmZip();
+    zip.addFile('bomb.md', Buffer.alloc(4 * 1024 * 1024, 0x61));
+    const bomb = zip.toBuffer();
+    // The uncompressed-size field: 22 bytes into the local header, 24 into the
+    // central-directory one.
+    bomb.writeUInt32LE(0, bomb.indexOf(Buffer.from([0x50, 0x4b, 0x03, 0x04])) + 22);
+    bomb.writeUInt32LE(0, bomb.indexOf(Buffer.from([0x50, 0x4b, 0x01, 0x02])) + 24);
+    await fs.writeFile(path.join(repoDir, 'bomb.zip'), bomb);
+
+    const res = await svc.unzipFile(workspaceId, 'bomb.zip', 'out');
+
+    expect(res.extracted).toEqual([]);
+    expect(res.skipped).toHaveLength(1);
+    expect(res.skipped[0]).toMatchObject({ path: 'bomb.md' });
+    expect(res.skipped[0].reason).toContain('declares an empty file');
+    await expect(fs.stat(path.join(repoDir, 'out', 'bomb.md'))).rejects.toThrow();
+  });
+
+  it('extracts the other entries of an archive in which one fails its checksum', async () => {
+    const { default: AdmZip } = await import('adm-zip');
+    const zip = new AdmZip();
+    zip.addFile('bad.md', Buffer.from('this entry will not match its checksum'));
+    zip.addFile('fine.md', Buffer.from('fine'));
+    const archive = zip.toBuffer();
+    // The CRC field of the FIRST entry, in both of its headers: 14 bytes into
+    // the local one, 16 into the central-directory one. A reader checks one or
+    // the other depending on the entry's flags.
+    const firstLocal = archive.indexOf(Buffer.from([0x50, 0x4b, 0x03, 0x04]));
+    const firstCentral = archive.indexOf(Buffer.from([0x50, 0x4b, 0x01, 0x02]));
+    archive.writeUInt32LE((archive.readUInt32LE(firstLocal + 14) ^ 0xffffffff) >>> 0, firstLocal + 14);
+    archive.writeUInt32LE((archive.readUInt32LE(firstCentral + 16) ^ 0xffffffff) >>> 0, firstCentral + 16);
+    await fs.writeFile(path.join(repoDir, 'crc.zip'), archive);
+
+    const res = await svc.unzipFile(workspaceId, 'crc.zip', 'out');
+
+    expect(res.extracted).toEqual(['knowledge-base/out/fine.md']);
+    expect(res.skipped).toHaveLength(1);
+    expect(res.skipped[0].path).toBe('bad.md');
+    expect(res.skipped[0].reason).toContain('could not be read');
+  });
+
+  it('still extracts a file that really is empty', async () => {
+    await writeZip('empty.zip', { 'empty.md': '', 'full.md': 'x' });
+    const res = await svc.unzipFile(workspaceId, 'empty.zip', 'out');
+    expect(res.extracted.sort()).toEqual(['knowledge-base/out/empty.md', 'knowledge-base/out/full.md']);
+    expect((await fs.readFile(path.join(repoDir, 'out', 'empty.md'))).byteLength).toBe(0);
+  });
+
   it('does not create the destination directory when every entry is blocked', async () => {
     await writeZip('d.zip', { 'a.md': '1', 'b.md': '2' });
     const res = await svc.unzipFile(workspaceId, 'd.zip', 'out', async () => {

package/src/modules/workspace/__tests__/workspace.tools.agents-file.test.ts

@@ -14,16 +14,19 @@ import { SpillStore } from '../spill-store.js';
 import { WorkflowHooks } from '../../workflow/workflow-hooks.js';
 import { ToolDescriptionNotes } from '../../workspace/agent-access.gate.js';
 import { registerWorkspaceTools } from '../workspace.tools.js';
+import { sharedFileRulesSection, sharedRulesPointer } from '../../agent-instructions/shared-file-rules.js';
 
 /**
  * What the platform TELLS AN AGENT about the conventions file, under the
  * default name and under a deployment's own.
  *
- * Descriptions only: the behaviour behind them is covered in
- * `workspace.tools.test.ts`, and what matters here is the text a remote agent
- * reads, which is the only place it learns that the organisation's own
- * `AGENTS.md` exists at all — it has no checkout, so no harness reads that file
- * for it.
+ * The conventions reminder and the platform-file list are SHARED RULES now —
+ * stated in the handshake instructions and in the managed agent guide, once
+ * each — so their wording is asserted against that one text. What each tool
+ * description still has to get right is the POINTER at the end, which names the
+ * guide by the name this deployment gave it; that is the only place a remote
+ * agent learns which file to open, and it has no checkout, so no harness reads
+ * that file for it.
  */
 const KB_DIR = 'knowledge-base';
 /** The context the tools read; a case applies a deployment's own names to it. */
@@ -61,21 +64,25 @@ async function listed(registry: ToolRegistry): Promise<Map<string, string>> {
 
 afterEach(() => kb.applyLayout({ ...DEFAULT_KB_LAYOUT }));
 
-describe('the conventions note every workspace tool carries', () => {
-  it('names AGENTS.md, and CLAUDE.md beside it, under the default name', async () => {
+describe("what names the guide, under the default name and under a deployment's own", () => {
+  it('names AGENTS.md, and CLAUDE.md beside it, under the default name', () => {
+    const rules = sharedFileRulesSection(kb.layout);
+    expect(rules).toContain(
+      'read `AGENTS.md` at the KB root — or `CLAUDE.md` on a knowledge base seeded before it was renamed',
+    );
+  });
+
+  it("points every entrypoint at the section, by the guide's own name", async () => {
     const byName = await descriptions();
     // On EVERY entrypoint, reads included: any of them can be a session's first.
     for (const name of ['grep', 'list_files', 'file_stat', 'write_file', 'move_file']) {
-      expect(byName.get(name), name).toContain(
-        'read `AGENTS.md` at the KB root — or `CLAUDE.md` on a knowledge base seeded before it was renamed',
-      );
+      expect(byName.get(name), name).toContain('see "Working with files" in AGENTS.md.');
     }
   });
 
-  it('names the configured file first and the organisation\'s own AGENTS.md second', async () => {
+  it("names the configured file first and the organisation's own AGENTS.md second", () => {
     kb.applyLayout({ ...DEFAULT_KB_LAYOUT, agentsFile: 'HEXIS.md' });
-    const byName = await descriptions();
-    const note = byName.get('grep') ?? '';
+    const note = sharedFileRulesSection(kb.layout);
     expect(note).toContain('read `HEXIS.md` at the KB root, then `AGENTS.md` if it also exists');
     expect(note).toContain("the organisation's own conventions");
     // Ours first: an agent that reads only one must read the platform's.
@@ -84,27 +91,23 @@ describe('the conventions note every workspace tool carries', () => {
     expect(note).toContain('`CLAUDE.md`');
   });
 
-  it('describes the platform files under the configured name, and no longer under AGENTS.md', async () => {
+  it('lists the platform files under the configured name, and no longer under AGENTS.md', () => {
     kb.applyLayout({ ...DEFAULT_KB_LAYOUT, agentsFile: 'HEXIS.md' });
-    const byName = await descriptions();
-    const stat = byName.get('file_stat') ?? '';
-    expect(stat).toContain('`access.md`, `roles.yaml`, `.bevelignore`, `HEXIS.md`');
-
-    for (const name of ['delete_file', 'move_file']) {
-      const text = byName.get(name) ?? '';
-      expect(text, name).toContain('`roles.yaml` or `HEXIS.md` at the repository root');
-      // The customer's file is content on such a deployment, so the rule that
-      // refuses a move must not claim it.
-      expect(text.replace(/`AGENTS\.md` if it also exists/g, ''), name).not.toContain(
-        'or `AGENTS.md` at the repository root',
-      );
-    }
+    const rules = sharedFileRulesSection(kb.layout);
+    // Listed with the depth each one counts at — `access.md` and
+    // `.bevelignore` govern the folder they sit in, the other two are read from
+    // the root — because the names alone would have an agent refuse a nested
+    // `HEXIS.md` it may rename.
+    expect(rules).toContain('`access.md` or `.bevelignore` in any folder, `roles.yaml` or `HEXIS.md` at the repository root');
+    // The customer's file is content on such a deployment, so the rule that
+    // refuses a move must not claim it.
+    expect(rules.replace(/`AGENTS\.md` if it also exists/g, '')).not.toContain('`AGENTS.md`');
   });
 
-  it('keeps naming AGENTS.md as a platform file under the default name', async () => {
-    const byName = await descriptions();
-    expect(byName.get('file_stat')).toContain('`access.md`, `roles.yaml`, `.bevelignore`, `AGENTS.md`');
-    expect(byName.get('delete_file')).toContain('`roles.yaml` or `AGENTS.md` at the repository root');
+  it('keeps naming AGENTS.md as a platform file under the default name', () => {
+    expect(sharedFileRulesSection(kb.layout)).toContain(
+      '`access.md` or `.bevelignore` in any folder, `roles.yaml` or `AGENTS.md` at the repository root',
+    );
   });
 
   /**
@@ -117,14 +120,14 @@ describe('the conventions note every workspace tool carries', () => {
   it('follows a layout applied after the tools were mounted', async () => {
     const registry = new ToolRegistry();
     const atMount = await descriptions(registry);
-    expect(atMount.get('grep')).toContain('read `AGENTS.md` at the KB root');
+    expect(atMount.get('grep')).toContain('in AGENTS.md.');
 
     kb.applyLayout({ ...DEFAULT_KB_LAYOUT, agentsFile: 'HEXIS.md' });
 
     const now = await listed(registry);
-    expect(now.get('grep')).toContain('read `HEXIS.md` at the KB root, then `AGENTS.md` if it also exists');
-    expect(now.get('file_stat')).toContain('`access.md`, `roles.yaml`, `.bevelignore`, `HEXIS.md`');
-    expect(now.get('delete_file')).toContain('`roles.yaml` or `HEXIS.md` at the repository root');
-    expect(now.get('move_file')).toContain('`roles.yaml` or `HEXIS.md` at the repository root');
+    for (const name of ['grep', 'file_stat', 'delete_file', 'move_file']) {
+      expect(now.get(name), name).toContain(sharedRulesPointer(kb.layout));
+      expect(now.get(name), name).not.toContain('in AGENTS.md.');
+    }
   });
 });