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

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

@@ -3,14 +3,14 @@ import { testKbContext } from '../../../__tests__/kb-context.js';
 import type { AuthUser, PullRequestSummary } 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 type { FileLockService } from '../file-lock.service.js';
 import type { PendingCommitsService } from '../pending-commits.service.js';
 import type { Database } from '../../database/connection.js';
 import { hashEmail } from '../../../shared/email-identity.js';
-import { WorkflowService } from '../workflow.service.js';
+import { VersionControlService } from '../version-control.service.js';
 import { openChangeGate } from '../../../__tests__/open-change-gate.js';
 
 /**
@@ -130,11 +130,11 @@ function makeHarness(requests: PullRequestSummary[], access: Access = {}) {
     }),
   });
 
-  const svc = new WorkflowService(
+  const svc = new VersionControlService(
     chain as unknown as Database,
     git,
     prs,
-    {} as IReviewWorkflowService,
+    {} as IChangeRequestReviewService,
     workspaceService,
     accessControl,
     fileLocks,
@@ -176,7 +176,7 @@ const elsewhere = summary({
   touchedNodePaths: ['Data/ReportsArchive/old.md'],
 });
 
-describe('WorkflowService.changeRequestsUnderFolder', () => {
+describe('VersionControlService.changeRequestsUnderFolder', () => {
   it('names only the requests proposing files under the folder, with only those paths', async () => {
     const { svc } = makeHarness([aliceRequest, bobRequest, elsewhere], { admins: [ALICE.email] });
     const requests = await svc.changeRequestsUnderFolder('Data/Reports', ALICE);
@@ -252,7 +252,7 @@ describe('WorkflowService.changeRequestsUnderFolder', () => {
   });
 });
 
-describe('WorkflowService.removeFolderFromChangeRequests', () => {
+describe('VersionControlService.removeFolderFromChangeRequests', () => {
   const aliceWs = encodeURIComponent(aliceRequest.branch);
   const bobWs = encodeURIComponent(bobRequest.branch);
   type Plans = Parameters<GitService['revertPathsAndPush']>[1];
@@ -544,7 +544,7 @@ describe('WorkflowService.removeFolderFromChangeRequests', () => {
   });
 });
 
-describe('WorkflowService.closeEmptyChangeRequest', () => {
+describe('VersionControlService.closeEmptyChangeRequest', () => {
   const emptied = summary({ number: 40, branch: 'suggestions/bob-u-bob/knowledge', touchedNodePaths: [] });
 
   it('withdraws a request whose diff is empty and whose branch has nothing landing', async () => {

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

@@ -3,13 +3,13 @@ import { testKbContext } from '../../../__tests__/kb-context.js';
 import type { AuthUser } 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 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 { VersionControlEventBus } from '../event-bus.js';
+import { VersionControlService } from '../version-control.service.js';
 import type { Database } from '../../database/connection.js';
 import { AccessDeniedError } from '../../access-model/access-errors.js';
 import { openChangeGate } from '../../../__tests__/open-change-gate.js';
@@ -45,18 +45,18 @@ function makeService(canRestorePlatformFile: IAccessControl['canRestorePlatformF
     eligibleWritersAtRef: vi.fn(async () => ({ roles: [], users: [] })),
     canRestorePlatformFile: vi.fn(canRestorePlatformFile),
   } as unknown as IAccessControl;
-  const svc = new WorkflowService(
+  const svc = new VersionControlService(
     {} as unknown as Database,
     {} as GitService,
     {} as PullRequestService,
-    {} as IReviewWorkflowService,
+    {} as IChangeRequestReviewService,
     {} as WorkspaceService,
     accessControl,
     { acquire, get: vi.fn(async () => null) } as unknown as FileLockService,
     {} as PendingCommitsService,
     testKbContext({ kbDirName: KB }),
     openChangeGate(),
-    new WorkflowEventBus(),
+    new VersionControlEventBus(),
   );
   return { svc, acquire, accessControl };
 }

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

@@ -3,13 +3,13 @@ import { testKbContext } from '../../../__tests__/kb-context.js';
 import type { AuthUser } 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 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 { VersionControlEventBus } from '../event-bus.js';
+import { VersionControlService } from '../version-control.service.js';
 import type { Database } from '../../database/connection.js';
 import { AccessDeniedError } from '../../access-model/access-errors.js';
 import type { ChangeReadVerdict, IChangeReadGate } from '../../access-model/change-gate.js';
@@ -53,31 +53,31 @@ function makeService(opts: {
     eligibleWritersAtRef: vi.fn(async () => ({ roles: [], users: [] })),
     canRestorePlatformFile: vi.fn(async () => opts.canRestorePlatformFile ?? false),
   } as unknown as IAccessControl;
-  const svc = new WorkflowService(
+  const svc = new VersionControlService(
     {} as unknown as Database,
     {} as GitService,
     {} as PullRequestService,
-    {} as IReviewWorkflowService,
+    {} as IChangeRequestReviewService,
     {} as WorkspaceService,
     accessControl,
     { acquire, get: vi.fn(async () => null) } as unknown as FileLockService,
     {} as PendingCommitsService,
     testKbContext({ kbDirName: KB }),
     opts.gate ?? gateThat({ allowed: true, via: 'readable' }).gate,
-    new WorkflowEventBus(),
+    new VersionControlEventBus(),
   );
   return { svc, acquire, accessControl };
 }
 
-describe('WorkflowService cannot exist without the gate', () => {
+describe('VersionControlService cannot exist without the gate', () => {
   it('refuses construction when none is given, whatever the compiler was told', () => {
     expect(
       () =>
-        new WorkflowService(
+        new VersionControlService(
           {} as unknown as Database,
           {} as GitService,
           {} as PullRequestService,
-          {} as IReviewWorkflowService,
+          {} as IChangeRequestReviewService,
           {} as WorkspaceService,
           {} as IAccessControl,
           {} as FileLockService,

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

@@ -3,28 +3,28 @@ import { testKbContext } from '../../../__tests__/kb-context.js';
 import type { AuthUser, Change } 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 { WorkspaceService } from '../../workspace/workspace.service.js';
-import type { IAccessControl } from '../../access/access-control.interface.js';
+import type { IChangeRequestReviewService } from '../change-request-review/change-request-review.interface.js';
+import type { WorkspaceService } from '../../workspace/index.js';
+import type { IAccessControl } from '../../access/index.js';
 import { FileLockService } from '../file-lock.service.js';
 import { PendingCommitsService } from '../pending-commits.service.js';
-import { WorkflowEventBus } from '../event-bus.js';
-import { WorkflowService, syncConflictMessage } from '../workflow.service.js';
+import { VersionControlEventBus } from '../event-bus.js';
+import { VersionControlService, syncConflictMessage } from '../version-control.service.js';
 import { openChangeGate } from '../../../__tests__/open-change-gate.js';
-import type { Database } from '../../database/connection.js';
+import type { Database } from '../../database/index.js';
 import {
   PullRebaseConflictError,
   PullRebaseConflictError,
   PushNeedsAgentResolutionError,
-  WorkflowValidationError,
+  VersionControlValidationError,
 } from '../../../shared/domain-errors.js';
 
 /**
  * Two surfaces under test:
  *
- *   1. `WorkflowService.releaseLock` — new shape (enqueue + drop lock,
+ *   1. `VersionControlService.releaseLock` — new shape (enqueue + drop lock,
  *      no synchronous commit).
- *   2. `WorkflowService.runPendingCommit` — what the background worker
+ *   2. `VersionControlService.runPendingCommit` — what the background worker
  *      calls per claimed row. This is where the old releaseLock's
  *      commit + cooperative-push + recovery body now lives, so the
  *      non-FF + auth-failure + double-push-fail scenarios moved here.
@@ -87,24 +87,39 @@ function makePending(): PendingCommitsService {
   } as unknown as PendingCommitsService;
 }
 
-function makeGit(overrides: Partial<{
+interface GitBehavior {
   commitFile: Change | null;
   pushBehavior: 'ok' | 'nff' | 'auth-fail';
   pullBehavior: 'ok' | 'fail' | 'conflict';
   pushAfterPullBehavior: 'ok' | 'fail';
   hasUnpushedCommits: boolean;
-}> = {}): GitService {
-  const commitFileResult = overrides.commitFile === undefined ? CHANGE : overrides.commitFile;
-  const pushBehavior = overrides.pushBehavior ?? 'ok';
-  const pullBehavior = overrides.pullBehavior ?? 'ok';
-  const pushAfterPullBehavior = overrides.pushAfterPullBehavior ?? 'ok';
+}
+
+/** The git stub, whose behaviour a test changes in place (`behave`) — the service keeps the one instance it was given. */
+type GitStub = GitService & { behave(next: Partial<GitBehavior>): void };
+
+function makeGit(overrides: Partial<GitBehavior> = {}): GitStub {
+  const b: GitBehavior = {
+    commitFile: CHANGE,
+    pushBehavior: 'ok',
+    pullBehavior: 'ok',
+    pushAfterPullBehavior: 'ok',
+    hasUnpushedCommits: false,
+    ...overrides,
+  };
   let pushCalls = 0;
+  const behave = (next: Partial<GitBehavior>): void => {
+    Object.assign(b, next);
+    pushCalls = 0;
+  };
   return {
-    commitFile: vi.fn().mockResolvedValue(commitFileResult),
+    behave,
+    commitFile: vi.fn().mockImplementation(async () => b.commitFile),
     discardPath: vi.fn().mockResolvedValue(undefined),
-    hasUnpushedCommits: vi.fn().mockResolvedValue(overrides.hasUnpushedCommits ?? false),
+    hasUnpushedCommits: vi.fn().mockImplementation(async () => b.hasUnpushedCommits),
     push: vi.fn().mockImplementation(async () => {
       pushCalls++;
+      const { pushBehavior, pushAfterPullBehavior } = b;
       const phase = pushCalls === 1 ? pushBehavior : pushAfterPullBehavior;
       if (phase === 'nff') {
         throw new Error(
@@ -122,24 +137,24 @@ function makeGit(overrides: Partial<{
       }
     }),
     pull: vi.fn().mockImplementation(async () => {
-      if (pullBehavior === 'fail') throw new Error('git pull failed: merge conflict');
-      if (pullBehavior === 'conflict') throw new PullRebaseConflictError('feat/x', ['foo.md'], 'CONFLICT (content)');
+      if (b.pullBehavior === 'fail') throw new Error('git pull failed: merge conflict');
+      if (b.pullBehavior === 'conflict') throw new PullRebaseConflictError('feat/x', ['foo.md'], 'CONFLICT (content)');
       return { treeChanged: true };
     }),
-  } as unknown as GitService;
+  } as unknown as GitStub;
 }
 
 function makeFacade(
   git: GitService,
   locks: FileLockService,
   pending: PendingCommitsService,
-  events: WorkflowEventBus,
-): WorkflowService {
-  return new WorkflowService(
+  events: VersionControlEventBus,
+): VersionControlService {
+  return new VersionControlService(
     {} as unknown as Database,
     git,
     {} as PullRequestService,
-    {} as IReviewWorkflowService,
+    {} as IChangeRequestReviewService,
     {} as WorkspaceService,
     {} as IAccessControl,
     locks,
@@ -150,12 +165,12 @@ function makeFacade(
   );
 }
 
-describe('WorkflowService.releaseLock — new (enqueue, no synchronous commit)', () => {
-  let events: WorkflowEventBus;
+describe('VersionControlService.releaseLock — new (enqueue, no synchronous commit)', () => {
+  let events: VersionControlEventBus;
   let emitSpy: MockInstance;
 
   beforeEach(() => {
-    events = new WorkflowEventBus();
+    events = new VersionControlEventBus();
     emitSpy = vi.spyOn(events, 'emit');
   });
 
@@ -203,7 +218,7 @@ describe('WorkflowService.releaseLock — new (enqueue, no synchronous commit)',
     const svc = makeFacade(git, locks, pending, events);
 
     await expect(svc.releaseLock('ws-1', 'feat/x', 'foo.md', USER)).rejects.toBeInstanceOf(
-      WorkflowValidationError,
+      VersionControlValidationError,
     );
     // Ownership guard MUST run before we enqueue — otherwise a non-holder
     // could schedule a commit attributed to themselves on any file.
@@ -222,13 +237,13 @@ describe('WorkflowService.releaseLock — new (enqueue, no synchronous commit)',
     const svc = makeFacade(git, locks, pending, events);
 
     await expect(svc.releaseLock('ws-1', 'feat/x', 'foo.md', USER)).rejects.toBeInstanceOf(
-      WorkflowValidationError,
+      VersionControlValidationError,
     );
     expect(pending.enqueue).not.toHaveBeenCalled();
   });
 
   it('surfaces lock-release failure without rolling back the enqueue', async () => {
-    // Documents the deliberate ordering at workflow.service.ts:
+    // Documents the deliberate ordering at version-control.service.ts:
     // enqueue first, drop second. If `locks.release` throws after a
     // successful `pending.enqueue`, we let the error propagate — the
     // queued row stays so the worker eventually commits the file, and
@@ -281,20 +296,20 @@ describe('WorkflowService.releaseLock — new (enqueue, no synchronous commit)',
       .releaseLock('ws-1', 'feat/x', 'foo.md', USER)
       .then(() => null)
       .catch((e: unknown) => e);
-    expect(err).toBeInstanceOf(WorkflowValidationError);
-    expect((err as WorkflowValidationError).payload?.kind).toBe('coordination-hold');
+    expect(err).toBeInstanceOf(VersionControlValidationError);
+    expect((err as VersionControlValidationError).payload?.kind).toBe('coordination-hold');
     expect(pending.enqueue).not.toHaveBeenCalled();
     expect(locks.release).not.toHaveBeenCalled();
     expect(emitSpy).not.toHaveBeenCalled();
   });
 });
 
-describe('WorkflowService.releaseLockUntouched — drop the row, leave disk AND queue alone', () => {
-  let events: WorkflowEventBus;
+describe('VersionControlService.releaseLockUntouched — drop the row, leave disk AND queue alone', () => {
+  let events: VersionControlEventBus;
   let emitSpy: MockInstance;
 
   beforeEach(() => {
-    events = new WorkflowEventBus();
+    events = new VersionControlEventBus();
     emitSpy = vi.spyOn(events, 'emit');
   });
 
@@ -330,11 +345,11 @@ describe('WorkflowService.releaseLockUntouched — drop the row, leave disk AND
   });
 });
 
-describe('WorkflowService.releaseLockNoCommit — coordination-hold discard guard', () => {
-  let events: WorkflowEventBus;
+describe('VersionControlService.releaseLockNoCommit — coordination-hold discard guard', () => {
+  let events: VersionControlEventBus;
 
   beforeEach(() => {
-    events = new WorkflowEventBus();
+    events = new VersionControlEventBus();
   });
 
   it('discards as usual on an EDIT hold, without consulting the queue', async () => {
@@ -388,23 +403,23 @@ describe('WorkflowService.releaseLockNoCommit — coordination-hold discard guar
   });
 });
 
-describe('WorkflowService.hasQueuedCommit', () => {
+describe('VersionControlService.hasQueuedCommit', () => {
   it('delegates to the pending-commits queue per (workspace, branch, path)', async () => {
     const pending = makePending();
     (pending.hasLiveRowFor as ReturnType<typeof vi.fn>).mockResolvedValue(true);
-    const svc = makeFacade(makeGit(), makeFileLocks(USER.id), pending, new WorkflowEventBus());
+    const svc = makeFacade(makeGit(), makeFileLocks(USER.id), pending, new VersionControlEventBus());
 
     await expect(svc.hasQueuedCommit('ws-1', 'feat/x', 'foo.md')).resolves.toBe(true);
     expect(pending.hasLiveRowFor).toHaveBeenCalledWith('ws-1', 'feat/x', 'foo.md');
   });
 });
 
-describe('WorkflowService.runPendingCommit — worker entry point', () => {
-  let events: WorkflowEventBus;
+describe('VersionControlService.runPendingCommit — worker entry point', () => {
+  let events: VersionControlEventBus;
   let emitSpy: MockInstance;
 
   beforeEach(() => {
-    events = new WorkflowEventBus();
+    events = new VersionControlEventBus();
     emitSpy = vi.spyOn(events, 'emit');
   });
 
@@ -574,12 +589,12 @@ describe('WorkflowService.runPendingCommit — worker entry point', () => {
   });
 });
 
-describe('WorkflowService — git-sync visibility events', () => {
-  let events: WorkflowEventBus;
+describe('VersionControlService — git-sync visibility events', () => {
+  let events: VersionControlEventBus;
   let emitSpy: MockInstance;
 
   beforeEach(() => {
-    events = new WorkflowEventBus();
+    events = new VersionControlEventBus();
     emitSpy = vi.spyOn(events, 'emit');
   });
 
@@ -642,18 +657,15 @@ describe('WorkflowService — git-sync visibility events', () => {
   });
 
   it('emits git-sync-recovered once when a push finally lands, then goes quiet again', async () => {
-    const failing = makeGit({ pushBehavior: 'auth-fail' });
-    const svc = makeFacade(failing, makeFileLocks(USER.id), makePending(), events);
+    const git = makeGit({ pushBehavior: 'auth-fail' });
+    const svc = makeFacade(git, makeFileLocks(USER.id), makePending(), events);
     await svc.runPendingCommit('ws-1', 'feat/x', 'foo.md', USER).catch(() => undefined);
     expect(kinds()).toEqual(['git-sync-failed']);
 
     // Same service instance — the failing/healthy state is per-workspace and
-    // lives on it, so recovery has to be observed through the same object.
-    const healthy = makeGit();
-    const recovered = makeFacade(healthy, makeFileLocks(USER.id), makePending(), events);
-    Object.assign(svc as unknown as Record<string, unknown>, {
-      git: (recovered as unknown as { git: GitService }).git,
-    });
+    // lives on it, so recovery has to be observed through the same object;
+    // the remote comes back by the stub's behaviour changing.
+    git.behave({ pushBehavior: 'ok' });
 
     await svc.runPendingCommit('ws-1', 'feat/x', 'foo.md', USER);
     await svc.runPendingCommit('ws-1', 'feat/x', 'foo.md', USER);
@@ -672,15 +684,11 @@ describe('WorkflowService — git-sync visibility events', () => {
     // callers hand the encoded form (user%2Ffeat). The tracker must treat
     // them as one workspace, or a failure recorded by one caller can never
     // be cleared by the other's success and the banner sticks forever.
-    const svc = makeFacade(
-      makeGit({ pushBehavior: 'auth-fail', pushAfterPullBehavior: 'fail' }),
-      makeFileLocks(USER.id),
-      makePending(),
-      events,
-    );
+    const git = makeGit({ pushBehavior: 'auth-fail', pushAfterPullBehavior: 'fail' });
+    const svc = makeFacade(git, makeFileLocks(USER.id), makePending(), events);
     await svc.runPendingCommit('user%2Ffeat', 'user/feat', 'foo.md', USER).catch(() => undefined);
 
-    Object.assign(svc as unknown as Record<string, unknown>, { git: makeGit() });
+    git.behave({ pushBehavior: 'ok', pushAfterPullBehavior: 'ok' });
     await svc.runPendingCommit('user/feat', 'user/feat', 'foo.md', USER);
 
     const sync = emitSpy.mock.calls
@@ -694,18 +702,20 @@ describe('WorkflowService — git-sync visibility events', () => {
   });
 
   it('tracks workspaces independently — one recovering neither clears nor suppresses another', async () => {
-    const failingGit = () => makeGit({ pushBehavior: 'auth-fail', pushAfterPullBehavior: 'fail' });
-    const svc = makeFacade(failingGit(), makeFileLocks(USER.id), makePending(), events);
+    const failing = { pushBehavior: 'auth-fail', pushAfterPullBehavior: 'fail' } as const;
+    const git = makeGit(failing);
+    const svc = makeFacade(git, makeFileLocks(USER.id), makePending(), events);
 
     // Both workspaces broken.
     await svc.runPendingCommit('ws-1', 'feat/x', 'foo.md', USER).catch(() => undefined);
+    git.behave(failing);
     await svc.runPendingCommit('ws-2', 'feat/y', 'bar.md', USER).catch(() => undefined);
 
     // ws-1 recovers; ws-2 is still broken and must (a) not be cleared by
     // ws-1's recovery and (b) still announce its own next failure.
-    Object.assign(svc as unknown as Record<string, unknown>, { git: makeGit() });
+    git.behave({ pushBehavior: 'ok', pushAfterPullBehavior: 'ok' });
     await svc.runPendingCommit('ws-1', 'feat/x', 'foo.md', USER);
-    Object.assign(svc as unknown as Record<string, unknown>, { git: failingGit() });
+    git.behave(failing);
     await svc.runPendingCommit('ws-2', 'feat/y', 'bar.md', USER).catch(() => undefined);
 
     expect(
@@ -723,7 +733,7 @@ describe('WorkflowService — git-sync visibility events', () => {
   });
 });
 
-describe('WorkflowService.updateFromRemote — pull-conflict recovery dispatch', () => {
+describe('VersionControlService.updateFromRemote — pull-conflict recovery dispatch', () => {
   const CONFLICT = new PullRebaseConflictError(
     'main',
     ['PR-Overviews/PR-7.html', 'other.md'],
@@ -739,7 +749,7 @@ describe('WorkflowService.updateFromRemote — pull-conflict recovery dispatch',
   it('queues ONE recovery row (first conflicted path, triggering user) and rethrows', async () => {
     const pending = makePending();
     const svc = makeFacade(
-      makeConflictingGit(CONFLICT), makeFileLocks(USER.id), pending, new WorkflowEventBus(),
+      makeConflictingGit(CONFLICT), makeFileLocks(USER.id), pending, new VersionControlEventBus(),
     );
 
     await expect(svc.updateFromRemote('main', USER)).rejects.toBe(CONFLICT);
@@ -760,7 +770,7 @@ describe('WorkflowService.updateFromRemote — pull-conflict recovery dispatch',
   it('falls back to the recovery-bot identity when no user is available', async () => {
     const pending = makePending();
     const svc = makeFacade(
-      makeConflictingGit(CONFLICT), makeFileLocks(USER.id), pending, new WorkflowEventBus(),
+      makeConflictingGit(CONFLICT), makeFileLocks(USER.id), pending, new VersionControlEventBus(),
     );
 
     await expect(svc.updateFromRemote('main')).rejects.toBe(CONFLICT);
@@ -773,7 +783,7 @@ describe('WorkflowService.updateFromRemote — pull-conflict recovery dispatch',
     const pending = makePending();
     const transient = new Error('git fetch failed: could not resolve host');
     const svc = makeFacade(
-      makeConflictingGit(transient), makeFileLocks(USER.id), pending, new WorkflowEventBus(),
+      makeConflictingGit(transient), makeFileLocks(USER.id), pending, new VersionControlEventBus(),
     );
 
     await expect(svc.updateFromRemote('main', USER)).rejects.toBe(transient);
@@ -786,14 +796,14 @@ describe('WorkflowService.updateFromRemote — pull-conflict recovery dispatch',
       new Error('db down'),
     );
     const svc = makeFacade(
-      makeConflictingGit(CONFLICT), makeFileLocks(USER.id), pending, new WorkflowEventBus(),
+      makeConflictingGit(CONFLICT), makeFileLocks(USER.id), pending, new VersionControlEventBus(),
     );
 
     await expect(svc.updateFromRemote('main', USER)).rejects.toBe(CONFLICT);
   });
 });
 
-describe('WorkflowService.updateFromRemote — the tree-change announcement', () => {
+describe('VersionControlService.updateFromRemote — the tree-change announcement', () => {
   /**
    * The announcement under test is what keeps the DEFAULT branch's catalog
    * caches (skills, tool manuals, plugin index) honest: a pull is the one way
@@ -829,7 +839,7 @@ describe('WorkflowService.updateFromRemote — the tree-change announcement', ()
   }
 
   it('emits fs-tree-changed for the default workspace once the pull has changed the tree', async () => {
-    const events = new WorkflowEventBus();
+    const events = new VersionControlEventBus();
     const emitSpy = vi.spyOn(events, 'emit');
     const { git, pullSettled } = makePullingGit({ treeChanged: true });
     let settledAtEmit: boolean | undefined;
@@ -849,7 +859,7 @@ describe('WorkflowService.updateFromRemote — the tree-change announcement', ()
   });
 
   it('stays silent when the pull found nothing new (treeChanged: false)', async () => {
-    const events = new WorkflowEventBus();
+    const events = new VersionControlEventBus();
     const emitSpy = vi.spyOn(events, 'emit');
     const { git } = makePullingGit({ treeChanged: false });
     const svc = makeFacade(git, makeFileLocks(USER.id), makePending(), events);
@@ -862,7 +872,7 @@ describe('WorkflowService.updateFromRemote — the tree-change announcement', ()
   });
 
   it('stays silent for a non-default workspace even when the tree changed', async () => {
-    const events = new WorkflowEventBus();
+    const events = new VersionControlEventBus();
     const emitSpy = vi.spyOn(events, 'emit');
     const { git } = makePullingGit({ treeChanged: true });
     const svc = makeFacade(git, makeFileLocks(USER.id), makePending(), events);
@@ -873,7 +883,7 @@ describe('WorkflowService.updateFromRemote — the tree-change announcement', ()
   });
 
   it('stays silent when the pull throws', async () => {
-    const events = new WorkflowEventBus();
+    const events = new VersionControlEventBus();
     const emitSpy = vi.spyOn(events, 'emit');
     const { git } = makePullingGit(new Error('git fetch failed: could not resolve host'));
     const svc = makeFacade(git, makeFileLocks(USER.id), makePending(), events);

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

@@ -2,13 +2,13 @@ import { describe, it, expect, vi } from 'vitest';
 import { testKbContext } from '../../../__tests__/kb-context.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 { 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 type { FileLockService } from '../file-lock.service.js';
 import type { PendingCommitsService } from '../pending-commits.service.js';
 import type { Database } from '../../database/connection.js';
-import { WorkflowService } from '../workflow.service.js';
+import { VersionControlService } from '../version-control.service.js';
 import { openChangeGate } from '../../../__tests__/open-change-gate.js';
 
 /**
@@ -74,11 +74,11 @@ function makeService(passes: ClosedRow[][], openCount = passes.flat().length) {
   const prs = {
     invalidateDetailCache: vi.fn((n: number) => invalidated.push(n)),
   } as unknown as PullRequestService;
-  const svc = new WorkflowService(
+  const svc = new VersionControlService(
     makeDb(passes, sets, openCount),
     {} as GitService,
     prs,
-    {} as IReviewWorkflowService,
+    {} as IChangeRequestReviewService,
     {} as WorkspaceService,
     {} as IAccessControl,
     fileLocks,