newpr 1.0.21 → 1.0.23

package/src/stack/merge-groups.test.ts

@@ -216,4 +216,27 @@ describe("mergeEmptyGroups", () => {
 		expect(result.groups[0]!.order).toBe(0);
 		expect(result.groups[1]!.order).toBe(1);
 	});
+
+	test("removes self deps after empty-group merge remapping", () => {
+		const groups: StackGroup[] = [
+			makeStackGroup({
+				id: "A",
+				name: "A",
+				files: ["a.ts"],
+				order: 0,
+				stats: nonZeroStats,
+				deps: ["B"],
+				explicit_deps: ["B"],
+			}),
+			makeStackGroup({ id: "B", name: "B", files: ["b.ts"], order: 1, stats: zeroStats }),
+		];
+		const ownership = new Map([["a.ts", "A"], ["b.ts", "B"]]);
+		const trees = new Map([["A", "tree-a"], ["B", "tree-b"]]);
+
+		const result = mergeEmptyGroups(groups, ownership, trees);
+		expect(result.groups.length).toBe(1);
+		expect(result.groups[0]!.id).toBe("A");
+		expect(result.groups[0]!.deps).toEqual([]);
+		expect(result.groups[0]!.explicit_deps).toEqual([]);
+	});
 });

package/src/stack/merge-groups.ts

@@ -149,7 +149,23 @@ export function mergeEmptyGroups(
 		working.splice(i, 1);
 
 		for (let j = 0; j < working.length; j++) {
-			working[j]!.order = j;
+			const current = working[j];
+			if (!current) continue;
+
+			current.order = j;
+			const nextDeps = (current.deps ?? [])
+				.map((dep) => dep === g.id ? neighbor.id : dep)
+				.filter((dep) => dep !== current.id)
+				.filter((dep) => working.some((w) => w.id === dep));
+			current.deps = Array.from(new Set(nextDeps));
+
+			if (current.explicit_deps) {
+				const nextExplicitDeps = current.explicit_deps
+					.map((dep) => dep === g.id ? neighbor.id : dep)
+					.filter((dep) => dep !== current.id)
+					.filter((dep) => working.some((w) => w.id === dep));
+				current.explicit_deps = Array.from(new Set(nextExplicitDeps));
+			}
 		}
 	}
 

package/src/stack/plan.test.ts

@@ -80,6 +80,35 @@ describe("createStackPlan", () => {
 		expect(plan.groups[1]?.files).toContain("src/ui.tsx");
 	});
 
+	test("ignores self dependency edges when building group deps", 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,
+			dependency_edges: [{ from: "UI", to: "UI" }],
+		});
+
+		const uiGroup = plan.groups.find((g) => g.id === "UI");
+		expect(uiGroup).toBeDefined();
+		expect(uiGroup?.deps).toEqual([]);
+	});
+
 	test("final tree matches HEAD tree (suffix propagation)", async () => {
 		const deltas = await extractDeltas(testRepoPath, baseSha, headSha);
 
@@ -101,6 +130,7 @@ describe("createStackPlan", () => {
 			ownership,
 			group_order: ["Auth", "UI"],
 			groups,
+			dependency_edges: [{ from: "Auth", to: "UI" }],
 		});
 
 		const headTreeResult = await Bun.$`git -C ${testRepoPath} rev-parse ${headSha}^{tree}`.quiet();

package/src/stack/plan.ts

@@ -13,15 +13,21 @@ export interface PlanInput {
 	ownership: Map<string, string>;
 	group_order: string[];
 	groups: FileGroup[];
+	dependency_edges?: Array<{ from: string; to: string }>;
 }
 
 export async function createStackPlan(input: PlanInput): Promise<StackPlan> {
-	const { repo_path, base_sha, head_sha, deltas, ownership, group_order, groups } = input;
+	const { repo_path, base_sha, head_sha, deltas, ownership, group_order, groups, dependency_edges } = input;
 
 	const groupRank = new Map<string, number>();
 	group_order.forEach((gid, idx) => groupRank.set(gid, idx));
 
-	const stackGroups = buildStackGroups(groups, group_order, ownership);
+	const edges = dependency_edges ?? [];
+	const dagParents = buildDagParents(group_order, edges);
+	const explicitDagParents = buildExplicitDagParents(group_order, edges);
+	const ancestorSets = buildAncestorSets(group_order, dagParents);
+
+	const stackGroups = buildStackGroups(groups, group_order, ownership, dagParents, explicitDagParents);
 
 	const tmpIndexFiles: string[] = [];
 	const expectedTrees = new Map<string, string>();
@@ -47,8 +53,12 @@ export async function createStackPlan(input: PlanInput): Promise<StackPlan> {
 				const fileRank = groupRank.get(fileGroupId);
 				if (fileRank === undefined) continue;
 
-				// Suffix propagation: update index[fileRank] through index[N-1]
-				for (let idxNum = fileRank; idxNum < group_order.length; idxNum++) {
+				for (let idxNum = 0; idxNum < group_order.length; idxNum++) {
+					const targetGroupId = group_order[idxNum]!;
+					const isOwner = targetGroupId === fileGroupId;
+					const isAncestorOfOwner = ancestorSets.get(targetGroupId)?.has(fileGroupId) ?? false;
+					if (!isOwner && !isAncestorOfOwner) continue;
+
 					let batch = batchPerIndex.get(idxNum);
 					if (!batch) {
 						batch = [];
@@ -100,18 +110,71 @@ export async function createStackPlan(input: PlanInput): Promise<StackPlan> {
 		}
 	}
 
+	const ancestorSetsRecord = new Map<string, string[]>();
+	for (const [gid, set] of ancestorSets) {
+		ancestorSetsRecord.set(gid, Array.from(set));
+	}
+
 	return {
 		base_sha,
 		head_sha,
 		groups: stackGroups,
 		expected_trees: expectedTrees,
+		ancestor_sets: ancestorSetsRecord,
 	};
 }
 
+export function buildDagParents(
+	groupOrder: string[],
+	dependencyEdges: Array<{ from: string; to: string }>,
+): Map<string, string[]> {
+	return buildExplicitDagParents(groupOrder, dependencyEdges);
+}
+
+export function buildExplicitDagParents(
+	groupOrder: string[],
+	dependencyEdges: Array<{ from: string; to: string }>,
+): Map<string, string[]> {
+	const parents = new Map<string, string[]>();
+	for (const gid of groupOrder) parents.set(gid, []);
+
+	for (const edge of dependencyEdges) {
+		if (!parents.has(edge.to)) continue;
+		if (edge.from === edge.to) continue;
+		const arr = parents.get(edge.to)!;
+		if (!arr.includes(edge.from)) arr.push(edge.from);
+	}
+
+	return parents;
+}
+
+export function buildAncestorSets(
+	groupOrder: string[],
+	dagParents: Map<string, string[]>,
+): Map<string, Set<string>> {
+	const ancestors = new Map<string, Set<string>>();
+
+	for (const gid of groupOrder) {
+		const set = new Set<string>();
+		const queue = [...(dagParents.get(gid) ?? [])];
+		while (queue.length > 0) {
+			const node = queue.shift()!;
+			if (set.has(node)) continue;
+			set.add(node);
+			for (const p of dagParents.get(node) ?? []) queue.push(p);
+		}
+		ancestors.set(gid, set);
+	}
+
+	return ancestors;
+}
+
 function buildStackGroups(
 	groups: FileGroup[],
 	groupOrder: string[],
 	ownership: Map<string, string>,
+	dagParents: Map<string, string[]>,
+	explicitDagParents: Map<string, string[]>,
 ): StackGroup[] {
 	const groupNameMap = new Map<string, FileGroup>();
 	for (const g of groups) {
@@ -132,7 +195,8 @@ function buildStackGroups(
 			type: (original?.type ?? "chore") as GroupType,
 			description: original?.description ?? "",
 			files: files.sort(),
-			deps: original?.dependencies ?? [],
+			deps: dagParents.get(gid) ?? [],
+			explicit_deps: explicitDagParents.get(gid) ?? [],
 			order: idx,
 		};
 	});

package/src/stack/publish.test.ts

@@ -0,0 +1,83 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { PrMeta } from "../types/output.ts";
+import { buildStackPublishPreview } from "./publish.ts";
+import type { StackExecResult } from "./types.ts";
+
+let repoPath = "";
+let headSha = "";
+
+beforeAll(async () => {
+	repoPath = mkdtempSync(join(tmpdir(), "publish-preview-test-"));
+
+	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();
+
+	writeFileSync(join(repoPath, "README.md"), "initial\n");
+	await Bun.$`git -C ${repoPath} add README.md`.quiet();
+	await Bun.$`git -C ${repoPath} commit -m "Initial commit"`.quiet();
+
+	headSha = (await Bun.$`git -C ${repoPath} rev-parse HEAD`.quiet()).stdout.toString().trim();
+});
+
+afterAll(() => {
+	if (repoPath) rmSync(repoPath, { recursive: true, force: true });
+});
+
+describe("buildStackPublishPreview", () => {
+	test("uses DAG dependency bases instead of linear previous branch", async () => {
+		const execResult: StackExecResult = {
+			run_id: "run-1",
+			source_copy_branch: "newpr/stack-source/pr-42",
+			group_commits: [
+				{ group_id: "A", commit_sha: headSha, tree_sha: headSha, branch_name: "stack/a", pr_title: "A title" },
+				{ group_id: "B", commit_sha: headSha, tree_sha: headSha, branch_name: "stack/b", pr_title: "B title" },
+				{ group_id: "C", commit_sha: headSha, tree_sha: headSha, branch_name: "stack/c", pr_title: "C title" },
+			],
+			final_tree_sha: headSha,
+			verified: true,
+		};
+
+		const prMeta: PrMeta = {
+			pr_number: 42,
+			pr_title: "Source PR",
+			pr_url: "https://github.com/acme/repo/pull/42",
+			base_branch: "main",
+			head_branch: "feature/source",
+			author: "tester",
+			total_files_changed: 3,
+			total_additions: 10,
+			total_deletions: 2,
+			analyzed_at: new Date().toISOString(),
+			model_used: "test-model",
+		};
+
+		const preview = await buildStackPublishPreview({
+			repo_path: repoPath,
+			exec_result: execResult,
+			pr_meta: prMeta,
+			base_branch: "main",
+			owner: "acme",
+			repo: "repo",
+			plan_groups: [
+				{ id: "A", name: "A", description: "A desc", files: ["a.ts"], order: 0, deps: [] },
+				{ id: "B", name: "B", description: "B desc", files: ["b.ts"], order: 1, deps: ["A"] },
+				{ id: "C", name: "C", description: "C desc", files: ["c.ts"], order: 2, deps: [] },
+			],
+		});
+
+		const itemById = new Map(preview.items.map((item) => [item.group_id, item]));
+
+		expect(itemById.get("A")?.base_branch).toBe("main");
+		expect(itemById.get("B")?.base_branch).toBe("stack/a");
+		expect(itemById.get("C")?.base_branch).toBe("main");
+
+		expect(itemById.get("B")?.title).toContain("L1");
+		expect(itemById.get("C")?.title).toContain("L0");
+		expect(itemById.get("B")?.body).toContain("Stack L1");
+		expect(itemById.get("C")?.body).toContain("Stack L0");
+	});
+});

package/src/stack/publish.ts

@@ -24,6 +24,7 @@ export interface StackPublishGroupMeta {
 	order: number;
 	type?: string;
 	pr_title?: string;
+	deps?: string[];
 }
 
 export interface StackPublishPreviewItem {
@@ -87,6 +88,45 @@ function buildGroupMetaMap(groups: StackPublishGroupMeta[] | undefined): Map<str
 	return map;
 }
 
+function buildDagLevelMap(
+	groupCommits: StackExecResult["group_commits"],
+	groupMetaById: Map<string, StackPublishGroupMeta>,
+): Map<string, number> {
+	const levels = new Map<string, number>();
+	const inDegree = new Map<string, number>();
+
+	for (const gc of groupCommits) {
+		inDegree.set(gc.group_id, 0);
+	}
+
+	for (const gc of groupCommits) {
+		const deps = groupMetaById.get(gc.group_id)?.deps ?? [];
+		if (deps.length > 0) {
+			inDegree.set(gc.group_id, deps.length);
+		}
+	}
+
+	const queue = groupCommits.filter((gc) => (inDegree.get(gc.group_id) ?? 0) === 0).map((gc) => gc.group_id);
+	for (const gid of queue) levels.set(gid, 0);
+
+	while (queue.length > 0) {
+		const gid = queue.shift()!;
+		const level = levels.get(gid) ?? 0;
+		for (const gc of groupCommits) {
+			const deps = groupMetaById.get(gc.group_id)?.deps ?? [];
+			if (deps.includes(gid)) {
+				const newLevel = Math.max(levels.get(gc.group_id) ?? 0, level + 1);
+				levels.set(gc.group_id, newLevel);
+				const remaining = (inDegree.get(gc.group_id) ?? 1) - 1;
+				inDegree.set(gc.group_id, remaining);
+				if (remaining === 0) queue.push(gc.group_id);
+			}
+		}
+	}
+
+	return levels;
+}
+
 function buildEffectiveGroupMeta(
 	execResult: StackExecResult,
 	groupMetaById: Map<string, StackPublishGroupMeta>,
@@ -105,6 +145,24 @@ function buildEffectiveGroupMeta(
 	});
 }
 
+function resolvePrBaseBranch(
+	groupId: string,
+	baseBranch: string,
+	planGroups: StackPublishGroupMeta[] | undefined,
+	branchByGroupId: Map<string, string>,
+): string {
+	const planGroup = planGroups?.find((g) => g.id === groupId);
+	const directDeps: string[] = planGroup?.deps ?? [];
+	if (directDeps.length > 0) {
+		const depBranch = directDeps
+			.map((dep: string) => branchByGroupId.get(dep))
+			.find((b: string | undefined): b is string => Boolean(b));
+		if (depBranch) return depBranch;
+	}
+
+	return baseBranch;
+}
+
 function isPreviewCompatible(execResult: StackExecResult, preview: StackPublishPreviewResult | null | undefined): boolean {
 	if (!preview || preview.items.length === 0) return false;
 	if (preview.items.length !== execResult.group_commits.length) return false;
@@ -458,6 +516,10 @@ export async function publishStack(input: PublishInput): Promise<StackPublishRes
 	const prs: PrInfo[] = [];
 	const total = exec_result.group_commits.length;
 
+	const branchByGroupId = new Map(exec_result.group_commits.map((gc) => [gc.group_id, gc.branch_name]));
+
+	const dagLevelMap = buildDagLevelMap(exec_result.group_commits, groupMetaById);
+
 	for (const gc of exec_result.group_commits) {
 		const pushResult = await Bun.$`git -C ${repo_path} push origin refs/heads/${gc.branch_name}:refs/heads/${gc.branch_name} --force-with-lease`.quiet().nothrow();
 
@@ -480,11 +542,12 @@ export async function publishStack(input: PublishInput): Promise<StackPublishRes
 		if (!branchInfo?.pushed) continue;
 
 		const previewItem = previewByGroup.get(gc.group_id);
-		const prBase = previewItem?.base_branch ?? (i === 0 ? base_branch : exec_result.group_commits[i - 1]?.branch_name);
+		const prBase = previewItem?.base_branch ?? resolvePrBaseBranch(gc.group_id, base_branch, plan_groups, branchByGroupId);
 		if (!prBase) continue;
 
 		const order = i + 1;
-		const title = previewItem?.title ?? buildStackPrTitle(gc, pr_meta, order, total);
+		const dagLevel = dagLevelMap.get(gc.group_id);
+		const title = previewItem?.title ?? buildStackPrTitle(gc, pr_meta, order, total, dagLevel);
 
 		const placeholder = previewItem?.body ?? buildPlaceholderBody(
 			gc.group_id,
@@ -496,6 +559,7 @@ export async function publishStack(input: PublishInput): Promise<StackPublishRes
 			prBase,
 			gc.branch_name,
 			llmPrefillByGroup.get(gc.group_id),
+			dagLevel,
 		);
 
 		const prResult = await runWithBodyFile(
@@ -507,6 +571,7 @@ export async function publishStack(input: PublishInput): Promise<StackPublishRes
 			const prUrl = prResult.stdout.toString().trim();
 			const prNumberMatch = prUrl.match(/\/pull\/(\d+)/);
 
+			const planGroupDeps = plan_groups?.find((g) => g.id === gc.group_id)?.deps ?? [];
 			prs.push({
 				group_id: gc.group_id,
 				number: prNumberMatch ? parseInt(prNumberMatch[1]!, 10) : 0,
@@ -514,6 +579,7 @@ export async function publishStack(input: PublishInput): Promise<StackPublishRes
 				title,
 				base_branch: prBase,
 				head_branch: gc.branch_name,
+				dep_group_ids: planGroupDeps,
 			});
 		} else {
 			const stderr = prResult.stderr.toString().trim();
@@ -521,8 +587,8 @@ export async function publishStack(input: PublishInput): Promise<StackPublishRes
 		}
 	}
 
-	await updatePrBodies(ghRepo, prs, pr_meta, prTemplate, groupMetaById, llmPrefillByGroup, previewByGroup);
-	await postStackNavigationComments(ghRepo, prs);
+	await updatePrBodies(ghRepo, prs, pr_meta, prTemplate, groupMetaById, llmPrefillByGroup, previewByGroup, dagLevelMap);
+	await postStackNavigationComments(ghRepo, prs, dagLevelMap);
 
 	return { branches, prs };
 }
@@ -534,6 +600,8 @@ export async function buildStackPublishPreview(input: PublishInput): Promise<Sta
 	const prTemplate = prTemplateData?.content ?? null;
 	const total = exec_result.group_commits.length;
 	const groupMetaById = buildGroupMetaMap(plan_groups);
+	const branchByGroupId = new Map(exec_result.group_commits.map((gc) => [gc.group_id, gc.branch_name]));
+	const dagLevelMap = buildDagLevelMap(exec_result.group_commits, groupMetaById);
 	const effectiveGroups = buildEffectiveGroupMeta(exec_result, groupMetaById);
 	const llmPrefillByGroup = await generateTemplatePrefillWithLlm(
 		llm_client,
@@ -545,8 +613,9 @@ export async function buildStackPublishPreview(input: PublishInput): Promise<Sta
 
 	const items = exec_result.group_commits.map((gc, i) => {
 		const order = i + 1;
-		const title = buildStackPrTitle(gc, pr_meta, order, total);
-		const prBase = i === 0 ? base_branch : exec_result.group_commits[i - 1]?.branch_name ?? base_branch;
+		const dagLevel = dagLevelMap.get(gc.group_id);
+		const title = buildStackPrTitle(gc, pr_meta, order, total, dagLevel);
+		const prBase = resolvePrBaseBranch(gc.group_id, base_branch, plan_groups, branchByGroupId);
 		const groupMeta = groupMetaById.get(gc.group_id);
 		return {
 			group_id: gc.group_id,
@@ -565,6 +634,7 @@ export async function buildStackPublishPreview(input: PublishInput): Promise<Sta
 				prBase,
 				gc.branch_name,
 				llmPrefillByGroup.get(gc.group_id),
+				dagLevel,
 			),
 		};
 	});
@@ -583,6 +653,7 @@ async function updatePrBodies(
 	groupMetaById: Map<string, StackPublishGroupMeta>,
 	llmPrefillByGroup: Map<string, SectionBullets>,
 	previewByGroup: Map<string, StackPublishPreviewItem>,
+	dagLevelMap: Map<string, number>,
 ): Promise<void> {
 	if (prs.length === 0) return;
 
@@ -591,6 +662,7 @@ async function updatePrBodies(
 		const previewItem = previewByGroup.get(pr.group_id);
 		const previewBody = previewItem?.body;
 		const groupMeta = groupMetaById.get(pr.group_id);
+		const dagLevel = dagLevelMap.get(pr.group_id);
 		const body = previewBody ?? buildFullBody(
 			pr,
 			i,
@@ -601,6 +673,7 @@ async function updatePrBodies(
 			pr.base_branch,
 			pr.head_branch,
 			llmPrefillByGroup.get(pr.group_id),
+			dagLevel,
 		);
 		const editResult = await runWithBodyFile(
 			body,
@@ -613,7 +686,11 @@ async function updatePrBodies(
 	}
 }
 
-async function postStackNavigationComments(ghRepo: string, prs: PrInfo[]): Promise<void> {
+async function postStackNavigationComments(
+	ghRepo: string,
+	prs: PrInfo[],
+	dagLevelMap: Map<string, number>,
+): Promise<void> {
 	if (prs.length === 0) return;
 
 	for (let i = 0; i < prs.length; i++) {
@@ -621,7 +698,7 @@ async function postStackNavigationComments(ghRepo: string, prs: PrInfo[]): Promi
 		const alreadyPosted = await hasStackNavigationComment(ghRepo, pr.number);
 		if (alreadyPosted) continue;
 
-		const comment = buildStackNavigationComment(i, prs);
+		const comment = buildStackNavigationComment(i, prs, dagLevelMap);
 		const commentResult = await runWithBodyFile(
 			comment,
 			(filePath) => Bun.$`gh pr comment ${pr.number} --repo ${ghRepo} --body-file ${filePath}`.quiet().nothrow(),
@@ -655,8 +732,9 @@ function buildPlaceholderBody(
 	baseBranch?: string,
 	headBranch?: string,
 	llmBullets?: SectionBullets,
+	dagLevel?: number,
 ): string {
-	return buildDescriptionBody(groupId, order, total, prMeta, prTemplate, groupMeta, baseBranch, headBranch, llmBullets);
+	return buildDescriptionBody(groupId, order, total, prMeta, prTemplate, groupMeta, baseBranch, headBranch, llmBullets, dagLevel);
 }
 
 function buildStackPrTitle(
@@ -664,8 +742,10 @@ function buildStackPrTitle(
 	prMeta: PrMeta,
 	order: number,
 	total: number,
+	dagLevel?: number,
 ): string {
-	const stackPrefix = `[PR#${prMeta.pr_number} ${order}/${total}]`;
+	const levelLabel = dagLevel !== undefined ? `L${dagLevel}` : `${order}/${total}`;
+	const stackPrefix = `[PR#${prMeta.pr_number} ${levelLabel}]`;
 	return groupCommit.pr_title
 		? `${stackPrefix} ${groupCommit.pr_title}`
 		: `${stackPrefix} ${groupCommit.group_id}`;
@@ -681,11 +761,16 @@ function buildDescriptionBody(
 	baseBranch?: string,
 	headBranch?: string,
 	llmBullets?: SectionBullets,
+	dagLevel?: number,
 ): string {
+	const positionLabel = dagLevel !== undefined ? `L${dagLevel}` : `${order}/${total}`;
+	const depNames = (groupMeta?.deps ?? []).length > 0
+		? `Depends on: ${(groupMeta?.deps ?? []).join(", ")}`
+		: "Base of stack";
 	const lines = [
-		`> **Stack ${order}/${total}** — This PR is part of a stacked PR chain created by [newpr](https://github.com/jiwonMe/newpr).`,
+		`> **Stack ${positionLabel}** — This PR is part of a stacked PR chain created by [newpr](https://github.com/jiwonMe/newpr).`,
 		`> Source: #${prMeta.pr_number} ${prMeta.pr_title}`,
-		`> Stack navigation is posted as a discussion comment.`,
+		`> ${depNames} · Stack navigation is posted as a discussion comment.`,
 		``,
 		`---`,
 		``,
@@ -721,39 +806,60 @@ function buildFullBody(
 	baseBranch?: string,
 	headBranch?: string,
 	llmBullets?: SectionBullets,
+	dagLevel?: number,
 ): string {
-	return buildDescriptionBody(current.group_id, index + 1, allPrs.length, prMeta, prTemplate, groupMeta, baseBranch, headBranch, llmBullets);
+	return buildDescriptionBody(current.group_id, index + 1, allPrs.length, prMeta, prTemplate, groupMeta, baseBranch, headBranch, llmBullets, dagLevel);
 }
 
-function buildStackNavigationComment(index: number, allPrs: PrInfo[]): string {
+function buildStackNavigationComment(
+	index: number,
+	allPrs: PrInfo[],
+	dagLevelMap: Map<string, number>,
+): string {
 	const total = allPrs.length;
-	const order = index + 1;
+	const currentPr = allPrs[index]!;
+	const currentLevel = dagLevelMap.get(currentPr.group_id) ?? index;
+	const prByGroupId = new Map(allPrs.map((pr) => [pr.group_id, pr]));
+
+	const depPrs = (currentPr.dep_group_ids ?? [])
+		.map((depId) => prByGroupId.get(depId))
+		.filter((pr): pr is PrInfo => Boolean(pr));
+
+	const dependentPrs = allPrs.filter((pr) =>
+		(pr.dep_group_ids ?? []).includes(currentPr.group_id),
+	);
 
 	const stackTable = allPrs.map((pr, i) => {
-		const num = i + 1;
 		const isCurrent = i === index;
 		const marker = isCurrent ? "👉" : statusEmoji(i, index);
 		const link = `[#${pr.number}](${pr.url})`;
 		const titleText = pr.title.replace(/^\[(?:PR#\d+\s+\d+\/\d+|Stack\s+\d+\/\d+|\d+\/\d+)\]\s*/i, "");
-		return `| ${marker} | ${num}/${total} | ${link} | ${titleText} |`;
+		const level = dagLevelMap.get(pr.group_id) ?? i;
+		const indent = level > 0 ? "  ".repeat(level) : "";
+		return `| ${marker} | L${level} | ${link} | ${indent}${titleText} |`;
 	}).join("\n");
 
-	const prev = index > 0
-		? `⬅️ Previous: [#${allPrs[index - 1]!.number}](${allPrs[index - 1]!.url})`
-		: "⬅️ Previous: base branch";
-	const next = index < total - 1
-		? `➡️ Next: [#${allPrs[index + 1]!.number}](${allPrs[index + 1]!.url})`
-		: "➡️ Next: top of stack";
+	const navLines: string[] = [];
+	if (depPrs.length > 0) {
+		navLines.push(`⬆️ Depends on: ${depPrs.map((p) => `[#${p.number}](${p.url})`).join(", ")}`);
+	} else {
+		navLines.push("⬆️ Depends on: base branch");
+	}
+	if (dependentPrs.length > 0) {
+		navLines.push(`⬇️ Required by: ${dependentPrs.map((p) => `[#${p.number}](${p.url})`).join(", ")}`);
+	} else {
+		navLines.push("⬇️ Required by: (top of stack)");
+	}
 
 	return [
 		STACK_NAV_COMMENT_MARKER,
-		`### 📚 Stack Navigation (${order}/${total})`,
+		`### 📚 Stack Navigation (L${currentLevel}, PR ${index + 1}/${total})`,
 		``,
-		`| | Order | PR | Title |`,
+		`| | Level | PR | Title |`,
 		`|---|---|---|---|`,
 		stackTable,
 		``,
-		`${prev} | ${next}`,
+		navLines.join(" | "),
 		``,
 		`_Posted by newpr during stack publish._`,
 	].join("\n");

package/src/stack/types.ts

@@ -89,6 +89,7 @@ export interface CycleReport {
 export interface FeasibilityResult {
 	feasible: boolean;
 	ordered_group_ids?: string[];
+	dependency_edges?: Array<{ from: string; to: string }>;
 	cycle?: CycleReport;
 	unassigned_paths?: Array<{ path: string; commits: string[] }>;
 	ambiguous_paths?: Array<{ path: string; groups: string[]; commits: string[] }>;
@@ -106,15 +107,22 @@ export interface StackGroupStats {
 	files_deleted: number;
 }
 
+export interface StackFileStats {
+	additions: number;
+	deletions: number;
+}
+
 export interface StackGroup {
 	id: string;
 	name: string;
 	type: GroupType;
 	description: string;
 	files: string[];
-	deps: string[]; // groupIds
+	deps: string[];
+	explicit_deps?: string[];
 	order: number;
 	stats?: StackGroupStats;
+	file_stats?: Record<string, StackFileStats>;
 	pr_title?: string;
 }
 
@@ -122,7 +130,8 @@ export interface StackPlan {
 	base_sha: string;
 	head_sha: string;
 	groups: StackGroup[];
-	expected_trees: Map<string, string>; // groupId -> treeSha
+	expected_trees: Map<string, string>;
+	ancestor_sets: Map<string, string[]>;
 }
 
 // ============================================================================
@@ -161,6 +170,7 @@ export interface PrInfo {
 	title: string;
 	base_branch: string;
 	head_branch: string;
+	dep_group_ids?: string[];
 }
 
 export interface StackPublishResult {