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

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

@@ -6,7 +6,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import type { WorkspaceService } from '../../../workspace/workspace.service.js';
-import { WorkflowHooks } from '../../workflow-hooks.js';
+import { VersionControlHooks } from '../../version-control-hooks.js';
 import { GitService } from '../git.service.js';
 
 /**
@@ -69,12 +69,12 @@ function stubWorkspaceService(workspaceId: string, workspaceDir: string): Worksp
   } as unknown as WorkspaceService;
 }
 
-function makeValidator(): { hooks: WorkflowHooks; runValidation: ReturnType<typeof vi.fn> } {
+function makeValidator(): { hooks: VersionControlHooks; runValidation: ReturnType<typeof vi.fn> } {
   const report = { ok: true, mustFix: [], warnings: [], rawOutput: '' };
   const runValidation = vi.fn(async () => report);
   // Registered as a commit-validation hook — the seam GitService consults
   // where it used to call the injected validator.
-  const hooks = new WorkflowHooks();
+  const hooks = new VersionControlHooks();
   hooks.onCommitValidation(() => runValidation());
   return { hooks, runValidation };
 }

package/src/modules/version-control/git/__tests__/git.service.commitLanded.test.ts

@@ -0,0 +1,199 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import type { FilesChange } from '@bevel-software/platform-shared';
+import { testKbContext } from '../../../../__tests__/kb-context.js';
+import type { IGitRunner } from '../../../../shared/git.contract.js';
+import { VersionControlHooks } from '../../version-control-hooks.js';
+import { GitService } from '../git.service.js';
+import { NodeGitRunner } from '../node-git-runner.js';
+import { gitOut, runGit, stubWorkspaceService } from './git-test-helpers.js';
+
+/**
+ * Every commit the git service lands is reported once through
+ * `VersionControlHooks.onCommitLanded` — the one place a commit is announced
+ * from, so no committer can be forgotten. Each way of committing is driven
+ * here on a real repository: the one-file `commit`, `commitFile`, a scoped
+ * `commitChanges`, a `commitChanges` that finds its scope clean, and a merge.
+ * Paths arrive workspace-relative (the notifier sorts them), as the person.
+ */
+const KB = 'knowledge-base';
+const WS = 'ws-landed';
+const USER = { id: 'u-alice', name: 'Alice', email: 'alice@bevel.software' };
+
+describe('GitService reports every commit it lands through onCommitLanded', () => {
+  let root: string;
+  let repo: string;
+  let git: GitService;
+  let landed: FilesChange[];
+
+  const write = async (rel: string, text: string) => {
+    const abs = path.join(repo, rel);
+    await fs.mkdir(path.dirname(abs), { recursive: true });
+    await fs.writeFile(abs, text);
+  };
+  /** As the notifier will hand it on: paths sorted. */
+  const heard = () => landed.map((c) => ({ ...c, paths: [...c.paths].sort() }));
+
+  beforeEach(async () => {
+    root = await fs.mkdtemp(path.join(os.tmpdir(), 'bevel-git-landed-'));
+    const workspaceDir = path.join(root, WS);
+    repo = path.join(workspaceDir, KB);
+    await fs.mkdir(repo, { recursive: true });
+    await runGit(repo, ['init', '-b', 'main']);
+    await runGit(repo, ['config', 'user.email', 'test@bevel.local']);
+    await runGit(repo, ['config', 'user.name', 'Test Runner']);
+    await write('Old.md', 'old\n');
+    await runGit(repo, ['add', '-A']);
+    await runGit(repo, ['commit', '-m', 'seed']);
+
+    const hooks = new VersionControlHooks();
+    hooks.onCommitValidation(vi.fn(async () => ({ ok: true, mustFix: [], warnings: [], rawOutput: '' })));
+    landed = [];
+    hooks.onCommitLanded((change) => landed.push(change));
+    git = new GitService(stubWorkspaceService({ [WS]: workspaceDir }), hooks, testKbContext({ kbDirName: KB }));
+  });
+
+  afterEach(async () => {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+  });
+
+  it('commit: the one file the change touched', async () => {
+    await write('A.md', 'a\n');
+    await git.commit(WS, USER, { summary: 'add A' });
+    expect(heard()).toEqual([{ workspaceId: WS, branch: 'main', paths: [`${KB}/A.md`], byUser: USER }]);
+  });
+
+  it('commit: every file of a new folder, and both ends of a rename — the commit, not the status listing, names them', async () => {
+    await write('Folder/one.md', '1\n');
+    await write('Folder/two.md', '2\n');
+    await git.commit(WS, USER, { summary: 'add a folder' });
+    expect(heard().map((c) => c.paths)).toEqual([[`${KB}/Folder/one.md`, `${KB}/Folder/two.md`]]);
+
+    landed.length = 0;
+    await runGit(repo, ['mv', 'Old.md', 'New.md']);
+    await git.commit(WS, USER, { summary: 'rename' });
+    expect(heard().map((c) => c.paths)).toEqual([[`${KB}/New.md`, `${KB}/Old.md`]]);
+  });
+
+  it('commitChanges without a scope: both ends of a rename', async () => {
+    await runGit(repo, ['mv', 'Old.md', 'Moved.md']);
+    await write('K.md', 'k\n');
+    await git.commitChanges(WS, USER, 'move and add');
+    expect(heard().map((c) => c.paths)).toEqual([[`${KB}/K.md`, `${KB}/Moved.md`, `${KB}/Old.md`]]);
+  });
+
+  it('commitFile: the file named, once — a non-ASCII name verbatim', async () => {
+    await write('B.md', 'b\n');
+    await git.commitFile(WS, USER, `${KB}/B.md`);
+    await write('Ünïcode ñ.md', 'ü\n');
+    await git.commitFile(WS, USER, `${KB}/Ünïcode ñ.md`);
+    expect(heard().map((c) => c.paths)).toEqual([[`${KB}/B.md`], [`${KB}/Ünïcode ñ.md`]]);
+  });
+
+  it('a commit is reported with the paths known before it when the read of its files fails', async () => {
+    const real = new NodeGitRunner();
+    const diffTreeFails: IGitRunner = {
+      defaultTimeoutMs: real.defaultTimeoutMs,
+      credentials: real.credentials,
+      run: ((cwd: string, args: string[], opts?: unknown) =>
+        args[0] === 'diff-tree' ? Promise.reject(new Error('diff-tree unavailable')) : real.run(cwd, args, opts as never)) as IGitRunner['run'],
+    };
+    const hooks = new VersionControlHooks();
+    hooks.onCommitValidation(vi.fn(async () => ({ ok: true, mustFix: [], warnings: [], rawOutput: '' })));
+    const heardHere: FilesChange[] = [];
+    hooks.onCommitLanded((change) => heardHere.push(change));
+    const fragile = new GitService(stubWorkspaceService({ [WS]: path.join(root, WS) }), hooks, testKbContext({ kbDirName: KB }), undefined, null, diffTreeFails);
+
+    await write('L.md', 'l\n');
+    await fragile.commit(WS, USER, { summary: 'add L' });
+    await write('M.md', 'm\n');
+    await write('N.md', 'n\n');
+    await fragile.commitChanges(WS, USER, 'add M and N', [`${KB}/M.md`, `${KB}/N.md`]);
+    await write('O.md', 'o\n');
+    await fragile.commitFile(WS, USER, `${KB}/O.md`);
+
+    // The status listing stands in: the files are still named, the report still made.
+    expect(heardHere.map((c) => [...c.paths].sort())).toEqual([[`${KB}/L.md`], [`${KB}/M.md`, `${KB}/N.md`], [`${KB}/O.md`]]);
+  });
+
+  it('commitChanges: exactly the scoped dirty set — a dirty path outside the scope stays out', async () => {
+    await write('C.md', 'c\n');
+    await write('D.md', 'd\n');
+    await write('E.md', 'e\n');
+    await git.commitChanges(WS, USER, 'batch', [`${KB}/C.md`, `${KB}/D.md`]);
+    expect(heard()).toEqual([{ workspaceId: WS, branch: 'main', paths: [`${KB}/C.md`, `${KB}/D.md`], byUser: USER }]);
+    // E is still the caller's uncommitted business.
+    expect(await gitOut(repo, ['status', '--porcelain'])).toContain('E.md');
+  });
+
+  it('commitChanges on a clean scope lands nothing and reports nothing', async () => {
+    expect(await git.commitChanges(WS, USER, 'nothing', [`${KB}/Old.md`])).toBeNull();
+    expect(landed).toEqual([]);
+  });
+
+  it('a merge: every path the merge brought onto the branch, as the person who merged', async () => {
+    await runGit(repo, ['checkout', '-b', 'topic']);
+    await write('F.md', 'f\n');
+    await write('Old.md', 'old, edited on topic\n');
+    await runGit(repo, ['add', '-A']);
+    await runGit(repo, ['commit', '-m', 'topic work']);
+    await runGit(repo, ['checkout', 'main']);
+    // Main moves too, so the merge is a real merge commit, not a fast-forward.
+    await write('G.md', 'g\n');
+    await runGit(repo, ['add', '-A']);
+    await runGit(repo, ['commit', '-m', 'main work']);
+    // The merge reads the other side as `origin/<branch>`: this repository is its own remote.
+    await runGit(repo, ['remote', 'add', 'origin', repo]);
+
+    const outcome = await git.mergeIntoBranch(WS, 'main', 'topic', USER, { subject: 'Merge topic', body: '' });
+    expect(outcome.kind).toBe('merged');
+    expect(heard()).toEqual([{ workspaceId: WS, branch: 'main', paths: [`${KB}/F.md`, `${KB}/Old.md`], byUser: USER }]);
+  });
+
+  it('a commit is reported even when the attribution read after it fails — the commit exists, so the reactors hear of it', async () => {
+    // A runner like the real one, except that `git log` fails: what a disk or
+    // process fault between the commit and its attribution read looks like.
+    const real = new NodeGitRunner();
+    const logFails: IGitRunner = {
+      defaultTimeoutMs: real.defaultTimeoutMs,
+      credentials: real.credentials,
+      run: ((cwd: string, args: string[], opts?: unknown) =>
+        args[0] === 'log' ? Promise.reject(new Error('git log unavailable')) : real.run(cwd, args, opts as never)) as IGitRunner['run'],
+    };
+    const hooks = new VersionControlHooks();
+    hooks.onCommitValidation(vi.fn(async () => ({ ok: true, mustFix: [], warnings: [], rawOutput: '' })));
+    const heardHere: FilesChange[] = [];
+    hooks.onCommitLanded((change) => heardHere.push(change));
+    const fragile = new GitService(stubWorkspaceService({ [WS]: path.join(root, WS) }), hooks, testKbContext({ kbDirName: KB }), undefined, null, logFails);
+    const before = Number(await gitOut(repo, ['rev-list', '--count', 'HEAD']));
+
+    await write('I.md', 'i\n');
+    await expect(fragile.commitFile(WS, USER, `${KB}/I.md`)).rejects.toThrow('git log unavailable');
+    await write('J.md', 'j\n');
+    await expect(fragile.commit(WS, USER, { summary: 'add J' })).rejects.toThrow('git log unavailable');
+
+    // Both commits landed, and both were reported before the read that failed.
+    expect(Number(await gitOut(repo, ['rev-list', '--count', 'HEAD']))).toBe(before + 2);
+    expect(heardHere.map((c) => c.paths)).toEqual([[`${KB}/I.md`], [`${KB}/J.md`]]);
+  });
+
+  it('a hook that throws, or whose promise rejects, is isolated: the commit stands and the other hooks still hear of it', async () => {
+    const hooks = new VersionControlHooks();
+    hooks.onCommitValidation(vi.fn(async () => ({ ok: true, mustFix: [], warnings: [], rawOutput: '' })));
+    const others: FilesChange[] = [];
+    hooks.onCommitLanded(() => {
+      throw new Error('reactor exploded');
+    });
+    hooks.onCommitLanded(async () => Promise.reject(new Error('reactor exploded later')));
+    hooks.onCommitLanded((change) => others.push(change));
+    const loud = new GitService(stubWorkspaceService({ [WS]: path.join(root, WS) }), hooks, testKbContext({ kbDirName: KB }));
+
+    await write('H.md', 'h\n');
+    const change = await loud.commitFile(WS, USER, `${KB}/H.md`);
+    expect(change?.sha).toMatch(/^[0-9a-f]{40}$/);
+    expect(await gitOut(repo, ['status', '--porcelain'])).toBe('');
+    expect(others.map((c) => c.paths)).toEqual([[`${KB}/H.md`]]);
+  });
+});

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

@@ -6,7 +6,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import type { WorkspaceService } from '../../../workspace/workspace.service.js';
-import { WorkflowHooks } from '../../workflow-hooks.js';
+import { VersionControlHooks } from '../../version-control-hooks.js';
 import { GitService } from '../git.service.js';
 
 const execFileAsync = promisify(execFile);
@@ -90,7 +90,7 @@ describe('GitService.createBranch', () => {
     const { upstream } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, path.join(root, workspaceId)),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -133,7 +133,7 @@ describe('GitService.createBranch', () => {
     const repo = path.join(root, workspaceId, 'knowledge-base');
     const svc = new GitService(
       stubWorkspaceService(workspaceId, path.join(root, workspaceId)),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 

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

@@ -7,14 +7,14 @@ import path from 'node:path';
 import os from 'node:os';
 import type { AuthUser } from '@bevel-software/platform-shared';
 import type { WorkspaceService } from '../../../workspace/workspace.service.js';
-import { WorkflowHooks } from '../../workflow-hooks.js';
+import { VersionControlHooks } from '../../version-control-hooks.js';
 import type { IAccessControl } from '../../../access/access-control.interface.js';
 import { GitService } from '../git.service.js';
 import {
   BranchAuthorshipError,
   BranchDeleteRefusedError,
   ProtectedBranchError,
-  WorkflowValidationError,
+  VersionControlValidationError,
 } from '../../../../shared/domain-errors.js';
 
 const execFileAsync = promisify(execFile);
@@ -160,7 +160,7 @@ describe('GitService.deleteBranch — authorship + remote delete', () => {
   function makeService(): GitService {
     return new GitService(
       stubWorkspaceService(workspaceId, path.join(root, workspaceId)),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
   }
@@ -276,7 +276,7 @@ describe('GitService.deleteBranch — authorship + remote delete', () => {
     const svc = makeService();
     await expect(
       svc.deleteBranch(workspaceId, 'alice/my-draft', ALICE),
-    ).rejects.toBeInstanceOf(WorkflowValidationError);
+    ).rejects.toBeInstanceOf(VersionControlValidationError);
   });
 
   it('onlyIfNoRemote: true bypasses the authorship check (orphan-tidy-up path stays open)', async () => {
@@ -305,7 +305,7 @@ describe('GitService.deleteBranch — authorship + remote delete', () => {
 
     await expect(
       svc.deleteBranch(workspaceId, 'alice/my-draft', ALICE, { onlyIfNoRemote: true }),
-    ).rejects.toBeInstanceOf(WorkflowValidationError);
+    ).rejects.toBeInstanceOf(VersionControlValidationError);
   });
 
   // Admin-can-delete: when the user is in the `Admin` role per `roles.yaml`
@@ -315,7 +315,7 @@ describe('GitService.deleteBranch — authorship + remote delete', () => {
   function makeServiceWithAccess(ac: IAccessControl): GitService {
     return new GitService(
       stubWorkspaceService(workspaceId, path.join(root, workspaceId)),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
       undefined,
       ac,
@@ -391,7 +391,7 @@ describe('GitService — branch state for a checked delete', () => {
   function makeService(): GitService {
     return new GitService(
       stubWorkspaceService(workspaceId, path.join(root, workspaceId)),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
   }

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

@@ -6,9 +6,9 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import type { WorkspaceService } from '../../../workspace/workspace.service.js';
-import { WorkflowHooks } from '../../workflow-hooks.js';
+import { VersionControlHooks } from '../../version-control-hooks.js';
 import { GitService } from '../git.service.js';
-import { WorkflowValidationError } from '../../../../shared/domain-errors.js';
+import { VersionControlValidationError } from '../../../../shared/domain-errors.js';
 
 const execFileAsync = promisify(execFile);
 const PROCESS_MAP_DIR = 'knowledge-base';
@@ -108,7 +108,7 @@ describe('GitService.diffFileAtCommit', () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -125,7 +125,7 @@ describe('GitService.diffFileAtCommit', () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -141,7 +141,7 @@ describe('GitService.diffFileAtCommit', () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -157,7 +157,7 @@ describe('GitService.diffFileAtCommit', () => {
     const { workspaceDir } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -170,13 +170,13 @@ describe('GitService.diffFileAtCommit', () => {
     const { workspaceDir } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
     await expect(
       svc.diffFileAtCommit(workspaceId, '../etc/passwd', 'abcdef1'),
-    ).rejects.toBeInstanceOf(WorkflowValidationError);
+    ).rejects.toBeInstanceOf(VersionControlValidationError);
   });
 
   // Regression: pathspec literal handling. `git show <sha> -- '[New] memo.md'`
@@ -187,7 +187,7 @@ describe('GitService.diffFileAtCommit', () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
     await runGit(repo, ['commit', '--allow-empty', '-m', 'init']);

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

@@ -6,9 +6,9 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import type { WorkspaceService } from '../../../workspace/workspace.service.js';
-import { WorkflowHooks } from '../../workflow-hooks.js';
+import { VersionControlHooks } from '../../version-control-hooks.js';
 import { GitService } from '../git.service.js';
-import { WorkflowValidationError, BranchNameError } from '../../../../shared/domain-errors.js';
+import { VersionControlValidationError, BranchNameError } from '../../../../shared/domain-errors.js';
 import { GitRunError, type IGitRunner } from '../../../../shared/git.contract.js';
 import { NodeGitRunner } from '../node-git-runner.js';
 
@@ -101,7 +101,7 @@ describe('GitService.diffFileBetweenBranches', () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -121,7 +121,7 @@ describe('GitService.diffFileBetweenBranches', () => {
 
   it('asks the caller\'s verdict at the two commits served, before the path is described at either', async () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
-    const svc = new GitService(stubWorkspaceService(workspaceId, workspaceDir), new WorkflowHooks(), testKbContext());
+    const svc = new GitService(stubWorkspaceService(workspaceId, workspaceDir), new VersionControlHooks(), testKbContext());
     await commitFile(repo, 'Knowledge/Foo.md', 'line one\n', 'base');
     await commitFile(repo, 'Docs/a.md', 'a\n', 'a folder');
     const base = (await execFileAsync('git', ['rev-parse', 'HEAD'], { cwd: repo })).stdout.trim();
@@ -141,7 +141,7 @@ describe('GitService.diffFileBetweenBranches', () => {
     // A folder the caller may not read is refused as unreadable, never as a folder.
     const refuse = async (s: unknown): Promise<void> => {
       asked.push(s);
-      throw new WorkflowValidationError('not yours to read');
+      throw new VersionControlValidationError('not yours to read');
     };
     await expect(svc.diffFileBetweenBranches(workspaceId, 'Docs', 'current-company-state', 'alice/edit-foo', refuse)).rejects.toThrow(/not yours to read/);
     expect(asked).toEqual([sides, sides]);
@@ -165,7 +165,7 @@ describe('GitService.diffFileBetweenBranches', () => {
         return inner.run(cwd, args, opts as never);
       },
     } as unknown as IGitRunner;
-    const svc = new GitService(stubWorkspaceService(workspaceId, workspaceDir), new WorkflowHooks(), testKbContext(), undefined, null, gitRunner);
+    const svc = new GitService(stubWorkspaceService(workspaceId, workspaceDir), new VersionControlHooks(), testKbContext(), undefined, null, gitRunner);
     const asked: unknown[] = [];
     const authorize = async (s: unknown): Promise<void> => { asked.push(s); };
     for (const f of [
@@ -186,7 +186,7 @@ describe('GitService.diffFileBetweenBranches', () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -208,7 +208,7 @@ describe('GitService.diffFileBetweenBranches', () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -230,7 +230,7 @@ describe('GitService.diffFileBetweenBranches', () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -272,7 +272,7 @@ describe('GitService.diffFileBetweenBranches', () => {
 
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -297,7 +297,7 @@ describe('GitService.diffFileBetweenBranches', () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -322,7 +322,7 @@ describe('GitService.diffFileBetweenBranches', () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -347,7 +347,7 @@ describe('GitService.diffFileBetweenBranches', () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -370,7 +370,7 @@ describe('GitService.diffFileBetweenBranches', () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -392,7 +392,7 @@ describe('GitService.diffFileBetweenBranches', () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -417,7 +417,7 @@ describe('GitService.diffFileBetweenBranches', () => {
     const { workspaceDir } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -428,7 +428,7 @@ describe('GitService.diffFileBetweenBranches', () => {
         'current-company-state',
         'current-company-state',
       ),
-    ).rejects.toBeInstanceOf(WorkflowValidationError);
+    ).rejects.toBeInstanceOf(VersionControlValidationError);
   });
 
   it('rejects an unknown branch', async () => {
@@ -436,7 +436,7 @@ describe('GitService.diffFileBetweenBranches', () => {
     await commitFile(repo, 'Knowledge/Foo.md', 'base\n', 'base');
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -447,14 +447,14 @@ describe('GitService.diffFileBetweenBranches', () => {
         'current-company-state',
         'does-not-exist',
       ),
-    ).rejects.toBeInstanceOf(WorkflowValidationError);
+    ).rejects.toBeInstanceOf(VersionControlValidationError);
   });
 
   it('rejects a path-traversal attempt', async () => {
     const { workspaceDir } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -465,14 +465,14 @@ describe('GitService.diffFileBetweenBranches', () => {
         'current-company-state',
         'target-company-state',
       ),
-    ).rejects.toBeInstanceOf(WorkflowValidationError);
+    ).rejects.toBeInstanceOf(VersionControlValidationError);
   });
 
   it('rejects a branch name with shell metacharacters', async () => {
     const { workspaceDir } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -494,7 +494,7 @@ describe('GitService.diffFileBetweenBranches', () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
     await runGit(repo, ['commit', '--allow-empty', '-m', 'init']);

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

@@ -7,10 +7,10 @@ import { GitService } from '../git.service.js';
 import {
   VersionNotOnBranchError,
   VERSION_NOT_ON_BRANCH_MESSAGE,
-  WorkflowValidationError,
+  VersionControlValidationError,
 } from '../../../../shared/domain-errors.js';
 import { GitRunError, assertOneSpecPerLine } from '../../../../shared/git.contract.js';
-import { runGit, gitOut, stubWorkflowHooks, stubWorkspaceService } from './git-test-helpers.js';
+import { runGit, gitOut, stubVersionControlHooks, stubWorkspaceService } from './git-test-helpers.js';
 
 /**
  * A past version has to come back BYTE FOR BYTE, and only for saves on the
@@ -62,7 +62,7 @@ describe('GitService.fileBytesAtCommit', () => {
 
     svc = new GitService(
       stubWorkspaceService({ [workspaceId]: workspaceDir }),
-      stubWorkflowHooks(),
+      stubVersionControlHooks(),
       testKbContext(),
     );
   });
@@ -156,13 +156,13 @@ describe('GitService.fileBytesAtCommit', () => {
       // `assertValidRelativePath` — the shared one in
       // `packages/shared/src/workspace/filename.ts`, which throws a plain
       // `Error('Invalid path: …')`, and the kb-fs one in
-      // `modules/kb-fs/branch-name.ts`, which throws `WorkflowValidationError`
+      // `modules/kb-fs/branch-name.ts`, which throws `VersionControlValidationError`
       // (status 400). `GitService` imports the kb-fs one, and the 400 is what
       // makes the route answer 400 rather than 500, so the type is asserted
       // here deliberately and the message pins which of the two ran.
       await expect(
         svc.fileBytesAtCommit(workspaceId, injected, addSha, 'after'),
-      ).rejects.toThrow(WorkflowValidationError);
+      ).rejects.toThrow(VersionControlValidationError);
       await expect(
         svc.fileBytesAtCommit(workspaceId, injected, addSha, 'after'),
       ).rejects.toThrow(/control character/);
@@ -188,7 +188,7 @@ describe('GitService.fileBytesAtCommit', () => {
   it('refuses a sha that is not a sha', async () => {
     await expect(
       svc.fileBytesAtCommit(workspaceId, 'knowledge-base/logo.png', 'HEAD', 'after'),
-    ).rejects.toThrow(WorkflowValidationError);
+    ).rejects.toThrow(VersionControlValidationError);
   });
 
   it('refuses a save that is not in this branch\'s history, and a made-up one, alike', async () => {
@@ -229,7 +229,7 @@ describe('GitService.fileBytesAtCommit', () => {
       .catch((e: unknown) => e);
     // `GitRunError` specifically, not just `Error`: the route reads the error's
     // TYPE to decide its status, so a future re-wrap into
-    // `WorkflowValidationError` would turn this into a 400 about the caller's
+    // `VersionControlValidationError` would turn this into a 400 about the caller's
     // request rather than the logged 500 a broken repository earns, and a bare
     // `toBeInstanceOf(Error)` would not notice.
     expect(err).toBeInstanceOf(GitRunError);

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

@@ -6,7 +6,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import type { WorkspaceService } from '../../../workspace/workspace.service.js';
-import { WorkflowHooks } from '../../workflow-hooks.js';
+import { VersionControlHooks } from '../../version-control-hooks.js';
 import { GitService } from '../git.service.js';
 
 const execFileAsync = promisify(execFile);
@@ -86,7 +86,7 @@ describe('GitService.fileContentsAtCommit', () => {
     const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
 
@@ -123,7 +123,7 @@ describe('GitService.fileContentsAtCommit', () => {
     const { workspaceDir } = await seedWorkspace(root, workspaceId);
     const svc = new GitService(
       stubWorkspaceService(workspaceId, workspaceDir),
-      new WorkflowHooks(),
+      new VersionControlHooks(),
       testKbContext(),
     );
     await expect(