@bevel-software/platform-core-backend 0.35.0 → 0.36.1

package/src/modules/{workflow/__tests__/workflow.service.facade.test.ts → version-control/__tests__/version-control.service.facade.test.ts}

@@ -10,23 +10,23 @@ import type {
 } from '@bevel-software/platform-shared';
 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 { IChangeRequestReviewService } from '../change-request-review/change-request-review.interface.js';
 import type { WorkspaceService } from '../../workspace/workspace.service.js';
 import type { IAccessControl } from '../../access/access-control.interface.js';
 import { FileLockService } from '../file-lock.service.js';
 import { PendingCommitsService, type PendingCommit } from '../pending-commits.service.js';
 import { PendingCommitsWorker } from '../pending-commits.worker.js';
 import { HttpCommunicationProtocol } from '@utcp/http';
-import { WorkflowService } from '../workflow.service.js';
+import { VersionControlService } from '../version-control.service.js';
 import type { ChangeRequestOpenedEvent, IChangeRequestHooks } from '../change-request-hooks.js';
 import {
   ChangeRequestConflictsError,
   PullRebaseConflictError,
   PushNeedsAgentResolutionError,
-  WorkflowDomainError,
-  WorkflowValidationError,
+  VersionControlDomainError,
+  VersionControlValidationError,
 } from '../../../shared/domain-errors.js';
-import type { WorkflowEventBus } from '../event-bus.js';
+import type { VersionControlEventBus } from '../event-bus.js';
 import { DEFAULT_BRANCH } from '@bevel-software/platform-shared';
 import type { Database } from '../../database/connection.js';
 import { openChangeGate } from '../../../__tests__/open-change-gate.js';
@@ -173,9 +173,7 @@ function makeAccessControl(): IAccessControl {
 /**
  * The facade exists only to delegate — these tests pin down that contract.
  * For each backed method we verify (a) the right underlying call is made
- * with the right arguments, (b) the underlying return propagates back. For
- * each unimplemented method we verify it rejects with
- * `NotImplementedWorkflowError` so consumers can switch on the error class.
+ * with the right arguments, (b) the underlying return propagates back.
  *
  * Cache invalidation (`PullRequestService.invalidateDetailCache`) is part
  * of the facade contract for mutating change-request methods — without it
@@ -236,7 +234,7 @@ function makePrs(): PullRequestService {
   } as unknown as PullRequestService;
 }
 
-function makeReviewWorkflow(): IReviewWorkflowService {
+function makeChangeRequestReview(): IChangeRequestReviewService {
   return {
     getApprovalStates: vi.fn(),
     approveFile: vi.fn(),
@@ -244,16 +242,16 @@ function makeReviewWorkflow(): IReviewWorkflowService {
     evaluateMergeGate: vi.fn(),
     mergePr: vi.fn(),
     cancelPr: vi.fn(),
-  } as unknown as IReviewWorkflowService;
+  } as unknown as IChangeRequestReviewService;
 }
 
-describe('WorkflowService — branch delegation', () => {
+describe('VersionControlService — branch delegation', () => {
   it('listBranches delegates to git.listBranches', async () => {
     const git = makeGit();
     const branches = [{ name: 'main', isCurrent: true, isProtected: true, hasRemote: true }];
     (git.listBranches as ReturnType<typeof vi.fn>).mockResolvedValue(branches);
 
-    const svc = new WorkflowService(makeDb(), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     await expect(svc.listBranches('w1')).resolves.toBe(branches);
     // listBranches(workspaceId, opts?) forwards opts — undefined when omitted.
     expect(git.listBranches).toHaveBeenCalledWith('w1', undefined);
@@ -263,7 +261,7 @@ describe('WorkflowService — branch delegation', () => {
     const git = makeGit();
     (git.createBranch as ReturnType<typeof vi.fn>).mockResolvedValue({ name: 'feat' });
 
-    const svc = new WorkflowService(makeDb(), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     await svc.createBranch('w1', 'feat', 'current-company-state');
     expect(git.createBranch).toHaveBeenCalledWith('w1', 'feat', 'current-company-state');
   });
@@ -273,13 +271,13 @@ describe('WorkflowService — branch delegation', () => {
     const status = { branch: 'main', isDirty: false, hasUpstream: true, unpushedCommits: 0, conflicted: [], unmergedFromUpstream: false };
     (git.status as ReturnType<typeof vi.fn>).mockResolvedValue(status);
 
-    const svc = new WorkflowService(makeDb(), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     await expect(svc.branchStatus('w1')).resolves.toBe(status);
     expect(git.status).toHaveBeenCalledWith('w1');
   });
 });
 
-describe('WorkflowService.updateBranch', () => {
+describe('VersionControlService.updateBranch', () => {
   const user = { id: 'u1', email: 'ada@x.io', name: 'Ada' };
   /** A git double whose merge answers `outcome`, with the source on the remote. */
   const gitThatMerges = (outcome: unknown) => {
@@ -289,14 +287,14 @@ describe('WorkflowService.updateBranch', () => {
     return git;
   };
   const build = (git: GitService, pending = makePendingCommits()) =>
-    new WorkflowService(makeDb(), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), pending, testKbContext(), openChangeGate());
+    new VersionControlService(makeDb(), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), pending, testKbContext(), openChangeGate());
 
   it('refuses a protected branch before asking git anything', async () => {
     const git = gitThatMerges({ kind: 'merged', sha: 'm', from: 'x', resolvedPaths: [] });
     const err = await build(git).updateBranch('target-company-state', user).catch((e: unknown) => e);
-    expect(err).toBeInstanceOf(WorkflowDomainError);
-    expect((err as WorkflowDomainError).status).toBe(403);
-    expect((err as WorkflowDomainError).payload).toMatchObject({ kind: 'protected-update-target' });
+    expect(err).toBeInstanceOf(VersionControlDomainError);
+    expect((err as VersionControlDomainError).status).toBe(403);
+    expect((err as VersionControlDomainError).payload).toMatchObject({ kind: 'protected-update-target' });
     expect((git as unknown as { mergeIntoBranch: ReturnType<typeof vi.fn> }).mergeIntoBranch).not.toHaveBeenCalled();
     expect(git.push).not.toHaveBeenCalled();
   });
@@ -314,7 +312,7 @@ describe('WorkflowService.updateBranch', () => {
   it('refuses an update that would land an open change request from `from` into the draft, as the merge tool refuses it', async () => {
     const git = gitThatMerges({ kind: 'merged', sha: 'm', from: 'target-company-state', resolvedPaths: [] });
     const open = [{ number: 5, sourceBranch: 'target-company-state', targetBranch: 'ada/draft', state: 'open' }];
-    const svc = new WorkflowService(makeDb(open), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(open), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     const err = await svc.updateBranch('ada%2Fdraft', user, { from: 'target-company-state' }).catch((e: unknown) => e);
     expect(err).toMatchObject({ status: 409, payload: { kind: 'open-change-request-blocks-merge', number: 5 } });
     expect((git as unknown as { mergeIntoBranch: ReturnType<typeof vi.fn> }).mergeIntoBranch).not.toHaveBeenCalled();
@@ -322,7 +320,7 @@ describe('WorkflowService.updateBranch', () => {
     // The other direction — the draft's own request, open INTO `from` — is
     // how a draft under review stays current: never blocked.
     const reverse = [{ number: 6, sourceBranch: 'ada/draft', targetBranch: 'target-company-state', state: 'open' }];
-    const syncing = new WorkflowService(makeDb(reverse), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const syncing = new VersionControlService(makeDb(reverse), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     expect(await syncing.updateBranch('ada%2Fdraft', user, { from: 'target-company-state' })).toMatchObject({ kind: 'merged' });
   });
 
@@ -404,7 +402,7 @@ describe('WorkflowService.updateBranch', () => {
     expect(git.push).not.toHaveBeenCalled();
   });
 
-  it("publishes through the one push policy every workflow push takes, over the merge's own moves", async () => {
+  it("publishes through the one push policy every version-control push takes, over the merge's own moves", async () => {
     const git = gitThatMerges({ kind: 'merged', sha: 'm', from: 'target-company-state', resolvedPaths: [] });
     await build(git).updateBranch('ada%2Fdraft', user, { from: 'target-company-state' });
     const merge = (git as unknown as { mergeIntoBranch: ReturnType<typeof vi.fn> }).mergeIntoBranch;
@@ -432,7 +430,7 @@ describe('WorkflowService.updateBranch', () => {
     expect(diverged).toBeInstanceOf(PushNeedsAgentResolutionError);
     expect(diverged as PushNeedsAgentResolutionError).toMatchObject({ branch: 'ada/draft', path: 'ada/draft', cause: 'diverged' });
     expect((diverged as Error).message).not.toContain('Secret/Plan.md');
-    expect(JSON.stringify((diverged as WorkflowDomainError).payload)).not.toContain('Secret/Plan.md');
+    expect(JSON.stringify((diverged as VersionControlDomainError).payload)).not.toContain('Secret/Plan.md');
 
     // A host that refuses: the same hand-off, `refused`, no replay attempted.
     const untouched = vi.fn();
@@ -453,7 +451,7 @@ describe('WorkflowService.updateBranch', () => {
     gate.assertMayChange = async (...args: unknown[]) => {
       asked.push(args);
     };
-    const svc = new WorkflowService(makeDb(), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), access, makeFileLockService(), makePendingCommits(), testKbContext(), gate);
+    const svc = new VersionControlService(makeDb(), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), access, makeFileLockService(), makePendingCommits(), testKbContext(), gate);
     const validated: unknown[][] = [];
     const validateWrite = vi.fn(async (...args: unknown[]) => { validated.push(args); });
     await svc.updateBranch('ada%2Fdraft', user, {
@@ -476,7 +474,7 @@ describe('WorkflowService.updateBranch', () => {
     expect(asked).toEqual([['ada%2Fdraft', 'ada@x.io', 'knowledge-base/A.md', 'file'], ['ada%2Fdraft', 'ada@x.io', 'knowledge-base/B.md', 'file']]);
 
     // The write gate's refusal refuses the update (a roles.yaml that would not parse, say).
-    validateWrite.mockRejectedValueOnce(new WorkflowDomainError('roles.yaml would be invalid', 422));
+    validateWrite.mockRejectedValueOnce(new VersionControlDomainError('roles.yaml would be invalid', 422));
     await expect(opts.authorizeResolutions({ ours: 'o', theirs: 't' })).rejects.toMatchObject({ status: 422 });
 
     // Not readable at the draft's commit: refused before the change gate is asked.
@@ -521,7 +519,7 @@ describe('WorkflowService.updateBranch', () => {
   });
 });
 
-describe('WorkflowService — change delegation', () => {
+describe('VersionControlService — change delegation', () => {
   it('commitChange delegates to git.commit', async () => {
     const git = makeGit();
     const user = makeUser();
@@ -529,7 +527,7 @@ describe('WorkflowService — change delegation', () => {
     const commit = { sha: 'abc', authorName: 'Alice', authorEmail: 'alice@example.com', subject: 'tweak owner', committedAt: '2026-01-01T00:00:00Z' };
     (git.commit as ReturnType<typeof vi.fn>).mockResolvedValue(commit);
 
-    const svc = new WorkflowService(makeDb(), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     await expect(svc.commitChange('w1', user, input)).resolves.toBe(commit);
     expect(git.commit).toHaveBeenCalledWith('w1', user, input);
   });
@@ -538,7 +536,7 @@ describe('WorkflowService — change delegation', () => {
     const git = makeGit();
     (git.logForFile as ReturnType<typeof vi.fn>).mockResolvedValue([]);
 
-    const svc = new WorkflowService(makeDb(), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     await svc.listChangesForFile('w1', 'Knowledge/Foo.md', 5);
     expect(git.logForFile).toHaveBeenCalledWith('w1', 'Knowledge/Foo.md', 5);
   });
@@ -547,7 +545,7 @@ describe('WorkflowService — change delegation', () => {
     const git = makeGit();
     (git.diffFileBetweenBranches as ReturnType<typeof vi.fn>).mockResolvedValue({ diff: '@@ diff', from: 'a1', to: 'b1' });
 
-    const svc = new WorkflowService(makeDb(), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     // The caller's verdict travels down to the git layer, which asks it at
     // the pinned commits; those commits travel back with the diff.
     const authorize = vi.fn(async () => {});
@@ -557,40 +555,40 @@ describe('WorkflowService — change delegation', () => {
   });
 });
 
-describe('WorkflowService — change request delegation + cache invalidation', () => {
+describe('VersionControlService — change request delegation + cache invalidation', () => {
   it('listChangeRequests forwards opts to prs.listOpenPrs', async () => {
     const prs = makePrs();
     (prs.listOpenPrs as ReturnType<typeof vi.fn>).mockResolvedValue([]);
 
-    const svc = new WorkflowService(makeDb(), makeGit(), prs, makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), makeGit(), prs, makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     await svc.listChangeRequests({ fresh: true });
     expect(prs.listOpenPrs).toHaveBeenCalledWith({ fresh: true });
   });
 
   it('approveFile invalidates the PR detail cache exactly once', async () => {
     const prs = makePrs();
-    const reviewWorkflow = makeReviewWorkflow();
-    (reviewWorkflow.approveFile as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+    const changeRequestReview = makeChangeRequestReview();
+    (changeRequestReview.approveFile as ReturnType<typeof vi.fn>).mockResolvedValue([]);
 
-    const svc = new WorkflowService(makeDb(), makeGit(), prs, reviewWorkflow, makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), makeGit(), prs, changeRequestReview, makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     await svc.approveFile(7, 'Foo.md', makeUser(), [], 'sha', 'main', null, 'w1');
     expect(prs.invalidateDetailCache).toHaveBeenCalledWith(7);
     expect(prs.invalidateDetailCache).toHaveBeenCalledTimes(1);
   });
 
-  it('rejectChangeRequest delegates to reviewWorkflow.cancelPr', async () => {
+  it('rejectChangeRequest delegates to changeRequestReview.cancelPr', async () => {
     const prs = makePrs();
-    const reviewWorkflow = makeReviewWorkflow();
-    (reviewWorkflow.cancelPr as ReturnType<typeof vi.fn>).mockResolvedValue({ prNumber: 9, cancelledAt: 't' });
+    const changeRequestReview = makeChangeRequestReview();
+    (changeRequestReview.cancelPr as ReturnType<typeof vi.fn>).mockResolvedValue({ prNumber: 9, cancelledAt: 't' });
     // A caller holding no grant: not the author, not an admin, no files to own.
     const access = makeAccessControl();
     (access.canWriteAtRef as ReturnType<typeof vi.fn>).mockResolvedValue(false);
 
-    const svc = new WorkflowService(makeDb(), makeGit(), prs, reviewWorkflow, makeWorkspaceService(), access, makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), makeGit(), prs, changeRequestReview, makeWorkspaceService(), access, makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     const user = makeUser();
     await svc.rejectChangeRequest(9, user, 'open', null, 'main', 'w1');
     // Passed through unchanged: `cancelPr` is the one that refuses it.
-    expect(reviewWorkflow.cancelPr).toHaveBeenCalledWith(9, user, 'open', null, 'main', 'w1');
+    expect(changeRequestReview.cancelPr).toHaveBeenCalledWith(9, user, 'open', null, 'main', 'w1');
     expect(prs.invalidateDetailCache).toHaveBeenCalledWith(9);
   });
 
@@ -599,8 +597,8 @@ describe('WorkflowService — change request delegation + cache invalidation', (
   it('rejectChangeRequest lets the holder of write on every changed file close it as the author would', async () => {
     const prs = makePrs();
     (prs.getPrDetail as ReturnType<typeof vi.fn>).mockResolvedValue({ files: [{ path: 'a.md' }, { path: 'b.md' }] });
-    const reviewWorkflow = makeReviewWorkflow();
-    (reviewWorkflow.cancelPr as ReturnType<typeof vi.fn>).mockResolvedValue({ prNumber: 9, cancelledAt: 't' });
+    const changeRequestReview = makeChangeRequestReview();
+    (changeRequestReview.cancelPr as ReturnType<typeof vi.fn>).mockResolvedValue({ prNumber: 9, cancelledAt: 't' });
     const access = makeAccessControl();
     (access.canWriteAtRef as ReturnType<typeof vi.fn>).mockResolvedValue(false);
     (access.canWriteBatchAtRef as ReturnType<typeof vi.fn>).mockResolvedValue(
@@ -608,44 +606,44 @@ describe('WorkflowService — change request delegation + cache invalidation', (
     );
     const workspaceService = makeWorkspaceService();
 
-    const svc = new WorkflowService(makeDb(), makeGit(), prs, reviewWorkflow, workspaceService, access, makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), makeGit(), prs, changeRequestReview, workspaceService, access, makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     const user = makeUser();
     await svc.rejectChangeRequest(9, user, 'open', 'someone-else', 'main', 'w1');
     expect(workspaceService.ensureRemotesFetched).toHaveBeenCalledWith('w1', { strict: true, force: true });
     expect(access.canWriteBatchAtRef).toHaveBeenCalledWith('w1', 'origin/main', user.email, ['a.md', 'b.md']);
-    expect(reviewWorkflow.cancelPr).toHaveBeenCalledWith(9, user, 'open', hashEmail(user.email), 'main', 'w1');
+    expect(changeRequestReview.cancelPr).toHaveBeenCalledWith(9, user, 'open', hashEmail(user.email), 'main', 'w1');
   });
 
   it('rejectChangeRequest refuses with a worded 409 when origin cannot be fetched, never against a stale tree', async () => {
-    const reviewWorkflow = makeReviewWorkflow();
+    const changeRequestReview = makeChangeRequestReview();
     const workspaceService = makeWorkspaceService();
     (workspaceService.ensureRemotesFetched as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('offline'));
     const access = makeAccessControl();
 
-    const svc = new WorkflowService(makeDb(), makeGit(), makePrs(), reviewWorkflow, workspaceService, access, makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), makeGit(), makePrs(), changeRequestReview, workspaceService, access, makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     await expect(svc.rejectChangeRequest(9, makeUser(), 'open', 'someone-else', 'main', 'w1')).rejects.toMatchObject({
       status: 409,
       message: expect.stringContaining('origin was unreachable'),
     });
     expect(access.canWriteAtRef).not.toHaveBeenCalled();
-    expect(reviewWorkflow.cancelPr).not.toHaveBeenCalled();
+    expect(changeRequestReview.cancelPr).not.toHaveBeenCalled();
   });
 
   it("rejectChangeRequest reads no grant for a request that is no longer open — cancelPr answers it", async () => {
-    const reviewWorkflow = makeReviewWorkflow();
-    (reviewWorkflow.cancelPr as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('already-applied'));
+    const changeRequestReview = makeChangeRequestReview();
+    (changeRequestReview.cancelPr as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('already-applied'));
     const workspaceService = makeWorkspaceService();
 
-    const svc = new WorkflowService(makeDb(), makeGit(), makePrs(), reviewWorkflow, workspaceService, makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), makeGit(), makePrs(), changeRequestReview, workspaceService, makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     await expect(svc.rejectChangeRequest(9, makeUser(), 'merged', null, 'main', 'w1')).rejects.toThrow('already-applied');
     expect(workspaceService.ensureRemotesFetched).not.toHaveBeenCalled();
   });
 
   it('mergeChangeRequest wraps the underlying merge result in a "merged" outcome', async () => {
     const prs = makePrs();
-    const reviewWorkflow = makeReviewWorkflow();
+    const changeRequestReview = makeChangeRequestReview();
     const mergeResult = { prNumber: 4, sha: 'abc', mergedAt: 't' };
-    (reviewWorkflow.mergePr as ReturnType<typeof vi.fn>).mockResolvedValue(mergeResult);
+    (changeRequestReview.mergePr as ReturnType<typeof vi.fn>).mockResolvedValue(mergeResult);
     // The roles.yaml-preservation guard resolves the CR's source branch via
     // getPr. readFileAtRef (stubbed in makeGit) returns identical roles.yaml for
     // base + head, so the guard no-ops and the merge proceeds.
@@ -653,8 +651,8 @@ describe('WorkflowService — change request delegation + cache invalidation', (
 
     const git = makeGit();
     const workspaceService = makeWorkspaceService();
-    const svc = new WorkflowService(makeDb(), git, prs, reviewWorkflow, workspaceService, makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
-    // Conflicts are surfaced by the local merge inside `reviewWorkflow.mergePr`
+    const svc = new VersionControlService(makeDb(), git, prs, changeRequestReview, workspaceService, makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    // Conflicts are surfaced by the local merge inside `changeRequestReview.mergePr`
     // (mocked here), so there's no provider "mergeable" pre-check to stub.
     const outcome = await svc.mergeChangeRequest(
       4,
@@ -671,7 +669,7 @@ describe('WorkflowService — change request delegation + cache invalidation', (
     // The target branch's workspace is pulled so it doesn't fall behind origin.
     expect(workspaceService.getOrCreateForBranch).toHaveBeenCalledWith('main');
     expect(git.pull).toHaveBeenCalledWith('main', {});
-    expect(reviewWorkflow.mergePr).toHaveBeenCalledWith(
+    expect(changeRequestReview.mergePr).toHaveBeenCalledWith(
       4,
       expect.objectContaining({ email: 'alice@example.com' }),
       'sha',
@@ -687,9 +685,9 @@ describe('WorkflowService — change request delegation + cache invalidation', (
 
   it('mergeChangeRequest still merges when the post-merge pull conflicts, and queues recovery on the TARGET workspace', async () => {
     const prs = makePrs();
-    const reviewWorkflow = makeReviewWorkflow();
+    const changeRequestReview = makeChangeRequestReview();
     const mergeResult = { prNumber: 4, sha: 'abc', mergedAt: 't' };
-    (reviewWorkflow.mergePr as ReturnType<typeof vi.fn>).mockResolvedValue(mergeResult);
+    (changeRequestReview.mergePr as ReturnType<typeof vi.fn>).mockResolvedValue(mergeResult);
     (prs.getPr as ReturnType<typeof vi.fn>).mockResolvedValue({ branch: 'alice/feat', base: 'main' });
 
     const git = makeGit();
@@ -708,7 +706,7 @@ describe('WorkflowService — change request delegation + cache invalidation', (
       id: 'resolved-target-ws',
     });
     const pending = makePendingCommits();
-    const svc = new WorkflowService(makeDb(), git, prs, reviewWorkflow, workspaceService, makeAccessControl(), makeFileLockService(), pending, testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), git, prs, changeRequestReview, workspaceService, makeAccessControl(), makeFileLockService(), pending, testKbContext(), openChangeGate());
 
     const outcome = await svc.mergeChangeRequest(
       4, makeUser(), 'sha', [], 'open', 'PR title', 'main', 'w1', { bypass: true },
@@ -728,10 +726,10 @@ describe('WorkflowService — change request delegation + cache invalidation', (
   });
 });
 
-describe('WorkflowService — file lock delegation', () => {
+describe('VersionControlService — file lock delegation', () => {
   it('acquireLock delegates to FileLockService.acquire', async () => {
     const fileLocks = makeFileLockService();
-    const svc = new WorkflowService(makeDb(), makeGit(), makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), fileLocks, makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), makeGit(), makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), fileLocks, makePendingCommits(), testKbContext(), openChangeGate());
     await svc.acquireLock('w1', 'b', 'p', makeUser());
     expect(fileLocks.acquire).toHaveBeenCalledWith('w1', 'b', 'p', expect.objectContaining({ email: 'alice@example.com' }), undefined);
   });
@@ -741,7 +739,7 @@ describe('WorkflowService — file lock delegation', () => {
     // a coordination hold masquerade as an edit lock on the very next read
     // (which is how the write paths decide what the holder may do).
     const fileLocks = makeFileLockService();
-    const svc = new WorkflowService(makeDb(), makeGit(), makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), fileLocks, makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), makeGit(), makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), fileLocks, makePendingCommits(), testKbContext(), openChangeGate());
     await svc.acquireLock('w1', 'b', 'p', makeUser(), { coordination: true });
     expect(fileLocks.acquire).toHaveBeenCalledWith(
       'w1', 'b', 'p', expect.objectContaining({ email: 'alice@example.com' }), { coordination: true },
@@ -750,7 +748,7 @@ describe('WorkflowService — file lock delegation', () => {
 
   it('getLock delegates to FileLockService.get', async () => {
     const fileLocks = makeFileLockService();
-    const svc = new WorkflowService(makeDb(), makeGit(), makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), fileLocks, makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), makeGit(), makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), fileLocks, makePendingCommits(), testKbContext(), openChangeGate());
     await expect(svc.getLock('w1', 'b', 'p')).resolves.toBeNull();
     expect(fileLocks.get).toHaveBeenCalledWith('w1', 'b', 'p');
   });
@@ -765,7 +763,7 @@ describe('WorkflowService — file lock delegation', () => {
       acquiredAt: '', lastHeartbeatAt: '', expiresAt: '',
     });
     const pending = makePendingCommits();
-    const svc = new WorkflowService(makeDb(), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), fileLocks, pending, testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), fileLocks, pending, testKbContext(), openChangeGate());
     await expect(svc.releaseLock('w1', 'feat', 'Foo.md', makeUser())).resolves.toBeUndefined();
     // No inline git work — the worker handles that out of band.
     expect(git.commitFile).not.toHaveBeenCalled();
@@ -784,28 +782,28 @@ describe('WorkflowService — file lock delegation', () => {
     // One open request rides the branch — deleting it would strand the request.
     // `sourceBranch` matters to the guard now: it decides whether the refusal
     // says "withdraw yours" (source) or names the other request's actors (target).
-    const svc = new WorkflowService(makeDb([{ number: 7, sourceBranch: 'feat/x', targetBranch: 'dev', state: 'open' }]), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb([{ number: 7, sourceBranch: 'feat/x', targetBranch: 'dev', state: 'open' }]), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     await expect(svc.deleteBranch('w1', 'feat/x', makeUser())).rejects.toThrow(/open change request \(#7\)/);
     expect(git.deleteBranch).not.toHaveBeenCalled();
   });
 
   it('deleteBranch refuses when an open request proposes INTO the branch (target end)', async () => {
     const git = makeGit();
-    const svc = new WorkflowService(makeDb([{ number: 9, sourceBranch: 'other/y', targetBranch: 'feat/x', state: 'open' }]), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb([{ number: 9, sourceBranch: 'other/y', targetBranch: 'feat/x', state: 'open' }]), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     await expect(svc.deleteBranch('w1', 'feat/x', makeUser())).rejects.toThrow(/proposes changes into/);
     expect(git.deleteBranch).not.toHaveBeenCalled();
   });
 
   it('deleteBranch proceeds past a CLOSED request — the guard filters on state, not mere mention', async () => {
     const git = makeGit();
-    const svc = new WorkflowService(makeDb([{ number: 7, sourceBranch: 'feat/x', targetBranch: 'dev', state: 'closed' }]), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb([{ number: 7, sourceBranch: 'feat/x', targetBranch: 'dev', state: 'closed' }]), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     await expect(svc.deleteBranch('w1', 'feat/x', makeUser())).resolves.toBeUndefined();
     expect(git.deleteBranch).toHaveBeenCalled();
   });
 
   it('deleteBranch deletes when the branch has no open change request', async () => {
     const git = makeGit();
-    const svc = new WorkflowService(makeDb(), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     await expect(svc.deleteBranch('w1', 'feat/x', makeUser())).resolves.toBeUndefined();
     expect(git.deleteBranch).toHaveBeenCalledWith('w1', 'feat/x', expect.objectContaining({ email: 'alice@example.com' }), undefined);
   });
@@ -825,7 +823,7 @@ describe('WorkflowService — file lock delegation', () => {
     vi.mocked(git.deleteBranch)
       .mockImplementationOnce(async () => { order.push('first:start'); await gate; order.push('first:end'); return { lastCommit: null }; })
       .mockImplementationOnce(async () => { order.push('second'); return { lastCommit: null }; });
-    const svc = new WorkflowService(makeDb(), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     const first = svc.deleteBranch('w1', 'feat/x', makeUser());
     const second = svc.deleteBranch('w1', 'feat/x', makeUser());
     // Only release the gate once the first operation is provably inside its
@@ -840,7 +838,7 @@ describe('WorkflowService — file lock delegation', () => {
   it('releaseLock refuses when the caller does not hold the lock', async () => {
     const git = makeGit();
     const fileLocks = makeFileLockService(); // default: get → null
-    const svc = new WorkflowService(makeDb(), git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), fileLocks, makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), fileLocks, makePendingCommits(), testKbContext(), openChangeGate());
     await expect(svc.releaseLock('w1', 'feat', 'Foo.md', makeUser())).rejects.toThrow(/not held by you/);
     // The commit must NOT run when the caller doesn't hold the lock —
     // otherwise a non-holder could trigger a commit attributed as them.
@@ -854,7 +852,7 @@ describe('WorkflowService — file lock delegation', () => {
  * predicate, the restore→commit→push order, the lock discipline, and the
  * authoritative emptiness re-check before anything closes.
  */
-describe('WorkflowService — revertChangeRequestFile / closeEmptyChangeRequest', () => {
+describe('VersionControlService — revertChangeRequestFile / closeEmptyChangeRequest', () => {
   const SUMMARY = { number: 7, base: 'main', branch: 'ali/x', state: 'open' };
 
   function makeRevertGit(overrides: Record<string, unknown> = {}): GitService {
@@ -875,7 +873,7 @@ describe('WorkflowService — revertChangeRequestFile / closeEmptyChangeRequest'
     canWriteAtRef?: boolean | null;
     prState?: string;
     updateRows?: unknown[];
-    events?: WorkflowEventBus;
+    events?: VersionControlEventBus;
   } = {}) {
     const git = opts.git ?? makeRevertGit();
     const prs = makePrs();
@@ -902,7 +900,7 @@ describe('WorkflowService — revertChangeRequestFile / closeEmptyChangeRequest'
       returning: vi.fn(async () => updateRows),
     });
     const db = chain as unknown as Database;
-    const svc = new WorkflowService(db, git, prs, makeReviewWorkflow(), makeWorkspaceService(), access, fileLocks, makePendingCommits(), testKbContext(), openChangeGate(), opts.events);
+    const svc = new VersionControlService(db, git, prs, makeChangeRequestReview(), makeWorkspaceService(), access, fileLocks, makePendingCommits(), testKbContext(), openChangeGate(), opts.events);
     return { svc, git, prs, access, fileLocks, db: chain };
   }
 
@@ -1057,7 +1055,7 @@ describe('WorkflowService — revertChangeRequestFile / closeEmptyChangeRequest'
         // so the cooperative pull runs first; it changes nothing here.
         pull: vi.fn().mockResolvedValue({ treeChanged: false }),
       });
-      const { svc, fileLocks, prs, db } = makeHarness({ git, events: { emit } as unknown as WorkflowEventBus });
+      const { svc, fileLocks, prs, db } = makeHarness({ git, events: { emit } as unknown as VersionControlEventBus });
 
       const err = await svc.revertChangeRequestFile(7, makeUser(), 'Docs/a.md').catch((e: unknown) => e);
       expect(err).toBeInstanceOf(PushNeedsAgentResolutionError);
@@ -1091,7 +1089,7 @@ describe('WorkflowService — revertChangeRequestFile / closeEmptyChangeRequest'
       const emit = vi.fn();
       const push = vi.fn().mockRejectedValueOnce(REFUSED).mockRejectedValueOnce(REFUSED).mockResolvedValue(undefined);
       const git = makeRevertGit({ push, pull: vi.fn().mockResolvedValue({ treeChanged: false }) });
-      const { svc } = makeHarness({ git, events: { emit } as unknown as WorkflowEventBus });
+      const { svc } = makeHarness({ git, events: { emit } as unknown as VersionControlEventBus });
 
       await expect(svc.revertChangeRequestFile(7, makeUser(), 'Docs/a.md')).rejects.toBeInstanceOf(
         PushNeedsAgentResolutionError,
@@ -1129,7 +1127,7 @@ describe('WorkflowService — revertChangeRequestFile / closeEmptyChangeRequest'
           new Error("fatal: unable to access 'https://github.com/acme/kb.git/': The requested URL returned error: 403"),
         );
       const git = makeRevertGit({ push, pull });
-      const { svc } = makeHarness({ git, events: { emit } as unknown as WorkflowEventBus });
+      const { svc } = makeHarness({ git, events: { emit } as unknown as VersionControlEventBus });
 
       await expect(svc.revertChangeRequestFile(7, makeUser(), 'Docs/a.md')).rejects.toBeInstanceOf(
         PushNeedsAgentResolutionError,
@@ -1149,7 +1147,7 @@ describe('WorkflowService — revertChangeRequestFile / closeEmptyChangeRequest'
         .mockResolvedValue(undefined);
       const pull = vi.fn().mockResolvedValue({ treeChanged: true });
       const git = makeRevertGit({ push, pull });
-      const { svc } = makeHarness({ git, events: { emit } as unknown as WorkflowEventBus });
+      const { svc } = makeHarness({ git, events: { emit } as unknown as VersionControlEventBus });
 
       await expect(svc.revertChangeRequestFile(7, makeUser(), 'Docs/a.md')).resolves.toMatchObject({ closed: false });
       expect(push).toHaveBeenCalledTimes(2);
@@ -1204,7 +1202,7 @@ describe('WorkflowService — revertChangeRequestFile / closeEmptyChangeRequest'
   });
 });
 
-describe('WorkflowService — deleteChangeRequest (the author’s and the admin’s verb)', () => {
+describe('VersionControlService — deleteChangeRequest (the author’s and the admin’s verb)', () => {
   const AUTHOR_EMAIL = 'alice@example.com'; // makeUser()'s default caller
   const STRANGER_AUTHOR = 'mallory@example.com';
 
@@ -1252,7 +1250,7 @@ describe('WorkflowService — deleteChangeRequest (the author’s and the admin
       returning: vi.fn(async () => [{ id: 1 }]),
     });
     const workspaces = makeWorkspaceService();
-    const svc = new WorkflowService(chain as unknown as Database, git, prs, makeReviewWorkflow(), workspaces, access, makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
+    const svc = new VersionControlService(chain as unknown as Database, git, prs, makeChangeRequestReview(), workspaces, access, makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate());
     return { svc, prs, db: chain, access, workspaces, git };
   }
 
@@ -1426,7 +1424,7 @@ describe('WorkflowService — deleteChangeRequest (the author’s and the admin
   });
 });
 
-describe('WorkflowService.mergeBranch — an agent merges branches, never an open change request', () => {
+describe('VersionControlService.mergeBranch — an agent merges branches, never an open change request', () => {
   // One open request, `alice/feat` → the protected default branch;
   // `alice/other` is an unprotected draft with no request.
   const PROTECTED = DEFAULT_BRANCH;
@@ -1466,7 +1464,7 @@ describe('WorkflowService.mergeBranch — an agent merges branches, never an ope
           const unpushed = await (git as unknown as { hasUnpushedCommits: (id: string) => Promise<boolean> })
             .hasUnpushedCommits(workspaceId);
           if (dirty.length > 0 || unpushed) {
-            throw new WorkflowDomainError(
+            throw new VersionControlDomainError(
               `"${target}" has edits that are not shared yet.`,
               409,
               { kind: 'merge-target-busy', targetBranch: target },
@@ -1489,7 +1487,7 @@ describe('WorkflowService.mergeBranch — an agent merges branches, never an ope
     (access.canWriteBatchAtRef as ReturnType<typeof vi.fn>).mockResolvedValue(opts.canWrite === undefined ? null : opts.canWrite);
     const workspaceService = makeWorkspaceService();
     const pending = opts.pending ?? makePendingCommits();
-    const svc = new WorkflowService(makeDb([OPEN_REQUEST]), git, makePrs(), makeReviewWorkflow(), workspaceService, access, makeFileLockService(), pending, testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb([OPEN_REQUEST]), git, makePrs(), makeChangeRequestReview(), workspaceService, access, makeFileLockService(), pending, testKbContext(), openChangeGate());
     const merge = (git as unknown as { mergeChangeRequest: ReturnType<typeof vi.fn> }).mergeChangeRequest;
     return { svc, git, access, merge, pending };
   }
@@ -1614,7 +1612,7 @@ describe('WorkflowService.mergeBranch — an agent merges branches, never an ope
  * refuses must not undo the open: the merge is committed locally, the request
  * is a DB row, and the next push of the branch carries the commits.
  */
-describe('WorkflowService.openChangeRequest — when the repository host refuses the push', () => {
+describe('VersionControlService.openChangeRequest — when the repository host refuses the push', () => {
   const INPUT = { sourceBranch: 'ali/x', targetBranch: 'main', title: 'Tidy the glossary' };
 
   function makeOpenHarness(push: ReturnType<typeof vi.fn>) {
@@ -1629,10 +1627,10 @@ describe('WorkflowService.openChangeRequest — when the repository host refuses
     (prs.getPrDetail as ReturnType<typeof vi.fn>).mockResolvedValue({ number: 12, branch: 'ali/x', base: 'main' });
     const values = vi.fn(() => ({ returning: vi.fn(async () => [{ number: 12 }]) }));
     const db = { insert: vi.fn(() => ({ values })) } as unknown as Database;
-    const svc = new WorkflowService(
-      db, git, prs, makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(),
+    const svc = new VersionControlService(
+      db, git, prs, makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(),
       makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate(),
-      { emit } as unknown as WorkflowEventBus,
+      { emit } as unknown as VersionControlEventBus,
     );
     return { svc, git, prs, values, emit };
   }
@@ -1716,7 +1714,7 @@ describe('WorkflowService.openChangeRequest — when the repository host refuses
  * people the `## Affected owners` block lists, resolved to accounts and
  * handed over once each; who could not be is counted.
  */
-describe('WorkflowService.openChangeRequest — tells the change-request listeners', () => {
+describe('VersionControlService.openChangeRequest — tells the change-request listeners', () => {
   const INPUT = { sourceBranch: 'ali/x', targetBranch: 'main', title: '  Tidy the glossary  ' };
   const PATHS = ['KnowledgeBase/Sales/Deal.md', 'KnowledgeBase/Legal/Terms.md'];
   const ACCOUNTS: Record<string, { id: string; email: string; name: string }> = {
@@ -1800,10 +1798,10 @@ describe('WorkflowService.openChangeRequest — tells the change-request listene
               return found;
             }),
           };
-    const svc = new WorkflowService(
-      db, git, prs, makeReviewWorkflow(), workspaces, access,
+    const svc = new VersionControlService(
+      db, git, prs, makeChangeRequestReview(), workspaces, access,
       makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate(),
-      { emit: vi.fn() } as unknown as WorkflowEventBus, undefined, undefined, hooks, accounts,
+      { emit: vi.fn() } as unknown as VersionControlEventBus, undefined, undefined, hooks, accounts,
     );
     return { svc, run, prs, access, accounts, values };
   }
@@ -1934,13 +1932,13 @@ describe('WorkflowService.openChangeRequest — tells the change-request listene
     expect(failing.run.mock.calls[0]![0]).toMatchObject({ number: 12, pushPending: false });
 
     const missing = makeNotifyHarness({ detail: vi.fn().mockResolvedValue(null) });
-    await expect(missing.svc.openChangeRequest('ali%2Fx', makeUser(), INPUT)).rejects.toBeInstanceOf(WorkflowValidationError);
+    await expect(missing.svc.openChangeRequest('ali%2Fx', makeUser(), INPUT)).rejects.toBeInstanceOf(VersionControlValidationError);
     expect(missing.run).toHaveBeenCalledTimes(1);
   });
 
   it('a refused open tells nobody: a validation failure, a conflicting auto-merge', async () => {
     const invalid = makeNotifyHarness();
-    await expect(invalid.svc.openChangeRequest('ali%2Fx', makeUser(), { ...INPUT, title: '   ' })).rejects.toBeInstanceOf(WorkflowValidationError);
+    await expect(invalid.svc.openChangeRequest('ali%2Fx', makeUser(), { ...INPUT, title: '   ' })).rejects.toBeInstanceOf(VersionControlValidationError);
     expect(invalid.run).not.toHaveBeenCalled();
     expect(invalid.values).not.toHaveBeenCalled();
 
@@ -1967,7 +1965,7 @@ describe('WorkflowService.openChangeRequest — tells the change-request listene
  * for the source's queue first — bounded, outside the lifecycle locks — and
  * says plainly when there was nothing to merge.
  */
-describe('WorkflowService.mergeBranch — waits for the source branch\'s pending commits', () => {
+describe('VersionControlService.mergeBranch — waits for the source branch\'s pending commits', () => {
   const SOURCE = 'alice/other';
   const TARGET = 'alice/feat';
 
@@ -2031,9 +2029,9 @@ describe('WorkflowService.mergeBranch — waits for the source branch\'s pending
     (git as unknown as Record<string, unknown>).remoteBranchExists = vi.fn().mockResolvedValue(true);
     const merge = vi.fn(async (): Promise<unknown> => ({ kind: 'merged', sha: 'merge-sha', mergeCommit: 'merge-sha' }));
     (git as unknown as Record<string, unknown>).mergeChangeRequest = merge;
-    const svc = new WorkflowService(
+    const svc = new VersionControlService(
       makeDb([{ number: 12, sourceBranch: 'alice/feat', targetBranch: DEFAULT_BRANCH, state: 'open' }]),
-      git, makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(),
+      git, makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(), makeFileLockService(),
       pending, testKbContext(), openChangeGate(),
     );
     svc.mergeWaitForPendingCommits = wait;
@@ -2057,7 +2055,7 @@ describe('WorkflowService.mergeBranch — waits for the source branch\'s pending
     // after a moment, the way a commit + push takes a few seconds.
     const worker = new PendingCommitsWorker({
       service,
-      workflow: {
+      versionControl: {
         runPendingCommit: async (_ws: string, branch: string, path: string) => {
           await new Promise((r) => setTimeout(r, 150));
           remote.get(branch)!.add(path);
@@ -2109,8 +2107,8 @@ describe('WorkflowService.mergeBranch — waits for the source branch\'s pending
   });
 
   it('bounds the wait well inside the timeout an agent\'s call is forwarded under', () => {
-    const svc = new WorkflowService(
-      makeDb(), makeGit(), makePrs(), makeReviewWorkflow(), makeWorkspaceService(), makeAccessControl(),
+    const svc = new VersionControlService(
+      makeDb(), makeGit(), makePrs(), makeChangeRequestReview(), makeWorkspaceService(), makeAccessControl(),
       makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate(),
     );
     // Over `/api/mcp` the call reaches the tool through `@utcp/http`, whose
@@ -2201,11 +2199,11 @@ describe('WorkflowService.mergeBranch — waits for the source branch\'s pending
   it('leaves the app\'s change-request apply as it was: no wait, same outcome', async () => {
     const { service } = memoryQueue([row({ branch: 'alice/feat' })]);
     const prs = makePrs();
-    const reviewWorkflow = makeReviewWorkflow();
+    const changeRequestReview = makeChangeRequestReview();
     const mergeResult = { prNumber: 4, sha: 'abc', mergedAt: 't' };
-    (reviewWorkflow.mergePr as ReturnType<typeof vi.fn>).mockResolvedValue(mergeResult);
+    (changeRequestReview.mergePr as ReturnType<typeof vi.fn>).mockResolvedValue(mergeResult);
     (prs.getPr as ReturnType<typeof vi.fn>).mockResolvedValue({ branch: 'alice/feat', base: 'main' });
-    const svc = new WorkflowService(makeDb(), makeGit(), prs, reviewWorkflow, makeWorkspaceService(), makeAccessControl(), makeFileLockService(), service, testKbContext(), openChangeGate());
+    const svc = new VersionControlService(makeDb(), makeGit(), prs, changeRequestReview, makeWorkspaceService(), makeAccessControl(), makeFileLockService(), service, testKbContext(), openChangeGate());
     const outcome = await svc.mergeChangeRequest(4, makeUser(), 'sha', [], 'open', 'PR title', 'main', 'w1', { bypass: true });
     expect(outcome).toEqual({ kind: 'merged', result: mergeResult });
     expect(service.queuedOnBranch).not.toHaveBeenCalled();