@bevel-software/platform-core-backend 0.29.0 → 0.30.0

package/src/modules/workspace/__tests__/workspace.routes.folders.test.ts

@@ -16,6 +16,7 @@ import type { ICreatorAccess } from '../../access-model/creator.js';
 import { createWorkspaceRoutes } from '../workspace.routes.js';
 import { WorkspaceService } from '../workspace.service.js';
 import { workspaceIdForBranch } from '../../../shared/workspace-id.js';
+import { newWorkspaceService } from '../../../__tests__/workspace-service.js';
 
 /**
  * A folder exists until someone deletes it, and its placeholder is never shown
@@ -56,7 +57,7 @@ async function makeHarness(): Promise<Harness> {
   const workspaceDir = path.join(root, workspaceId);
   // The inner `.git` lets the service accept the workspace without cloning.
   await fs.mkdir(path.join(workspaceDir, KB, '.git'), { recursive: true });
-  const workspaceService = new WorkspaceService(root, 'https://example.invalid/kb.git', testKbContext({ kbDirName: KB }), new NodeFs());
+  const workspaceService = newWorkspaceService(root, 'https://example.invalid/kb.git', testKbContext({ kbDirName: KB }), new NodeFs());
   await workspaceService.getWorkspacePath(workspaceId);
 
   const releaseLock = vi.fn<(...args: unknown[]) => Promise<never>>(async () => undefined as never);
@@ -335,7 +336,7 @@ describe('WorkspaceService.writeFolderPlaceholder', () => {
     const workspaceId = workspaceIdForBranch('placeholders');
     const kbDir = path.join(root, workspaceId, KB);
     await fs.mkdir(path.join(kbDir, '.git'), { recursive: true });
-    return { svc: new WorkspaceService(root, 'https://example.invalid/kb.git', testKbContext({ kbDirName: KB }), new NodeFs()), workspaceId, kbDir };
+    return { svc: newWorkspaceService(root, 'https://example.invalid/kb.git', testKbContext({ kbDirName: KB }), new NodeFs()), workspaceId, kbDir };
   }
 
   it('writes into an empty folder, and leaves a full or a vanished one alone', async () => {
@@ -378,7 +379,7 @@ describe('WorkspaceService.withFolderTurn', () => {
     root = await fs.mkdtemp(path.join(os.tmpdir(), 'folder-turn-'));
     const workspaceId = workspaceIdForBranch('turns');
     await fs.mkdir(path.join(root, workspaceId, KB, '.git'), { recursive: true });
-    const svc = new WorkspaceService(root, 'https://example.invalid/kb.git', testKbContext({ kbDirName: KB }), new NodeFs());
+    const svc = newWorkspaceService(root, 'https://example.invalid/kb.git', testKbContext({ kbDirName: KB }), new NodeFs());
 
     const events: string[] = [];
     let open!: () => void;

package/src/modules/workspace/__tests__/workspace.service.any-workspace-credentials.test.ts

@@ -6,9 +6,9 @@ import path from 'node:path';
 import os from 'node:os';
 import { testKbContext } from '../../../__tests__/kb-context.js';
 import { NodeFs } from '../../kb-fs/node-fs.js';
-import { WorkspaceService } from '../workspace.service.js';
 import { NodeGitRunner } from '../../workflow/git/node-git-runner.js';
 import { gitCredentials } from '../../../shared/git.contract.js';
+import { newWorkspaceService } from '../../../__tests__/workspace-service.js';
 
 const execFileAsync = promisify(execFile);
 
@@ -87,7 +87,7 @@ async function anOldCloneWithNoHelper(branch: string): Promise<string> {
 }
 
 function service(token: string | null) {
-  return new WorkspaceService(
+  return newWorkspaceService(
     workspacesRoot,
     () => upstream,
     testKbContext({ kbDirName: KB_DIR, branchModel: { defaultBranch: BRANCH, protectedBranches: [BRANCH] } }),

package/src/modules/workspace/__tests__/workspace.service.ensure-remotes-fetched.test.ts

@@ -4,8 +4,8 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import { NodeFs } from '../../kb-fs/node-fs.js';
-import { WorkspaceService } from '../workspace.service.js';
 import type { IGitRunner } from '../../../shared/git.contract.js';
+import { newWorkspaceService } from '../../../__tests__/workspace-service.js';
 
 /**
  * `ensureRemotesFetched` is one `git fetch --prune origin` for a whole clone,
@@ -42,7 +42,7 @@ describe('WorkspaceService.ensureRemotesFetched', () => {
   });
 
   const service = () =>
-    new WorkspaceService(
+    newWorkspaceService(
       root,
       'https://example.test/kb.git',
       testKbContext(),

package/src/modules/workspace/__tests__/workspace.service.forget-clone-races.test.ts

@@ -4,8 +4,8 @@ import path from 'node:path';
 import os from 'node:os';
 import { testKbContext } from '../../../__tests__/kb-context.js';
 import { NodeFs } from '../../kb-fs/node-fs.js';
-import { WorkspaceService } from '../workspace.service.js';
 import type { IGitRunner } from '../../../shared/git.contract.js';
+import { newWorkspaceService } from '../../../__tests__/workspace-service.js';
 
 /**
  * What happens to work ALREADY IN FLIGHT when the knowledge-base repository is
@@ -56,7 +56,7 @@ function heldRunner() {
 }
 
 function service(runner: IGitRunner) {
-  return new WorkspaceService(
+  return newWorkspaceService(
     workspacesRoot,
     () => `${root}/configured.git`,
     testKbContext({ branchModel: { defaultBranch: BRANCH, protectedBranches: [BRANCH] } }),
@@ -138,12 +138,19 @@ describe('a bootstrap in flight when the working copy is taken away', () => {
 
     // The replacement lands while the clone runs.
     svc.forgetClone(WORKSPACE_ID);
-    // Let the clone — and every config call after it — finish.
-    for (let i = 0; i < 40 && calls.length > 0; i++) {
+    // Let the checkout — and every git call after it — finish. Until the open
+    // has settled, not until no call is pending for a moment: making the
+    // repository does filesystem work between its git calls.
+    let settled = false;
+    void opening.then(
+      () => (settled = true),
+      () => (settled = true),
+    );
+    for (let i = 0; i < 400 && !settled; i++) {
       const pending = calls.splice(0, calls.length);
       for (const call of pending) call.settle();
       await Promise.resolve();
-      await new Promise((r) => setTimeout(r, 0));
+      await new Promise((r) => setTimeout(r, 5));
     }
 
     await refused;

package/src/modules/workspace/__tests__/workspace.service.list-cloned.test.ts

@@ -4,7 +4,7 @@ import { NodeFs } from '../../kb-fs/node-fs.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
-import { WorkspaceService } from '../workspace.service.js';
+import { newWorkspaceService } from '../../../__tests__/workspace-service.js';
 
 /**
  * `listClonedWorkspaces` is what the remote sync enumerates. It must read the
@@ -37,7 +37,7 @@ describe('WorkspaceService.listClonedWorkspaces', () => {
     // A stray file at the root is ignored.
     await fs.writeFile(path.join(root, 'notes.txt'), 'x');
 
-    const svc = new WorkspaceService(root, 'https://example.test/kb.git', testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(root, 'https://example.test/kb.git', testKbContext(), new NodeFs());
     const found = await svc.listClonedWorkspaces();
     expect(found.sort((a, b) => a.branch.localeCompare(b.branch))).toEqual([
       { id: 'ali%2Fnew-skill', branch: 'ali/new-skill' },
@@ -46,7 +46,7 @@ describe('WorkspaceService.listClonedWorkspaces', () => {
   });
 
   it('is empty when the workspaces root does not exist yet', async () => {
-    const svc = new WorkspaceService(path.join(root, 'missing'), 'https://example.test/kb.git', testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(path.join(root, 'missing'), 'https://example.test/kb.git', testKbContext(), new NodeFs());
     expect(await svc.listClonedWorkspaces()).toEqual([]);
   });
 });
@@ -67,14 +67,14 @@ describe('WorkspaceService.listClonedWorkspaces — what is not a clone', () =>
     for (const name of ['main', 'foo!', '-leading-dash', 'a..b', 'has space']) {
       await fs.mkdir(path.join(root, name, 'knowledge-base', '.git'), { recursive: true });
     }
-    const svc = new WorkspaceService(root, 'https://example.test/kb.git', testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(root, 'https://example.test/kb.git', testKbContext(), new NodeFs());
     expect(await svc.listClonedWorkspaces()).toEqual([{ id: 'main', branch: 'main' }]);
   });
 
   it('a branch whose bootstrap is in flight right now', async () => {
     await fs.mkdir(path.join(root, 'main', 'knowledge-base', '.git'), { recursive: true });
     await fs.mkdir(path.join(root, 'ali%2Fx', 'knowledge-base', '.git'), { recursive: true });
-    const svc = new WorkspaceService(root, 'https://example.test/kb.git', testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(root, 'https://example.test/kb.git', testKbContext(), new NodeFs());
     // While a clone runs, `.git` exists but the tree is not checked out yet.
     // The listing asks the public predicate, which is stubbed here rather than
     // the tracker behind it — no public seam can hold a real clone open.
@@ -89,7 +89,7 @@ describe('WorkspaceService.listClonedWorkspaces — what is not a clone', () =>
     // to stage one in a temp dir; the code path is the same `throw err`.
     const file = path.join(root, 'not-a-dir');
     await fs.writeFile(file, 'x');
-    const svc = new WorkspaceService(file, 'https://example.test/kb.git', testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(file, 'https://example.test/kb.git', testKbContext(), new NodeFs());
     expect(await svc.listClonedWorkspaces()).toEqual([]);
   });
 });

package/src/modules/workspace/__tests__/workspace.service.move-never-overwrites.test.ts

@@ -6,6 +6,7 @@ import os from 'node:os';
 import { NodeFs } from '../../kb-fs/node-fs.js';
 import { WorkspaceService } from '../workspace.service.js';
 import { workspaceIdForBranch } from '../../../shared/workspace-id.js';
+import { newWorkspaceService } from '../../../__tests__/workspace-service.js';
 
 /**
  * A rename never overwrites.
@@ -55,7 +56,7 @@ describe('WorkspaceService.moveEntry — a name that is taken is refused, never
     // The inner `.git` is what lets `resolveWorkspaceDir` accept the workspace
     // without trying to clone.
     await fs.mkdir(path.join(workspaceDir, KB, '.git'), { recursive: true });
-    svc = new WorkspaceService(
+    svc = newWorkspaceService(
       root,
       'https://github.com/Bevel-Software/knowledge-base.git',
       testKbContext({ kbDirName: KB }),

package/src/modules/workspace/__tests__/workspace.service.read-filter.test.ts

@@ -6,6 +6,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { WorkspaceService, type ReadTreeFilter } from '../workspace.service.js';
 import { workspaceIdForBranch } from '../../../shared/workspace-id.js';
+import { newWorkspaceService } from '../../../__tests__/workspace-service.js';
 
 const KB = 'knowledge-base';
 
@@ -48,7 +49,7 @@ describe('WorkspaceService.listFiles — read filter', () => {
     // readers, say), and its files are readable.
     await mkFile(workspaceDir, 'Scopes/Deploy/SKILL.md');
     await mkFile(workspaceDir, 'Scopes/other.md');
-    svc = new WorkspaceService(root, 'https://example.invalid/repo.git', testKbContext({ kbDirName: KB }), new NodeFs());
+    svc = newWorkspaceService(root, 'https://example.invalid/repo.git', testKbContext({ kbDirName: KB }), new NodeFs());
     await svc.getWorkspacePath(workspaceId);
   });
 

package/src/modules/workspace/__tests__/workspace.service.replaced-repository.test.ts

@@ -8,6 +8,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { WorkspaceService } from '../workspace.service.js';
 import { NodeGitRunner } from '../../workflow/git/node-git-runner.js';
+import { newWorkspaceService } from '../../../__tests__/workspace-service.js';
 
 const execFileAsync = promisify(execFile);
 
@@ -77,7 +78,7 @@ function service(
   aroundSetAside?: (workspaceId: string, move: () => Promise<void>) => Promise<void>,
   gitRunner: NodeGitRunner = new NodeGitRunner(),
 ) {
-  return new WorkspaceService(
+  return newWorkspaceService(
     workspacesRoot,
     kbRepoUrl,
     testKbContext({ branchModel: { defaultBranch: BRANCH, protectedBranches: [BRANCH] } }),

package/src/modules/workspace/__tests__/workspace.service.test.ts

@@ -8,6 +8,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { WorkspaceService } from '../workspace.service.js';
 import { workspaceIdForBranch } from '../../../shared/workspace-id.js';
+import { newWorkspaceService } from '../../../__tests__/workspace-service.js';
 
 const execFileAsync = promisify(execFile);
 
@@ -66,7 +67,7 @@ describe('WorkspaceService — branch-keyed identity', () => {
   });
 
   it('a malformed workspace id (bad percent-escape) rejects as a 400 BranchNameError, not a 500', async () => {
-    const svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
     // `%zz` fails decodeURIComponent, falls back to itself, and `%` never
     // passes the branch-name rules — the cold-path bootstrap must surface
     // that as the status-carrying domain error, not a wrapped plain Error.
@@ -78,7 +79,7 @@ describe('WorkspaceService — branch-keyed identity', () => {
 
   it('returns workspace info derived from the branch — no .workspace.json on disk', async () => {
     const { workspaceId, workspaceDir } = await seedBranchWorkspace(root, 'target-company-state');
-    const svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
     const info = await svc.getOrCreateForBranch('target-company-state');
 
     expect(info.id).toBe(workspaceId);
@@ -91,7 +92,7 @@ describe('WorkspaceService — branch-keyed identity', () => {
   it('two branches map to distinct directories', async () => {
     const a = await seedBranchWorkspace(root, 'target-company-state');
     const b = await seedBranchWorkspace(root, 'alice/feature');
-    const svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
 
     const infoA = await svc.getOrCreateForBranch('target-company-state');
     const infoB = await svc.getOrCreateForBranch('alice/feature');
@@ -114,7 +115,7 @@ describe('WorkspaceService — branch-keyed identity', () => {
     const squatter = path.join(workspaceDir, 'knowledge-base');
     await fs.writeFile(squatter, 'not a clone', 'utf8');
 
-    const svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
     await expect(svc.getOrCreateForBranch('target-company-state')).rejects.toThrow(
       /"knowledge-base" in this workspace exists but is not a directory/,
     );
@@ -122,21 +123,21 @@ describe('WorkspaceService — branch-keyed identity', () => {
   });
 
   it('rejects invalid branch names before touching disk', async () => {
-    const svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
     await expect(svc.getOrCreateForBranch('')).rejects.toThrow();
     await expect(svc.getOrCreateForBranch('-bad-leading-dash')).rejects.toThrow();
   });
 
   it('getOrCreateForUser falls back to target-company-state when no branch is supplied', async () => {
     await seedBranchWorkspace(root, 'target-company-state');
-    const svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
     const info = await svc.getOrCreateForUser({ id: 'u', email: 'a@b.c', name: 'A' });
     expect(info.id).toBe(workspaceIdForBranch('target-company-state'));
   });
 
   it('getOrCreateForUser respects an explicit branch override', async () => {
     await seedBranchWorkspace(root, 'alice/feature');
-    const svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
     const info = await svc.getOrCreateForUser({ id: 'u', email: 'a@b.c', name: 'A' }, 'alice/feature');
     expect(info.id).toBe(workspaceIdForBranch('alice/feature'));
   });
@@ -156,7 +157,7 @@ describe('WorkspaceService.createDirectory', () => {
     workspaceDir = seeded.workspaceDir;
     repoDir = path.join(workspaceDir, 'knowledge-base');
     workspaceId = seeded.workspaceId;
-    svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
     // Hydrate the in-memory map so subsequent ops resolve fast.
     await svc.getWorkspacePath(workspaceId);
   });
@@ -267,7 +268,7 @@ describe('WorkspaceService.writeFile — expectedContent', () => {
     const seeded = await seedBranchWorkspace(root, 'target-company-state');
     workspaceDir = seeded.workspaceDir;
     workspaceId = seeded.workspaceId;
-    svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
   });
 
   afterEach(async () => {
@@ -408,7 +409,7 @@ describe('WorkspaceService.withPathTurn', () => {
     const seeded = await seedBranchWorkspace(root, 'target-company-state');
     workspaceDir = seeded.workspaceDir;
     workspaceId = seeded.workspaceId;
-    svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
   });
 
   afterEach(async () => {
@@ -636,7 +637,7 @@ describe('WorkspaceService.assertContentMatches', () => {
     const seeded = await seedBranchWorkspace(root, 'target-company-state');
     workspaceDir = seeded.workspaceDir;
     workspaceId = seeded.workspaceId;
-    svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
   });
 
   afterEach(async () => {
@@ -681,7 +682,7 @@ describe('WorkspaceService.createFolderZip', () => {
     workspaceDir = seeded.workspaceDir;
     repoDir = path.join(workspaceDir, 'knowledge-base');
     workspaceId = seeded.workspaceId;
-    svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
     await svc.getWorkspacePath(workspaceId);
   });
 
@@ -879,7 +880,7 @@ describe('WorkspaceService — clone bootstrap & sibling reference', () => {
   });
 
   it('clones a branch on first bootstrap and checks out the right ref', async () => {
-    const svc = new WorkspaceService(workspacesRoot, upstream, testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(workspacesRoot, upstream, testKbContext(), new NodeFs());
     const info = await svc.getOrCreateForBranch('target-company-state');
 
     const repo = path.join(info.absolutePath, 'knowledge-base');
@@ -888,7 +889,7 @@ describe('WorkspaceService — clone bootstrap & sibling reference', () => {
   });
 
   it('uses an existing sibling clone as a --reference and stays dissociated', async () => {
-    const svc = new WorkspaceService(workspacesRoot, upstream, testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(workspacesRoot, upstream, testKbContext(), new NodeFs());
     // First branch: plain clone — becomes the sibling for the next bootstrap.
     await svc.getOrCreateForBranch('target-company-state');
     // Second branch: should borrow the first clone's objects, then dissociate.
@@ -916,7 +917,7 @@ describe('WorkspaceService — clone bootstrap & sibling reference', () => {
   // post-merge pull of a target branch. Every clone this service hands out must
   // therefore track exactly one upstream ref through exactly one refspec.
   it('stamps a single fetch refspec and upstream ref on a fresh clone', async () => {
-    const svc = new WorkspaceService(workspacesRoot, upstream, testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(workspacesRoot, upstream, testKbContext(), new NodeFs());
     const info = await svc.getOrCreateForBranch('target-company-state');
     const repo = path.join(info.absolutePath, 'knowledge-base');
 
@@ -940,7 +941,7 @@ describe('WorkspaceService — clone bootstrap & sibling reference', () => {
     await runGit(repo, ['config', '--add', 'remote.origin.fetch', '+refs/heads/*:refs/remotes/origin/*']);
     await runGit(repo, ['config', '--add', 'branch.alice/draft.merge', 'refs/heads/target-company-state']);
 
-    const svc = new WorkspaceService(workspacesRoot, upstream, testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(workspacesRoot, upstream, testKbContext(), new NodeFs());
     await svc.getOrCreateForBranch('alice/draft');
 
     expect(await gitOut(repo, ['config', '--get-all', 'remote.origin.fetch']))
@@ -952,7 +953,7 @@ describe('WorkspaceService — clone bootstrap & sibling reference', () => {
   });
 
   it('notifies the cloned-workspace listener with the workspace id after a clone', async () => {
-    const svc = new WorkspaceService(workspacesRoot, upstream, testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(workspacesRoot, upstream, testKbContext(), new NodeFs());
     const cloned: string[] = [];
     svc.setWorkspaceClonedListener((id) => cloned.push(id));
 
@@ -980,7 +981,7 @@ describe('WorkspaceService — symbolic links', () => {
     const seeded = await seedBranchWorkspace(root, 'main');
     workspaceDir = seeded.workspaceDir;
     workspaceId = seeded.workspaceId;
-    svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
   });
 
   afterEach(async () => {
@@ -1065,7 +1066,7 @@ describe('WorkspaceService — symbolic links', () => {
     // A mounted-volume shape: the whole workspaces root reached through a link.
     const mount = path.join(root, 'mount');
     await fs.symlink(root, mount, linkType);
-    const viaMount = new WorkspaceService(mount, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    const viaMount = newWorkspaceService(mount, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
     expect(await viaMount.readFile(workspaceId, rel)).toBe('Hello.');
     await viaMount.writeFile(workspaceId, rel, 'Hello again.');
     expect(await fs.readFile(path.join(workspaceDir, rel), 'utf-8')).toBe('Hello again.');
@@ -1098,7 +1099,7 @@ describe('WorkspaceService.sweepOrphanedWorkspaces', () => {
 
   it('removes the clone of a branch that is not in the known set', async () => {
     const { workspaceId, workspaceDir } = await seedBranchWorkspace(root, 'target-company-state');
-    const svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    const svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
     await svc.getOrCreateForBranch('target-company-state');
 
     // The branch vanishes from the known set; the sweep reclaims its clone.
@@ -1119,7 +1120,7 @@ describe('WorkspaceService.readAllKbFiles', () => {
     const seeded = await seedBranchWorkspace(root, 'target-company-state');
     repoRoot = path.join(seeded.workspaceDir, 'knowledge-base');
     workspaceId = seeded.workspaceId;
-    svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
     await svc.getWorkspacePath(workspaceId);
   });
 
@@ -1178,7 +1179,7 @@ describe('WorkspaceService.unzipFile — per-entry write guard', () => {
     workspaceDir = seeded.workspaceDir;
     repoDir = path.join(workspaceDir, 'knowledge-base');
     workspaceId = seeded.workspaceId;
-    svc = new WorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
+    svc = newWorkspaceService(root, 'https://github.com/Bevel-Software/knowledge-base.git', testKbContext(), new NodeFs());
     await svc.getWorkspacePath(workspaceId);
   });
 
@@ -1389,7 +1390,7 @@ describe('WorkspaceService — every operation resolves inside the repository',
     workspaceDir = seeded.workspaceDir;
     repoDir = path.join(workspaceDir, 'knowledge-base');
     workspaceId = seeded.workspaceId;
-    svc = new WorkspaceService(root, 'https://example.invalid/kb.git', testKbContext(), new NodeFs());
+    svc = newWorkspaceService(root, 'https://example.invalid/kb.git', testKbContext(), new NodeFs());
     await svc.getWorkspacePath(workspaceId);
   });
 

package/src/modules/workspace/__tests__/workspace.service.unknown-branch.test.ts

@@ -8,6 +8,7 @@ import os from 'node:os';
 import { NodeFs } from '../../kb-fs/node-fs.js';
 import { WorkspaceService } from '../workspace.service.js';
 import { workspaceIdForBranch } from '../../../shared/workspace-id.js';
+import { newWorkspaceService } from '../../../__tests__/workspace-service.js';
 
 const execFileAsync = promisify(execFile);
 
@@ -64,7 +65,7 @@ describe('WorkspaceService — a branch origin does not have', () => {
   const deleteOnHost = (branch: string): Promise<void> => runGit(upstream, ['branch', '-D', branch]);
 
   const service = (repoUrl = upstream): WorkspaceService =>
-    new WorkspaceService(workspacesRoot, repoUrl, testKbContext(), new NodeFs());
+    newWorkspaceService(workspacesRoot, repoUrl, testKbContext(), new NodeFs());
 
   it('a name nothing has ever cloned or listed is a 404 that names only the branch', async () => {
     const svc = service();