newpr 1.0.21 → 1.0.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newpr",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "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

@@ -2,7 +2,9 @@ import { describe, test, expect, beforeAll, afterAll } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { extractDeltas, buildRenameMap } from "./delta.ts";
+import { extractDeltas, buildRenameMap, computeGroupStats, computeGroupStatsWithFiles } from "./delta.ts";
+import { createStackPlan } from "./plan.ts";
+import type { FileGroup } from "../types/output.ts";
 
 let testRepoPath: string;
 
@@ -116,6 +118,82 @@ describe("extractDeltas", () => {
 	});
 });
 
+describe("computeGroupStats", () => {
+	test("uses merged dependency baseline for multi-parent DAG groups", async () => {
+		const repoPath = mkdtempSync(join(tmpdir(), "group-stats-dag-test-"));
+		try {
+			await Bun.$`git init ${repoPath}`.quiet();
+			await Bun.$`git -C ${repoPath} config user.name "Test User"`.quiet();
+			await Bun.$`git -C ${repoPath} config user.email "test@example.com"`.quiet();
+
+			await Bun.$`echo "a0" > ${join(repoPath, "a.txt")}`.quiet();
+			await Bun.$`echo "b0" > ${join(repoPath, "b.txt")}`.quiet();
+			await Bun.$`echo "c0" > ${join(repoPath, "c.txt")}`.quiet();
+			await Bun.$`git -C ${repoPath} add -A`.quiet();
+			await Bun.$`git -C ${repoPath} commit -m "base"`.quiet();
+			const baseSha = await getCurrentSha(repoPath);
+
+			await Bun.$`echo "a1" > ${join(repoPath, "a.txt")}`.quiet();
+			await Bun.$`git -C ${repoPath} add a.txt`.quiet();
+			await Bun.$`git -C ${repoPath} commit -m "A change"`.quiet();
+
+			await Bun.$`echo "b1" > ${join(repoPath, "b.txt")}`.quiet();
+			await Bun.$`git -C ${repoPath} add b.txt`.quiet();
+			await Bun.$`git -C ${repoPath} commit -m "B change"`.quiet();
+
+			await Bun.$`echo "c1" > ${join(repoPath, "c.txt")}`.quiet();
+			await Bun.$`git -C ${repoPath} add c.txt`.quiet();
+			await Bun.$`git -C ${repoPath} commit -m "C change"`.quiet();
+			const headSha = await getCurrentSha(repoPath);
+
+			const deltas = await extractDeltas(repoPath, baseSha, headSha);
+			const ownership = new Map([
+				["a.txt", "A"],
+				["b.txt", "B"],
+				["c.txt", "C"],
+			]);
+			const groups: FileGroup[] = [
+				{ name: "A", type: "feature", description: "A", files: ["a.txt"] },
+				{ name: "B", type: "feature", description: "B", files: ["b.txt"] },
+				{ name: "C", type: "feature", description: "C", files: ["c.txt"] },
+			];
+
+			const plan = await createStackPlan({
+				repo_path: repoPath,
+				base_sha: baseSha,
+				head_sha: headSha,
+				deltas,
+				ownership,
+				group_order: ["A", "B", "C"],
+				groups,
+				dependency_edges: [
+					{ from: "A", to: "C" },
+					{ from: "B", to: "C" },
+				],
+			});
+
+			const dagParents = new Map(plan.groups.map((g) => [g.id, g.deps ?? []]));
+			const stats = await computeGroupStats(repoPath, baseSha, ["A", "B", "C"], plan.expected_trees, dagParents);
+			const detailed = await computeGroupStatsWithFiles(repoPath, baseSha, ["A", "B", "C"], plan.expected_trees, dagParents);
+
+			expect(stats.get("A")?.additions).toBe(1);
+			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(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);
+		} finally {
+			rmSync(repoPath, { recursive: true, force: true });
+		}
+	});
+});
+
 describe("buildRenameMap", () => {
 	test("builds rename map from deltas", () => {
 		const deltas = [

package/src/stack/delta.ts

@@ -1,4 +1,4 @@
-import type { DeltaEntry, DeltaFileChange, DeltaStatus, StackGroupStats } from "./types.ts";
+import type { DeltaEntry, DeltaFileChange, DeltaStatus, StackFileStats, StackGroupStats } from "./types.ts";
 
 export class DeltaExtractionError extends Error {
 	constructor(message: string) {
@@ -183,22 +183,120 @@ function checkForUnsupportedModes(
 	}
 }
 
-export async function computeGroupStats(
+async function resolveParentTree(
+	repoPath: string,
+	baseSha: string,
+	gid: string,
+	expectedTrees: Map<string, string>,
+	dagParents: Map<string, string[]>,
+): Promise<string | null> {
+	const parentIds = dagParents.get(gid) ?? [];
+
+	if (parentIds.length === 0) {
+		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;
+}
+
+export interface StackGroupComputedStats {
+	stats: StackGroupStats;
+	file_stats: Record<string, StackFileStats>;
+}
+
+function materializeRenamedPath(path: string): string {
+	const bracePattern = /(.*)\{([^{}]*) => ([^{}]*)\}(.*)/;
+	const braceMatch = path.match(bracePattern);
+	if (braceMatch) {
+		const [, prefix = "", _from = "", to = "", suffix = ""] = braceMatch;
+		return `${prefix}${to}${suffix}`;
+	}
+
+	if (path.includes(" => ")) {
+		const parts = path.split(" => ");
+		const candidate = parts[parts.length - 1]?.trim();
+		if (candidate) return candidate;
+	}
+
+	return path;
+}
+
+function accumulateFileStats(
+	fileStats: Record<string, StackFileStats>,
+	path: string,
+	additions: number,
+	deletions: number,
+): void {
+	const existing = fileStats[path];
+	if (existing) {
+		existing.additions += additions;
+		existing.deletions += deletions;
+		return;
+	}
+
+	fileStats[path] = { additions, deletions };
+}
+
+export async function computeGroupStatsWithFiles(
 	repoPath: string,
 	baseSha: string,
 	orderedGroupIds: string[],
 	expectedTrees: Map<string, string>,
-): Promise<Map<string, StackGroupStats>> {
-	const stats = new Map<string, StackGroupStats>();
+	dagParents?: Map<string, string[]>,
+): Promise<Map<string, StackGroupComputedStats>> {
+	const stats = new Map<string, StackGroupComputedStats>();
+	const linearParents = new Map<string, string[]>(
+		orderedGroupIds.map((gid, i) => [gid, i === 0 ? [] : [orderedGroupIds[i - 1]!]]),
+	);
+	const effectiveDagParents = dagParents ?? linearParents;
 
 	for (let i = 0; i < orderedGroupIds.length; i++) {
 		const gid = orderedGroupIds[i]!;
 		const tree = expectedTrees.get(gid);
 		if (!tree) continue;
 
-		const prevTree = i === 0
-			? await resolveTree(repoPath, baseSha)
-			: expectedTrees.get(orderedGroupIds[i - 1]!);
+		const prevTree = await resolveParentTree(repoPath, baseSha, gid, expectedTrees, effectiveDagParents);
 		if (!prevTree) continue;
 
 		const numstatResult = await Bun.$`git -C ${repoPath} diff-tree --numstat -r ${prevTree} ${tree}`.quiet().nothrow();
@@ -209,16 +307,47 @@ export async function computeGroupStats(
 		let filesAdded = 0;
 		let filesModified = 0;
 		let filesDeleted = 0;
+		const fileStats: Record<string, StackFileStats> = {};
 
 		if (numstatResult.exitCode === 0) {
 			const lines = numstatResult.stdout.toString().trim().split("\n").filter(Boolean);
 			for (const line of lines) {
 				const parts = line.split("\t");
 				if (parts.length < 3) continue;
-				const [addStr, delStr] = parts;
+				const [addStr, delStr, ...pathParts] = parts;
 				if (addStr === "-" || delStr === "-") continue;
-				additions += parseInt(addStr!, 10);
-				deletions += parseInt(delStr!, 10);
+
+				const addCount = parseInt(addStr!, 10);
+				const delCount = parseInt(delStr!, 10);
+				if (Number.isNaN(addCount) || Number.isNaN(delCount)) continue;
+
+				additions += addCount;
+				deletions += delCount;
+
+				const normalizedParts = pathParts.map((p) => p.trim()).filter((p) => p.length > 0);
+				if (normalizedParts.length === 0) continue;
+
+				if (normalizedParts.length === 1) {
+					const rawPath = normalizedParts[0]!;
+					accumulateFileStats(fileStats, rawPath, addCount, delCount);
+					const materialized = materializeRenamedPath(rawPath);
+					if (materialized !== rawPath) {
+						accumulateFileStats(fileStats, materialized, addCount, delCount);
+					}
+					continue;
+				}
+
+				const oldPath = normalizedParts[0]!;
+				const newPath = normalizedParts[normalizedParts.length - 1]!;
+				const candidates = new Set<string>([
+					oldPath,
+					newPath,
+					materializeRenamedPath(oldPath),
+					materializeRenamedPath(newPath),
+				]);
+				for (const candidate of candidates) {
+					accumulateFileStats(fileStats, candidate, addCount, delCount);
+				}
 			}
 		}
 
@@ -235,12 +364,36 @@ export async function computeGroupStats(
 			}
 		}
 
-		stats.set(gid, { additions, deletions, files_added: filesAdded, files_modified: filesModified, files_deleted: filesDeleted });
+		stats.set(gid, {
+			stats: {
+				additions,
+				deletions,
+				files_added: filesAdded,
+				files_modified: filesModified,
+				files_deleted: filesDeleted,
+			},
+			file_stats: fileStats,
+		});
 	}
 
 	return stats;
 }
 
+export async function computeGroupStats(
+	repoPath: string,
+	baseSha: string,
+	orderedGroupIds: string[],
+	expectedTrees: Map<string, string>,
+	dagParents?: Map<string, string[]>,
+): Promise<Map<string, StackGroupStats>> {
+	const detailed = await computeGroupStatsWithFiles(repoPath, baseSha, orderedGroupIds, expectedTrees, dagParents);
+	const stats = new Map<string, StackGroupStats>();
+	for (const [gid, value] of detailed) {
+		stats.set(gid, value.stats);
+	}
+	return stats;
+}
+
 async function resolveTree(repoPath: string, commitSha: string): Promise<string> {
 	const result = await Bun.$`git -C ${repoPath} rev-parse ${commitSha}^{tree}`.quiet().nothrow();
 	if (result.exitCode !== 0) {

package/src/stack/execute.test.ts

@@ -43,7 +43,7 @@ afterAll(() => {
 });
 
 describe("executeStack", () => {
-	test("creates commit chain with correct parent links", async () => {
+	test("creates commit chain with explicit dependency links", async () => {
 		const deltas = await extractDeltas(testRepoPath, baseSha, headSha);
 		const ownership = new Map([
 			["src/auth.ts", "Auth"],
@@ -62,6 +62,7 @@ describe("executeStack", () => {
 			ownership,
 			group_order: ["Auth", "UI"],
 			groups,
+			dependency_edges: [{ from: "Auth", to: "UI" }],
 		});
 
 		const result = await executeStack({
@@ -101,6 +102,133 @@ describe("executeStack", () => {
 		}
 	});
 
+	test("uses base as parent for independent groups", async () => {
+		const deltas = await extractDeltas(testRepoPath, baseSha, headSha);
+		const ownership = new Map([
+			["src/auth.ts", "Auth"],
+			["src/ui.tsx", "UI"],
+		]);
+		const groups: FileGroup[] = [
+			{ name: "Auth", type: "feature", description: "Auth changes", files: ["src/auth.ts"] },
+			{ name: "UI", type: "feature", description: "UI changes", files: ["src/ui.tsx"] },
+		];
+
+		const plan = await createStackPlan({
+			repo_path: testRepoPath,
+			base_sha: baseSha,
+			head_sha: headSha,
+			deltas,
+			ownership,
+			group_order: ["Auth", "UI"],
+			groups,
+		});
+
+		const result = await executeStack({
+			repo_path: testRepoPath,
+			plan,
+			deltas,
+			ownership,
+			pr_author: { name: "Test Author", email: "author@test.com" },
+			pr_number: 43,
+			head_branch: "feature-branch",
+		});
+
+		const commit0 = result.group_commits[0];
+		const commit1 = result.group_commits[1];
+
+		if (commit0) {
+			const parent0 = (await Bun.$`git -C ${testRepoPath} rev-parse ${commit0.commit_sha}^`.quiet()).stdout.toString().trim();
+			expect(parent0).toBe(baseSha);
+		}
+
+		if (commit1) {
+			const parent1 = (await Bun.$`git -C ${testRepoPath} rev-parse ${commit1.commit_sha}^`.quiet()).stdout.toString().trim();
+			expect(parent1).toBe(baseSha);
+		}
+	});
+
+	test("continues when planned expected tree is stale", async () => {
+		const deltas = await extractDeltas(testRepoPath, baseSha, headSha);
+		const ownership = new Map([
+			["src/auth.ts", "Auth"],
+			["src/ui.tsx", "UI"],
+		]);
+		const groups: FileGroup[] = [
+			{ name: "Auth", type: "feature", description: "Auth changes", files: ["src/auth.ts"] },
+			{ name: "UI", type: "feature", description: "UI changes", files: ["src/ui.tsx"] },
+		];
+
+		const plan = await createStackPlan({
+			repo_path: testRepoPath,
+			base_sha: baseSha,
+			head_sha: headSha,
+			deltas,
+			ownership,
+			group_order: ["Auth", "UI"],
+			groups,
+		});
+
+		plan.expected_trees.set("Auth", "0".repeat(40));
+
+		const result = await executeStack({
+			repo_path: testRepoPath,
+			plan,
+			deltas,
+			ownership,
+			pr_author: { name: "Test", email: "t@t.com" },
+			pr_number: 44,
+			head_branch: "feature-branch",
+		});
+
+		expect(result.group_commits.length).toBe(2);
+		const headTree = (await Bun.$`git -C ${testRepoPath} rev-parse ${headSha}^{tree}`.quiet()).stdout.toString().trim();
+		expect(result.final_tree_sha).toBe(headTree);
+	});
+
+	test("ignores self dependency on group while creating parents", async () => {
+		const deltas = await extractDeltas(testRepoPath, baseSha, headSha);
+		const ownership = new Map([
+			["src/auth.ts", "Auth"],
+			["src/ui.tsx", "UI"],
+		]);
+		const groups: FileGroup[] = [
+			{ name: "Auth", type: "feature", description: "Auth", files: ["src/auth.ts"] },
+			{ name: "UI", type: "feature", description: "UI", files: ["src/ui.tsx"] },
+		];
+
+		const plan = await createStackPlan({
+			repo_path: testRepoPath,
+			base_sha: baseSha,
+			head_sha: headSha,
+			deltas,
+			ownership,
+			group_order: ["Auth", "UI"],
+			groups,
+		});
+
+		if (plan.groups[1]) {
+			plan.groups[1].deps = [plan.groups[1].id];
+		}
+
+		const result = await executeStack({
+			repo_path: testRepoPath,
+			plan,
+			deltas,
+			ownership,
+			pr_author: { name: "Test", email: "t@t.com" },
+			pr_number: 45,
+			head_branch: "feature-branch",
+		});
+
+		expect(result.group_commits.length).toBe(2);
+		const uiCommit = result.group_commits.find((gc) => gc.group_id === "UI");
+		expect(uiCommit).toBeDefined();
+		if (uiCommit) {
+			const parent = (await Bun.$`git -C ${testRepoPath} rev-parse ${uiCommit.commit_sha}^`.quiet()).stdout.toString().trim();
+			expect(parent).toBe(baseSha);
+		}
+	});
+
 	test("final tree equals HEAD tree", async () => {
 		const deltas = await extractDeltas(testRepoPath, baseSha, headSha);
 		const ownership = new Map([

package/src/stack/execute.ts

@@ -4,6 +4,7 @@ import type {
 	StackExecResult,
 	GroupCommitInfo,
 } from "./types.ts";
+import { buildAncestorSets } from "./plan.ts";
 
 export class StackExecutionError extends Error {
 	constructor(message: string) {
@@ -78,8 +79,33 @@ export async function executeStack(input: ExecuteInput): Promise<StackExecResult
 	const groupRank = new Map<string, number>();
 	groupOrder.forEach((gid, idx) => groupRank.set(gid, idx));
 
+	const ancestorSets = new Map<string, Set<string>>();
+	if (plan.ancestor_sets && plan.ancestor_sets.size > 0) {
+		for (const [gid, ancestors] of plan.ancestor_sets) {
+			ancestorSets.set(gid, new Set(ancestors));
+		}
+	} else {
+		const groupIdSet = new Set(groupOrder);
+		const dagParents = new Map<string, string[]>();
+		for (const g of plan.groups) {
+			dagParents.set(g.id, (g.deps ?? []).filter((dep) => groupIdSet.has(dep)));
+		}
+		for (const [gid, set] of buildAncestorSets(groupOrder, dagParents)) {
+			ancestorSets.set(gid, set);
+		}
+	}
+
+	const allDeps = new Set<string>();
+	for (const g of plan.groups) {
+		for (const dep of g.deps ?? []) allDeps.add(dep);
+	}
+	const leafGroups = groupOrder.filter((gid) => !allDeps.has(gid));
+	const hasMultipleLeaves = leafGroups.length > 1;
+	const allChangesIdxSlot = hasMultipleLeaves ? groupOrder.length : -1;
+	const totalIndexSlots = hasMultipleLeaves ? groupOrder.length + 1 : groupOrder.length;
+
 	try {
-		for (let i = 0; i < groupOrder.length; i++) {
+		for (let i = 0; i < totalIndexSlots; i++) {
 			const idxFile = `/tmp/newpr-exec-idx-${runId}-${i}`;
 			tmpIndexFiles.push(idxFile);
 
@@ -101,25 +127,35 @@ export async function executeStack(input: ExecuteInput): Promise<StackExecResult
 				const fileRank = groupRank.get(fileGroupId);
 				if (fileRank === undefined) continue;
 
-				// Suffix propagation: update index[fileRank] through index[N-1]
-				for (let idxNum = fileRank; idxNum < groupOrder.length; idxNum++) {
-					let batch = batchPerIndex.get(idxNum);
-					if (!batch) {
-						batch = [];
-						batchPerIndex.set(idxNum, batch);
-					}
-
-					if (change.status === "D") {
-						batch.push(`0 ${"0".repeat(40)}\t${change.path}`);
-					} else if (change.status === "R") {
-						if (change.old_path) {
-							batch.push(`0 ${"0".repeat(40)}\t${change.old_path}`);
-						}
-						batch.push(`${change.new_mode} ${change.new_blob}\t${change.path}`);
-					} else {
-						batch.push(`${change.new_mode} ${change.new_blob}\t${change.path}`);
+			const addToBatch = (idxNum: number) => {
+				let batch = batchPerIndex.get(idxNum);
+				if (!batch) {
+					batch = [];
+					batchPerIndex.set(idxNum, batch);
+				}
+				if (change.status === "D") {
+					batch.push(`0 ${"0".repeat(40)}\t${change.path}`);
+				} else if (change.status === "R") {
+					if (change.old_path) {
+						batch.push(`0 ${"0".repeat(40)}\t${change.old_path}`);
 					}
+					batch.push(`${change.new_mode} ${change.new_blob}\t${change.path}`);
+				} else {
+					batch.push(`${change.new_mode} ${change.new_blob}\t${change.path}`);
 				}
+			};
+
+			for (let idxNum = 0; idxNum < groupOrder.length; idxNum++) {
+				const targetGroupId = groupOrder[idxNum]!;
+				const isOwner = targetGroupId === fileGroupId;
+				const isAncestorOfOwner = ancestorSets.get(targetGroupId)?.has(fileGroupId) ?? false;
+				if (!isOwner && !isAncestorOfOwner) continue;
+				addToBatch(idxNum);
+			}
+
+			if (allChangesIdxSlot >= 0) {
+				addToBatch(allChangesIdxSlot);
+			}
 			}
 
 			for (const [idxNum, lines] of batchPerIndex) {
@@ -137,7 +173,7 @@ export async function executeStack(input: ExecuteInput): Promise<StackExecResult
 		}
 
 		const groupCommits: GroupCommitInfo[] = [];
-		let prevCommitSha = plan.base_sha;
+		const commitBySha = new Map<string, string>();
 
 		for (let i = 0; i < groupOrder.length; i++) {
 			const idxFile = tmpIndexFiles[i];
@@ -155,14 +191,30 @@ export async function executeStack(input: ExecuteInput): Promise<StackExecResult
 
 			const expectedTree = plan.expected_trees.get(gid);
 			if (expectedTree && treeSha !== expectedTree) {
-				throw new StackExecutionError(
-					`Tree mismatch for group "${gid}": expected ${expectedTree}, got ${treeSha}`,
+				console.warn(
+					`[stack] Tree mismatch for group "${gid}": expected ${expectedTree}, got ${treeSha}. Continuing with computed tree.`,
 				);
+				plan.expected_trees.set(gid, treeSha);
 			}
 
 			const commitMessage = group.pr_title ?? `${group.type}(${group.name}): ${group.description}`;
 
-			const commitTree = await Bun.$`git -C ${repo_path} commit-tree ${treeSha} -p ${prevCommitSha} -m ${commitMessage}`.env({
+			const deps = Array.from(new Set((group.deps ?? []).filter((dep) => dep !== gid)));
+			const directParents = deps.length > 0
+				? deps.map((dep) => {
+					const parentCommit = commitBySha.get(dep);
+					if (!parentCommit) {
+						throw new StackExecutionError(
+							`Missing parent commit for dependency "${dep}" of group "${gid}"`,
+						);
+					}
+					return parentCommit;
+				})
+				: [plan.base_sha];
+
+			const parentArgs = directParents.flatMap((p) => ["-p", p]);
+
+			const commitTree = await Bun.$`git -C ${repo_path} commit-tree ${treeSha} ${parentArgs} -m ${commitMessage}`.env({
 				GIT_AUTHOR_NAME: pr_author.name,
 				GIT_AUTHOR_EMAIL: pr_author.email,
 				GIT_COMMITTER_NAME: pr_author.name,
@@ -175,6 +227,7 @@ export async function executeStack(input: ExecuteInput): Promise<StackExecResult
 				);
 			}
 			const commitSha = commitTree.stdout.toString().trim();
+			commitBySha.set(gid, commitSha);
 
 			const branchName = buildStackBranchName(pr_number, head_branch, group);
 
@@ -193,12 +246,20 @@ export async function executeStack(input: ExecuteInput): Promise<StackExecResult
 				branch_name: branchName,
 				pr_title: group.pr_title,
 			});
-
-			prevCommitSha = commitSha;
 		}
 
-		const lastCommit = groupCommits[groupCommits.length - 1];
-		const finalTreeSha = lastCommit?.tree_sha ?? "";
+		let finalTreeSha: string;
+		if (allChangesIdxSlot >= 0) {
+			const allChangesIdxFile = tmpIndexFiles[allChangesIdxSlot];
+			if (!allChangesIdxFile) throw new StackExecutionError("Missing all-changes index file");
+			const writeAllTree = await Bun.$`GIT_INDEX_FILE=${allChangesIdxFile} git -C ${repo_path} write-tree`.quiet().nothrow();
+			if (writeAllTree.exitCode !== 0) {
+				throw new StackExecutionError(`write-tree failed for all-changes index: ${writeAllTree.stderr.toString().trim()}`);
+			}
+			finalTreeSha = writeAllTree.stdout.toString().trim();
+		} else {
+			finalTreeSha = groupCommits[groupCommits.length - 1]?.tree_sha ?? "";
+		}
 
 		return {
 			run_id: runId,

package/src/stack/feasibility.ts

@@ -190,10 +190,11 @@ function deduplicateEdges(edges: ConstraintEdge[]): ConstraintEdge[] {
 
 function topologicalSort(
 	groups: string[],
-	edges: ConstraintEdge[],
+	acyclicEdges: ConstraintEdge[],
 	deltas: DeltaEntry[],
 	ownership?: Map<string, string>,
 ): FeasibilityResult {
+	const edges = acyclicEdges;
 	const inDegree = new Map<string, number>();
 	const adjacency = new Map<string, string[]>();
 	const edgeMap = new Map<string, ConstraintEdge>();
@@ -238,9 +239,13 @@ function topologicalSort(
 	}
 
 	if (sorted.length === groups.length) {
+		const dependencyEdges = acyclicEdges
+			.filter((e) => e.kind === "dependency" || e.kind === "path-order")
+			.map((e) => ({ from: e.from, to: e.to }));
 		return {
 			feasible: true,
 			ordered_group_ids: sorted,
+			dependency_edges: dependencyEdges,
 		};
 	}
 

package/src/stack/integration.test.ts

@@ -63,6 +63,7 @@ async function runFullPipeline(
 		ownership: coupled.ownership,
 		group_order: feasibility.ordered_group_ids,
 		groups,
+		dependency_edges: feasibility.dependency_edges,
 	});
 
 	const execResult = await executeStack({