newpr 0.6.5 → 1.0.0

package/src/stack/integration.test.ts

@@ -0,0 +1,266 @@
+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 { extractDeltas } from "./delta.ts";
+import { applyCouplingRules } from "./coupling.ts";
+import { checkFeasibility } from "./feasibility.ts";
+import { createStackPlan } from "./plan.ts";
+import { executeStack } from "./execute.ts";
+import { verifyStack } from "./verify.ts";
+import type { FileGroup } from "../types/output.ts";
+
+const tmpDirs: string[] = [];
+
+function makeTmpRepo(): string {
+	const dir = mkdtempSync(join(tmpdir(), "stack-integ-"));
+	tmpDirs.push(dir);
+	return dir;
+}
+
+afterAll(() => {
+	for (const dir of tmpDirs) {
+		rmSync(dir, { recursive: true, force: true });
+	}
+});
+
+async function initRepo(path: string): Promise<void> {
+	await Bun.$`git init ${path}`.quiet();
+	await Bun.$`git -C ${path} config user.name "Test"`.quiet();
+	await Bun.$`git -C ${path} config user.email "test@test.com"`.quiet();
+}
+
+async function getSha(path: string): Promise<string> {
+	return (await Bun.$`git -C ${path} rev-parse HEAD`.quiet()).stdout.toString().trim();
+}
+
+async function getTree(path: string, sha: string): Promise<string> {
+	return (await Bun.$`git -C ${path} rev-parse ${sha}^{tree}`.quiet()).stdout.toString().trim();
+}
+
+async function runFullPipeline(
+	repoPath: string,
+	baseSha: string,
+	headSha: string,
+	groups: FileGroup[],
+	ownership: Map<string, string>,
+	groupOrder: string[],
+) {
+	const changedFiles = [...ownership.keys()];
+	const coupled = applyCouplingRules(ownership, changedFiles, groupOrder);
+	const deltas = await extractDeltas(repoPath, baseSha, headSha);
+	const feasibility = checkFeasibility({ deltas, ownership: coupled.ownership });
+
+	if (!feasibility.feasible || !feasibility.ordered_group_ids) {
+		return { feasibility, plan: null, execResult: null, verifyResult: null };
+	}
+
+	const plan = await createStackPlan({
+		repo_path: repoPath,
+		base_sha: baseSha,
+		head_sha: headSha,
+		deltas,
+		ownership: coupled.ownership,
+		group_order: feasibility.ordered_group_ids,
+		groups,
+	});
+
+	const execResult = await executeStack({
+		repo_path: repoPath,
+		plan,
+		deltas,
+		ownership: coupled.ownership,
+		pr_author: { name: "Test", email: "test@test.com" },
+		pr_number: 1,
+		head_branch: "test-branch",
+	});
+
+	const verifyResult = await verifyStack({
+		repo_path: repoPath,
+		base_sha: baseSha,
+		head_sha: headSha,
+		exec_result: execResult,
+		ownership: coupled.ownership,
+	});
+
+	return { feasibility, plan, execResult, verifyResult };
+}
+
+describe("integration: full stacking pipeline", () => {
+	test("happy path with 3 groups", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+
+		mkdirSync(join(repo, "src"), { recursive: true });
+		writeFileSync(join(repo, "README.md"), "init\n");
+		await Bun.$`git -C ${repo} add -A`.quiet();
+		await Bun.$`git -C ${repo} commit -m "Init"`.quiet();
+		const base = await getSha(repo);
+
+		writeFileSync(join(repo, "src", "auth.ts"), "export const auth = true;\n");
+		await Bun.$`git -C ${repo} add src/auth.ts`.quiet();
+		await Bun.$`git -C ${repo} commit -m "Add auth"`.quiet();
+
+		writeFileSync(join(repo, "src", "api.ts"), "export const api = '/v1';\n");
+		await Bun.$`git -C ${repo} add src/api.ts`.quiet();
+		await Bun.$`git -C ${repo} commit -m "Add api"`.quiet();
+
+		writeFileSync(join(repo, "src", "ui.tsx"), "export const UI = () => <div/>;\n");
+		await Bun.$`git -C ${repo} add src/ui.tsx`.quiet();
+		await Bun.$`git -C ${repo} commit -m "Add ui"`.quiet();
+		const head = await getSha(repo);
+
+		const groups: FileGroup[] = [
+			{ name: "Auth", type: "feature", description: "Auth", files: ["src/auth.ts"] },
+			{ name: "API", type: "feature", description: "API", files: ["src/api.ts"] },
+			{ name: "UI", type: "feature", description: "UI", files: ["src/ui.tsx"] },
+		];
+		const ownership = new Map([
+			["src/auth.ts", "Auth"],
+			["src/api.ts", "API"],
+			["src/ui.tsx", "UI"],
+		]);
+
+		const result = await runFullPipeline(repo, base, head, groups, ownership, ["Auth", "API", "UI"]);
+
+		expect(result.feasibility.feasible).toBe(true);
+		expect(result.plan!.groups.length).toBe(3);
+		expect(result.execResult!.group_commits.length).toBe(3);
+		expect(result.verifyResult!.verified).toBe(true);
+		expect(result.verifyResult!.errors).toEqual([]);
+		expect(result.verifyResult!.warnings).toBeDefined();
+
+		const headTree = await getTree(repo, head);
+		expect(result.execResult!.final_tree_sha).toBe(headTree);
+	});
+
+	test("file rename preserves tree equivalence", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+
+		writeFileSync(join(repo, "old.ts"), "content\n");
+		await Bun.$`git -C ${repo} add -A`.quiet();
+		await Bun.$`git -C ${repo} commit -m "Init"`.quiet();
+		const base = await getSha(repo);
+
+		await Bun.$`git -C ${repo} mv old.ts new.ts`.quiet();
+		await Bun.$`git -C ${repo} commit -m "Rename"`.quiet();
+		const head = await getSha(repo);
+
+		const groups: FileGroup[] = [
+			{ name: "Rename", type: "refactor", description: "Rename file", files: ["old.ts", "new.ts"] },
+		];
+		const ownership = new Map([
+			["old.ts", "Rename"],
+			["new.ts", "Rename"],
+		]);
+
+		const result = await runFullPipeline(repo, base, head, groups, ownership, ["Rename"]);
+
+		expect(result.feasibility.feasible).toBe(true);
+		expect(result.verifyResult!.verified).toBe(true);
+
+		const headTree = await getTree(repo, head);
+		expect(result.execResult!.final_tree_sha).toBe(headTree);
+	});
+
+	test("file deletion preserves tree equivalence", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+
+		writeFileSync(join(repo, "keep.ts"), "keep\n");
+		writeFileSync(join(repo, "remove.ts"), "remove\n");
+		await Bun.$`git -C ${repo} add -A`.quiet();
+		await Bun.$`git -C ${repo} commit -m "Init"`.quiet();
+		const base = await getSha(repo);
+
+		await Bun.$`git -C ${repo} rm remove.ts`.quiet();
+		await Bun.$`git -C ${repo} commit -m "Delete"`.quiet();
+		const head = await getSha(repo);
+
+		const groups: FileGroup[] = [
+			{ name: "Cleanup", type: "chore", description: "Remove file", files: ["remove.ts"] },
+		];
+		const ownership = new Map([["remove.ts", "Cleanup"]]);
+
+		const result = await runFullPipeline(repo, base, head, groups, ownership, ["Cleanup"]);
+
+		expect(result.feasibility.feasible).toBe(true);
+		expect(result.verifyResult!.verified).toBe(true);
+
+		const headTree = await getTree(repo, head);
+		expect(result.execResult!.final_tree_sha).toBe(headTree);
+	});
+
+	test("single group stacks to one commit", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+
+		writeFileSync(join(repo, "a.ts"), "a\n");
+		await Bun.$`git -C ${repo} add -A`.quiet();
+		await Bun.$`git -C ${repo} commit -m "Init"`.quiet();
+		const base = await getSha(repo);
+
+		writeFileSync(join(repo, "a.ts"), "a-updated\n");
+		writeFileSync(join(repo, "b.ts"), "b-new\n");
+		await Bun.$`git -C ${repo} add -A`.quiet();
+		await Bun.$`git -C ${repo} commit -m "Changes"`.quiet();
+		const head = await getSha(repo);
+
+		const groups: FileGroup[] = [
+			{ name: "Single", type: "feature", description: "All changes", files: ["a.ts", "b.ts"] },
+		];
+		const ownership = new Map([
+			["a.ts", "Single"],
+			["b.ts", "Single"],
+		]);
+
+		const result = await runFullPipeline(repo, base, head, groups, ownership, ["Single"]);
+
+		expect(result.feasibility.feasible).toBe(true);
+		expect(result.execResult!.group_commits.length).toBe(1);
+		expect(result.verifyResult!.verified).toBe(true);
+
+		const headTree = await getTree(repo, head);
+		expect(result.execResult!.final_tree_sha).toBe(headTree);
+	});
+
+	test("declared dependency cycle is detected as infeasible", async () => {
+		const repo = makeTmpRepo();
+		await initRepo(repo);
+
+		mkdirSync(join(repo, "src"), { recursive: true });
+		writeFileSync(join(repo, "src", "a.ts"), "a\n");
+		writeFileSync(join(repo, "src", "b.ts"), "b\n");
+		await Bun.$`git -C ${repo} add -A`.quiet();
+		await Bun.$`git -C ${repo} commit -m "Init"`.quiet();
+		const base = await getSha(repo);
+
+		writeFileSync(join(repo, "src", "a.ts"), "a-v2\n");
+		await Bun.$`git -C ${repo} add -A`.quiet();
+		await Bun.$`git -C ${repo} commit -m "Update a"`.quiet();
+
+		writeFileSync(join(repo, "src", "b.ts"), "b-v2\n");
+		await Bun.$`git -C ${repo} add -A`.quiet();
+		await Bun.$`git -C ${repo} commit -m "Update b"`.quiet();
+		const head = await getSha(repo);
+
+		const ownership = new Map([
+			["src/a.ts", "GroupA"],
+			["src/b.ts", "GroupB"],
+		]);
+
+		const deltas = await extractDeltas(repo, base, head);
+		const feasibility = checkFeasibility({
+			deltas,
+			ownership,
+			declared_deps: new Map([
+				["GroupA", ["GroupB"]],
+				["GroupB", ["GroupA"]],
+			]),
+		});
+
+		expect(feasibility.feasible).toBe(false);
+		expect(feasibility.cycle).toBeDefined();
+	});
+});

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

@@ -0,0 +1,97 @@
+import { describe, test, expect } from "bun:test";
+import { mergeGroups } from "./merge-groups.ts";
+import type { FileGroup } from "../types/output.ts";
+
+describe("mergeGroups", () => {
+	test("no-op when already at or below target", () => {
+		const groups: FileGroup[] = [
+			{ name: "A", type: "feature", description: "A", files: ["a.ts"] },
+			{ name: "B", type: "feature", description: "B", files: ["b.ts"] },
+		];
+		const ownership = new Map([["a.ts", "A"], ["b.ts", "B"]]);
+
+		const result = mergeGroups(groups, ownership, 3);
+		expect(result.groups.length).toBe(2);
+		expect(result.merges).toEqual([]);
+	});
+
+	test("merges 4 groups down to 2", () => {
+		const groups: FileGroup[] = [
+			{ name: "Big", type: "feature", description: "Big", files: ["a.ts", "b.ts", "c.ts"] },
+			{ name: "Small1", type: "feature", description: "Small1", files: ["d.ts"] },
+			{ name: "Small2", type: "feature", description: "Small2", files: ["e.ts"] },
+			{ name: "Medium", type: "feature", description: "Medium", files: ["f.ts", "g.ts"] },
+		];
+		const ownership = new Map([
+			["a.ts", "Big"], ["b.ts", "Big"], ["c.ts", "Big"],
+			["d.ts", "Small1"], ["e.ts", "Small2"],
+			["f.ts", "Medium"], ["g.ts", "Medium"],
+		]);
+
+		const result = mergeGroups(groups, ownership, 2);
+		expect(result.groups.length).toBe(2);
+		expect(result.merges.length).toBe(2);
+
+		const allFiles = result.groups.flatMap((g) => g.files);
+		expect(allFiles.sort()).toEqual(["a.ts", "b.ts", "c.ts", "d.ts", "e.ts", "f.ts", "g.ts"]);
+
+		for (const [path] of ownership) {
+			expect(result.ownership.has(path)).toBe(true);
+			const owner = result.ownership.get(path)!;
+			expect(result.groups.some((g) => g.name === owner)).toBe(true);
+		}
+	});
+
+	test("ownership updated for absorbed group files", () => {
+		const groups: FileGroup[] = [
+			{ name: "A", type: "feature", description: "A", files: ["a1.ts", "a2.ts"] },
+			{ name: "B", type: "feature", description: "B", files: ["b.ts"] },
+		];
+		const ownership = new Map([
+			["a1.ts", "A"], ["a2.ts", "A"], ["b.ts", "B"],
+		]);
+
+		const result = mergeGroups(groups, ownership, 1);
+		expect(result.groups.length).toBe(1);
+
+		const survivorName = result.groups[0]!.name;
+		expect(result.ownership.get("a1.ts")).toBe(survivorName);
+		expect(result.ownership.get("a2.ts")).toBe(survivorName);
+		expect(result.ownership.get("b.ts")).toBe(survivorName);
+	});
+
+	test("targetCount 0 or negative returns single group", () => {
+		const groups: FileGroup[] = [
+			{ name: "A", type: "feature", description: "A", files: ["a.ts"] },
+			{ name: "B", type: "feature", description: "B", files: ["b.ts"] },
+		];
+		const ownership = new Map([["a.ts", "A"], ["b.ts", "B"]]);
+
+		const result = mergeGroups(groups, ownership, 0);
+		expect(result.groups.length).toBe(2);
+		expect(result.merges).toEqual([]);
+	});
+
+	test("single group unchanged", () => {
+		const groups: FileGroup[] = [
+			{ name: "Only", type: "feature", description: "Only", files: ["a.ts", "b.ts"] },
+		];
+		const ownership = new Map([["a.ts", "Only"], ["b.ts", "Only"]]);
+
+		const result = mergeGroups(groups, ownership, 1);
+		expect(result.groups.length).toBe(1);
+		expect(result.merges).toEqual([]);
+	});
+
+	test("preserves key_changes from absorbed group", () => {
+		const groups: FileGroup[] = [
+			{ name: "A", type: "feature", description: "A", files: ["a.ts"], key_changes: ["Added auth"] },
+			{ name: "B", type: "feature", description: "B", files: ["b.ts"], key_changes: ["Added UI"] },
+		];
+		const ownership = new Map([["a.ts", "A"], ["b.ts", "B"]]);
+
+		const result = mergeGroups(groups, ownership, 1);
+		expect(result.groups[0]!.key_changes).toContain("Added auth");
+		expect(result.groups[0]!.key_changes).toContain("Added UI");
+	});
+});

package/src/stack/merge-groups.ts

@@ -0,0 +1,87 @@
+import type { FileGroup } from "../types/output.ts";
+
+export interface MergeResult {
+	groups: FileGroup[];
+	ownership: Map<string, string>;
+	merges: Array<{ absorbed: string; into: string }>;
+}
+
+export function mergeGroups(
+	groups: FileGroup[],
+	ownership: Map<string, string>,
+	targetCount: number,
+): MergeResult {
+	if (targetCount <= 0 || groups.length <= targetCount) {
+		return { groups: [...groups], ownership: new Map(ownership), merges: [] };
+	}
+
+	const working = groups.map((g) => ({ ...g, files: [...g.files] }));
+	const newOwnership = new Map(ownership);
+	const merges: Array<{ absorbed: string; into: string }> = [];
+
+	while (working.length > targetCount) {
+		let minSize = Infinity;
+		let minIdx = -1;
+
+		for (let i = 0; i < working.length; i++) {
+			const size = working[i]!.files.length;
+			if (size < minSize) {
+				minSize = size;
+				minIdx = i;
+			}
+		}
+
+		if (minIdx === -1) break;
+
+		const smallest = working[minIdx]!;
+
+		let bestNeighborIdx = minIdx === 0 ? 1 : minIdx - 1;
+		if (working.length > 2) {
+			const left = minIdx > 0 ? minIdx - 1 : -1;
+			const right = minIdx < working.length - 1 ? minIdx + 1 : -1;
+
+			if (left >= 0 && right >= 0) {
+				bestNeighborIdx = working[left]!.files.length <= working[right]!.files.length
+					? left
+					: right;
+			} else if (left >= 0) {
+				bestNeighborIdx = left;
+			} else {
+				bestNeighborIdx = right;
+			}
+		}
+
+		const neighbor = working[bestNeighborIdx]!;
+
+		const absorbed = smallest.files.length <= neighbor.files.length ? smallest : neighbor;
+		const survivor = absorbed === smallest ? neighbor : smallest;
+
+		for (const file of absorbed.files) {
+			if (!survivor.files.includes(file)) {
+				survivor.files.push(file);
+			}
+		}
+
+		if (absorbed.key_changes) {
+			survivor.key_changes = [
+				...(survivor.key_changes ?? []),
+				...absorbed.key_changes,
+			];
+		}
+
+		for (const [path, groupId] of newOwnership) {
+			if (groupId === absorbed.name) {
+				newOwnership.set(path, survivor.name);
+			}
+		}
+
+		merges.push({ absorbed: absorbed.name, into: survivor.name });
+
+		const removeIdx = working.indexOf(absorbed);
+		if (removeIdx >= 0) {
+			working.splice(removeIdx, 1);
+		}
+	}
+
+	return { groups: working, ownership: newOwnership, merges };
+}

package/src/stack/partition.test.ts

@@ -0,0 +1,233 @@
+import { describe, test, expect } from "bun:test";
+import { detectAmbiguousPaths, partitionGroups, buildStackPartitionPrompt } from "./partition.ts";
+import type { FileGroup } from "../types/output.ts";
+import type { LlmClient, LlmResponse } from "../llm/client.ts";
+
+const mockGroups: FileGroup[] = [
+	{ name: "Auth", type: "feature", description: "Authentication changes", files: ["src/auth.ts", "src/shared.ts"] },
+	{ name: "UI", type: "feature", description: "UI updates", files: ["src/ui.tsx", "src/shared.ts"] },
+	{ name: "Config", type: "config", description: "Config changes", files: ["tsconfig.json"] },
+];
+
+describe("detectAmbiguousPaths", () => {
+	test("identifies exclusive, ambiguous, and unassigned files", () => {
+		const report = detectAmbiguousPaths({
+			groups: mockGroups,
+			changed_files: ["src/auth.ts", "src/ui.tsx", "src/shared.ts", "src/unknown.ts"],
+		});
+
+		expect(report.exclusive.get("src/auth.ts")).toBe("Auth");
+		expect(report.exclusive.get("src/ui.tsx")).toBe("UI");
+
+		expect(report.ambiguous).toEqual([
+			{ path: "src/shared.ts", groups: ["Auth", "UI"] },
+		]);
+
+		expect(report.unassigned).toEqual(["src/unknown.ts"]);
+	});
+
+	test("all files exclusive → no ambiguous or unassigned", () => {
+		const groups: FileGroup[] = [
+			{ name: "A", type: "feature", description: "A", files: ["a.ts"] },
+			{ name: "B", type: "feature", description: "B", files: ["b.ts"] },
+		];
+
+		const report = detectAmbiguousPaths({
+			groups,
+			changed_files: ["a.ts", "b.ts"],
+		});
+
+		expect(report.exclusive.size).toBe(2);
+		expect(report.ambiguous).toEqual([]);
+		expect(report.unassigned).toEqual([]);
+	});
+});
+
+describe("buildStackPartitionPrompt", () => {
+	test("generates prompt with ambiguous and unassigned files", () => {
+		const result = buildStackPartitionPrompt(
+			[{ path: "src/shared.ts", groups: ["Auth", "UI"] }],
+			["src/unknown.ts"],
+			mockGroups,
+			[{ path: "src/shared.ts", status: "modified", summary: "Shared utilities" }],
+			[],
+		);
+
+		expect(result.system).toContain("exactly one group");
+		expect(result.user).toContain("src/shared.ts");
+		expect(result.user).toContain("src/unknown.ts");
+		expect(result.user).toContain("Auth");
+		expect(result.user).toContain("UI");
+	});
+});
+
+describe("partitionGroups", () => {
+	test("returns immediately when all files are exclusive (no LLM call)", async () => {
+		let llmCalled = false;
+		const mockClient: LlmClient = {
+			complete: async () => {
+				llmCalled = true;
+				return { content: "{}", model: "test", usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 } };
+			},
+			completeStream: async () => {
+				return { content: "{}", model: "test", usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 } };
+			},
+		};
+
+		const groups: FileGroup[] = [
+			{ name: "A", type: "feature", description: "A", files: ["a.ts"] },
+			{ name: "B", type: "feature", description: "B", files: ["b.ts"] },
+		];
+
+		const result = await partitionGroups(
+			mockClient,
+			groups,
+			["a.ts", "b.ts"],
+			[],
+			[],
+		);
+
+		expect(llmCalled).toBe(false);
+		expect(result.ownership.get("a.ts")).toBe("A");
+		expect(result.ownership.get("b.ts")).toBe("B");
+		expect(result.reattributed).toEqual([]);
+	});
+
+	test("calls LLM when ambiguous files exist and parses response", async () => {
+		const mockResponse: LlmResponse = {
+			content: JSON.stringify({
+				assignments: [
+					{ path: "src/shared.ts", group: "Auth", reason: "Primarily used for auth" },
+					{ path: "src/unknown.ts", group: "Config", reason: "Configuration file" },
+				],
+				shared_foundation: null,
+			}),
+			model: "test",
+			usage: { prompt_tokens: 100, completion_tokens: 50, total_tokens: 150 },
+		};
+
+		const mockClient: LlmClient = {
+			complete: async () => mockResponse,
+			completeStream: async () => mockResponse,
+		};
+
+		const result = await partitionGroups(
+			mockClient,
+			mockGroups,
+			["src/auth.ts", "src/ui.tsx", "src/shared.ts", "src/unknown.ts"],
+			[{ path: "src/shared.ts", status: "modified", summary: "Shared utils" }],
+			[],
+		);
+
+		expect(result.ownership.get("src/auth.ts")).toBe("Auth");
+		expect(result.ownership.get("src/ui.tsx")).toBe("UI");
+		expect(result.ownership.get("src/shared.ts")).toBe("Auth");
+		expect(result.ownership.get("src/unknown.ts")).toBe("Config");
+
+		expect(result.reattributed.length).toBe(2);
+		expect(result.reattributed[0]?.path).toBe("src/shared.ts");
+		expect(result.reattributed[0]?.to_group).toBe("Auth");
+		expect(result.reattributed[0]?.from_groups).toEqual(["Auth", "UI"]);
+	});
+
+	test("handles LLM response with code block wrapper", async () => {
+		const mockResponse: LlmResponse = {
+			content: "```json\n" + JSON.stringify({
+				assignments: [
+					{ path: "src/shared.ts", group: "Auth", reason: "Auth" },
+				],
+				shared_foundation: null,
+			}) + "\n```",
+			model: "test",
+			usage: { prompt_tokens: 100, completion_tokens: 50, total_tokens: 150 },
+		};
+
+		const mockClient: LlmClient = {
+			complete: async () => mockResponse,
+			completeStream: async () => mockResponse,
+		};
+
+		const groups: FileGroup[] = [
+			{ name: "Auth", type: "feature", description: "Auth", files: ["src/auth.ts", "src/shared.ts"] },
+			{ name: "UI", type: "feature", description: "UI", files: ["src/shared.ts"] },
+		];
+
+		const result = await partitionGroups(
+			mockClient,
+			groups,
+			["src/auth.ts", "src/shared.ts"],
+			[],
+			[],
+		);
+
+		expect(result.ownership.get("src/shared.ts")).toBe("Auth");
+	});
+
+	test("warns on invalid group name in LLM response", async () => {
+		const mockResponse: LlmResponse = {
+			content: JSON.stringify({
+				assignments: [
+					{ path: "src/shared.ts", group: "NonExistentGroup", reason: "Bad" },
+				],
+				shared_foundation: null,
+			}),
+			model: "test",
+			usage: { prompt_tokens: 100, completion_tokens: 50, total_tokens: 150 },
+		};
+
+		const mockClient: LlmClient = {
+			complete: async () => mockResponse,
+			completeStream: async () => mockResponse,
+		};
+
+		const groups: FileGroup[] = [
+			{ name: "Auth", type: "feature", description: "Auth", files: ["src/auth.ts", "src/shared.ts"] },
+			{ name: "UI", type: "feature", description: "UI", files: ["src/shared.ts"] },
+		];
+
+		const result = await partitionGroups(
+			mockClient,
+			groups,
+			["src/auth.ts", "src/shared.ts"],
+			[],
+			[],
+		);
+
+		expect(result.warnings.some((w) => w.includes("Unknown group"))).toBe(true);
+		expect(result.ownership.get("src/shared.ts")).toBe("UI");
+		expect(result.warnings.some((w) => w.includes("force-assigned"))).toBe(true);
+	});
+
+	test("force-assigns unassigned files to last group when LLM omits them", async () => {
+		const mockResponse: LlmResponse = {
+			content: JSON.stringify({
+				assignments: [],
+				shared_foundation: null,
+			}),
+			model: "test",
+			usage: { prompt_tokens: 100, completion_tokens: 50, total_tokens: 150 },
+		};
+
+		const mockClient: LlmClient = {
+			complete: async () => mockResponse,
+			completeStream: async () => mockResponse,
+		};
+
+		const groups: FileGroup[] = [
+			{ name: "Auth", type: "feature", description: "Auth", files: ["src/auth.ts"] },
+			{ name: "UI", type: "feature", description: "UI", files: ["src/ui.tsx"] },
+		];
+
+		const result = await partitionGroups(
+			mockClient,
+			groups,
+			["src/auth.ts", "src/ui.tsx", "src/orphan.ts"],
+			[],
+			[],
+		);
+
+		expect(result.ownership.get("src/orphan.ts")).toBe("UI");
+		expect(result.reattributed.some((r) => r.path === "src/orphan.ts")).toBe(true);
+		expect(result.warnings.some((w) => w.includes("force-assigned"))).toBe(true);
+	});
+});