newpr 1.0.4 → 1.0.7

package/package.json

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

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

@@ -1,6 +1,7 @@
 import { describe, test, expect } from "bun:test";
-import { mergeGroups } from "./merge-groups.ts";
+import { mergeGroups, mergeEmptyGroups } from "./merge-groups.ts";
 import type { FileGroup } from "../types/output.ts";
+import type { StackGroup, StackGroupStats } from "./types.ts";
 
 describe("mergeGroups", () => {
 	test("no-op when already at or below target", () => {
@@ -95,3 +96,124 @@ describe("mergeGroups", () => {
 		expect(result.groups[0]!.key_changes).toContain("Added UI");
 	});
 });
+
+function makeStackGroup(overrides: Partial<StackGroup> & { id: string; name: string }): StackGroup {
+	return {
+		type: "feature",
+		description: "",
+		files: [],
+		deps: [],
+		order: 0,
+		...overrides,
+	};
+}
+
+const zeroStats: StackGroupStats = { additions: 0, deletions: 0, files_added: 0, files_modified: 0, files_deleted: 0 };
+const nonZeroStats: StackGroupStats = { additions: 10, deletions: 5, files_added: 1, files_modified: 1, files_deleted: 0 };
+
+describe("mergeEmptyGroups", () => {
+	test("no-op when no empty groups", () => {
+		const groups: StackGroup[] = [
+			makeStackGroup({ id: "A", name: "A", files: ["a.ts"], order: 0, stats: nonZeroStats }),
+			makeStackGroup({ id: "B", name: "B", files: ["b.ts"], order: 1, stats: nonZeroStats }),
+		];
+		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(2);
+		expect(result.merges).toEqual([]);
+	});
+
+	test("merges empty group into next neighbor", () => {
+		const groups: StackGroup[] = [
+			makeStackGroup({ id: "A", name: "A", files: ["a.ts"], order: 0, stats: zeroStats }),
+			makeStackGroup({ id: "B", name: "B", files: ["b.ts"], order: 1, stats: nonZeroStats }),
+		];
+		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("B");
+		expect(result.groups[0]!.files).toContain("a.ts");
+		expect(result.groups[0]!.files).toContain("b.ts");
+		expect(result.ownership.get("a.ts")).toBe("B");
+		expect(result.expectedTrees.has("A")).toBe(false);
+		expect(result.expectedTrees.has("B")).toBe(true);
+		expect(result.merges).toEqual([{ absorbed: "A", into: "B" }]);
+	});
+
+	test("merges last empty group into previous neighbor", () => {
+		const groups: StackGroup[] = [
+			makeStackGroup({ id: "A", name: "A", files: ["a.ts"], order: 0, stats: nonZeroStats }),
+			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]!.files).toContain("b.ts");
+		expect(result.ownership.get("b.ts")).toBe("A");
+	});
+
+	test("merges multiple empty groups", () => {
+		const groups: StackGroup[] = [
+			makeStackGroup({ id: "A", name: "A", files: ["a.ts"], order: 0, stats: zeroStats }),
+			makeStackGroup({ id: "B", name: "B", files: ["b.ts"], order: 1, stats: nonZeroStats }),
+			makeStackGroup({ id: "C", name: "C", files: ["c.ts"], order: 2, stats: zeroStats }),
+		];
+		const ownership = new Map([["a.ts", "A"], ["b.ts", "B"], ["c.ts", "C"]]);
+		const trees = new Map([["A", "tree-a"], ["B", "tree-b"], ["C", "tree-c"]]);
+
+		const result = mergeEmptyGroups(groups, ownership, trees);
+		expect(result.groups.length).toBe(1);
+		expect(result.groups[0]!.id).toBe("B");
+		expect(result.groups[0]!.files).toContain("a.ts");
+		expect(result.groups[0]!.files).toContain("b.ts");
+		expect(result.groups[0]!.files).toContain("c.ts");
+		expect(result.merges.length).toBe(2);
+	});
+
+	test("single group is never merged even if empty", () => {
+		const groups: StackGroup[] = [
+			makeStackGroup({ id: "A", name: "A", files: ["a.ts"], order: 0, stats: zeroStats }),
+		];
+		const ownership = new Map([["a.ts", "A"]]);
+		const trees = new Map([["A", "tree-a"]]);
+
+		const result = mergeEmptyGroups(groups, ownership, trees);
+		expect(result.groups.length).toBe(1);
+		expect(result.merges).toEqual([]);
+	});
+
+	test("groups without stats are not considered empty", () => {
+		const groups: StackGroup[] = [
+			makeStackGroup({ id: "A", name: "A", files: ["a.ts"], order: 0 }),
+			makeStackGroup({ id: "B", name: "B", files: ["b.ts"], order: 1, stats: nonZeroStats }),
+		];
+		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(2);
+		expect(result.merges).toEqual([]);
+	});
+
+	test("order is recalculated after merges", () => {
+		const groups: StackGroup[] = [
+			makeStackGroup({ id: "A", name: "A", files: ["a.ts"], order: 0, stats: zeroStats }),
+			makeStackGroup({ id: "B", name: "B", files: ["b.ts"], order: 1, stats: nonZeroStats }),
+			makeStackGroup({ id: "C", name: "C", files: ["c.ts"], order: 2, stats: nonZeroStats }),
+		];
+		const ownership = new Map([["a.ts", "A"], ["b.ts", "B"], ["c.ts", "C"]]);
+		const trees = new Map([["A", "tree-a"], ["B", "tree-b"], ["C", "tree-c"]]);
+
+		const result = mergeEmptyGroups(groups, ownership, trees);
+		expect(result.groups.length).toBe(2);
+		expect(result.groups[0]!.order).toBe(0);
+		expect(result.groups[1]!.order).toBe(1);
+	});
+});

package/src/stack/merge-groups.ts

@@ -1,4 +1,5 @@
 import type { FileGroup } from "../types/output.ts";
+import type { StackGroup } from "./types.ts";
 
 export interface MergeResult {
 	groups: FileGroup[];
@@ -6,6 +7,13 @@ export interface MergeResult {
 	merges: Array<{ absorbed: string; into: string }>;
 }
 
+export interface EmptyMergeResult {
+	groups: StackGroup[];
+	ownership: Map<string, string>;
+	expectedTrees: Map<string, string>;
+	merges: Array<{ absorbed: string; into: string }>;
+}
+
 export function mergeGroups(
 	groups: FileGroup[],
 	ownership: Map<string, string>,
@@ -85,3 +93,65 @@ export function mergeGroups(
 
 	return { groups: working, ownership: newOwnership, merges };
 }
+
+export function mergeEmptyGroups(
+	groups: StackGroup[],
+	ownership: Map<string, string>,
+	expectedTrees: Map<string, string>,
+): EmptyMergeResult {
+	if (groups.length <= 1) {
+		return { groups: [...groups], ownership: new Map(ownership), expectedTrees: new Map(expectedTrees), merges: [] };
+	}
+
+	const working = groups.map((g) => ({ ...g, files: [...g.files] }));
+	const newOwnership = new Map(ownership);
+	const newTrees = new Map(expectedTrees);
+	const merges: Array<{ absorbed: string; into: string }> = [];
+
+	let i = 0;
+	while (i < working.length) {
+		const g = working[i]!;
+		const stats = g.stats;
+		const totalChanges = stats ? stats.additions + stats.deletions : -1;
+
+		if (totalChanges !== 0 || working.length <= 1) {
+			i++;
+			continue;
+		}
+
+		const neighborIdx = i < working.length - 1 ? i + 1 : i - 1;
+		const neighbor = working[neighborIdx]!;
+
+		for (const file of g.files) {
+			if (!neighbor.files.includes(file)) {
+				neighbor.files.push(file);
+			}
+		}
+
+		if (neighbor.stats && stats) {
+			neighbor.stats = {
+				additions: neighbor.stats.additions + stats.additions,
+				deletions: neighbor.stats.deletions + stats.deletions,
+				files_added: neighbor.stats.files_added + stats.files_added,
+				files_modified: neighbor.stats.files_modified + stats.files_modified,
+				files_deleted: neighbor.stats.files_deleted + stats.files_deleted,
+			};
+		}
+
+		for (const [path, groupId] of newOwnership) {
+			if (groupId === g.id) {
+				newOwnership.set(path, neighbor.id);
+			}
+		}
+
+		newTrees.delete(g.id);
+		merges.push({ absorbed: g.name, into: neighbor.name });
+		working.splice(i, 1);
+
+		for (let j = 0; j < working.length; j++) {
+			working[j]!.order = j;
+		}
+	}
+
+	return { groups: working, ownership: newOwnership, expectedTrees: newTrees, merges };
+}

package/src/stack/pr-title.ts

@@ -1,22 +1,32 @@
 import type { LlmClient } from "../llm/client.ts";
 import type { StackGroup } from "./types.ts";
 
-function truncateTitle(type: string, text: string): string {
-	const words = text.split(/\s+/).filter(Boolean);
-	const kept = words.slice(0, 5).join(" ");
-	const title = `${type}: ${kept}`;
-	return title.length > 40 ? title.slice(0, 40).trimEnd() : title;
+const MAX_TITLE_LENGTH = 72;
+
+function sanitizeTitle(raw: string): string {
+	let title = raw.trim().replace(/\.+$/, "");
+	if (title.length > MAX_TITLE_LENGTH) {
+		title = title.slice(0, MAX_TITLE_LENGTH).replace(/\s\S*$/, "").trimEnd();
+	}
+	return title;
 }
 
 function fallbackTitle(g: StackGroup): string {
-	const slug = g.name.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
-	return truncateTitle(g.type, slug);
+	const desc = g.description || g.name;
+	const cleaned = desc.replace(/[^\w\s\-/.,()]/g, " ").replace(/\s+/g, " ").trim();
+	const prefix = `${g.type}: `;
+	const maxDesc = MAX_TITLE_LENGTH - prefix.length;
+	const truncated = cleaned.length > maxDesc
+		? cleaned.slice(0, maxDesc).replace(/\s\S*$/, "").trimEnd()
+		: cleaned;
+	return truncated ? `${prefix}${truncated}` : `${g.type}: ${g.name}`;
 }
 
 export async function generatePrTitles(
 	llmClient: LlmClient,
 	groups: StackGroup[],
 	prTitle: string,
+	language?: string,
 ): Promise<Map<string, string>> {
 	const groupSummaries = groups
 		.map((g, i) => [
@@ -27,38 +37,46 @@ export async function generatePrTitles(
 		].join("\n"))
 		.join("\n\n");
 
-	const system = `You generate short PR titles for stacked PRs — like real GitHub PR titles.
+	const lang = language && language !== "English" ? language : null;
+	const langRule = lang
+		? `- Write the description part in ${lang}. Keep the type prefix (feat/fix/etc.) in English.`
+		: "- Write the description in English.";
+
+	const system = `You generate PR titles for stacked PRs — concise but descriptive, like titles written by a senior engineer.
 
 Rules:
 - Format: "type: description"
-- type must be one of: feat | fix | refactor | chore | docs | test | perf
-- description: 2-5 words MAX. Imperative mood, lowercase, no period
-- HARD LIMIT: entire title must be under 40 characters total
-- Cut aggressively. Think of it as a git branch name in prose form
-- NO scope parentheses, NO filler words (add, implement, introduce, update, support, handle, ensure)
+- type must be one of: feat | fix | refactor | chore | docs | test | perf | style | ci
+- description: 5-12 words, imperative mood, no trailing period
+- Target length: 40-72 characters total
+- Be specific about WHAT changed, not vague
 - Each title must be unique across the set
+- Never leave description empty
+${langRule}
 
 Good examples:
-- "feat: jwt token refresh"
-- "fix: null user crash"
-- "refactor: shared validators"
-- "chore: eslint config"
-- "test: auth edge cases"
-- "feat: loop node schema"
-- "refactor: canvas renderer"
-
-Bad examples (TOO LONG):
-- "feat: add jwt token refresh middleware for authentication" (way too long)
-- "feat: implement loop node support for workflow editor" (too many words)
-- "refactor: update canvas rendering logic to support new shapes" (sentence, not title)
-
-Return ONLY JSON array: [{"group_id": "...", "title": "..."}]`;
+- "feat: add JWT token refresh middleware for auth flow"
+- "fix: prevent null user crash on session expiry"
+- "refactor: extract shared validation logic into helpers"
+- "chore: migrate eslint config to flat format"
+- "feat: implement drag-and-drop reordering for canvas nodes"
+- "test: add integration tests for payment webhook handler"
+- "refactor: split monolithic API router into domain modules"
+
+Bad examples:
+- "feat: auth" (too vague)
+- "fix: bug" (meaningless)
+- "refactor: code" (says nothing)
+- "feat: jwt" (just a keyword, not a title)
+- "" (empty)
+
+Return ONLY a JSON array: [{"group_id": "...", "title": "..."}]`;
 
 	const user = `Original PR: "${prTitle}"
 
 ${groupSummaries}
 
-Generate a unique, short PR title for each group (<40 chars). Return JSON array:
+Generate a descriptive PR title (40-72 chars) for each group. Return JSON array:
 [{"group_id": "...", "title": "..."}]`;
 
 	const response = await llmClient.complete(system, user);
@@ -69,9 +87,8 @@ Generate a unique, short PR title for each group (<40 chars). Return JSON array:
 		const cleaned = response.content.replace(/```(?:json)?\s*/g, "").replace(/```\s*/g, "").trim();
 		const parsed = JSON.parse(cleaned) as Array<{ group_id: string; title: string }>;
 		for (const item of parsed) {
-			if (item.group_id && item.title) {
-				const t = item.title.length > 40 ? truncateTitle(item.title.split(":")[0] ?? "chore", item.title.split(":").slice(1).join(":").trim()) : item.title;
-				titles.set(item.group_id, t);
+			if (item.group_id && item.title?.trim()) {
+				titles.set(item.group_id, sanitizeTitle(item.title));
 			}
 		}
 	} catch {
@@ -81,7 +98,7 @@ Generate a unique, short PR title for each group (<40 chars). Return JSON array:
 	}
 
 	for (const g of groups) {
-		if (!titles.has(g.id)) {
+		if (!titles.has(g.id) || !titles.get(g.id)) {
 			titles.set(g.id, fallbackTitle(g));
 		}
 	}

package/src/stack/publish.ts

@@ -10,10 +10,34 @@ export interface PublishInput {
 	repo: string;
 }
 
+const PR_TEMPLATE_PATHS = [
+	".github/PULL_REQUEST_TEMPLATE.md",
+	".github/pull_request_template.md",
+	".github/PULL_REQUEST_TEMPLATE",
+	"PULL_REQUEST_TEMPLATE.md",
+	"PULL_REQUEST_TEMPLATE",
+	"docs/PULL_REQUEST_TEMPLATE.md",
+	"docs/pull_request_template.md",
+];
+
+async function readPrTemplate(repoPath: string, headSha: string): Promise<string | null> {
+	for (const path of PR_TEMPLATE_PATHS) {
+		const result = await Bun.$`git -C ${repoPath} show ${headSha}:${path}`.quiet().nothrow();
+		if (result.exitCode === 0) {
+			const content = result.stdout.toString().trim();
+			if (content) return content;
+		}
+	}
+	return null;
+}
+
 export async function publishStack(input: PublishInput): Promise<StackPublishResult> {
 	const { repo_path, exec_result, pr_meta, base_branch, owner, repo } = input;
 	const ghRepo = `${owner}/${repo}`;
 
+	const headSha = exec_result.group_commits.at(-1)?.commit_sha ?? "HEAD";
+	const prTemplate = await readPrTemplate(repo_path, headSha);
+
 	const branches: BranchInfo[] = [];
 	const prs: PrInfo[] = [];
 	const total = exec_result.group_commits.length;
@@ -68,17 +92,17 @@ export async function publishStack(input: PublishInput): Promise<StackPublishRes
 		}
 	}
 
-	await updatePrBodies(ghRepo, prs, pr_meta);
+	await updatePrBodies(ghRepo, prs, pr_meta, prTemplate);
 
 	return { branches, prs };
 }
 
-async function updatePrBodies(ghRepo: string, prs: PrInfo[], prMeta: PrMeta): Promise<void> {
+async function updatePrBodies(ghRepo: string, prs: PrInfo[], prMeta: PrMeta, prTemplate: string | null): Promise<void> {
 	if (prs.length === 0) return;
 
 	for (let i = 0; i < prs.length; i++) {
 		const pr = prs[i]!;
-		const body = buildFullBody(pr, i, prs, prMeta);
+		const body = buildFullBody(pr, i, prs, prMeta, prTemplate);
 
 		await Bun.$`gh pr edit ${pr.number} --repo ${ghRepo} --body ${body}`.quiet().nothrow();
 	}
@@ -105,6 +129,7 @@ function buildFullBody(
 	index: number,
 	allPrs: PrInfo[],
 	prMeta: PrMeta,
+	prTemplate: string | null,
 ): string {
 	const total = allPrs.length;
 	const order = index + 1;
@@ -125,7 +150,7 @@ function buildFullBody(
 		? `➡️ Next: [#${allPrs[index + 1]!.number}](${allPrs[index + 1]!.url})`
 		: "➡️ Next: top of stack";
 
-	return [
+	const lines = [
 		`> **Stack ${order}/${total}** — This PR is part of a stacked PR chain created by [newpr](https://github.com/jiwonMe/newpr).`,
 		`> Source: #${prMeta.pr_number} ${prMeta.pr_title}`,
 		``,
@@ -142,7 +167,13 @@ function buildFullBody(
 		`## ${current.group_id}`,
 		``,
 		`*From PR [#${prMeta.pr_number}](${prMeta.pr_url}): ${prMeta.pr_title}*`,
-	].join("\n");
+	];
+
+	if (prTemplate) {
+		lines.push(``, `---`, ``, prTemplate);
+	}
+
+	return lines.join("\n");
 }
 
 function statusEmoji(prIndex: number, currentIndex: number): string {

package/src/web/client/components/ChatSection.tsx

@@ -109,11 +109,13 @@ function ThrottledMarkdown({ content, onAnchorClick, activeId }: {
 				timerRef.current = null;
 			}, 150);
 		}
-		return () => {};
 	}, [content]);
 
 	useEffect(() => {
-		return () => { if (timerRef.current) clearTimeout(timerRef.current); };
+		return () => {
+			if (timerRef.current) clearTimeout(timerRef.current);
+			setRendered(pendingRef.current);
+		};
 	}, []);
 
 	return <Markdown onAnchorClick={onAnchorClick} activeId={activeId}>{rendered}</Markdown>;
@@ -148,7 +150,11 @@ function AssistantMessage({ segments, activeToolName, isStreaming, onAnchorClick
 			{activeToolName && (
 				<div className="inline-flex items-center gap-1.5 px-2 py-0.5 rounded-md bg-accent/40 text-[11px] text-muted-foreground/50">
 					<Loader2 className="h-2.5 w-2.5 animate-spin" />
-					<span className="font-mono">{activeToolName}</span>
+					{activeToolName === "thinking" ? (
+						<span>Thinking…</span>
+					) : (
+						<span className="font-mono">{activeToolName}</span>
+					)}
 				</div>
 			)}
 			{isStreaming && !hasContent && !activeToolName && segments.length === 0 && (

package/src/web/client/components/ResultsScreen.tsx

@@ -69,6 +69,10 @@ export function ResultsScreen({
 	const [reviewOpen, setReviewOpen] = useState(false);
 	const outdated = useOutdatedCheck(sessionId);
 
+	useEffect(() => {
+		onTabChange?.(tab);
+	}, []);
+
 	const stickyRef = useRef<HTMLDivElement>(null);
 	const collapsibleRef = useRef<HTMLDivElement>(null);
 	const compactRef = useRef<HTMLDivElement>(null);

package/src/web/client/hooks/useChatStore.ts

@@ -140,7 +140,7 @@ class ChatStore {
 							case "tool_result": {
 								const tc = allToolCalls.find((c) => c.id === data.id);
 								if (tc) tc.result = data.result;
-								this.update(sessionId, { streaming: { segments: [...orderedSegments] } });
+								this.update(sessionId, { streaming: { segments: [...orderedSegments], activeToolName: "thinking" } });
 								break;
 							}
 							case "done": break;

package/src/web/client/hooks/useStack.ts

@@ -216,8 +216,9 @@ export function useStack(sessionId: string | null | undefined, options?: UseStac
 		});
 
 		es.onerror = () => {
-			es.close();
-			eventSourceRef.current = null;
+			if (es.readyState === EventSource.CLOSED) {
+				eventSourceRef.current = null;
+			}
 		};
 	}, []);
 

package/src/web/server/routes.ts

@@ -370,34 +370,47 @@ Before posting an inline comment, ALWAYS call \`get_file_diff\` first to find th
 			const stream = new ReadableStream({
 				start(controller) {
 					const encoder = new TextEncoder();
+					let closed = false;
 					const send = (eventType: string, data: string) => {
+						if (closed) return;
 						controller.enqueue(encoder.encode(`event: ${eventType}\ndata: ${data}\n\n`));
 					};
+					const safeClose = () => {
+						if (closed) return;
+						closed = true;
+						clearInterval(heartbeat);
+						setTimeout(() => { try { controller.close(); } catch {} }, 50);
+					};
+
+					const heartbeat = setInterval(() => {
+						if (closed) return;
+						try { controller.enqueue(encoder.encode(":keepalive\n\n")); } catch { safeClose(); }
+					}, 15_000);
 
 					const unsubscribe = subscribe(id, (event) => {
 						try {
 							if ("type" in event && event.type === "done") {
 								send("done", JSON.stringify({}));
-								controller.close();
+								safeClose();
 							} else if ("type" in event && event.type === "error") {
 								send("analysis_error", JSON.stringify({ message: event.data ?? "Unknown error" }));
-								controller.close();
+								safeClose();
 							} else {
 								send("progress", JSON.stringify(event));
 							}
 						} catch {
-							controller.close();
+							safeClose();
 						}
 					});
 
 					if (!unsubscribe) {
 						send("analysis_error", JSON.stringify({ message: "Session not found" }));
-						controller.close();
+						safeClose();
 					}
 
 					req.signal.addEventListener("abort", () => {
 						unsubscribe?.();
-						try { controller.close(); } catch {}
+						safeClose();
 					});
 				},
 			});
@@ -1756,23 +1769,36 @@ Before posting an inline comment, ALWAYS call \`get_file_diff\` first to find th
 			const stream = new ReadableStream({
 				start(controller) {
 					const encoder = new TextEncoder();
+					let closed = false;
 					const send = (eventType: string, data: string) => {
+						if (closed) return;
 						controller.enqueue(encoder.encode(`event: ${eventType}\ndata: ${data}\n\n`));
 					};
+					const safeClose = () => {
+						if (closed) return;
+						closed = true;
+						clearInterval(heartbeat);
+						setTimeout(() => { try { controller.close(); } catch {} }, 50);
+					};
+
+					const heartbeat = setInterval(() => {
+						if (closed) return;
+						try { controller.enqueue(encoder.encode(":keepalive\n\n")); } catch { safeClose(); }
+					}, 15_000);
 
 					const unsubscribe = subscribeStack(id, (event) => {
 						try {
 							if ("type" in event && event.type === "done") {
 								send("done", JSON.stringify({ state: getStackState(id) }));
-								controller.close();
+								safeClose();
 							} else if ("type" in event && event.type === "error") {
 								send("stack_error", JSON.stringify({ message: event.data ?? "Unknown error", state: getStackState(id) }));
-								controller.close();
+								safeClose();
 							} else {
 								send("progress", JSON.stringify({ ...event, state: getStackState(id) }));
 							}
 						} catch {
-							controller.close();
+							safeClose();
 						}
 					});
 
@@ -1783,12 +1809,12 @@ Before posting an inline comment, ALWAYS call \`get_file_diff\` first to find th
 						} else {
 							send("stack_error", JSON.stringify({ message: "No stack session found" }));
 						}
-						controller.close();
+						safeClose();
 					}
 
 					req.signal.addEventListener("abort", () => {
 						unsubscribe?.();
-						try { controller.close(); } catch {}
+						safeClose();
 					});
 				},
 			});

package/src/web/server/stack-manager.ts

@@ -12,7 +12,7 @@ import { partitionGroups } from "../../stack/partition.ts";
 import { applyCouplingRules } from "../../stack/coupling.ts";
 import { splitOversizedGroups } from "../../stack/split.ts";
 import { rebalanceGroups } from "../../stack/balance.ts";
-import { mergeGroups } from "../../stack/merge-groups.ts";
+import { mergeGroups, mergeEmptyGroups } from "../../stack/merge-groups.ts";
 import { checkFeasibility } from "../../stack/feasibility.ts";
 import { createStackPlan } from "../../stack/plan.ts";
 import { executeStack } from "../../stack/execute.ts";
@@ -288,7 +288,7 @@ async function runStackPipeline(
 		const baseBranch = baseObj.ref as string;
 		const headBranch = headObj.ref as string;
 
-		const repoPath = await ensureRepo(parsed.owner, parsed.repo, token);
+		const repoPath = await ensureRepo(parsed.owner, parsed.repo, token, undefined, [baseSha, headSha]);
 
 		session.context = {
 			repo_path: repoPath,
@@ -452,8 +452,34 @@ async function runStackPipeline(
 			if (s) group.stats = s;
 		}
 
+		const emptyMerged = mergeEmptyGroups(plan.groups, ownership, plan.expected_trees);
+		if (emptyMerged.merges.length > 0) {
+			plan.groups = emptyMerged.groups;
+			plan.expected_trees = emptyMerged.expectedTrees;
+			for (const [path, groupId] of emptyMerged.ownership) {
+				ownership.set(path, groupId);
+			}
+			const emptyDetails = emptyMerged.merges.map((m) => `"${m.absorbed}" → "${m.into}"`);
+			allWarnings.push(`Merged ${emptyMerged.merges.length} empty group(s): ${emptyDetails.join(", ")}`);
+			allStructuredWarnings.push({
+				category: "grouping",
+				severity: "info",
+				title: `${emptyMerged.merges.length} empty group(s) merged`,
+				message: "Groups with zero effective changes were absorbed into adjacent groups",
+				details: emptyDetails,
+			});
+			emit(session, "planning", `Merged ${emptyMerged.merges.length} empty group(s)...`);
+
+			session.partition = {
+				...session.partition!,
+				ownership: Object.fromEntries(ownership),
+				warnings: allWarnings,
+				structured_warnings: allStructuredWarnings,
+			};
+		}
+
 		emit(session, "planning", "Generating PR titles...");
-		const prTitles = await generatePrTitles(llmClient, plan.groups, stored.meta.pr_title);
+		const prTitles = await generatePrTitles(llmClient, plan.groups, stored.meta.pr_title, config.language);
 		for (const group of plan.groups) {
 			const title = prTitles.get(group.id);
 			if (title) group.pr_title = title;

package/src/web/server.ts

@@ -1,4 +1,4 @@
-import { join, dirname } from "node:path";
+import { join } from "node:path";
 import type { NewprConfig } from "../types/config.ts";
 import { createRoutes } from "./server/routes.ts";
 import index from "./index.html";
@@ -16,11 +16,12 @@ interface WebServerOptions {
 }
 
 function getCssPaths() {
-	const webDir = dirname(Bun.resolveSync("./src/web/index.html", process.cwd()));
+	const webDir = import.meta.dir;
+	const packageRoot = join(webDir, "..", "..");
 	return {
 		input: join(webDir, "styles", "globals.css"),
 		output: join(webDir, "styles", "built.css"),
-		bin: join(process.cwd(), "node_modules", ".bin", "tailwindcss"),
+		bin: join(packageRoot, "node_modules", ".bin", "tailwindcss"),
 	};
 }
 
@@ -86,7 +87,7 @@ export async function startWebServer(options: WebServerOptions): Promise<void> {
 			const path = url.pathname;
 
 			if (path.startsWith("/assets/")) {
-				const webDir = dirname(Bun.resolveSync("./src/web/index.html", process.cwd()));
+				const webDir = import.meta.dir;
 				const filePath = join(webDir, path);
 				const file = Bun.file(filePath);
 				return file.exists().then((exists) => {

package/src/workspace/repo-cache.ts

@@ -33,12 +33,18 @@ export async function ensureRepo(
 	repo: string,
 	token: string,
 	onProgress?: (msg: string) => void,
+	requiredShas?: string[],
 ): Promise<string> {
 	const repoPath = bareRepoPath(owner, repo);
 
 	if (existsSync(join(repoPath, "HEAD"))) {
-		if (needsFetch(repoPath)) {
-			onProgress?.("Fetching latest changes...");
+		const stale = needsFetch(repoPath);
+		const missing = !stale && requiredShas?.length
+			? await hasMissingShas(repoPath, requiredShas)
+			: false;
+
+		if (stale || missing) {
+			onProgress?.(missing ? "Fetching new commits..." : "Fetching latest changes...");
 			const fetch = await Bun.$`git -C ${repoPath} fetch --all --prune`.quiet().nothrow();
 			if (fetch.exitCode !== 0) {
 				throw new Error(`git fetch failed (exit ${fetch.exitCode}): ${fetch.stderr.toString().trim()}`);
@@ -64,6 +70,14 @@ export async function ensureRepo(
 	return repoPath;
 }
 
+async function hasMissingShas(repoPath: string, shas: string[]): Promise<boolean> {
+	for (const sha of shas) {
+		const result = await Bun.$`git -C ${repoPath} cat-file -t ${sha}`.quiet().nothrow();
+		if (result.exitCode !== 0) return true;
+	}
+	return false;
+}
+
 export function getReposDir(): string {
 	return REPOS_DIR;
 }