@bevel-software/platform-core-backend 0.32.0 → 0.34.0

package/src/modules/workflow/agent-tools/__tests__/update-change-request.parity.test.ts

@@ -0,0 +1,306 @@
+import type { Server as HttpServer } from 'node:http';
+import express from 'express';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import type { IWorkflowService } from '@bevel-software/platform-shared';
+import { testKbContext } from '../../../../__tests__/kb-context.js';
+import { ToolRegistry } from '../../../tool-registry/tool-registry.js';
+import { InternalTokenService } from '../../../tool-auth/internal-token.service.js';
+import { createToolAuthMiddleware } from '../../../tool-auth/tool-auth.middleware.js';
+import { createToolContextResolver } from '../../../tool-helpers/tool-context.js';
+import { createToolHandlerFactory } from '../../../tool-helpers/tool-handler.js';
+import { WorkflowDomainError } from '../../../../shared/domain-errors.js';
+import type { IAccessControl } from '../../../access/access-control.interface.js';
+import type { AuthService } from '../../../auth/auth.service.js';
+import type { WorkspaceService } from '../../../workspace/workspace.service.js';
+import type { WorkflowEventBus } from '../../event-bus.js';
+import { createWorkflowRoutes } from '../../workflow.routes.js';
+import { registerWorkflowTools } from '../workflow.tools.js';
+
+/**
+ * The app's `PATCH /api/workflow/change-requests/:number` and the agent's
+ * `update_change_request` are one verb: both reach the SAME service method
+ * with the same caller and the same fields, and every refusal it makes reaches
+ * both callers with the same status and the same words. The rule itself is
+ * pinned in `workflow.service.update-change-request.test.ts`; this pins that
+ * neither surface narrows, widens or rewords it.
+ *
+ * One answer differs, and on purpose: a request the caller may not READ is
+ * not found to the agent (404, as `get_change_request` answers it), before
+ * its state or the edit rule is consulted. The app serves every request's
+ * detail to any signed-in viewer, so its route has nothing to hide.
+ */
+
+const CALLER = { id: 'user-A', email: 'alice@example.com', name: 'Alice' };
+
+let calls: unknown[][] = [];
+/** What the shared service does next: answer the request, or refuse. */
+let outcome: () => unknown;
+/** `get_change_request`'s visibility gate, as the tool is handed it. */
+let maySee: (number: number) => Promise<boolean>;
+
+const updated = {
+  number: 9,
+  url: 'https://bevel.example.com/change-requests/9',
+  title: 'New title',
+  state: 'open',
+  touchedNodePaths: ['Docs/a.md'],
+};
+
+const workflowService = {
+  updateChangeRequest: async (number: number, user: { id: string; email: string }, input: unknown) => {
+    calls.push(['updateChangeRequest', number, user.id, input]);
+    return outcome();
+  },
+} as unknown as IWorkflowService;
+
+const authService = { getUserById: async () => CALLER } as unknown as AuthService;
+const workspaceService = {
+  getOrCreateForUser: async () => ({ id: 'ws' }),
+  findAnyWorkspaceId: async () => 'ws',
+} as unknown as WorkspaceService;
+const events = { emit: () => ({}) } as unknown as WorkflowEventBus;
+const internalToken = new InternalTokenService({ secret: 's' });
+
+let httpServer: HttpServer | undefined;
+/** The agent tools `start` registered, as the manual lists them. */
+let registry: ToolRegistry;
+
+async function start(): Promise<string> {
+  const app = express();
+  app.use(express.json());
+
+  // The app's route, signed in as CALLER.
+  const appRouter = express.Router();
+  appRouter.use((req, _res, next) => {
+    (req as unknown as { userId: string }).userId = CALLER.id;
+    next();
+  });
+  appRouter.use(
+    createWorkflowRoutes(
+      workflowService,
+      workspaceService,
+      authService,
+      events,
+      { canReadBatch: async () => new Map() } as unknown as IAccessControl,
+      'knowledge-base',
+    ),
+  );
+
+  // The agent's tool, as CALLER over an internal token.
+  registry = new ToolRegistry();
+  const toolRouter = express.Router();
+  const toolAuth = createToolAuthMiddleware(
+    { looksLikeExternalApiKey: () => false, verifyAndLoadToken: async () => null } as never,
+    internalToken,
+  );
+  const resolve = createToolContextResolver({
+    authService,
+    workspaceService,
+    workflowService,
+    events,
+    kbDirName: 'knowledge-base',
+    creatorAccess: { planForCreate: async () => null, grantInExtractedFile: async () => null, noteAccessFileWritten: () => {} },
+  } as never);
+  registerWorkflowTools(registry, toolRouter, toolAuth, createToolHandlerFactory(resolve), testKbContext(), async (_ctx, number) =>
+    maySee(number),
+  );
+
+  app.use('/api', toolRouter);
+  app.use('/api', appRouter);
+  httpServer = await new Promise<HttpServer>((r) => {
+    const s = app.listen(0, () => r(s));
+  });
+  return `http://127.0.0.1:${(httpServer.address() as { port: number }).port}`;
+}
+
+async function viaRoute(base: string, body: Record<string, unknown>) {
+  const res = await fetch(`${base}/api/workflow/change-requests/9`, {
+    method: 'PATCH',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  return { status: res.status, body: (await res.json()) as Record<string, unknown> };
+}
+
+async function viaTool(base: string, body: Record<string, unknown>) {
+  const res = await fetch(`${base}/api/agent/tools/update_change_request`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', authorization: `Bearer ${internalToken.mint({ userId: CALLER.id })}` },
+    body: JSON.stringify({ number: 9, ...body }),
+  });
+  return { status: res.status, body: (await res.json()) as Record<string, unknown> };
+}
+
+beforeEach(() => {
+  calls = [];
+  outcome = () => updated;
+  maySee = async () => true;
+});
+afterEach(async () => {
+  if (httpServer) await new Promise<void>((r) => httpServer!.close(() => r()));
+  httpServer = undefined;
+});
+
+describe('update_change_request ⇔ PATCH /workflow/change-requests/:number', () => {
+  it('both hand the same service call the same caller and the same fields', async () => {
+    const base = await start();
+    const fields = { title: 'New title', description: 'P2 - Planned\n\nWhy.' };
+    expect((await viaRoute(base, fields)).status).toBe(200);
+    expect((await viaTool(base, fields)).status).toBe(200);
+    expect(calls).toEqual([
+      ['updateChangeRequest', 9, CALLER.id, fields],
+      ['updateChangeRequest', 9, CALLER.id, fields],
+    ]);
+  });
+
+  it('a description alone reaches the service as a description alone, from both', async () => {
+    const base = await start();
+    await viaRoute(base, { description: 'Only this.' });
+    await viaTool(base, { description: 'Only this.' });
+    expect(calls).toEqual([
+      ['updateChangeRequest', 9, CALLER.id, { title: undefined, description: 'Only this.' }],
+      ['updateChangeRequest', 9, CALLER.id, { title: undefined, description: 'Only this.' }],
+    ]);
+  });
+
+  it('an append reaches the service as an append, from both — the tool offers the field the route takes', async () => {
+    const base = await start();
+    expect((await viaRoute(base, { appendDescription: 'Round two.' })).status).toBe(200);
+    expect((await viaTool(base, { appendDescription: 'Round two.' })).status).toBe(200);
+    expect(calls).toEqual([
+      ['updateChangeRequest', 9, CALLER.id, { title: undefined, description: undefined, appendDescription: 'Round two.' }],
+      ['updateChangeRequest', 9, CALLER.id, { title: undefined, description: undefined, appendDescription: 'Round two.' }],
+    ]);
+  });
+
+  it("the tool's input schema names every field the route takes", async () => {
+    await start();
+    const tool = (await registry.listInternal()).find((t) => t.name === 'update_change_request');
+    // The catalog nests a tool's arguments under `body`.
+    const top = (tool?.inputs as { properties: Record<string, { properties?: Record<string, unknown> }> }).properties;
+    const props = top.body?.properties ?? top;
+    expect(Object.keys(props).sort()).toEqual(['appendDescription', 'description', 'number', 'title']);
+  });
+
+  const refusals: [string, () => never][] = [
+    [
+      'neither the author nor someone who may merge it (403)',
+      () => {
+        throw new WorkflowDomainError(
+          "Only the request's author, an admin, or someone who may approve every file it changes can edit its title and description.",
+          403,
+        );
+      },
+    ],
+    [
+      'a merged request (409)',
+      () => {
+        throw new WorkflowDomainError(
+          'This change request has already been applied; its title and description can no longer be changed.',
+          409,
+        );
+      },
+    ],
+    [
+      'a closed request (409)',
+      () => {
+        throw new WorkflowDomainError(
+          'This change request is closed; its title and description can no longer be changed.',
+          409,
+        );
+      },
+    ],
+  ];
+
+  for (const [name, refuse] of refusals) {
+    it(`refuses ${name} with the same status and the same words`, async () => {
+      const base = await start();
+      outcome = refuse;
+      const route = await viaRoute(base, { title: 'New title' });
+      const tool = await viaTool(base, { title: 'New title' });
+      expect(route.status).toBeGreaterThanOrEqual(400);
+      expect(tool).toEqual(route);
+      expect(typeof route.body.error).toBe('string');
+      expect((route.body.error as string).length).toBeGreaterThan(20);
+    });
+  }
+
+  it('the tool answers a request the caller may not see as not found, whatever its state or the rule would say', async () => {
+    const base = await start();
+    maySee = async () => false;
+    for (const [, refuse] of refusals) {
+      outcome = refuse;
+      const tool = await viaTool(base, { title: 'New title' });
+      expect(tool).toEqual({ status: 404, body: { error: 'Change request #9 not found.' } });
+    }
+    expect(calls).toEqual([]);
+  });
+
+  it('the tool answers the request’s link and its title; the route the request', async () => {
+    const base = await start();
+    const tool = await viaTool(base, { title: 'New title' });
+    expect(tool.body).toEqual({
+      number: 9,
+      url: 'https://bevel.example.com/change-requests/9',
+      title: 'New title',
+    });
+    const route = await viaRoute(base, { title: 'New title' });
+    expect(route.body).toMatchObject({ number: 9, title: 'New title' });
+  });
+
+  it('asks for something to change before reaching the service', async () => {
+    const base = await start();
+    const tool = await viaTool(base, {});
+    expect(tool.status).toBe(400);
+    expect(calls).toEqual([]);
+  });
+
+  it('the route refuses a non-string field before reaching the service', async () => {
+    const base = await start();
+    const route = await viaRoute(base, { title: 7 });
+    expect(route.status).toBe(400);
+    expect(calls).toEqual([]);
+  });
+});
+
+/**
+ * The comment system is gone: no screen ever showed a comment, so the routes,
+ * the service methods, the storage and the two agent tools were removed
+ * rather than surfaced. Its old addresses answer 404 and its tools are not
+ * offered; the request itself still answers on its own address.
+ */
+describe('change-request comments are gone', () => {
+  const routes: [string, string][] = [
+    ['GET', '/api/workflow/change-requests/9/comments'],
+    ['POST', '/api/workflow/change-requests/9/comments'],
+    ['PATCH', '/api/workflow/change-requests/9/comments/00000000-0000-4000-8000-000000000000'],
+    ['DELETE', '/api/workflow/change-requests/9/comments/00000000-0000-4000-8000-000000000000'],
+  ];
+  for (const [method, path] of routes) {
+    it(`${method} ${path.replace('/api', '')} answers 404`, async () => {
+      const base = await start();
+      const res = await fetch(`${base}${path}`, {
+        method,
+        headers: { 'content-type': 'application/json' },
+        ...(method === 'GET' || method === 'DELETE' ? {} : { body: JSON.stringify({ body: 'hi' }) }),
+      });
+      expect(res.status).toBe(404);
+      expect(calls).toEqual([]);
+    });
+  }
+
+  it('the agent is offered no comment tool, and calling one answers 404', async () => {
+    const base = await start();
+    for (const name of ['post_change_request_comment']) {
+      const res = await fetch(`${base}/api/agent/tools/${name}`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', authorization: `Bearer ${internalToken.mint({ userId: CALLER.id })}` },
+        body: JSON.stringify({ number: 9, body: 'hi' }),
+      });
+      expect(res.status).toBe(404);
+    }
+    const names = (await registry.listInternal()).map((t) => t.name);
+    expect(names).toContain('update_change_request');
+    expect(names.filter((n) => n.includes('comment'))).toEqual([]);
+  });
+});

package/src/modules/workflow/agent-tools/__tests__/workflow.tools.test.ts

@@ -72,7 +72,6 @@ function detailOf(files: Record<string, unknown>[]): Record<string, unknown> {
     headSha: 'head-1',
     baseSha: 'base-1',
     files,
-    comments: [],
     approvals: files.map((f) => approvalOf(f.path as string)),
     mergeableInBevel: false,
     mergeBlockedReasons: files.map((f) => `${f.path as string} is not approved`),
@@ -94,8 +93,6 @@ const externalApiKeyService = {
     t === 'bevel_key' ? { user: { id: 'user-A', email: 'e@x', name: 'N' }, tokenId: 'tok' } : null,
 } as never;
 const authService = { getUserById: async (id: string) => ({ id, email: 'e@x', name: 'N' }) } as never;
-/** A declined change request: no sha records what it proposed, so it has no head. */
-const DECLINED_CR = 21;
 
 const workspaceService = {
   getOrCreateForUser: async () => ({ id: WS }),
@@ -107,6 +104,9 @@ const workspaceService = {
 const workflowService = {
   listBranches: async (ws: string) => {
     calls.push(['listBranches', ws]);
+    // A real listing fetches first; mark when that fetch has landed.
+    await new Promise((r) => setTimeout(r, 0));
+    calls.push(['listBranches:fetched', ws]);
     return [{ name: 'main', isProtected: true }];
   },
   commitChange: async (ws: string, user: { id: string }, body: unknown) => {
@@ -120,7 +120,7 @@ const workflowService = {
   },
   createBranch: async (ws: string, name: string) => {
     calls.push(['createBranch', ws, name]);
-    return { name, isProtected: false, ahead: 0, behind: 0, hasRemote: true };
+    return { name, isProtected: false, hasRemote: true };
   },
   acquireLock: async (ws: string, branch: string, path: string) => {
     calls.push(['acquireLock', ws, branch, path]);
@@ -129,15 +129,12 @@ const workflowService = {
   releaseLock: async (ws: string, branch: string, path: string) => {
     calls.push(['releaseLock', ws, branch, path]);
   },
-  // #21 is DECLINED: the service reads such a row from nothing (no sha records
-  // what it proposed), so its detail carries no head — which is what the comment
-  // tool has to anchor to. Every other number is an ordinary open request.
   getChangeRequestDetail: async (number: number) => ({
     number,
     url: `https://bevel.example.com/change-requests/${number}`,
-    headSha: number === DECLINED_CR ? '' : 'head-1',
+    headSha: 'head-1',
     approvals: [],
-    state: number === DECLINED_CR ? 'closed' : 'open',
+    state: 'open',
     title: 'T',
     base: 'main',
   }),
@@ -181,10 +178,6 @@ const workflowService = {
     }
     return { kind: 'deleted', branch: name, lastCommit: 'tip-1', discardedCommits: name === 'me/unmerged' ? 3 : 0 };
   },
-  postComment: async (number: number, _user: unknown, input: { path?: string }) => {
-    calls.push(['postComment', number, input.path]);
-    return { id: 'c-1' };
-  },
   // The history and syncing reads, answered from a fixed script.
   listChangesForFile: async (ws: string, path: string, limit?: number) => {
     calls.push(['listChangesForFile', ws, path, limit]);
@@ -216,6 +209,10 @@ const workflowService = {
     calls.push(['branchStatus', ws]);
     return { branch: ws, hasUpstream: true, unmergedFromUpstream: true };
   },
+  branchCounts: async (ws: string) => {
+    calls.push(['branchCounts', ws]);
+    return { ahead: 3, behind: 1 };
+  },
   listPendingChangePaths: async (ws: string) => {
     calls.push(['listPendingChangePaths', ws]);
     return ['knowledge-base/KnowledgeBase/Pending.md'];
@@ -373,51 +370,6 @@ describe('registerWorkflowTools', () => {
     expect(calls).toContainEqual(['commitChange', WS, 'user-A', { summary: 'fix typo', description: undefined }]);
   });
 
-  // A change request's files are repository-relative; the Copy path form
-  // carries the clone folder, which is dropped so the comment lands on the file.
-  it('post_change_request_comment anchors a copied workspace path to the repository-relative file', async () => {
-    const base = await start();
-    for (const path of ['/knowledge-base/KnowledgeBase/Foo.md', 'knowledge-base/KnowledgeBase/Foo.md', 'KnowledgeBase/Foo.md']) {
-      const res = await post(`${base}/api/agent/tools/post_change_request_comment`, writeTok(), { number: 3, body: 'hi', path });
-      expect(res.status, path).toBe(200);
-    }
-    expect(calls.filter((c) => c[0] === 'postComment')).toEqual([
-      ['postComment', 3, 'KnowledgeBase/Foo.md'],
-      ['postComment', 3, 'KnowledgeBase/Foo.md'],
-      ['postComment', 3, 'KnowledgeBase/Foo.md'],
-    ]);
-  });
-
-  // An agent hands the change request's link to a person, so the tools that
-  // act on one by number return its `{ number, url }` beside their own payload.
-  it('post_change_request_comment returns the change request link', async () => {
-    const base = await start();
-    const comment = await post(`${base}/api/agent/tools/post_change_request_comment`, writeTok(), { number: 3, body: 'hi' });
-    expect(comment.status).toBe(200);
-    const commentBody = await comment.json();
-    expect(commentBody).toMatchObject({
-      comment: { id: 'c-1' },
-      changeRequest: { number: 3, url: 'https://bevel.example.com/change-requests/3' },
-    });
-    // A configured address yields an absolute link, so no note rides along.
-    expect(commentBody.changeRequest).not.toHaveProperty('urlNote');
-  });
-
-  // A comment anchors to a commit. A declined request records none — nothing
-  // durable says what it proposed, so it is read from nothing and its detail
-  // carries no head. Say so, rather than letting the service's `head sha is
-  // required` come back as a 400 about an argument the caller never passed.
-  it('post_change_request_comment says why a declined request takes no comment', async () => {
-    const base = await start();
-    const res = await post(`${base}/api/agent/tools/post_change_request_comment`, writeTok(), { number: DECLINED_CR, body: 'why was this turned down?' });
-    expect(res.status).toBe(409);
-    expect(((await res.json()) as { error: string }).error).toMatch(
-      new RegExp(`#${DECLINED_CR} is closed and has no commit to anchor a comment to`),
-    );
-    // Nothing was written: the refusal happens before the service is asked.
-    expect(calls.some((c) => c[0] === 'postComment')).toBe(false);
-  });
-
   describe('delete_branch', () => {
     it('is on both catalogs, takes name, dryRun and discardUnmerged, and is a write tool', async () => {
       await start();
@@ -573,6 +525,24 @@ describe('registerWorkflowTools', () => {
     expect(calls).toContainEqual(['listBranches', 'existing-ws']);
   });
 
+  it('list_branches declares names, protection and remote presence, and no commit counts', async () => {
+    await start();
+    for (const tools of [await registryRef!.listInternal(), await registryRef!.listExternal()]) {
+      const listBranches = tools.find((t) => t.name === 'list_branches')!;
+      const branch = (listBranches.outputs as { properties: { branches: { items: { properties: object; required: string[] } } } })
+        .properties.branches.items;
+      expect(Object.keys(branch.properties).sort()).toEqual(['hasRemote', 'isProtected', 'name']);
+      expect([...branch.required].sort()).toEqual(['hasRemote', 'isProtected', 'name']);
+      expect(listBranches.description).toContain('{ name, isProtected, hasRemote }');
+      expect(listBranches.description).not.toMatch(/\bahead\b,|\bbehind\b,/);
+      // The counts are still `branch_status`'s answer, for its one branch.
+      const branchStatus = tools.find((t) => t.name === 'branch_status')!;
+      expect((branchStatus.outputs as { required: string[] }).required).toEqual(
+        expect.arrayContaining(['ahead', 'behind', 'behindRemote']),
+      );
+    }
+  });
+
   it('open_change_request acts on the SOURCE branch\'s workspace', async () => {
     const base = await start();
     const res = await post(`${base}/api/agent/tools/open_change_request`, writeTok(), {
@@ -746,6 +716,37 @@ describe('registerWorkflowTools', () => {
       ]);
     });
 
+    it('names each user owner by name, or by email when the name is empty — never a blank string', async () => {
+      const base = await start();
+      opened = detailOf([
+        { path: 'Skills/Owned/SKILL.md', status: 'modified', additions: 1, deletions: 1, isBinary: false, sha: 'b5', rawUrl: 'r5' },
+      ]);
+      // What the resolver hands back for owners `roles.yaml` lists by email:
+      // an empty name. QA saw `users: [""]` here while `mergeBlockedReasons`
+      // named qa-user2@example.com.
+      opened.approvals = [
+        {
+          path: 'Skills/Owned/SKILL.md',
+          eligibleApprovers: {
+            roles: [],
+            users: [
+              { name: '', email: 'qa-user2@example.com' },
+              { name: 'Razvan Radulescu', email: 'razvan.radulescu@bevel.software' },
+              { name: '  ', email: 'qa-user3@example.com' },
+              { name: '', email: '' },
+            ],
+          },
+          approvedBy: [],
+          eligibilityResolved: true,
+          isApproved: false,
+          inMergeGate: true,
+        },
+      ];
+      const [entry] = (await open(base)).approvals as { users: string[] }[];
+      expect(entry.users).toEqual(['qa-user2@example.com', 'Razvan Radulescu', 'qa-user3@example.com']);
+      expect(entry.users.every((u) => u.trim() !== '')).toBe(true);
+    });
+
     it('surfaces the `change-request-conflicts` error as before', async () => {
       const base = await start();
       openFails = new ChangeRequestConflictsError('me/draft', 'target-company-state', ['KnowledgeBase/Clash.md']);
@@ -1032,6 +1033,26 @@ describe('save_file and the repository folder', () => {
     expect(calls.some((c) => c[0] === 'acquireLock')).toBe(false);
   });
 
+  it('refuses a tmp ref in every path input, before any lock — save_file, the history tools and update_branch\'s resolutions alike', async () => {
+    const base = await start();
+    const calls_: Array<[string, Record<string, unknown>]> = [
+      ['save_file', { path: '__tmp__/chat-uploads/plan.xlsx' }],
+      ['read_file_at', { path: '__tmp__/chat-uploads/plan.xlsx', at: 'HEAD' }],
+      ['compare_file', { path: '__tmp__/chat-uploads/plan.xlsx' }],
+      ['list_file_changes', { path: '__tmp__/chat-uploads/plan.xlsx' }],
+      ['update_branch', { resolutions: [{ path: '__tmp__/chat-uploads/plan.xlsx', choose: 'ours' }] }],
+    ];
+    for (const [tool, args] of calls_) {
+      const res = await post(`${base}/api/agent/tools/${tool}`, writeTok(), { ...args, branch: WS });
+      expect(res.status, tool).toBe(400);
+      const body = (await res.json()) as { error: string; kind: string };
+      expect(body.kind, tool).toBe('tmp-ref-read-only');
+      expect(body.error).toContain(`${tool} does not take one there`);
+      expect(body.error).toContain('copy_file');
+    }
+    expect(calls.some((c) => c[0] === 'acquireLock')).toBe(false);
+  });
+
   it('answers a missing path with a 400, not a crash', async () => {
     const base = await start();
     const res = await post(`${base}/api/agent/tools/save_file`, writeTok(), { branch: WS });
@@ -1189,8 +1210,9 @@ describe('history and syncing tools', () => {
       // The listing double names only `main`, so the draft's own entry is unknown.
       isProtected: false,
       hasRemote: true,
-      ahead: null,
-      behind: null,
+      // Counted for the draft alone, by its own workspace — not read off a listing.
+      ahead: 3,
+      behind: 1,
       behindRemote: true,
       uncommittedPaths: ['KnowledgeBase/Pending.md'],
       forkBase: 'main',
@@ -1199,6 +1221,11 @@ describe('history and syncing tools', () => {
       withheldPaths: 0,
     });
     expect(calls).toContainEqual(['changedPathsBetweenBranches', DRAFT_WS, 'main', DRAFT]);
+    expect(calls).toContainEqual(['branchCounts', DRAFT_WS]);
+    // Counted only once the listing's fetch has refreshed the remote-tracking refs.
+    const fetched = calls.findIndex((c) => c[0] === 'listBranches:fetched' && c[1] === DRAFT_WS);
+    expect(fetched).toBeGreaterThanOrEqual(0);
+    expect(calls.findIndex((c) => c[0] === 'branchCounts')).toBeGreaterThan(fetched);
 
     calls = [];
     const named = await post(tool(base, 'branch_status'), writeTok(), { branch: DRAFT, base: 'release' });