newpr 1.0.24 → 1.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newpr",
-  "version": "1.0.24",
+  "version": "1.0.25",
   "description": "AI-powered large PR review tool - understand PRs with 1000+ lines of changes",
   "module": "src/cli/index.ts",
   "type": "module",

package/src/stack/delta.test.ts

@@ -119,7 +119,7 @@ describe("extractDeltas", () => {
 });
 
 describe("computeGroupStats", () => {
-	test("uses merged dependency baseline for multi-parent DAG groups", async () => {
+	test("uses first dependency as baseline (matching publish base branch) for multi-parent DAG groups", async () => {
 		const repoPath = mkdtempSync(join(tmpdir(), "group-stats-dag-test-"));
 		try {
 			await Bun.$`git init ${repoPath}`.quiet();
@@ -180,14 +180,16 @@ describe("computeGroupStats", () => {
 			expect(stats.get("A")?.deletions).toBe(1);
 			expect(stats.get("B")?.additions).toBe(1);
 			expect(stats.get("B")?.deletions).toBe(1);
-			expect(stats.get("C")?.additions).toBe(1);
-			expect(stats.get("C")?.deletions).toBe(1);
+			expect(stats.get("C")?.additions).toBe(2);
+			expect(stats.get("C")?.deletions).toBe(2);
 			expect(detailed.get("A")?.file_stats["a.txt"]?.additions).toBe(1);
 			expect(detailed.get("A")?.file_stats["a.txt"]?.deletions).toBe(1);
 			expect(detailed.get("B")?.file_stats["b.txt"]?.additions).toBe(1);
 			expect(detailed.get("B")?.file_stats["b.txt"]?.deletions).toBe(1);
 			expect(detailed.get("C")?.file_stats["c.txt"]?.additions).toBe(1);
 			expect(detailed.get("C")?.file_stats["c.txt"]?.deletions).toBe(1);
+			expect(detailed.get("C")?.file_stats["b.txt"]?.additions).toBe(1);
+			expect(detailed.get("C")?.file_stats["b.txt"]?.deletions).toBe(1);
 		} finally {
 			rmSync(repoPath, { recursive: true, force: true });
 		}

package/src/stack/delta.ts

@@ -196,48 +196,7 @@ async function resolveParentTree(
 		return resolveTree(repoPath, baseSha);
 	}
 
-	if (parentIds.length === 1) {
-		return expectedTrees.get(parentIds[0]!) ?? resolveTree(repoPath, baseSha);
-	}
-
-	const parentTrees = parentIds.map((p) => expectedTrees.get(p)).filter((t): t is string => Boolean(t));
-	if (parentTrees.length === 0) return resolveTree(repoPath, baseSha);
-	if (parentTrees.length === 1) return parentTrees[0]!;
-
-	const syntheticCommitByTree = new Map<string, string>();
-	const ensureSyntheticCommit = async (treeSha: string): Promise<string | null> => {
-		const existing = syntheticCommitByTree.get(treeSha);
-		if (existing) return existing;
-
-		const result = await Bun.$`git -C ${repoPath} commit-tree ${treeSha} -p ${baseSha} -m "newpr synthetic parent"`.quiet().nothrow();
-		if (result.exitCode !== 0) return null;
-		const commitSha = result.stdout.toString().trim();
-		if (!commitSha) return null;
-		syntheticCommitByTree.set(treeSha, commitSha);
-		return commitSha;
-	};
-
-	let mergedTree = parentTrees[0]!;
-	let mergedCommit = await ensureSyntheticCommit(mergedTree);
-	if (!mergedCommit) return null;
-
-	for (let i = 1; i < parentTrees.length; i++) {
-		const nextCommit = await ensureSyntheticCommit(parentTrees[i]!);
-		if (!nextCommit) return null;
-
-		const mergeResult = await Bun.$`git -C ${repoPath} merge-tree --write-tree --allow-unrelated-histories ${mergedCommit} ${nextCommit}`.quiet().nothrow();
-		if (mergeResult.exitCode !== 0) return null;
-		const nextTree = mergeResult.stdout.toString().trim().split("\n")[0]?.trim();
-		if (!nextTree) return null;
-		mergedTree = nextTree;
-
-		const mergedCommitResult = await Bun.$`git -C ${repoPath} commit-tree ${mergedTree} -p ${mergedCommit} -p ${nextCommit} -m "newpr synthetic merged parent"`.quiet().nothrow();
-		if (mergedCommitResult.exitCode !== 0) return null;
-		mergedCommit = mergedCommitResult.stdout.toString().trim();
-		if (!mergedCommit) return null;
-	}
-
-	return mergedTree;
+	return expectedTrees.get(parentIds[0]!) ?? resolveTree(repoPath, baseSha);
 }
 
 export interface StackGroupComputedStats {

package/src/stack/feasibility.test.ts

@@ -181,4 +181,115 @@ describe("checkFeasibility", () => {
 		const order = result.ordered_group_ids!;
 		expect(order.indexOf("group-a")).toBeLessThan(order.indexOf("group-b"));
 	});
+
+	test("dependency edge wins over conflicting path-order edge", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [{ status: "A", path: "ui.tsx" }]),
+			makeDelta("c2", "c1", [{ status: "A", path: "lib.ts" }]),
+		];
+
+		const ownership = new Map([
+			["ui.tsx", "ui-group"],
+			["lib.ts", "lib-group"],
+		]);
+
+		const declaredDeps = new Map([
+			["ui-group", ["lib-group"]],
+		]);
+
+		const result = checkFeasibility({ deltas, ownership, declared_deps: declaredDeps });
+
+		expect(result.feasible).toBe(true);
+		const order = result.ordered_group_ids!;
+		expect(order.indexOf("lib-group")).toBeLessThan(order.indexOf("ui-group"));
+		expect(result.dependency_edges).toBeDefined();
+		const depEdge = result.dependency_edges!.find(
+			(e) => e.from === "lib-group" && e.to === "ui-group",
+		);
+		expect(depEdge).toBeDefined();
+	});
+
+	test("dependency edge preserved when path-order creates opposing cycle", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [
+				{ status: "A", path: "ui.tsx" },
+				{ status: "A", path: "hook.ts" },
+			]),
+			makeDelta("c2", "c1", [{ status: "M", path: "ui.tsx" }]),
+		];
+
+		const ownership = new Map([
+			["ui.tsx", "ui-group"],
+			["hook.ts", "lib-group"],
+		]);
+
+		const declaredDeps = new Map([
+			["ui-group", ["lib-group"]],
+		]);
+
+		const result = checkFeasibility({ deltas, ownership, declared_deps: declaredDeps });
+
+		expect(result.feasible).toBe(true);
+		const order = result.ordered_group_ids!;
+		expect(order.indexOf("lib-group")).toBeLessThan(order.indexOf("ui-group"));
+	});
+
+	test("mutual dependency edges both survive when no path-order edges exist", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [
+				{ status: "A", path: "a.ts" },
+				{ status: "A", path: "b.ts" },
+			]),
+		];
+
+		const ownership = new Map([
+			["a.ts", "group-a"],
+			["b.ts", "group-b"],
+		]);
+
+		const declaredDeps = new Map([
+			["group-a", ["group-b"]],
+			["group-b", ["group-a"]],
+		]);
+
+		const result = checkFeasibility({ deltas, ownership, declared_deps: declaredDeps });
+
+		expect(result.feasible).toBe(true);
+		expect(result.ordered_group_ids).toHaveLength(2);
+	});
+
+	test("layer hint yields to import dep when they conflict", () => {
+		const deltas: DeltaEntry[] = [
+			makeDelta("c1", "base", [
+				{ status: "A", path: "api.ts" },
+				{ status: "A", path: "ui.tsx" },
+				{ status: "A", path: "types.ts" },
+			]),
+		];
+
+		const ownership = new Map([
+			["api.ts", "api-group"],
+			["ui.tsx", "ui-group"],
+			["types.ts", "types-group"],
+		]);
+
+		const declaredDeps = new Map([
+			["ui-group", ["api-group"]],
+		]);
+
+		const layerHints = new Map([
+			["api-group", ["ui-group"]],
+		]);
+
+		const result = checkFeasibility({
+			deltas,
+			ownership,
+			declared_deps: declaredDeps,
+			layer_hints: layerHints,
+		});
+
+		expect(result.feasible).toBe(true);
+		const order = result.ordered_group_ids!;
+		expect(order.indexOf("api-group")).toBeLessThan(order.indexOf("ui-group"));
+	});
 });

package/src/stack/feasibility.ts

@@ -9,10 +9,11 @@ interface FeasibilityInput {
 	deltas: DeltaEntry[];
 	ownership: Map<string, string>;
 	declared_deps?: Map<string, string[]>;
+	layer_hints?: Map<string, string[]>;
 }
 
 export function checkFeasibility(input: FeasibilityInput): FeasibilityResult {
-	const { deltas, ownership, declared_deps } = input;
+	const { deltas, ownership, declared_deps, layer_hints } = input;
 
 	const allGroups = new Set<string>(ownership.values());
 	if (allGroups.size <= 1) {
@@ -28,6 +29,9 @@ export function checkFeasibility(input: FeasibilityInput): FeasibilityResult {
 	if (declared_deps) {
 		addDeclaredDepEdges(declared_deps, allGroups, edges);
 	}
+	if (layer_hints) {
+		addLayerHintEdges(layer_hints, allGroups, edges);
+	}
 
 	const deduped = deduplicateEdges(edges);
 	const acyclic = breakAllCycles(deduped);
@@ -37,11 +41,22 @@ export function checkFeasibility(input: FeasibilityInput): FeasibilityResult {
 }
 
 function breakAllCycles(edges: ConstraintEdge[]): ConstraintEdge[] {
-	const edgeSet = new Set(edges.map((e) => `${e.from}→${e.to}`));
+	const edgeMap = new Map<string, ConstraintEdge>();
+	for (const e of edges) edgeMap.set(`${e.from}→${e.to}`, e);
+
 	const withoutMutual: ConstraintEdge[] = [];
 	for (const edge of edges) {
 		const reverseKey = `${edge.to}→${edge.from}`;
-		if (edgeSet.has(reverseKey) && edge.kind === "dependency") continue;
+		const reverse = edgeMap.get(reverseKey);
+		if (!reverse) {
+			// No mutual conflict — keep
+			withoutMutual.push(edge);
+			continue;
+		}
+		// Mutual conflict: drop the LESS important edge.
+		// dependency > path-order (dependency is build-critical)
+		if (edge.kind === "path-order" && reverse.kind === "dependency") continue;
+		// Same kind: keep both, let breakRemainingCycles handle it
 		withoutMutual.push(edge);
 	}
 	return breakRemainingCycles(withoutMutual);
@@ -77,7 +92,7 @@ function breakRemainingCycles(edges: ConstraintEdge[]): ConstraintEdge[] {
 
 	const prioritized = [...edges].sort((a, b) => {
 		const kindScore = (e: ConstraintEdge) =>
-			e.kind === "path-order" ? 0 : e.kind === "dependency" ? 1 : 2;
+			e.kind === "dependency" ? 0 : e.kind === "path-order" ? 1 : 2;
 		return kindScore(a) - kindScore(b);
 	});
 
@@ -174,6 +189,27 @@ function addDeclaredDepEdges(
 	}
 }
 
+function addLayerHintEdges(
+	layerHints: Map<string, string[]>,
+	allGroups: Set<string>,
+	edges: ConstraintEdge[],
+): void {
+	for (const [groupId, deps] of layerHints) {
+		if (!allGroups.has(groupId)) continue;
+
+		for (const depGroupId of deps) {
+			if (!allGroups.has(depGroupId)) continue;
+			if (groupId === depGroupId) continue;
+
+			edges.push({
+				from: depGroupId,
+				to: groupId,
+				kind: "path-order",
+			});
+		}
+	}
+}
+
 function deduplicateEdges(edges: ConstraintEdge[]): ConstraintEdge[] {
 	const seen = new Set<string>();
 	const result: ConstraintEdge[] = [];

package/src/stack/import-deps.test.ts

@@ -2,7 +2,7 @@ import { describe, test, expect, afterAll } from "bun:test";
 import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { analyzeImportDependencies } from "./import-deps.ts";
+import { analyzeImportDependencies, rebuildGroupDeps, mergeImportCycleGroups } from "./import-deps.ts";
 
 const tmpDirs: string[] = [];
 
@@ -251,4 +251,203 @@ describe("analyzeImportDependencies", () => {
 		expect(result.fileDeps.get("src/b.ts")).toContain("src/a.ts");
 		expect(result.groupDeps.size).toBe(0);
 	});
+
+	test("FSD feature: ui/ imports api/ across groups", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+		await commitFiles(repo, { "dummy.txt": "init" }, "init");
+
+		const headSha = await commitFiles(repo, {
+			"src/features/chat-trace/api/use-chat-trace-summary-query.ts":
+				"export function useChatTraceSummaryQuery() { return {}; }",
+			"src/features/chat-trace/ui/chat-trace-table/chat-trace-table.body.tsx": [
+				"import {",
+				"  useChatTraceSummaryQuery,",
+				"} from '../../api/use-chat-trace-summary-query';",
+				"",
+				"export function Body() { return useChatTraceSummaryQuery(); }",
+			].join("\n"),
+		}, "fsd feature");
+
+		const ownership = new Map([
+			["src/features/chat-trace/api/use-chat-trace-summary-query.ts", "API"],
+			["src/features/chat-trace/ui/chat-trace-table/chat-trace-table.body.tsx", "UI"],
+		]);
+
+		const result = await analyzeImportDependencies(repo, headSha, [...ownership.keys()], ownership);
+
+		expect(result.fileDeps.get("src/features/chat-trace/ui/chat-trace-table/chat-trace-table.body.tsx"))
+			.toContain("src/features/chat-trace/api/use-chat-trace-summary-query.ts");
+		expect(result.groupDeps.get("UI")).toContain("API");
+	});
+});
+
+describe("rebuildGroupDeps", () => {
+	test("recomputes group deps after file reassignment", () => {
+		const fileDeps = new Map([
+			["src/ui/button.ts", ["src/api/query.ts"]],
+			["src/api/query.ts", ["src/types/schema.ts"]],
+		]);
+
+		const originalOwnership = new Map([
+			["src/ui/button.ts", "UI"],
+			["src/api/query.ts", "API"],
+			["src/types/schema.ts", "Types"],
+		]);
+
+		const original = rebuildGroupDeps(fileDeps, originalOwnership);
+		expect(original.get("UI")).toContain("API");
+		expect(original.get("API")).toContain("Types");
+
+		const reassignedOwnership = new Map([
+			["src/ui/button.ts", "Feature"],
+			["src/api/query.ts", "Feature"],
+			["src/types/schema.ts", "Types"],
+		]);
+
+		const rebuilt = rebuildGroupDeps(fileDeps, reassignedOwnership);
+		expect(rebuilt.has("UI")).toBe(false);
+		expect(rebuilt.has("API")).toBe(false);
+		expect(rebuilt.get("Feature")).toContain("Types");
+	});
+
+	test("drops stale edges when files move to same group", () => {
+		const fileDeps = new Map([
+			["src/a.ts", ["src/b.ts"]],
+		]);
+
+		const before = rebuildGroupDeps(fileDeps, new Map([
+			["src/a.ts", "GroupA"],
+			["src/b.ts", "GroupB"],
+		]));
+		expect(before.get("GroupA")).toContain("GroupB");
+
+		const after = rebuildGroupDeps(fileDeps, new Map([
+			["src/a.ts", "Merged"],
+			["src/b.ts", "Merged"],
+		]));
+		expect(after.size).toBe(0);
+	});
+});
+
+describe("mergeImportCycleGroups", () => {
+	test("merges groups in a pairwise cycle (A↔B)", () => {
+		const groups = [
+			{ name: "GroupA", files: ["a.ts"], description: "Group A", key_changes: ["added a.ts"] },
+			{ name: "GroupB", files: ["b.ts"], description: "Group B", key_changes: ["added b.ts"] },
+			{ name: "GroupC", files: ["c.ts"], description: "Group C", key_changes: ["added c.ts"] },
+		];
+		const ownership = new Map([
+			["a.ts", "GroupA"],
+			["b.ts", "GroupB"],
+			["c.ts", "GroupC"],
+		]);
+		// A→B and B→A form a cycle; C depends on A (no cycle)
+		const groupDeps = new Map([
+			["GroupA", ["GroupB"]],
+			["GroupB", ["GroupA"]],
+			["GroupC", ["GroupA"]],
+		]);
+
+		const result = mergeImportCycleGroups(groups, ownership, groupDeps);
+
+		// A and B merged into one group, C remains
+		expect(result.groups).toHaveLength(2);
+		expect(result.mergedCycles).toHaveLength(1);
+		expect(result.mergedCycles[0]).toHaveLength(2);
+
+		// Survivor group has files from both A and B
+		const survivor = result.groups.find((g) => g.files.includes("a.ts"))!;
+		expect(survivor).toBeDefined();
+		expect(survivor.files).toContain("b.ts");
+		expect(survivor.key_changes).toContain("added a.ts");
+		expect(survivor.key_changes).toContain("added b.ts");
+
+		// Ownership updated: b.ts now points to survivor
+		expect(result.ownership.get("b.ts")).toBe(survivor.name);
+		expect(result.ownership.get("a.ts")).toBe(survivor.name);
+	});
+
+	test("merges groups in a transitive cycle (A→B→C→A)", () => {
+		const groups = [
+			{ name: "GroupA", files: ["a.ts"], description: "Group A" },
+			{ name: "GroupB", files: ["b.ts"], description: "Group B" },
+			{ name: "GroupC", files: ["c.ts"], description: "Group C" },
+			{ name: "GroupD", files: ["d.ts"], description: "Group D" },
+		];
+		const ownership = new Map([
+			["a.ts", "GroupA"],
+			["b.ts", "GroupB"],
+			["c.ts", "GroupC"],
+			["d.ts", "GroupD"],
+		]);
+		// A→B→C→A forms a cycle; D is standalone
+		const groupDeps = new Map([
+			["GroupA", ["GroupB"]],
+			["GroupB", ["GroupC"]],
+			["GroupC", ["GroupA"]],
+		]);
+
+		const result = mergeImportCycleGroups(groups, ownership, groupDeps);
+
+		// A, B, C merged into one group; D remains
+		expect(result.groups).toHaveLength(2);
+		expect(result.mergedCycles).toHaveLength(1);
+		expect(result.mergedCycles[0]).toHaveLength(3);
+
+		const survivor = result.groups.find((g) => g.files.includes("a.ts"))!;
+		expect(survivor.files).toContain("b.ts");
+		expect(survivor.files).toContain("c.ts");
+		expect(survivor.files).not.toContain("d.ts");
+
+		// All ownership for cycle members points to survivor
+		expect(result.ownership.get("a.ts")).toBe(survivor.name);
+		expect(result.ownership.get("b.ts")).toBe(survivor.name);
+		expect(result.ownership.get("c.ts")).toBe(survivor.name);
+		expect(result.ownership.get("d.ts")).toBe("GroupD");
+	});
+
+	test("no merge when no cycles exist", () => {
+		const groups = [
+			{ name: "GroupA", files: ["a.ts"], description: "Group A" },
+			{ name: "GroupB", files: ["b.ts"], description: "Group B" },
+			{ name: "GroupC", files: ["c.ts"], description: "Group C" },
+		];
+		const ownership = new Map([
+			["a.ts", "GroupA"],
+			["b.ts", "GroupB"],
+			["c.ts", "GroupC"],
+		]);
+		// Linear chain: A→B→C (no cycles)
+		const groupDeps = new Map([
+			["GroupA", ["GroupB"]],
+			["GroupB", ["GroupC"]],
+		]);
+
+		const result = mergeImportCycleGroups(groups, ownership, groupDeps);
+
+		expect(result.groups).toHaveLength(3);
+		expect(result.mergedCycles).toHaveLength(0);
+		// Ownership unchanged
+		expect(result.ownership.get("a.ts")).toBe("GroupA");
+		expect(result.ownership.get("b.ts")).toBe("GroupB");
+		expect(result.ownership.get("c.ts")).toBe("GroupC");
+	});
+
+	test("no merge when groups have no deps", () => {
+		const groups = [
+			{ name: "GroupA", files: ["a.ts"], description: "Group A" },
+			{ name: "GroupB", files: ["b.ts"], description: "Group B" },
+		];
+		const ownership = new Map([
+			["a.ts", "GroupA"],
+			["b.ts", "GroupB"],
+		]);
+		const groupDeps = new Map<string, string[]>();
+
+		const result = mergeImportCycleGroups(groups, ownership, groupDeps);
+
+		expect(result.groups).toHaveLength(2);
+		expect(result.mergedCycles).toHaveLength(0);
+	});
 });

package/src/stack/import-deps.ts

@@ -123,6 +123,119 @@ async function readFileFromGit(repoPath: string, sha: string, filePath: string):
 	return result.stdout.toString();
 }
 
+export function rebuildGroupDeps(
+	fileDeps: Map<string, string[]>,
+	ownership: Map<string, string>,
+): Map<string, string[]> {
+	const groupDeps = new Map<string, Set<string>>();
+	for (const [fromFile, toFiles] of fileDeps) {
+		const fromGroup = ownership.get(fromFile);
+		if (!fromGroup) continue;
+
+		for (const toFile of toFiles) {
+			const toGroup = ownership.get(toFile);
+			if (!toGroup || toGroup === fromGroup) continue;
+			if (!groupDeps.has(fromGroup)) groupDeps.set(fromGroup, new Set());
+			groupDeps.get(fromGroup)!.add(toGroup);
+		}
+	}
+
+	const result = new Map<string, string[]>();
+	for (const [group, deps] of groupDeps) {
+		if (deps.size > 0) {
+			result.set(group, Array.from(deps));
+		}
+	}
+	return result;
+}
+
+function tarjanSCC(nodes: string[], adj: Map<string, string[]>): string[][] {
+	let idx = 0;
+	const indices = new Map<string, number>();
+	const lowlinks = new Map<string, number>();
+	const onStack = new Set<string>();
+	const stack: string[] = [];
+	const sccs: string[][] = [];
+
+	function visit(v: string) {
+		indices.set(v, idx);
+		lowlinks.set(v, idx);
+		idx++;
+		stack.push(v);
+		onStack.add(v);
+
+		for (const w of adj.get(v) ?? []) {
+			if (!indices.has(w)) {
+				visit(w);
+				lowlinks.set(v, Math.min(lowlinks.get(v)!, lowlinks.get(w)!));
+			} else if (onStack.has(w)) {
+				lowlinks.set(v, Math.min(lowlinks.get(v)!, indices.get(w)!));
+			}
+		}
+
+		if (lowlinks.get(v) === indices.get(v)) {
+			const scc: string[] = [];
+			let w: string;
+			do {
+				w = stack.pop()!;
+				onStack.delete(w);
+				scc.push(w);
+			} while (w !== v);
+			sccs.push(scc);
+		}
+	}
+
+	for (const v of nodes) {
+		if (!indices.has(v)) visit(v);
+	}
+	return sccs;
+}
+
+export interface ImportCycleMergeResult<G extends { name: string; files: string[] }> {
+	groups: G[];
+	ownership: Map<string, string>;
+	mergedCycles: string[][];
+}
+
+export function mergeImportCycleGroups<G extends { name: string; files: string[]; key_changes?: string[]; description: string }>(
+	groups: G[],
+	ownership: Map<string, string>,
+	groupDeps: Map<string, string[]>,
+): ImportCycleMergeResult<G> {
+	const groupNames = groups.map((g) => g.name);
+	const sccs = tarjanSCC(groupNames, groupDeps);
+	const cycleSCCs = sccs.filter((scc) => scc.length > 1);
+
+	if (cycleSCCs.length === 0) {
+		return { groups: [...groups], ownership: new Map(ownership), mergedCycles: [] };
+	}
+
+	const newOwnership = new Map(ownership);
+	const groupMap = new Map(groups.map((g) => [g.name, g]));
+	const absorbed = new Set<string>();
+
+	for (const scc of cycleSCCs) {
+		const survivor = groupMap.get(scc[0]!)!;
+		for (let i = 1; i < scc.length; i++) {
+			const victim = groupMap.get(scc[i]!)!;
+			for (const file of victim.files) {
+				if (!survivor.files.includes(file)) survivor.files.push(file);
+			}
+			if (victim.key_changes) {
+				survivor.key_changes = [...(survivor.key_changes ?? []), ...victim.key_changes];
+			}
+			survivor.description = survivor.description || victim.description;
+			for (const [path, gid] of newOwnership) {
+				if (gid === victim.name) newOwnership.set(path, survivor.name);
+			}
+			absorbed.add(victim.name);
+		}
+	}
+
+	const remaining = groups.filter((g) => !absorbed.has(g.name));
+	return { groups: remaining, ownership: newOwnership, mergedCycles: cycleSCCs };
+}
+
 export interface ImportDepResult {
 	fileDeps: Map<string, string[]>;
 	groupDeps: Map<string, string[]>;
@@ -159,26 +272,5 @@ export async function analyzeImportDependencies(
 		}
 	}));
 
-	const groupDeps = new Map<string, Set<string>>();
-	for (const [fromFile, toFiles] of fileDeps) {
-		const fromGroup = ownership.get(fromFile);
-		if (!fromGroup) continue;
-
-		if (!groupDeps.has(fromGroup)) groupDeps.set(fromGroup, new Set());
-
-		for (const toFile of toFiles) {
-			const toGroup = ownership.get(toFile);
-			if (!toGroup || toGroup === fromGroup) continue;
-			groupDeps.get(fromGroup)!.add(toGroup);
-		}
-	}
-
-	const groupDepsMap = new Map<string, string[]>();
-	for (const [group, deps] of groupDeps) {
-		if (deps.size > 0) {
-			groupDepsMap.set(group, Array.from(deps));
-		}
-	}
-
-	return { fileDeps, groupDeps: groupDepsMap };
+	return { fileDeps, groupDeps: rebuildGroupDeps(fileDeps, ownership) };
 }