FN-5819: allow shared-group members to merge into group branch with auto-merge off

Allow shared branch-group members to continue member→group integration even when project auto-merge is disabled.

- add core helper to detect shared branch-group member integrations and export it
- update engine in-review enqueue/handoff/startup flows to permit shared-member integration while still honoring global/engine pause gates
- keep self-healing from pulling shared-member in-review tasks backward during auto-merge-off maintenance
- expand project-engine and reliability-interaction tests for shared-member autoMerge-off behavior and add FN-5819 backstop docs updates

Files changed:
 AGENTS.md                                          |  2 +
 docs/architecture.md                               |  3 +-
 packages/core/src/__tests__/task-merge.test.ts     | 37 +++++++++
 packages/core/src/index.ts                         |  1 +
 packages/core/src/task-merge.ts                    | 13 +++
 packages/engine/src/__tests__/project-engine.test.ts    | 64 ++++++++++++++
 packages/engine/src/__tests__/reliability-interactions/branch-group-merge-routing.test.ts             | 48 +++++++++++
 packages/engine/src/__tests__/reliability-interactions/shared-group-member-integration.test.ts        | 97 ++++++++++++++++++++++
 packages/engine/src/project-engine.ts              | 35 ++++----
 packages/engine/src/self-healing.ts                |  3 +-
 10 files changed, 284 insertions(+), 19 deletions(-)

Fusion-Task-Id: FN-5819

Fusion-Task-Lineage: b5eeced7-7c47-4573-9ab4-ca577bec65e1
This commit is contained in:
gsxdsm
2026-06-01 02:42:36 -07:00
parent e854d33375
commit 35ce9bd244
10 changed files with 284 additions and 19 deletions

View File

@@ -74,6 +74,54 @@ describe("FN-5782 reliability interactions: branch group merge routing", () => {
}
}, 30_000);
it.skipIf(!hasGit)("records shared-member landing even when autoMerge is false", async () => {
const fixture = await makeReliabilityFixture({
taskId: "FN-5819-RI-AUTO-OFF",
settings: { testMode: true, autoMerge: false } as any,
});
try {
const { rootDir, store, task } = fixture;
await stageMergeBranch(store, rootDir, task.id, "fn5819AutoOff");
const group = store.createBranchGroup({
sourceType: "planning",
sourceId: "PS-FN5819",
branchName: "fusion/groups/fn-5819-auto-off",
});
await store.setTaskBranchGroup(task.id, group.id);
const result = await aiMergeTask(store, rootDir, task.id);
expect(result.merged).toBe(true);
expect(git(rootDir, `git show ${group.branchName}:packages/engine/src/fn5819AutoOff.ts`)).toContain("fn5819AutoOff");
expect(() => git(rootDir, "git show main:packages/engine/src/fn5819AutoOff.ts")).toThrow();
const updatedGroup = store.getBranchGroup(group.id)!;
expect(updatedGroup.status).toBe("open");
expect(updatedGroup.worktreePath).toBe(join(`${rootDir}-worktrees`, task.id.toLowerCase()));
const events = store.getRunAuditEvents().filter((event) => event.target === task.id);
expect(events).toEqual(expect.arrayContaining([
expect.objectContaining({
mutationType: "merge:branch-group-routed",
metadata: expect.objectContaining({
mergeTargetBranch: group.branchName,
mergeTargetSource: "branch-group-integration",
}),
}),
expect.objectContaining({
mutationType: "merge:branch-group-promotion-gated",
metadata: expect.objectContaining({
groupId: group.id,
effectiveEligible: false,
}),
}),
]));
} finally {
await fixture.cleanup();
}
}, 45_000);
it.skipIf(!hasGit)("lands two shared members of same group onto one integration branch", async () => {
const fixture = await makeReliabilityFixture({ taskId: "FN-5782-RI-A", settings: { testMode: true } as any });

View File

@@ -0,0 +1,97 @@
import { mkdir } from "node:fs/promises";
import { join } from "node:path";
import { describe, expect, it, vi } from "vitest";
import { type TaskStore } from "@fusion/core";
import { aiMergeTask } from "../../merger.js";
import { git, hasGit, makeReliabilityFixture } from "./_helpers.js";
async function stageMergeBranch(store: TaskStore, rootDir: string, taskId: string, fileName: string): Promise<void> {
const task = await store.getTask(taskId);
const branch = `fusion/${taskId.toLowerCase()}`;
const worktreeRoot = `${rootDir}-worktrees`;
const worktreePath = join(worktreeRoot, taskId.toLowerCase());
await store.updateTask(taskId, {
baseBranch: "",
branch,
column: "in-review",
worktree: worktreePath,
steps: (task?.steps ?? []).map((step) => ({ ...step, status: "done" as const })),
currentStep: (task?.steps ?? []).length ?? 0,
} as any);
git(rootDir, `git checkout -b ${branch}`);
await mkdir(join(rootDir, "packages/engine/src"), { recursive: true });
git(rootDir, `sh -c 'printf ${JSON.stringify(`export const ${fileName} = true;\n`)} > ${JSON.stringify(`packages/engine/src/${fileName}.ts`)}'`);
git(rootDir, `git add ${JSON.stringify(`packages/engine/src/${fileName}.ts`)}`);
git(rootDir, `git commit -m ${JSON.stringify(`feat: add ${fileName}`)}`);
git(rootDir, "git checkout main");
}
describe("FN-5819 reliability interactions: shared group member integration", () => {
it.skipIf(!hasGit)("keeps shared-member integration forward under autoMerge false", async () => {
const fixture = await makeReliabilityFixture({
taskId: "FN-5819-RI-A",
settings: { testMode: true, autoMerge: false } as any,
});
try {
const { rootDir, store, task, manager } = fixture;
const second = await store.createTask({
id: "FN-5819-RI-B",
title: "FN-5819-RI-B",
description: "second member",
column: "in-review",
baseBranch: "main",
branch: "fusion/fn-5819-ri-b",
prompt: "## File Scope\n- packages/engine/src/__tests__/reliability-interactions/**/*.ts\n",
steps: [],
} as any);
const nongroup = await store.createTask({
id: "FN-5819-RI-NONGROUP",
title: "FN-5819-RI-NONGROUP",
description: "non-group in-review",
column: "in-review",
baseBranch: "main",
branch: "fusion/fn-5819-ri-nongroup",
prompt: "## File Scope\n- packages/engine/src/__tests__/reliability-interactions/**/*.ts\n",
steps: [],
} as any);
const group = store.createBranchGroup({
sourceType: "planning",
sourceId: "PS-FN5819",
branchName: "fusion/groups/fn-5819-shared",
});
await store.setTaskBranchGroup(task.id, group.id);
await store.setTaskBranchGroup(second.id, group.id);
await stageMergeBranch(store, rootDir, task.id, "fn5819MemberA");
await stageMergeBranch(store, rootDir, second.id, "fn5819MemberB");
const first = await aiMergeTask(store, rootDir, task.id);
const secondResult = await aiMergeTask(store, rootDir, second.id);
expect(first.merged).toBe(true);
expect(secondResult.merged).toBe(true);
expect(git(rootDir, `git show ${group.branchName}:packages/engine/src/fn5819MemberA.ts`)).toContain("fn5819MemberA");
expect(git(rootDir, `git show ${group.branchName}:packages/engine/src/fn5819MemberB.ts`)).toContain("fn5819MemberB");
expect(() => git(rootDir, "git show main:packages/engine/src/fn5819MemberA.ts")).toThrow();
expect(() => git(rootDir, "git show main:packages/engine/src/fn5819MemberB.ts")).toThrow();
const moveSpy = vi.spyOn(store, "moveTask");
await (manager as any).runMaintenance();
expect(moveSpy.mock.calls.some(([id, column]) => id === task.id && column === "todo")).toBe(false);
expect(moveSpy.mock.calls.some(([id, column]) => id === second.id && column === "todo")).toBe(false);
expect(moveSpy.mock.calls.some(([id, column]) => id === task.id && column === "in-progress")).toBe(false);
expect(moveSpy.mock.calls.some(([id, column]) => id === second.id && column === "in-progress")).toBe(false);
const refreshedNonGroup = await store.getTask(nongroup.id);
expect(refreshedNonGroup.column).toBe("in-review");
} finally {
await fixture.cleanup();
}
}, 60_000);
});