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

package/src/modules/kb-fs/locking-filesystem.ts

@@ -49,7 +49,6 @@ import {
 } from '@mastra/core/workspace';
 import type { AuthUser, Change, IVersionControlService } from '@bevel-software/platform-shared';
 import { PushNeedsAgentResolutionError } from '../../shared/domain-errors.js';
-import type { FileChangeNotifier } from './file-change-notifier.js';
 import { isAbsence } from '../../shared/fs.contract.js';
 import { DestinationTakenError, lstatOrNull, renameNoReplace, takenError } from '../../shared/rename-no-replace.js';
 import { linkedAncestor } from '../../shared/no-link-below.js';
@@ -167,12 +166,6 @@ export interface LockingFilesystemContext {
    * when the destination is a path the validator's `appliesTo` claims.
    */
   validateWrite?: WriteValidator;
-  /**
-   * Post-commit hook for the BATCH `writeFiles` path (which commits via
-   * `commitChanges` and so skips `runPendingCommit`'s emit). Single-file ops
-   * emit through the queue instead, so they don't need this. Optional.
-   */
-  fileChanges?: FileChangeNotifier;
   /**
    * Optional creator read-grant planner (see `modules/access/creator-access`).
    * When present, a write/mkdir that starts a NEW FOLDER directly under one
@@ -601,7 +594,6 @@ export class LockingFilesystem extends GitGuardedFilesystem {
       ].sort();
       const change = await versionControl.commitChanges(workspaceId, user, summary, scope);
       await release('untouched');
-      if (change) this.lockContext.fileChanges?.emit({ workspaceId, branch, paths: scope, byUser: user });
       return change;
     } catch (err) {
       if (err instanceof PushNeedsAgentResolutionError) {
@@ -1027,16 +1019,10 @@ export class LockingFilesystem extends GitGuardedFilesystem {
     await releaseAll((p) =>
       committed.has(p) || failedSeedDiscards.has(p) ? 'discard' : 'untouched',
     );
-    // This batch path commits via `commitChanges`, NOT the per-file queue, so it
-    // skips `runPendingCommit`'s emit — fire the post-commit hook here with the
-    // WHOLE batch as one event, so an expensive subscriber (id-repair rebuilds the
-    // id index) reacts once per batch, not once per file. A no-op commit (clean
-    // tree) changed nothing, so it emits nothing.
-    if (change) {
-      // `touched` = caller paths + any creator-grant seeds that landed in the
-      // same commit — the exact set this batch may have touched.
-      this.lockContext.fileChanges?.emit({ workspaceId, branch, paths: touched, byUser: user });
-    }
+    // The commit, if one landed, was reported by the git layer as it landed
+    // (`VersionControlHooks.onCommitLanded`) with the paths it committed —
+    // `touched` plus any creator-grant seed in the same commit. Nothing to
+    // announce here.
     return change;
   }
 

package/src/modules/onboarding/__tests__/starter-pack.service.test.ts

@@ -4,8 +4,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { DEFAULT_KB_LAYOUT, type AuthUser, type IVersionControlService, type KbLayout } from '@bevel-software/platform-shared';
 import { testKbContext } from '../../../__tests__/kb-context.js';
-import { NodeFs } from '../../kb-fs/node-fs.js';
-import { WorkspaceMutex } from '../../kb-fs/mutex.js';
+import { realDisk } from '../../../__tests__/real-disk.js';
+import { WorkspaceMutex } from '../../kb-fs/index.js';
 import { KbPluginSource } from '../../plugins/index.js';
 import { CLAIM_TTL_MS, StarterPackError, StarterPackService, commitSubjectOf, summaryOf } from '../starter-pack.service.js';
 
@@ -92,8 +92,8 @@ function harness({
   const svc = new StarterPackService({
     packsDir,
     kb,
-    disk: new NodeFs(),
-    pluginSource: new KbPluginSource(new NodeFs(), kb),
+    disk: realDisk(),
+    pluginSource: new KbPluginSource(realDisk(), kb),
     pluginLocks,
     workspaceService: {
       getOrCreateForBranch: vi.fn(async () => ({ id: 'ws-main' })),

package/src/modules/onboarding/starter-pack.service.ts

@@ -66,7 +66,7 @@ import { PushNeedsAgentResolutionError, VersionControlDomainError } from '../../
 import type { KbContext } from '../../shared/kb-context.js';
 import type { IAdminAccessService } from '../admin/index.js';
 import type { IAccessControl } from '../access/index.js';
-import type { FileChangeNotifier, WorkspaceMutex } from '../kb-fs/index.js';
+import type { WorkspaceMutex } from '../kb-fs/index.js';
 import { LockingFilesystem } from '../kb-fs/index.js';
 import type { IFsProbe, ITreeWalker } from '../../shared/fs.contract.js';
 import {
@@ -146,8 +146,6 @@ export interface StarterPackServiceDeps {
   pluginLocks: PluginIdentityLocks;
   /** The SSE bus: `fs-tree-changed` sends every open tree on the branch to fetch again. */
   events?: { emit(event: { kind: 'fs-tree-changed'; workspaceId: string; branch: string }): void };
-  /** The post-commit hook catalogs refresh on — the plugin's skills appear without a restart. */
-  fileChanges?: FileChangeNotifier;
   /**
    * One choice at a time on this replica: the second of two quick clicks
    * finds the first one's answer recorded. Across replicas the recorded
@@ -434,7 +432,7 @@ export class StarterPackService implements IStarterPackService, FirstRunStarterS
       const writes = await this.plan(user, pack, files, path.join(basePath, kb.kbDirName));
       const fsys = new LockingFilesystem(
         { basePath, contained: true },
-        { versionControl, workspaceId: ws.id, branch, user, kbDirName: kb.kbDirName, fileChanges: this.deps.fileChanges },
+        { versionControl, workspaceId: ws.id, branch, user, kbDirName: kb.kbDirName },
       );
       let written: string[] = [];
       try {

package/src/modules/plugins/__tests__/plugin-rename.service.test.ts

@@ -1,13 +1,12 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { NodeFs } from '../../kb-fs/node-fs.js';
-import type { TreeWalkOptions, WalkListener, WalkResult } from '../../../shared/fs.contract.js';
+import { realDisk } from '../../../__tests__/real-disk.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
 import { DEFAULT_BRANCH, pluginDisplayNameOf, type AuthUser } from '@bevel-software/platform-shared';
 
-import type { WorkspaceService } from '../../workspace/workspace.service.js';
-import { AccessControlService } from '../../access/access-control.service.js';
+import type { WorkspaceService } from '../../workspace/index.js';
+import { realAccessControl } from '../../../__tests__/real-access.js';
 import { PushNeedsAgentResolutionError } from '../../../shared/domain-errors.js';
 import { workspaceIdForBranch } from '../../../shared/workspace-id.js';
 import { KbPluginSource } from '../discovery/kb-plugin-source.js';
@@ -16,22 +15,22 @@ import { testKbContext } from '../../../__tests__/kb-context.js';
 
 // The one walk of the checkout, with a switch that makes it report a hole —
 // the way a folder it cannot list would — to every listener on it. The
-// walk is injected, so the switch is a disk that lies, not a module mock.
+// walk is injected, so the switch is a disk that lies, not a module mock:
+// the real disk the shared fixture hands out, its walk wrapped.
 const walkMock = { holeInTheWalk: false };
-class HoledFs extends NodeFs {
-  override async walkKb(
-    root: string,
-    listeners: readonly WalkListener[],
-    options?: Omit<TreeWalkOptions, 'skip'>,
-  ): Promise<WalkResult> {
-    const result = await super.walkKb(root, listeners, options);
+function holedDisk(): ReturnType<typeof realDisk> {
+  const disk = realDisk();
+  const walkKb = disk.walkKb.bind(disk);
+  disk.walkKb = async (root, listeners, options) => {
+    const result = await walkKb(root, listeners, options);
     if (walkMock.holeInTheWalk) {
       const err = Object.assign(new Error('EACCES: permission denied'), { code: 'EACCES' });
       for (const l of listeners) await l.onHole?.('KnowledgeBase/Notes', err);
       result.holes.push('KnowledgeBase/Notes');
     }
     return result;
-  }
+  };
+  return disk;
 }
 
 /**
@@ -58,15 +57,19 @@ describe('PluginRenameService', () => {
   let repo: string;
   let commits: { summary: string; paths: string[] }[];
   let failNextCommit: Error | null;
+  /** What each workspace-relative path last read as when it was committed — the driver's picture of the tree. */
+  let committed: Map<string, string>;
   let failWriteMatching: string | null;
   let invalidated: number;
-  let access: AccessControlService;
+  let access: ReturnType<typeof realAccessControl>;
   let svc: PluginRenameService;
 
+  // A seed is a committed file: what origin has before the rename runs.
   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);
+    committed.set(`${KB_DIR}/${rel}`, text);
   };
   const read = (rel: string) => fs.readFile(path.join(repo, rel), 'utf-8');
   const manifest = async () => JSON.parse(await read('Plugins/GTM/plugin.json'));
@@ -77,6 +80,7 @@ describe('PluginRenameService', () => {
     commits = [];
     failNextCommit = null;
     failWriteMatching = null;
+    committed = new Map();
     walkMock.holeInTheWalk = false;
     invalidated = 0;
     const workspaceService = {
@@ -101,7 +105,19 @@ describe('PluginRenameService', () => {
           failNextCommit = null;
           throw err;
         }
+        // Git's rule: a tree whose files all read as they were last committed
+        // has nothing to commit, and the service is answered null.
+        let changed = false;
+        for (const p of paths) {
+          const now = await fs.readFile(path.join(root, wsId, p), 'utf-8');
+          if (now !== committed.get(p)) {
+            changed = true;
+            committed.set(p, now);
+          }
+        }
+        if (!changed) return null;
         commits.push({ summary, paths });
+        return { sha: 'c0ffee' } as never;
       },
     };
 
@@ -114,8 +130,8 @@ describe('PluginRenameService', () => {
     await write('Skills/Eng/deploy/access.md', DEPLOY_RULES);
     await write('Skills/Eng/deploy/SKILL.md', '---\ndescription: Ship it.\n---\n');
 
-    access = new AccessControlService(workspaceService, KB_DIR, new NodeFs());
-    const disk = new HoledFs();
+    access = realAccessControl(workspaceService, KB_DIR, realDisk());
+    const disk = holedDisk();
     svc = new PluginRenameService(workspaceService, driver, access, new KbPluginSource(disk, testKbContext({ kbDirName: KB_DIR })), disk, testKbContext({ kbDirName: KB_DIR }), undefined, () => {
       invalidated += 1;
     });
@@ -125,7 +141,7 @@ describe('PluginRenameService', () => {
   it('refuses to claim a name against a listing with a hole in it — an unreadable folder may hold that very plugin', async () => {
     // Discovery as the walker reports it when a folder exists but could not
     // be read: the plugins it did see, plus the hole.
-    const real = new KbPluginSource(new NodeFs(), testKbContext({ kbDirName: KB_DIR }));
+    const real = new KbPluginSource(realDisk(), testKbContext({ kbDirName: KB_DIR }));
     const holed = {
       dialect: 'kb',
       discover: async (root: string) => ({ ...(await real.discover(root)), unreadable: ['Plugins/Hidden'] }),
@@ -135,7 +151,7 @@ describe('PluginRenameService', () => {
       { commitChanges: async () => { throw new Error('must not commit'); } },
       access,
       holed,
-      new NodeFs(),
+      realDisk(),
       testKbContext({ kbDirName: KB_DIR }),
     );
     await expect(svcOverHole.rename(manager, 'gtm', { name: 'go-to-market' })).rejects.toMatchObject({
@@ -156,7 +172,7 @@ describe('PluginRenameService', () => {
   });
 
   it('tells a NON-manager nothing about the tree — a holed discovery is still just "unknown plugin" to them', async () => {
-    const real = new KbPluginSource(new NodeFs(), testKbContext({ kbDirName: KB_DIR }));
+    const real = new KbPluginSource(realDisk(), testKbContext({ kbDirName: KB_DIR }));
     const holed = {
       dialect: 'kb',
       discover: async (root: string) => ({ ...(await real.discover(root)), unreadable: ['Plugins/Hidden'] }),
@@ -166,7 +182,7 @@ describe('PluginRenameService', () => {
       { commitChanges: async () => { throw new Error('must not commit'); } },
       access,
       holed,
-      new NodeFs(),
+      realDisk(),
       testKbContext({ kbDirName: KB_DIR }),
     );
     const refusal = await svcOverHole.rename(member, 'gtm', { name: 'go-to-market' }).catch((e: unknown) => e);
@@ -270,7 +286,7 @@ describe('PluginRenameService', () => {
       expect(await read('Skills/Eng/deploy/access.md')).toBe(DEPLOY_RULES);
       // The three answers that must never diverge: the rename's, the
       // discovery source's, and the shared reader's over the file itself.
-      const { plugins } = await new KbPluginSource(new NodeFs(), testKbContext({ kbDirName: KB_DIR })).discover(repo);
+      const { plugins } = await new KbPluginSource(realDisk(), testKbContext({ kbDirName: KB_DIR })).discover(repo);
       const found = plugins.find((p) => p.folder === 'Plugins/GTM')!;
       expect([found.name, found.displayName]).toEqual([result.name, result.displayName]);
       expect(pluginDisplayNameOf(JSON.parse(await read('Plugins/GTM/plugin.json')))).toBe(result.displayName);
@@ -413,6 +429,15 @@ describe('PluginRenameService', () => {
     expect(await access.canRead(wsId, member.email, 'Skills/Eng/deploy/SKILL.md')).toBe(true);
   });
 
+  it('changes no bytes when the manifest already reads as the rename writes it — a clean tree, nothing to commit', async () => {
+    // The manifest already reads exactly as the rename will write it.
+    const asWritten = `${JSON.stringify({ name: 'gtm', version: '1.0.0', displayName: 'GTM' }, null, 2)}\n`;
+    await write('Plugins/GTM/plugin.json', asWritten);
+    await svc.rename(manager, 'gtm', { displayName: 'GTM' });
+    expect(await read('Plugins/GTM/plugin.json')).toBe(asWritten);
+    expect(commits).toEqual([]);
+  });
+
   it('will not rename a plugin read from an external format — that repository owns its name', async () => {
     await write('Plugins/Ext/plugin.bundle.json', '{"name":"ext"}');
     await write('Plugins/Ext/access.md', GTM_RULES);

package/src/modules/plugins/__tests__/plugins.routes.test.ts

@@ -5,16 +5,16 @@ import path from 'node:path';
 import os from 'node:os';
 import express from 'express';
 import { describe, it, expect, afterEach, vi } from 'vitest';
-import { NodeFs } from '../../kb-fs/node-fs.js';
+import { realDisk } from '../../../__tests__/real-disk.js';
 import { KbPluginSource } from '../discovery/kb-plugin-source.js';
 
 import { DEFAULT_BRANCH, joinBranchFor } from '@bevel-software/platform-shared';
 import type { ChangeRequest, IVersionControlService } from '@bevel-software/platform-shared';
 import { workspaceIdForBranch } from '../../../shared/workspace-id.js';
-import type { WorkspaceService } from '../../workspace/workspace.service.js';
-import type { IAccessControl } from '../../access/access-control.interface.js';
-import type { ISkillService, SkillSummary } from '../../skills/skills.contract.js';
-import type { IToolManualService, ToolManualSummary } from '../../tool-manuals/tool-manuals.contract.js';
+import type { WorkspaceService } from '../../workspace/index.js';
+import type { IAccessControl } from '../../access/index.js';
+import type { ISkillService, SkillSummary } from '../../skills/index.js';
+import type { IToolManualService, ToolManualSummary } from '../../tool-manuals/index.js';
 import { PluginIndexService } from '../plugins.service.js';
 import { createPluginCreationRoutes, createPluginsRoutes } from '../plugins.routes.js';
 import type { JoinRequestsService } from '../join-requests.service.js';
@@ -162,7 +162,7 @@ async function makeHarness(opts: HarnessOpts = {}) {
       skillService,
       toolService,
       testKbContext({ kbDirName: KB }),
-      new KbPluginSource(new NodeFs(), testKbContext({ kbDirName: KB })),
+      new KbPluginSource(realDisk(), testKbContext({ kbDirName: KB })),
     );
 
   const email = opts.email === undefined ? ALI : opts.email;

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

@@ -11,8 +11,8 @@ import type {
 import type { GitService } from '../git/git.service.js';
 import type { PullRequestService } from '../git/pull-request.service.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 { WorkspaceService } from '../../workspace/index.js';
+import type { IAccessControl } from '../../access/index.js';
 import { FileLockService } from '../file-lock.service.js';
 import { PendingCommitsService, type PendingCommit } from '../pending-commits.service.js';
 import { PendingCommitsWorker } from '../pending-commits.worker.js';
@@ -28,7 +28,7 @@ import {
 } from '../../../shared/domain-errors.js';
 import type { VersionControlEventBus } from '../event-bus.js';
 import { DEFAULT_BRANCH } from '@bevel-software/platform-shared';
-import type { Database } from '../../database/connection.js';
+import type { Database } from '../../database/index.js';
 import { openChangeGate } from '../../../__tests__/open-change-gate.js';
 import { ReadOnBranchDeniedError } from '../read-on-branch.js';
 import { hashEmail } from '../../../shared/email-identity.js';
@@ -1801,7 +1801,7 @@ describe('VersionControlService.openChangeRequest — tells the change-request l
     const svc = new VersionControlService(
       db, git, prs, makeChangeRequestReview(), workspaces, access,
       makeFileLockService(), makePendingCommits(), testKbContext(), openChangeGate(),
-      { emit: vi.fn() } as unknown as VersionControlEventBus, undefined, undefined, hooks, accounts,
+      { emit: vi.fn() } as unknown as VersionControlEventBus, undefined, hooks, accounts,
     );
     return { svc, run, prs, access, accounts, values };
   }

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

@@ -4,14 +4,14 @@ 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 { 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 { 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 { 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,
@@ -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,11 +137,11 @@ 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(
@@ -642,18 +657,15 @@ describe('VersionControlService — 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('VersionControlService — 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('VersionControlService — 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(