@bevel-software/platform-core-backend 0.1.0

package/src/modules/workflow/git/__tests__/git.service.mergeChangeRequest.test.ts

@@ -0,0 +1,145 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs/promises';
+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 { GitService } from '../git.service.js';
+
+const execFileAsync = promisify(execFile);
+const BASE = 'current-company-state';
+const USER: AuthUser = { id: 'u1', email: 'alice@example.com', name: 'Alice' };
+
+async function runGit(cwd: string, args: string[]): Promise<void> {
+  await execFileAsync('git', args, {
+    cwd,
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: 'Seed', GIT_AUTHOR_EMAIL: 's@x.com',
+      GIT_COMMITTER_NAME: 'Seed', GIT_COMMITTER_EMAIL: 's@x.com',
+    },
+  });
+}
+async function gitOut(cwd: string, args: string[]): Promise<string> {
+  const { stdout } = await execFileAsync('git', args, { cwd });
+  return stdout.toString();
+}
+
+function stubWorkspaceService(baseWsId: string, baseRepo: string): WorkspaceService {
+  return {
+    getWorkspacePath: async (id: string) => {
+      if (id !== baseWsId) throw new Error(`unexpected workspace ${id}`);
+      return path.dirname(baseRepo);
+    },
+  } as unknown as WorkspaceService;
+}
+
+/**
+ * Bare upstream seeded on BASE with `files`, plus a base-branch workspace clone
+ * laid out like prod (`<root>/<wsId>/knowledge-base`). Returns handles for
+ * building feature branches and inspecting the merged remote.
+ */
+async function seed(root: string, baseFiles: Record<string, string>) {
+  const upstream = path.join(root, 'upstream.git');
+  await runGit(root, ['init', '--bare', '-b', BASE, upstream]);
+  const seedDir = path.join(root, '.seed');
+  await fs.mkdir(seedDir);
+  await runGit(seedDir, ['init', '-b', BASE]);
+  await runGit(seedDir, ['remote', 'add', 'origin', upstream]);
+  for (const [name, content] of Object.entries(baseFiles)) {
+    await fs.writeFile(path.join(seedDir, name), content);
+  }
+  await runGit(seedDir, ['add', '-A']);
+  await runGit(seedDir, ['commit', '-m', 'base']);
+  await runGit(seedDir, ['push', 'origin', BASE]);
+
+  const baseWsId = BASE;
+  const baseRepo = path.join(root, baseWsId, 'knowledge-base');
+  await fs.mkdir(path.join(root, baseWsId), { recursive: true });
+  await runGit(root, ['clone', '-b', BASE, upstream, baseRepo]);
+  return { upstream, seedDir, baseWsId, baseRepo };
+}
+
+/** Branch `name` off origin/BASE in a throwaway clone, apply `mutate`, push. */
+async function pushFeatureBranch(
+  root: string,
+  upstream: string,
+  name: string,
+  mutate: (dir: string) => Promise<void>,
+) {
+  const dir = path.join(root, `feat-${name.replace(/\W/g, '_')}`);
+  await runGit(root, ['clone', '-b', BASE, upstream, dir]);
+  await runGit(dir, ['checkout', '-b', name]);
+  await mutate(dir);
+  await runGit(dir, ['add', '-A']);
+  await runGit(dir, ['commit', '-m', `work on ${name}`]);
+  await runGit(dir, ['push', '-u', 'origin', name]);
+}
+
+describe('GitService.mergeChangeRequest', () => {
+  let root: string;
+  beforeEach(async () => {
+    root = await fs.mkdtemp(path.join(os.tmpdir(), 'bevel-merge-cr-'));
+  });
+  afterEach(async () => {
+    await fs.rm(root, { recursive: true, force: true }).catch(() => {});
+  });
+
+  it('merges a feature branch into base and pushes the merge commit', async () => {
+    const { upstream, baseWsId, baseRepo } = await seed(root, { 'base.md': 'base\n' });
+    await pushFeatureBranch(root, upstream, 'alice/add', async (dir) => {
+      await fs.writeFile(path.join(dir, 'feature.md'), 'new content\n');
+    });
+
+    const git = new GitService(stubWorkspaceService(baseWsId, baseRepo), new WorkflowHooks(), 'knowledge-base');
+    const result = await git.mergeChangeRequest(
+      baseWsId, 'alice/add', BASE, { subject: 'Add feature (#1)', body: 'Merged via Bevel' }, USER,
+    );
+
+    expect(result.kind).toBe('merged');
+    if (result.kind !== 'merged') return;
+    expect(result.sha).toMatch(/^[0-9a-f]{40}$/);
+
+    // The merge landed on origin/BASE: a fresh clone sees the feature file and a
+    // merge commit authored by the human triggerer.
+    const verify = path.join(root, 'verify');
+    await runGit(root, ['clone', '-b', BASE, upstream, verify]);
+    const merged = await fs.readFile(path.join(verify, 'feature.md'), 'utf8');
+    expect(merged.replace(/\r\n/g, '\n')).toBe('new content\n');
+    const log = await gitOut(verify, ['log', '-1', '--format=%an <%ae>%n%s']);
+    expect(log).toContain('Alice <alice@example.com>');
+    expect(log).toContain('Add feature (#1)');
+  });
+
+  it('returns the conflicting paths when base and source both changed a file', async () => {
+    const { upstream, baseWsId, baseRepo } = await seed(root, { 'shared.md': 'original\n' });
+    // Source edits shared.md one way…
+    await pushFeatureBranch(root, upstream, 'alice/edit', async (dir) => {
+      await fs.writeFile(path.join(dir, 'shared.md'), 'source version\n');
+    });
+    // …and BASE advances with a conflicting edit to the same file.
+    await pushFeatureBranch(root, upstream, 'tmp-base-advance', async (dir) => {
+      await fs.writeFile(path.join(dir, 'shared.md'), 'base advanced\n');
+    });
+    // Fast-forward BASE to that commit so origin/BASE conflicts with the source.
+    const advancer = path.join(root, 'advancer');
+    await runGit(root, ['clone', '-b', 'tmp-base-advance', upstream, advancer]);
+    await runGit(advancer, ['push', 'origin', 'tmp-base-advance:' + BASE]);
+
+    const git = new GitService(stubWorkspaceService(baseWsId, baseRepo), new WorkflowHooks(), 'knowledge-base');
+    const result = await git.mergeChangeRequest(
+      baseWsId, 'alice/edit', BASE, { subject: 'Edit (#2)', body: 'x' }, USER,
+    );
+
+    expect(result.kind).toBe('conflicts');
+    if (result.kind !== 'conflicts') return;
+    expect(result.paths).toContain('shared.md');
+
+    // The base workspace must be left clean (merge aborted) — not stuck mid-merge.
+    const status = await gitOut(baseRepo, ['status', '--porcelain=v1']);
+    expect(status.trim()).toBe('');
+  });
+});

package/src/modules/workflow/git/__tests__/git.service.pendingChanges.test.ts

@@ -0,0 +1,240 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+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 { GitService } from '../git.service.js';
+import { parsePorcelainZ } from '../git.service.js';
+
+const execFileAsync = promisify(execFile);
+const PROCESS_MAP_DIR = 'knowledge-base';
+
+async function mkTmpRoot(): Promise<string> {
+  return fs.mkdtemp(path.join(os.tmpdir(), 'bevel-pending-changes-'));
+}
+
+async function runGit(cwd: string, args: string[]): Promise<void> {
+  await execFileAsync('git', args, {
+    cwd,
+    env: {
+      ...process.env,
+      GIT_AUTHOR_NAME: 'Test',
+      GIT_AUTHOR_EMAIL: 't@x.com',
+      GIT_COMMITTER_NAME: 'Test',
+      GIT_COMMITTER_EMAIL: 't@x.com',
+    },
+  });
+}
+
+async function seedWorkspace(
+  root: string,
+  workspaceId: string,
+): Promise<{ workspaceDir: string; repo: string }> {
+  const workspaceDir = path.join(root, workspaceId);
+  const repo = path.join(workspaceDir, PROCESS_MAP_DIR);
+  await fs.mkdir(repo, { recursive: true });
+  await runGit(repo, ['init', '-b', 'current-company-state']);
+  return { workspaceDir, repo };
+}
+
+async function writeFile(repo: string, relativePath: string, contents: string): Promise<void> {
+  const absolutePath = path.join(repo, relativePath);
+  await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+  await fs.writeFile(absolutePath, contents);
+}
+
+async function commitFile(
+  repo: string,
+  relativePath: string,
+  contents: string,
+  subject: string,
+): Promise<void> {
+  await writeFile(repo, relativePath, contents);
+  await runGit(repo, ['add', relativePath]);
+  await runGit(repo, ['commit', '-m', subject]);
+}
+
+
+function stubWorkspaceService(workspaceId: string, workspaceDir: string): WorkspaceService {
+  return {
+    getWorkspacePath: async (id: string) => {
+      if (id !== workspaceId) throw new Error(`unexpected workspace ${id}`);
+      return workspaceDir;
+    },
+  } as unknown as WorkspaceService;
+}
+
+async function makeSvc(root: string, workspaceId: string) {
+  const { workspaceDir, repo } = await seedWorkspace(root, workspaceId);
+  const svc = new GitService(
+    stubWorkspaceService(workspaceId, workspaceDir),
+    new WorkflowHooks(),
+    'knowledge-base',
+  );
+  return { svc, repo };
+}
+
+describe('GitService.pendingChanges', () => {
+  let root: string;
+  const workspaceId = 'ws-pending-1';
+
+  beforeEach(async () => {
+    root = await mkTmpRoot();
+  });
+
+  afterEach(async () => {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+  });
+
+  it('lists an untracked file that has never been added', async () => {
+    const { svc, repo } = await makeSvc(root, workspaceId);
+    await commitFile(repo, 'Knowledge/Seed.md', 'seed\n', 'seed');
+    await runGit(repo, ['checkout', '-b', 'ali/demo']);
+    await writeFile(repo, 'juan.md', 'hello\n');
+
+    expect(await svc.pendingChanges(workspaceId)).toEqual(['juan.md']);
+  });
+
+  it('lists a modified tracked file once', async () => {
+    const { svc, repo } = await makeSvc(root, workspaceId);
+    await commitFile(repo, 'Knowledge/Foo.md', 'one\n', 'add foo');
+    await runGit(repo, ['checkout', '-b', 'ali/demo']);
+    await writeFile(repo, 'Knowledge/Foo.md', 'two\n');
+
+    expect(await svc.pendingChanges(workspaceId)).toEqual(['Knowledge/Foo.md']);
+  });
+
+  it('lists a deleted tracked file', async () => {
+    const { svc, repo } = await makeSvc(root, workspaceId);
+    await commitFile(repo, 'Knowledge/Foo.md', 'one\n', 'add foo');
+    await runGit(repo, ['checkout', '-b', 'ali/demo']);
+    await fs.rm(path.join(repo, 'Knowledge/Foo.md'));
+
+    expect(await svc.pendingChanges(workspaceId)).toEqual(['Knowledge/Foo.md']);
+  });
+
+  it('lists a staged-but-uncommitted new file exactly once', async () => {
+    const { svc, repo } = await makeSvc(root, workspaceId);
+    await commitFile(repo, 'Knowledge/Seed.md', 'seed\n', 'seed');
+    await runGit(repo, ['checkout', '-b', 'ali/demo']);
+    await writeFile(repo, 'Knowledge/Foo.md', 'new\n');
+    await runGit(repo, ['add', 'Knowledge/Foo.md']);
+
+    expect(await svc.pendingChanges(workspaceId)).toEqual(['Knowledge/Foo.md']);
+  });
+
+  it('lists the new path only for a rename, not the old one', async () => {
+    const { svc, repo } = await makeSvc(root, workspaceId);
+    await commitFile(repo, 'Knowledge/Old.md', 'one\n', 'add old');
+    await runGit(repo, ['checkout', '-b', 'ali/demo']);
+    await runGit(repo, ['mv', 'Knowledge/Old.md', 'Knowledge/New.md']);
+
+    expect(await svc.pendingChanges(workspaceId)).toEqual(['Knowledge/New.md']);
+  });
+
+  it('honours .gitignore — ignored untracked files are excluded', async () => {
+    const { svc, repo } = await makeSvc(root, workspaceId);
+    await commitFile(repo, 'Knowledge/Seed.md', 'seed\n', 'seed');
+    await runGit(repo, ['checkout', '-b', 'ali/demo']);
+    await writeFile(repo, '.gitignore', 'secret.txt\n');
+    await writeFile(repo, 'secret.txt', 'shh\n');
+    await writeFile(repo, 'visible.md', 'ok\n');
+
+    const paths = await svc.pendingChanges(workspaceId);
+    expect(paths).toContain('.gitignore');
+    expect(paths).toContain('visible.md');
+    expect(paths).not.toContain('secret.txt');
+  });
+
+  it('preserves filenames with spaces verbatim', async () => {
+    const { svc, repo } = await makeSvc(root, workspaceId);
+    await commitFile(repo, 'Knowledge/Seed.md', 'seed\n', 'seed');
+    await runGit(repo, ['checkout', '-b', 'ali/demo']);
+    await writeFile(repo, 'hello world.md', 'ok\n');
+
+    expect(await svc.pendingChanges(workspaceId)).toEqual(['hello world.md']);
+  });
+
+  it('returns an empty list when the tree is clean', async () => {
+    const { svc, repo } = await makeSvc(root, workspaceId);
+    await commitFile(repo, 'Knowledge/Seed.md', 'seed\n', 'seed');
+    await runGit(repo, ['checkout', '-b', 'ali/demo']);
+
+    expect(await svc.pendingChanges(workspaceId)).toEqual([]);
+  });
+
+  it('combines modified + deleted + staged + untracked without duplicates', async () => {
+    const { svc, repo } = await makeSvc(root, workspaceId);
+    await commitFile(repo, 'Knowledge/Mod.md', 'one\n', 'seed mod');
+    await commitFile(repo, 'Knowledge/Del.md', 'gone\n', 'seed del');
+    await runGit(repo, ['checkout', '-b', 'ali/demo']);
+
+    // Modified tracked.
+    await writeFile(repo, 'Knowledge/Mod.md', 'two\n');
+    // Deleted tracked (on disk only, not staged).
+    await fs.rm(path.join(repo, 'Knowledge/Del.md'));
+    // Staged new file.
+    await writeFile(repo, 'Knowledge/Staged.md', 'staged\n');
+    await runGit(repo, ['add', 'Knowledge/Staged.md']);
+    // Plain untracked.
+    await writeFile(repo, 'juan.md', 'hi\n');
+
+    const paths = await svc.pendingChanges(workspaceId);
+    expect(paths.sort()).toEqual([
+      'Knowledge/Del.md',
+      'Knowledge/Mod.md',
+      'Knowledge/Staged.md',
+      'juan.md',
+    ]);
+  });
+});
+
+describe('parsePorcelainZ', () => {
+  it('returns empty for empty input', () => {
+    expect(parsePorcelainZ('')).toEqual([]);
+  });
+
+  it('parses an untracked entry', () => {
+    expect(parsePorcelainZ('?? juan.md\0')).toEqual(['juan.md']);
+  });
+
+  it('parses a modified entry', () => {
+    expect(parsePorcelainZ(' M Knowledge/Foo.md\0')).toEqual(['Knowledge/Foo.md']);
+  });
+
+  it('parses a rename by keeping the new path and dropping the old one', () => {
+    expect(parsePorcelainZ('R  Knowledge/New.md\0Knowledge/Old.md\0'))
+      .toEqual(['Knowledge/New.md']);
+  });
+
+  it('parses a copy the same way as a rename', () => {
+    expect(parsePorcelainZ('C  b.md\0a.md\0')).toEqual(['b.md']);
+  });
+
+  it('dedupes multiple entries pointing at the same path', () => {
+    expect(parsePorcelainZ('MM foo.md\0')).toEqual(['foo.md']);
+  });
+
+  it('preserves spaces in filenames', () => {
+    expect(parsePorcelainZ('?? hello world.md\0')).toEqual(['hello world.md']);
+  });
+
+  it('parses a mix of entries in one buffer', () => {
+    const buf =
+      ' M Knowledge/Mod.md\0' +
+      ' D Knowledge/Del.md\0' +
+      'A  Knowledge/Staged.md\0' +
+      '?? juan.md\0' +
+      'R  Knowledge/New.md\0Knowledge/Old.md\0';
+    expect(parsePorcelainZ(buf).sort()).toEqual([
+      'Knowledge/Del.md',
+      'Knowledge/Mod.md',
+      'Knowledge/New.md',
+      'Knowledge/Staged.md',
+      'juan.md',
+    ]);
+  });
+});

package/src/modules/workflow/git/__tests__/git.service.postMergePull.test.ts

@@ -0,0 +1,272 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import type { AuthUser } from '@bevel-software/platform-shared';
+import { GitService } from '../git.service.js';
+import { runGit, gitOut, stubWorkflowHooks, stubWorkspaceService } from './git-test-helpers.js';
+
+/**
+ * The post-merge refresh path: `WorkflowService.mergeChangeRequest` merges a
+ * change request onto `origin/<base>` and then pulls the BASE branch's own
+ * workspace so its working tree (what every file read serves) isn't left behind
+ * the remote.
+ *
+ * The bug this covers: that pull ran against a clone whose git config had
+ * drifted — a duplicated `remote.origin.fetch` refspec and/or a multi-valued
+ * `branch.<base>.merge` — so git refused to refresh it with "Cannot rebase onto
+ * multiple branches", and the merge was followed by a
+ * `[merge] post-merge pull … failed` warning with the workspace stuck on the
+ * pre-merge tree.
+ */
+
+const execFileAsync = promisify(execFile);
+const BASE = 'current-company-state';
+const SOURCE = 'alice/add-feature';
+const KB_DIR = 'knowledge-base';
+const USER: AuthUser = { id: 'u1', email: 'alice@example.com', name: 'Alice' };
+
+/** Clone `branch` into `<root>/<wsId>/knowledge-base`, like prod's layout. */
+async function cloneWorkspace(root: string, upstream: string, branch: string): Promise<string> {
+  const wsDir = path.join(root, encodeURIComponent(branch));
+  const repo = path.join(wsDir, KB_DIR);
+  await fs.mkdir(wsDir, { recursive: true });
+  await runGit(root, ['clone', '-b', branch, upstream, repo]);
+  await runGit(repo, ['config', 'user.email', 'workspace@bevel.test']);
+  await runGit(repo, ['config', 'user.name', 'bevel Workspace']);
+  return repo;
+}
+
+/**
+ * Bare upstream carrying BASE and a SOURCE branch with one new file, plus the
+ * two workspaces prod would have: the source draft's (where the merge runs) and
+ * the base branch's own (the one the post-merge pull refreshes).
+ */
+async function seed(root: string) {
+  const upstream = path.join(root, 'upstream.git');
+  await runGit(root, ['init', '--bare', '-b', BASE, upstream]);
+
+  const seedDir = path.join(root, '.seed');
+  await fs.mkdir(seedDir);
+  await runGit(seedDir, ['init', '-b', BASE]);
+  await runGit(seedDir, ['remote', 'add', 'origin', upstream]);
+  await fs.writeFile(path.join(seedDir, 'base.md'), 'base\n');
+  await runGit(seedDir, ['add', '-A']);
+  await runGit(seedDir, ['commit', '-m', 'base']);
+  await runGit(seedDir, ['push', 'origin', BASE]);
+  await runGit(seedDir, ['checkout', '-b', SOURCE]);
+  await fs.writeFile(path.join(seedDir, 'feature.md'), 'from the change request\n');
+  await runGit(seedDir, ['add', '-A']);
+  await runGit(seedDir, ['commit', '-m', 'add feature']);
+  await runGit(seedDir, ['push', 'origin', SOURCE]);
+
+  const sourceRepo = await cloneWorkspace(root, upstream, SOURCE);
+  const baseRepo = await cloneWorkspace(root, upstream, BASE);
+  return { upstream, sourceRepo, baseRepo };
+}
+
+describe('post-merge refresh of the target branch workspace', () => {
+  let root: string;
+  const sourceWsId = encodeURIComponent(SOURCE);
+  const baseWsId = encodeURIComponent(BASE);
+
+  beforeEach(async () => {
+    root = await fs.mkdtemp(path.join(os.tmpdir(), 'bevel-post-merge-pull-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(root, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }).catch(() => {});
+  });
+
+  it('pulls the target workspace up to origin after a merge, even with a drifted clone config', async () => {
+    const { sourceRepo, baseRepo } = await seed(root);
+
+    // The target branch's workspace has drifted into the state that strands the
+    // refresh: the branch tracks two merge refs and origin is fetched through
+    // three refspecs.
+    await runGit(baseRepo, ['config', '--add', `branch.${BASE}.merge`, `refs/heads/${SOURCE}`]);
+    await runGit(baseRepo, ['config', '--add', 'remote.origin.fetch', '+refs/heads/*:refs/remotes/origin/*']);
+    await runGit(baseRepo, [
+      'config', '--add', 'remote.origin.fetch', `+refs/heads/${BASE}:refs/remotes/origin/${BASE}`,
+    ]);
+    // Guard: in this state git really does refuse to rebase — without the fix
+    // this is exactly what the post-merge pull hit. `LC_ALL`/`LANG` pinned to
+    // `C` for the same reason `GitService.git` pins them: the assertion below
+    // matches git's English text, and a non-English runner would otherwise
+    // report a false regression.
+    await expect(
+      execFileAsync('git', ['pull', '--rebase'], {
+        cwd: baseRepo,
+        env: { ...process.env, LC_ALL: 'C', LANG: 'C' },
+      }),
+    ).rejects.toThrow(/multiple branches/i);
+
+    const git = new GitService(
+      stubWorkspaceService({
+        [sourceWsId]: path.dirname(sourceRepo),
+        [baseWsId]: path.dirname(baseRepo),
+      }),
+      stubWorkflowHooks(),
+      KB_DIR,
+    );
+
+    // 1. The merge lands on origin/BASE (run from the caller's workspace).
+    const merged = await git.mergeChangeRequest(
+      sourceWsId, SOURCE, BASE, { subject: 'Add feature (#1)', body: 'Merged via Bevel' }, USER,
+    );
+    expect(merged.kind).toBe('merged');
+
+    // 2. The post-merge refresh of the TARGET branch's own workspace succeeds.
+    await expect(git.pull(baseWsId)).resolves.toBeUndefined();
+
+    // The workspace is at origin's head, and serves the merged file.
+    const originHead = await gitOut(baseRepo, ['rev-parse', `origin/${BASE}`]);
+    expect(await gitOut(baseRepo, ['rev-parse', 'HEAD'])).toBe(originHead);
+    if (merged.kind === 'merged') expect(originHead).toBe(merged.sha);
+    const feature = await fs.readFile(path.join(baseRepo, 'feature.md'), 'utf8');
+    expect(feature.replace(/\r\n/g, '\n')).toBe('from the change request\n');
+
+    // The clone was repaired rather than merely worked around, so the next
+    // refresh starts from a healthy config.
+    const mergeRefs = (await gitOut(baseRepo, ['config', '--get-all', `branch.${BASE}.merge`]))
+      .split('\n').filter(Boolean);
+    expect(mergeRefs).toEqual([`refs/heads/${BASE}`]);
+    const refspecs = (await gitOut(baseRepo, ['config', '--get-all', 'remote.origin.fetch']))
+      .split('\n').filter(Boolean);
+    expect(refspecs).toEqual(['+refs/heads/*:refs/remotes/origin/*']);
+  });
+
+  // The reported failure, reproduced. `git pull` reads its rebase target from
+  // `.git/FETCH_HEAD`, and the app fetches into the same clone from paths that
+  // don't share the workspace mutex (`GitService.fetchOriginIfStale`,
+  // `WorkspaceService.ensureRemotesFetched` — both driven by the polling the UI
+  // does around a merge). On a clone whose `branch.<base>.merge` has drifted to
+  // two values, one of those bare fetches writes TWO for-merge FETCH_HEAD
+  // entries; landing inside the pull's fetch→read window makes it die with
+  // "Cannot rebase onto multiple branches".
+  //
+  // Reproduced deterministically below: the drift is applied, ONE real bare
+  // fetch is run to capture the exact FETCH_HEAD bytes it produces (asserted to
+  // carry two for-merge entries — the loaded gun), and a second process then
+  // replays those real bytes in a tight loop while the refresh runs. Replaying
+  // is the concurrent fetch's last step; looping it removes the timing luck
+  // that a `git fetch` loop leaves to chance. Against the pre-fix
+  // `git pull --rebase --autostash origin <base>` this dies with the reported
+  // fatal; the refresh now touches no shared state, so it cannot.
+  it('refreshes the target workspace while a concurrent fetch rewrites FETCH_HEAD', async () => {
+    const { sourceRepo, baseRepo } = await seed(root);
+    const git = new GitService(
+      stubWorkspaceService({
+        [sourceWsId]: path.dirname(sourceRepo),
+        [baseWsId]: path.dirname(baseRepo),
+      }),
+      stubWorkflowHooks(),
+      KB_DIR,
+    );
+
+    const merged = await git.mergeChangeRequest(
+      sourceWsId, SOURCE, BASE, { subject: 'Add feature (#1)', body: 'Merged via Bevel' }, USER,
+    );
+    expect(merged.kind).toBe('merged');
+
+    // The drift, then one real bare fetch — exactly what
+    // `fetchOriginIfStale` / `ensureRemotesFetched` run outside the mutex.
+    await runGit(baseRepo, ['config', '--add', `branch.${BASE}.merge`, `refs/heads/${SOURCE}`]);
+    await runGit(baseRepo, ['fetch', '--prune', 'origin']);
+    const fetchHeadPath = path.join(baseRepo, '.git', 'FETCH_HEAD');
+    const concurrentFetchWrote = await fs.readFile(fetchHeadPath, 'utf8');
+    const forMerge = concurrentFetchWrote
+      .split('\n').filter((l) => l && !l.includes('not-for-merge'));
+    expect(forMerge.length).toBe(2);
+
+    // Now run that same bare fetch in a loop alongside the refresh. It re-adds
+    // the drift each round the way whatever added it in production kept doing
+    // — the refresh's own self-heal would otherwise disarm the reproduction
+    // after round one. A real `git fetch` (rather than a tight write loop) also
+    // keeps the competitor self-throttling instead of starving the box.
+    //
+    // Driven from Node rather than `sh -c` so the suite stays runnable on
+    // Windows: each round still spawns real, genuinely concurrent git
+    // processes — `git.pull` is awaiting its own child while these run.
+    let stop = false;
+    const noise = (async () => {
+      while (!stop) {
+        await runGit(baseRepo, [
+          'config', '--add', `branch.${BASE}.merge`, `refs/heads/${SOURCE}`,
+        ]).catch(() => undefined);
+        await runGit(baseRepo, ['fetch', '--prune', 'origin']).catch(() => undefined);
+      }
+    })();
+    try {
+      // ~40% of rounds hit the fatal pre-fix (measured), so 20 rounds makes a
+      // pre-fix regression a practical certainty while staying quick.
+      for (let round = 0; round < 20; round += 1) {
+        await expect(git.pull(baseWsId)).resolves.toBeUndefined();
+      }
+    } finally {
+      stop = true;
+      await noise;
+    }
+
+    // Still exactly where the merge left origin, with the merged file served.
+    expect(await gitOut(baseRepo, ['rev-parse', 'HEAD']))
+      .toBe(await gitOut(baseRepo, ['rev-parse', `origin/${BASE}`]));
+    const feature = await fs.readFile(path.join(baseRepo, 'feature.md'), 'utf8');
+    expect(feature.replace(/\r\n/g, '\n')).toBe('from the change request\n');
+  }, 60_000);
+
+  // The same config drift, one step earlier in the flow. `git fetch origin
+  // <branch>` updates `refs/remotes/origin/<branch>` only *opportunistically* —
+  // git consults `remote.origin.fetch` to decide — so a refspec narrowed to
+  // some other branch leaves `origin/<source>` frozen at whatever the clone
+  // last saw. The merge then lands a stale source tip on the base and the CR's
+  // latest revision silently goes missing (and every push attempt burns against
+  // the same stale ref). Naming the destination refspecs explicitly is what
+  // makes the fetch independent of that config.
+  it('merges the latest source tip even when remote.origin.fetch no longer covers it', async () => {
+    const { upstream, sourceRepo, baseRepo } = await seed(root);
+
+    // Drift: the clone the merge runs in now fetches ONLY the base branch, so
+    // nothing refreshes `origin/<SOURCE>` through ambient config any more.
+    await runGit(sourceRepo, [
+      'config', '--replace-all', 'remote.origin.fetch',
+      `+refs/heads/${BASE}:refs/remotes/origin/${BASE}`,
+    ]);
+
+    // The change request gets another revision pushed after that clone's last
+    // sight of it — the commit the merge must not miss.
+    const author = path.join(root, '.author');
+    await runGit(root, ['clone', '-b', SOURCE, upstream, author]);
+    await fs.writeFile(path.join(author, 'revision.md'), 'second revision\n');
+    await runGit(author, ['add', '-A']);
+    await runGit(author, ['commit', '-m', 'address review feedback']);
+    await runGit(author, ['push', 'origin', SOURCE]);
+    const latestSource = await gitOut(author, ['rev-parse', 'HEAD']);
+
+    const git = new GitService(
+      stubWorkspaceService({
+        [sourceWsId]: path.dirname(sourceRepo),
+        [baseWsId]: path.dirname(baseRepo),
+      }),
+      stubWorkflowHooks(),
+      KB_DIR,
+    );
+
+    const merged = await git.mergeChangeRequest(
+      sourceWsId, SOURCE, BASE, { subject: 'Add feature (#1)', body: 'Merged via Bevel' }, USER,
+    );
+    expect(merged.kind).toBe('merged');
+
+    // Origin's base carries the LATEST source commit, not the tip the drifted
+    // refspec would have left behind.
+    const upstreamLog = await gitOut(upstream, ['log', '--format=%H', BASE]);
+    expect(upstreamLog.split('\n')).toContain(latestSource);
+
+    // ...and the post-merge refresh of the base workspace serves that revision.
+    await expect(git.pull(baseWsId)).resolves.toBeUndefined();
+    const revision = await fs.readFile(path.join(baseRepo, 'revision.md'), 'utf8');
+    expect(revision.replace(/\r\n/g, '\n')).toBe('second revision\n');
+  });
+});