@bevel-software/platform-core-backend 0.26.0 → 0.27.0

package/src/modules/workflow/__tests__/preserve-roles-yaml.test.ts

@@ -13,7 +13,11 @@ import { FileLockService } from '../file-lock.service.js';
 import { PendingCommitsService } from '../pending-commits.service.js';
 import { WorkflowService } from '../workflow.service.js';
 import type { Database } from '../../database/connection.js';
-import { RolesYamlPreservationError } from '../../../shared/domain-errors.js';
+import {
+  PushNeedsAgentResolutionError,
+  RolesYamlPreservationError,
+} from '../../../shared/domain-errors.js';
+import type { WorkflowEventBus } from '../event-bus.js';
 import { openChangeGate } from '../../../__tests__/open-change-gate.js';
 
 /**
@@ -63,12 +67,18 @@ describe('mergeChangeRequest — roles.yaml preservation guard', () => {
     headRoles: string | null;
     baseRoles: string | null;
     commitFileResult?: unknown;
+    /**
+     * What the clone answers when asked whether its HEAD already holds all of
+     * origin/<head>; an Error makes the probe throw instead.
+     */
+    headContainsOrigin?: boolean | Error;
     pushImpl?: () => Promise<void>;
     getPrResult?: { branch: string; base: string } | null;
     getPrDetailResult?: unknown;
     // Simulate a concurrent editor already holding the roles.yaml lock. When set,
     // acquire returns { acquired: false } and the restore must fail-closed.
     lockHeldBy?: string;
+    events?: WorkflowEventBus;
   }) {
     const ac = noopAccessControl();
     const reviewWorkflow = {
@@ -91,6 +101,11 @@ describe('mergeChangeRequest — roles.yaml preservation guard', () => {
         'commitFileResult' in opts ? opts.commitFileResult : { sha: 'preserve-sha' },
       ),
       push: vi.fn(opts.pushImpl ?? (async () => undefined)),
+      headContainsOrigin: vi.fn(async () => {
+        const answer = opts.headContainsOrigin ?? false;
+        if (answer instanceof Error) throw answer;
+        return answer;
+      }),
     } as unknown as GitService;
 
     const prs = {
@@ -123,6 +138,7 @@ describe('mergeChangeRequest — roles.yaml preservation guard', () => {
       fileLocks, {} as unknown as PendingCommitsService,
       testKbContext({ kbDirName: KB_DIR }),
       openChangeGate(),
+      opts.events,
     );
     // Conflicts are now surfaced by the local merge inside `reviewWorkflow.mergePr`
     // (mocked to resolve here), so there's no provider "mergeable" pre-check to stub.
@@ -221,17 +237,55 @@ describe('mergeChangeRequest — roles.yaml preservation guard', () => {
     expect(git.push).toHaveBeenCalled();
   });
 
-  it('ABORTS the merge (RolesYamlPreservationError) if the restore push fails', async () => {
+  it('ABORTS the merge when the host refuses the restore push, keeping the restore locally (409, saved-locally, banner)', async () => {
     await fs.writeFile(path.join(headRepoDir, 'roles.yaml'), ATTACKER_ROLES);
-    const { svc, reviewWorkflow } = makeSvc({
+    const emit = vi.fn();
+    const { svc, git, reviewWorkflow, fileLocks } = makeSvc({
       headRoles: ATTACKER_ROLES,
       baseRoles: BASE_ROLES,
-      pushImpl: async () => { throw new Error('push rejected: non-fast-forward'); },
+      pushImpl: async () => {
+        throw new Error('git push failed: remote: Internal Server Error');
+      },
+      events: { emit } as unknown as WorkflowEventBus,
     });
 
-    await expect(merge(svc)).rejects.toBeInstanceOf(RolesYamlPreservationError);
-    // Fail-closed: the merge must NOT have run.
+    const err = await merge(svc).catch((e: unknown) => e);
+    // Answered like every refused push — not the 502 preservation error, and
+    // never a raw 500.
+    expect(err).toBeInstanceOf(PushNeedsAgentResolutionError);
+    expect((err as PushNeedsAgentResolutionError).status).toBe(409);
+    expect((err as Error).message).toContain(`Saved locally on "${HEAD}"`);
+    expect(JSON.stringify((err as PushNeedsAgentResolutionError).payload)).not.toContain('Internal Server Error');
+    // Fail-closed: the merge must NOT have run — origin still carries the
+    // divergent roles.yaml.
     expect(reviewWorkflow.mergePr).not.toHaveBeenCalled();
+    // The local result stays: base version on disk, committed, lock dropped.
+    expect(await fs.readFile(path.join(headRepoDir, 'roles.yaml'), 'utf-8')).toBe(BASE_ROLES);
+    expect(git.commitFile).toHaveBeenCalled();
+    expect(fileLocks.release).toHaveBeenCalled();
+    // A refusal is not a divergence: no cooperative pull-rebase, no retry.
+    expect(git.push).toHaveBeenCalledTimes(1);
+    expect(git.pull).not.toHaveBeenCalledWith(expect.anything(), { preserveMerges: true });
+    expect(emit).toHaveBeenCalledWith(
+      expect.objectContaining({ kind: 'git-sync-failed', workspaceId: HEAD, branch: HEAD }),
+    );
+  });
+
+  it('a non-fast-forward restore push takes the cooperative pull-rebase, then the merge proceeds', async () => {
+    await fs.writeFile(path.join(headRepoDir, 'roles.yaml'), ATTACKER_ROLES);
+    let pushes = 0;
+    const { svc, git, reviewWorkflow } = makeSvc({
+      headRoles: ATTACKER_ROLES,
+      baseRoles: BASE_ROLES,
+      pushImpl: async () => {
+        if (pushes++ === 0) throw new Error('push rejected: non-fast-forward');
+      },
+    });
+
+    await merge(svc);
+    expect(git.pull).toHaveBeenCalled();
+    expect(git.push).toHaveBeenCalledTimes(2);
+    expect(reviewWorkflow.mergePr).toHaveBeenCalledTimes(1);
   });
 
   it('ABORTS the merge if the CR (PR) cannot be resolved', async () => {
@@ -283,6 +337,56 @@ describe('mergeChangeRequest — roles.yaml preservation guard', () => {
     expect(reviewWorkflow.mergePr).not.toHaveBeenCalled();
   });
 
+  it('a merge retried after a refused restore push pushes the restore that is already committed, then merges', async () => {
+    // The earlier attempt restored and committed roles.yaml on the source,
+    // and the host refused the push (the 409 above). origin/head therefore
+    // still diverges, the working tree already matches base, and commitFile
+    // has nothing new — but the clone's HEAD holds the restore commit on top
+    // of everything origin has. The retry must push it and merge, not refuse
+    // "out of sync" forever.
+    await fs.writeFile(path.join(headRepoDir, 'roles.yaml'), BASE_ROLES);
+    const { svc, git, reviewWorkflow } = makeSvc({
+      headRoles: ATTACKER_ROLES,
+      baseRoles: BASE_ROLES,
+      commitFileResult: null,
+      headContainsOrigin: true,
+    });
+    await expect(merge(svc)).resolves.toMatchObject({ kind: 'merged' });
+    expect(git.push).toHaveBeenCalledTimes(1);
+    expect(reviewWorkflow.mergePr).toHaveBeenCalled();
+  });
+
+  it('still ABORTS when the base version is on disk but the clone is BEHIND origin/head (fail-closed)', async () => {
+    // The unsafe shape: HEAD never saw origin's divergent roles.yaml commit,
+    // the working tree matches base, and the clone carries some unpushed
+    // save. Pushing would rebase origin's divergent copy INTO HEAD first and
+    // the merge would land it — so holding unpushed work is not the question,
+    // holding all of origin is.
+    await fs.writeFile(path.join(headRepoDir, 'roles.yaml'), BASE_ROLES);
+    const { svc, git, reviewWorkflow } = makeSvc({
+      headRoles: ATTACKER_ROLES,
+      baseRoles: BASE_ROLES,
+      commitFileResult: null,
+      headContainsOrigin: false,
+    });
+    await expect(merge(svc)).rejects.toBeInstanceOf(RolesYamlPreservationError);
+    expect(git.push).not.toHaveBeenCalled();
+    expect(reviewWorkflow.mergePr).not.toHaveBeenCalled();
+  });
+
+  it('ABORTS when the probe for "does HEAD hold origin/head" itself fails (fail-closed, not open)', async () => {
+    await fs.writeFile(path.join(headRepoDir, 'roles.yaml'), BASE_ROLES);
+    const { svc, git, reviewWorkflow } = makeSvc({
+      headRoles: ATTACKER_ROLES,
+      baseRoles: BASE_ROLES,
+      commitFileResult: null,
+      headContainsOrigin: new Error("fatal: Not a valid object name refs/remotes/origin/mallory/escalate"),
+    });
+    await expect(merge(svc)).rejects.toBeInstanceOf(RolesYamlPreservationError);
+    expect(git.push).not.toHaveBeenCalled();
+    expect(reviewWorkflow.mergePr).not.toHaveBeenCalled();
+  });
+
   it('ABORTS the merge when the post-preservation CR detail cannot be reloaded (fail-closed)', async () => {
     // After a preservation commit advances the head, the gate inputs must be
     // re-resolved. If the fresh detail is unavailable, abort — never fall back to

package/src/modules/workflow/__tests__/sanitize-error.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { sanitizeError } from '../sanitize-error.js';
+import { describeSyncFailure, sanitizeError } from '../sanitize-error.js';
 
 describe('sanitizeError', () => {
   it('returns String(err) for non-Error throws', () => {
@@ -75,3 +75,91 @@ describe('sanitizeError', () => {
     expect(twice).toBe(once);
   });
 });
+
+describe('describeSyncFailure', () => {
+  // What a person reads about a failed push: the kind of failure, never a
+  // line of git's own output (the server log keeps that).
+  const cases: Array<[string, string]> = [
+    [
+      "fatal: Authentication failed for 'https://x-access-token:ghp_abc@github.com/acme/kb.git/'",
+      "The repository host did not accept this server's credentials.",
+    ],
+    [
+      "fatal: unable to access 'https://github.com/acme/kb.git/': The requested URL returned error: 401",
+      "The repository host did not accept this server's credentials.",
+    ],
+    [
+      "fatal: unable to access 'https://github.com/acme/kb.git/': The requested URL returned error: 403",
+      "The repository host did not give this server's credentials permission to push here.",
+    ],
+    [
+      'remote: Permission to acme/kb.git denied to kb-bot.',
+      "The repository host did not give this server's credentials permission to push here.",
+    ],
+    [
+      'git@github.com: Permission denied (publickey).\nfatal: Could not read from remote repository.',
+      "The repository host did not accept this server's credentials.",
+    ],
+    [
+      "error: cannot open .git/FETCH_HEAD: Permission denied",
+      "This server could not write to its own copy of the repository.",
+    ],
+    [
+      'error: insufficient permission for adding an object to repository database .git/objects',
+      "This server could not write to its own copy of the repository.",
+    ],
+    [
+      "fatal: unable to access 'https://127.0.0.1:9/none.git/': Failed to connect to 127.0.0.1 port 9: Connection refused",
+      'The repository host could not be reached.',
+    ],
+    [
+      '! [rejected] main -> main (non-fast-forward)',
+      'The branch changed on the repository host and could not be reconciled automatically.',
+    ],
+    [
+      'remote: Internal Server Error\n ! [remote rejected] ali/x -> ali/x (Internal Server Error)',
+      'The repository host refused the request.',
+    ],
+    // A timeout in git's own standalone wording, and Node's code for one.
+    [
+      "fatal: unable to access 'https://github.com/acme/kb.git/': Operation timed out after 30001 milliseconds",
+      'The repository host could not be reached.',
+    ],
+    ["fatal: unable to access 'https://github.com/acme/kb.git/': timed out", 'The repository host could not be reached.'],
+    ['connect ETIMEDOUT 140.82.121.3:443', 'The repository host could not be reached.'],
+    ['HTTP 401 Unauthorized', "The repository host did not accept this server's credentials."],
+    // A host's "token" wording is a rejected credential, as its "password" wording is.
+    ["remote: Invalid username or token. Password authentication is not supported", "The repository host did not accept this server's credentials."],
+    // "repository … not found" with git's quoted URL between the words.
+    ["remote: Repository 'https://github.com/acme/kb.git/' not found", "The repository host did not give this server's credentials permission to push here."],
+  ];
+
+  it.each(cases)('describes %j without quoting it', (raw, expected) => {
+    const said = describeSyncFailure(new Error(raw));
+    expect(said).toBe(expected);
+    expect(said).not.toMatch(/fatal|remote:|github\.com|ghp_|127\.0\.0\.1/);
+  });
+
+  it('says "access to this repository", not "push", when the PULL was refused', () => {
+    for (const raw of [
+      "fatal: unable to access 'https://github.com/acme/kb.git/': The requested URL returned error: 403",
+      'remote: Repository not found.\nfatal: repository \'https://github.com/acme/kb.git/\' not found',
+      'remote: Permission to acme/kb.git denied to kb-bot.',
+    ]) {
+      expect(describeSyncFailure(new Error(raw), 'pull')).toBe(
+        "The repository host did not give this server's credentials access to this repository.",
+      );
+      expect(describeSyncFailure(new Error(raw), 'push')).toBe(
+        "The repository host did not give this server's credentials permission to push here.",
+      );
+    }
+    // A rejected credential is the same fix whichever side met it.
+    expect(describeSyncFailure(new Error('fatal: Authentication failed'), 'pull')).toBe(
+      "The repository host did not accept this server's credentials.",
+    );
+  });
+
+  it('accepts a non-Error throw', () => {
+    expect(describeSyncFailure('something odd')).toBe('The repository host refused the request.');
+  });
+});

package/src/modules/workflow/__tests__/workflow.routes.push-refused.test.ts

@@ -0,0 +1,202 @@
+import type { Server } from 'node:http';
+import type { AddressInfo } from 'node:net';
+import express from 'express';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { testKbContext } from '../../../__tests__/kb-context.js';
+import type { AuthUser, IWorkflowService } from '@bevel-software/platform-shared';
+import type { Database } from '../../database/connection.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 { GitService } from '../git/git.service.js';
+import type { PullRequestService } from '../git/pull-request.service.js';
+import type { IReviewWorkflowService } from '../review-workflow/review-workflow.interface.js';
+import type { FileLockService } from '../file-lock.service.js';
+import type { PendingCommitsService } from '../pending-commits.service.js';
+import { WorkflowEventBus } from '../event-bus.js';
+import { WorkflowService } from '../workflow.service.js';
+import { createWorkflowRoutes } from '../workflow.routes.js';
+import { openChangeGate } from '../../../__tests__/open-change-gate.js';
+import {
+  BranchDeleteRefusedError,
+  PushNeedsAgentResolutionError,
+} from '../../../shared/domain-errors.js';
+
+/**
+ * Every route whose operation pushes answers a push the repository host
+ * refused the same way: 409, the saved-locally sentence naming the branch —
+ * or, for a branch deletion, the host-refused sentence — and never
+ * "Internal server error" or a line of git output.
+ *
+ * The services' own tests prove each operation THROWS the refusal; these
+ * prove the routes answer it. The share route runs over the real service,
+ * because it is the one that answered 500 for a raw push error before.
+ */
+
+const ALICE: AuthUser = { id: '11111111-1111-4111-8111-111111111111', email: 'alice@example.com', name: 'Alice' };
+const BRANCH = 'alice/deal';
+const WS = encodeURIComponent(BRANCH);
+/** What GitHub answered during its incident — none of it may reach the body. */
+const GIT_OUTPUT =
+  'git push failed: remote: Internal Server Error\nTo https://x-access-token:ghp_abc@github.com/acme/kb.git\n ! [remote rejected] alice/deal -> alice/deal (Internal Server Error)';
+
+function refused(path: string, branch = BRANCH): PushNeedsAgentResolutionError {
+  return new PushNeedsAgentResolutionError(branch, path, GIT_OUTPUT, '(cooperative path not attempted)', 'refused');
+}
+
+/**
+ * Each operation's refusal names its own branch, so a route that answered
+ * with a fixed name — or another operation's — fails its case.
+ */
+const REVERT_BRANCH = 'alice/revert-src';
+const OPEN_BRANCH = 'alice/open-src';
+const UPDATE_BRANCH = 'alice/update-src';
+
+async function serve(workflow: Partial<IWorkflowService>): Promise<{ server: Server; baseUrl: string }> {
+  const authService = { getUserById: vi.fn(async () => ALICE) } as unknown as AuthService;
+  const workspaceService = {
+    getOrCreateForBranch: vi.fn(async (branch: string) => ({ id: encodeURIComponent(branch) })),
+  } as unknown as WorkspaceService;
+  const app = express();
+  app.use(express.json());
+  app.use('/api', (req, _res, next) => {
+    (req as unknown as { userId: string }).userId = ALICE.id;
+    next();
+  });
+  app.use(
+    '/api',
+    createWorkflowRoutes(
+      workflow as IWorkflowService,
+      workspaceService,
+      authService,
+      new WorkflowEventBus(),
+      {} as unknown as IAccessControl,
+      'knowledge-base',
+    ),
+  );
+  const server = await new Promise<Server>((resolve) => {
+    const s = app.listen(0, () => resolve(s));
+  });
+  return { server, baseUrl: `http://127.0.0.1:${(server.address() as AddressInfo).port}` };
+}
+
+function close(s: Server): Promise<void> {
+  return new Promise((resolve, reject) => s.close((e) => (e ? reject(e) : resolve())));
+}
+
+async function call(baseUrl: string, method: string, path: string, body?: unknown) {
+  const res = await fetch(`${baseUrl}/api${path}`, {
+    method,
+    headers: { 'content-type': 'application/json' },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const text = await res.text();
+  return { status: res.status, text, json: JSON.parse(text) as Record<string, unknown> };
+}
+
+function expectNoGitOutput(text: string): void {
+  expect(text).not.toMatch(/Internal (server )?error|remote rejected|remote:|ghp_|github\.com/i);
+}
+
+describe('routes answer a push the host refused with 409 and the saved-locally sentence', () => {
+  let server: Server;
+  let baseUrl: string;
+
+  const workflow: Partial<IWorkflowService> = {
+    revertChangeRequestFile: vi.fn(async () => {
+      throw refused('Sales/Deal.md', REVERT_BRANCH);
+    }),
+    openChangeRequest: vi.fn(async () => {
+      throw refused('(opening a change request)', OPEN_BRANCH);
+    }),
+    getChangeRequest: vi.fn(async () => ({ number: 7, branch: BRANCH, base: 'main' }) as never),
+    updateFromTarget: vi.fn(async () => {
+      throw refused('(update from main)', UPDATE_BRANCH);
+    }),
+    deleteBranch: vi.fn(async () => {
+      throw new BranchDeleteRefusedError(BRANCH, GIT_OUTPUT);
+    }),
+  };
+
+  beforeEach(async () => {
+    ({ server, baseUrl } = await serve(workflow));
+  });
+  afterEach(async () => {
+    await close(server);
+  });
+
+  it.each([
+    ['reverting a file of a change request', REVERT_BRANCH, 'POST', '/workflow/change-requests/7/files/revert', { path: 'Sales/Deal.md' }],
+    ['opening a change request', OPEN_BRANCH, 'POST', '/workflow/change-requests', { sourceBranch: OPEN_BRANCH, targetBranch: 'main', title: 'Deal' }],
+    ['updating a change request from its target', UPDATE_BRANCH, 'POST', '/workflow/change-requests/7/update-from-target', undefined],
+  ])('%s', async (_what, branch, method, path, body) => {
+    const res = await call(baseUrl, method, path, body);
+    expect(res.status).toBe(409);
+    expect(res.json.error).toBe(
+      `Saved locally on "${branch}" but couldn't share with the team automatically — ` +
+        'the repository host refused the push; the next save on this branch will try sharing it again.',
+    );
+    expect(res.json).toMatchObject({ kind: 'push-needs-resolution', branch });
+    expect(res.json).not.toHaveProperty('originalDetail');
+    expect(res.json).not.toHaveProperty('recoveryDetail');
+    expectNoGitOutput(res.text);
+  });
+
+  it('deleting a branch: 409, the host refused, the branch is still there', async () => {
+    const res = await call(baseUrl, 'DELETE', `/workspace/main/workflow/branches/${WS}`);
+    expect(res.status).toBe(409);
+    expect(res.json).toEqual({
+      kind: 'branch-delete-refused',
+      branchName: BRANCH,
+      error: `The repository host refused to delete "${BRANCH}"; it is still there. Try again later.`,
+    });
+    expectNoGitOutput(res.text);
+  });
+});
+
+describe('the share route over the real service', () => {
+  let server: Server;
+  let baseUrl: string;
+  let push: ReturnType<typeof vi.fn>;
+
+  beforeEach(async () => {
+    // Twice: `[remote rejected]` reads like a divergence, so the cooperative
+    // pull-and-retry runs too — and is refused again.
+    push = vi
+      .fn()
+      .mockRejectedValueOnce(new Error(GIT_OUTPUT))
+      .mockRejectedValueOnce(new Error(GIT_OUTPUT))
+      .mockResolvedValue(undefined);
+    const git = {
+      push,
+      pull: vi.fn().mockResolvedValue({ treeChanged: false }),
+    } as unknown as GitService;
+    const workflow = new WorkflowService(
+      {} as unknown as Database,
+      git,
+      {} as PullRequestService,
+      {} as IReviewWorkflowService,
+      {} as WorkspaceService,
+      {} as IAccessControl,
+      {} as FileLockService,
+      {} as PendingCommitsService,
+      testKbContext(),
+      openChangeGate(),
+    );
+    ({ server, baseUrl } = await serve(workflow as unknown as IWorkflowService));
+  });
+  afterEach(async () => {
+    await close(server);
+  });
+
+  it('answers 409 with the sentence instead of 500, then shares once the host accepts', async () => {
+    const first = await call(baseUrl, 'POST', `/workspace/${WS}/workflow/share`);
+    expect(first.status).toBe(409);
+    expect(first.json.error).toContain(`Saved locally on "${BRANCH}"`);
+    expectNoGitOutput(first.text);
+
+    const second = await call(baseUrl, 'POST', `/workspace/${WS}/workflow/share`);
+    expect(second.status).toBe(200);
+    expect(second.json).toEqual({ status: 'shared' });
+  });
+});

package/src/modules/workflow/__tests__/workflow.service.branch-in-use.test.ts

@@ -137,7 +137,7 @@ describe('post-merge branch retirement', () => {
     const deleted: string[] = [];
     const { db, statements } = fakeDb([MERGED_23, OPEN_24_INTO_RFI]);
     const svc = makeService(db, {
-      deleteBranch: vi.fn(async (_ws: string, name: string) => void deleted.push(name)),
+      deleteBranch: vi.fn(async (_ws: string, name: string) => (deleted.push(name), { lastCommit: null })),
     });
 
     await retire(svc, 23, 'target-company-state');
@@ -153,7 +153,7 @@ describe('post-merge branch retirement', () => {
     // #24 is gone; only the merged request remains, so nothing needs the branch.
     const { db } = fakeDb([MERGED_23]);
     const svc = makeService(db, {
-      deleteBranch: vi.fn(async (_ws: string, name: string) => void deleted.push(name)),
+      deleteBranch: vi.fn(async (_ws: string, name: string) => (deleted.push(name), { lastCommit: null })),
     });
 
     await retire(svc, 23, 'target-company-state');
@@ -168,7 +168,7 @@ describe('post-merge branch retirement', () => {
       { number: 25, source_branch: 'juan/rfi', target_branch: 'other', state: 'open' },
     ]);
     const svc = makeService(db, {
-      deleteBranch: vi.fn(async (_ws: string, name: string) => void deleted.push(name)),
+      deleteBranch: vi.fn(async (_ws: string, name: string) => (deleted.push(name), { lastCommit: null })),
     });
 
     await retire(svc, 23, 'target-company-state');
@@ -180,7 +180,7 @@ describe('post-merge branch retirement', () => {
 describe('deleteBranch', () => {
   it('refuses a branch an open request proposes INTO, naming who can act', async () => {
     const { db } = fakeDb([OPEN_24_INTO_RFI]);
-    const svc = makeService(db, { deleteBranch: vi.fn() });
+    const svc = makeService(db, { deleteBranch: vi.fn(async () => ({ lastCommit: null })) });
 
     // Not "withdraw or decline it": the request belongs to someone else, and
     // the branch owner may be authorized to do neither. The message has to
@@ -194,7 +194,7 @@ describe('deleteBranch', () => {
     const { db } = fakeDb([
       { number: 26, source_branch: 'juan/rfi', target_branch: 'target-company-state', state: 'open' },
     ]);
-    const svc = makeService(db, { deleteBranch: vi.fn() });
+    const svc = makeService(db, { deleteBranch: vi.fn(async () => ({ lastCommit: null })) });
 
     await expect(svc.deleteBranch('ws', 'juan/rfi', USER)).rejects.toThrow(
       /open change request \(#26\)\. Withdraw or decline it/,
@@ -205,7 +205,7 @@ describe('deleteBranch', () => {
     const deleted: string[] = [];
     const { db } = fakeDb([OPEN_24_INTO_RFI]);
     const svc = makeService(db, {
-      deleteBranch: vi.fn(async (_ws: string, name: string) => void deleted.push(name)),
+      deleteBranch: vi.fn(async (_ws: string, name: string) => (deleted.push(name), { lastCommit: null })),
     });
 
     await svc.deleteBranch('ws', 'juan/unrelated', USER);