gentle-pi 4.2.0 → 4.4.0

package/tests/clipboard-image.test.ts

@@ -0,0 +1,114 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { isWsl, readClipboardImage, sniffImageMimeType, type ClipboardCommandRunner } from "../lib/clipboard-image.ts";
+
+// A 2×1 PNG header: signature, IHDR length/type, width 2, height 1.
+const PNG_2X1 = new Uint8Array([
+	0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+	0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
+	0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01,
+	0x08, 0x06, 0x00, 0x00, 0x00,
+]);
+
+type Call = { command: string; args: readonly string[] };
+type Reply = Buffer | undefined | ((call: Call) => Buffer | undefined);
+
+// Scripted backends keyed by `command firstArg`; anything unscripted is "not installed".
+function runner(replies: Record<string, Reply>): { run: ClipboardCommandRunner; calls: Call[] } {
+	const calls: Call[] = [];
+	const run: ClipboardCommandRunner = async (command, args) => {
+		const call = { command, args };
+		calls.push(call);
+		const reply = replies[`${command} ${args[0] ?? ""}`.trim()] ?? replies[command];
+		return typeof reply === "function" ? reply(call) : reply;
+	};
+	return { run, calls };
+}
+
+const BMP = new Uint8Array([0x42, 0x4d, 0x00, 0x00]);
+const noProc = () => undefined;
+
+test("WSL reads a Windows screenshot through PowerShell when the Linux clipboard has none", async () => {
+	const { run, calls } = runner({
+		"wl-paste --list-types": Buffer.from("text/plain\n"),
+		"powershell.exe": Buffer.from(`${Buffer.from(PNG_2X1).toString("base64")}\r\n`),
+	});
+	const image = await readClipboardImage({ env: { WSL_DISTRO_NAME: "Ubuntu" }, platform: "linux", run, native: () => undefined, procVersion: noProc });
+	assert.deepEqual(image && { mimeType: image.mimeType, bytes: [...image.bytes] }, { mimeType: "image/png", bytes: [...PNG_2X1] });
+	const powershell = calls.find((call) => call.command === "powershell.exe");
+	assert.ok(powershell, "PowerShell was consulted");
+	// The image travels on stdout as base64: no temp file path is ever passed.
+	const script = powershell.args.at(-1) ?? "";
+	assert.match(script, /ToBase64String/);
+	assert.doesNotMatch(script, /\$path|Save\('|tmp/i);
+});
+
+test("WSL falls back to PowerShell when wl-paste and xclip are not installed", async () => {
+	const { run, calls } = runner({ "powershell.exe": Buffer.from(Buffer.from(PNG_2X1).toString("base64")) });
+	const image = await readClipboardImage({ env: { WSL_INTEROP: "/run/WSL/1_interop" }, platform: "linux", run, native: () => undefined, procVersion: noProc });
+	assert.equal(image?.mimeType, "image/png");
+	assert.deepEqual(calls.map((call) => call.command), ["wl-paste", "xclip", "powershell.exe"]);
+});
+
+test("Wayland prefers PNG and never asks Windows on a native Linux desktop", async () => {
+	const { run, calls } = runner({
+		"wl-paste --list-types": Buffer.from("image/jpeg\nimage/png\ntext/plain\n"),
+		"wl-paste --type": (call) => call.args[1] === "image/png" ? Buffer.from(PNG_2X1) : undefined,
+	});
+	const image = await readClipboardImage({ env: { WAYLAND_DISPLAY: "wayland-0" }, platform: "linux", run, native: () => undefined, procVersion: noProc });
+	assert.equal(image?.mimeType, "image/png");
+	assert.ok(!calls.some((call) => call.command === "powershell.exe"));
+});
+
+test("an empty Windows clipboard, an unsupported format, or Termux leave the paste to Pi", async () => {
+	const empty = runner({ "powershell.exe": Buffer.from("\r\n") });
+	assert.equal(await readClipboardImage({ env: { WSL_DISTRO_NAME: "Ubuntu" }, platform: "linux", run: empty.run, native: () => undefined, procVersion: noProc }), null);
+	const bmp = runner({ "xclip -selection": (call) => call.args.includes("TARGETS") ? Buffer.from("image/png\n") : Buffer.from(BMP) });
+	assert.equal(await readClipboardImage({ env: {}, platform: "linux", run: bmp.run, native: () => undefined, procVersion: noProc }), null);
+	const termux = runner({});
+	assert.equal(await readClipboardImage({ env: { TERMUX_VERSION: "0.118" }, platform: "linux", run: termux.run, procVersion: noProc }), null);
+	assert.equal(termux.calls.length, 0);
+});
+
+test("macOS reads the native clipboard but leaves copied files to Pi", async () => {
+	const native = (files: string[] | null) => () => ({
+		getText: async () => null,
+		getImage: async () => PNG_2X1,
+		getFilePaths: async () => files,
+	});
+	const image = await readClipboardImage({ env: {}, platform: "darwin", native: native(null) });
+	assert.equal(image?.mimeType, "image/png");
+	assert.equal(await readClipboardImage({ env: {}, platform: "darwin", native: native(["/Users/me/shot.png"]) }), null);
+	assert.equal(await readClipboardImage({ env: {}, platform: "win32", native: () => undefined }), null);
+});
+
+test("a failed wl-paste read falls through to xclip, as Pi does", async () => {
+	const { run, calls } = runner({
+		"wl-paste --list-types": Buffer.from("image/png\n"),
+		"xclip -selection": (call) => call.args.includes("TARGETS") ? Buffer.from("image/png\n") : Buffer.from(PNG_2X1),
+	});
+	const image = await readClipboardImage({ env: { WAYLAND_DISPLAY: "wayland-0" }, platform: "linux", run, native: () => undefined, procVersion: noProc });
+	assert.equal(image?.mimeType, "image/png");
+	assert.deepEqual(calls.map((call) => call.command), ["wl-paste", "wl-paste", "xclip", "xclip"]);
+});
+
+test("files copied in a Linux file manager stay Pi's even when an image is offered too", async () => {
+	const { run, calls } = runner({ "wl-paste --list-types": Buffer.from("image/png\ntext/uri-list\n") });
+	const native = () => ({ getText: async () => null, getImage: async () => PNG_2X1, getFilePaths: async () => ["/home/me/shot.png"] });
+	assert.equal(await readClipboardImage({ env: { WAYLAND_DISPLAY: "wayland-0" }, platform: "linux", run, native, procVersion: noProc }), null);
+	assert.equal(calls.length, 0);
+});
+
+test("image formats are identified by signature", () => {
+	assert.equal(sniffImageMimeType(PNG_2X1), "image/png");
+	assert.equal(sniffImageMimeType(new Uint8Array([0xff, 0xd8, 0xff, 0xe0])), "image/jpeg");
+	assert.equal(sniffImageMimeType(new Uint8Array([0x47, 0x49, 0x46, 0x38, 0x39, 0x61])), "image/gif");
+	assert.equal(sniffImageMimeType(new Uint8Array([0x52, 0x49, 0x46, 0x46, 0, 0, 0, 0, 0x57, 0x45, 0x42, 0x50])), "image/webp");
+	assert.equal(sniffImageMimeType(BMP), undefined);
+});
+
+test("WSL is detected from its environment or the kernel version", () => {
+	assert.equal(isWsl({ WSL_DISTRO_NAME: "Ubuntu" }, noProc), true);
+	assert.equal(isWsl({}, () => "Linux version 6.6.87.2-microsoft-standard-WSL2"), true);
+	assert.equal(isWsl({}, () => "Linux version 6.8.0-generic"), false);
+});

package/tests/codegraph-tools.test.ts

@@ -1,8 +1,8 @@
 import assert from "node:assert/strict";
 import { execFileSync } from "node:child_process";
-import { chmodSync, existsSync, mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import test from "node:test";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import codeGraphTools, {
@@ -356,3 +356,124 @@ test("Windows launcher passes command metacharacters as one literal argv value",
 	}]);
 	assert.equal(existsSync(join(cwd, "shell-injection.txt")), false);
 });
+
+// Real CodeGraph writes .codegraph/.gitignore with `*` and `!.gitignore`, so the
+// .gitignore itself stays untracked and would otherwise enter every diff.
+const writeIndex: CodeGraphRunner = async (_args, options) => {
+	mkdirSync(join(options.cwd, ".codegraph"), { recursive: true });
+	writeFileSync(join(options.cwd, ".codegraph", ".gitignore"), "*\n!.gitignore\n");
+	writeFileSync(join(options.cwd, ".codegraph", "codegraph.db"), "index");
+	return { stdout: "indexed", stderr: "" };
+};
+
+function gitOutput(cwd: string, ...args: string[]): string {
+	return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+
+function excludeFile(cwd: string): string {
+	return realpathSync(resolve(cwd, gitOutput(cwd, "rev-parse", "--git-path", "info/exclude")));
+}
+
+function excludeLines(cwd: string): string[] {
+	return readFileSync(excludeFile(cwd), "utf8").split("\n").filter((line) => line.trim() === ".codegraph/");
+}
+
+test("CodeGraph init keeps the whole .codegraph index out of git through the local exclude file, idempotently", async (t) => {
+	const cwd = workspace(t);
+	writeFileSync(join(cwd, "tracked.txt"), "tracked\n");
+	execFileSync("git", ["add", "tracked.txt"], { cwd });
+	const tool = createCodeGraphTool(writeIndex);
+	const ctx = { cwd } as ExtensionContext;
+
+	const first = await tool.execute("test", { operation: "init" }, undefined, undefined, ctx);
+	const second = await tool.execute("test", { operation: "init" }, undefined, undefined, ctx);
+
+	assert.deepEqual(first.content, [{ type: "text", text: "indexed" }]);
+	assert.equal(gitOutput(cwd, "status", "--porcelain", "--untracked-files=all"), "A  tracked.txt");
+	assert.deepEqual(excludeLines(cwd), [".codegraph/"], "exactly one exclude line after repeated init");
+	assert.equal(existsSync(join(cwd, ".gitignore")), false, "never creates or edits a tracked .gitignore");
+	assert.deepEqual((first.details as { localExclude?: unknown }).localExclude, { status: "added", path: excludeFile(cwd) });
+	assert.deepEqual((second.details as { localExclude?: unknown }).localExclude, { status: "present", path: excludeFile(cwd) });
+});
+
+test("CodeGraph exclusion appends on a new line and recognizes an equivalent existing pattern", async (t) => {
+	const appended = workspace(t);
+	writeFileSync(excludeFile(appended), "# local\n*.log");
+	await createCodeGraphTool(writeIndex).execute("test", { operation: "init" }, undefined, undefined, { cwd: appended } as ExtensionContext);
+	assert.equal(readFileSync(excludeFile(appended), "utf8"), "# local\n*.log\n.codegraph/\n");
+
+	const equivalent = workspace(t);
+	writeFileSync(excludeFile(equivalent), "/.codegraph\n");
+	const result = await createCodeGraphTool(writeIndex).execute("test", { operation: "init" }, undefined, undefined, { cwd: equivalent } as ExtensionContext);
+	assert.equal(readFileSync(excludeFile(equivalent), "utf8"), "/.codegraph\n");
+	assert.equal((result.details as { localExclude?: { status: string } }).localExclude?.status, "present");
+	assert.equal(gitOutput(equivalent, "status", "--porcelain", "--untracked-files=all"), "");
+});
+
+test("CodeGraph exclusion uses the exclude file git resolves for a linked worktree", async (t) => {
+	const base = realpathSync(mkdtempSync(join(tmpdir(), "gentle-pi-codegraph-worktree-")));
+	t.after(() => rmSync(base, { recursive: true, force: true }));
+	const primary = join(base, "primary");
+	const linked = join(base, "linked");
+	mkdirSync(primary);
+	execFileSync("git", ["init", "-b", "main"], { cwd: primary, stdio: "ignore" });
+	execFileSync("git", ["-c", "user.name=Fixture", "-c", "user.email=fixture@example.invalid", "-c", "commit.gpgsign=false", "commit", "--allow-empty", "-m", "fixture"], { cwd: primary, stdio: "ignore" });
+	execFileSync("git", ["worktree", "add", "-b", "feature", linked], { cwd: primary, stdio: "ignore" });
+
+	const result = await createCodeGraphTool(writeIndex).execute("test", { operation: "init" }, undefined, undefined, { cwd: linked } as ExtensionContext);
+
+	assert.deepEqual(result.content, [{ type: "text", text: "indexed" }]);
+	assert.equal(gitOutput(linked, "status", "--porcelain", "--untracked-files=all"), "");
+	assert.deepEqual(excludeLines(linked), [".codegraph/"]);
+	assert.equal((result.details as { localExclude?: { path: string } }).localExclude?.path, excludeFile(linked));
+	assert.equal(existsSync(join(linked, ".git", "info")), false, "the linked worktree's .git file is never treated as a directory");
+});
+
+test("CodeGraph query excludes an index that already exists, and leaves the exclude file alone without one", async (t) => {
+	const indexed = workspace(t);
+	await writeIndex(["init", indexed], { cwd: indexed, maxBuffer: 1 });
+	const answer: CodeGraphRunner = async () => ({ stdout: "found", stderr: "" });
+	await createCodeGraphTool(answer).execute("test", { operation: "query", query: "symbol" }, undefined, undefined, { cwd: indexed } as ExtensionContext);
+	assert.deepEqual(excludeLines(indexed), [".codegraph/"]);
+	assert.equal(gitOutput(indexed, "status", "--porcelain", "--untracked-files=all"), "");
+
+	const bare = workspace(t);
+	const result = await createCodeGraphTool(answer).execute("test", { operation: "query", query: "symbol" }, undefined, undefined, { cwd: bare } as ExtensionContext);
+	assert.deepEqual(excludeLines(bare), []);
+	assert.equal((result.details as { localExclude?: unknown }).localExclude, undefined);
+});
+
+test("CodeGraph init still succeeds and reports when git is unavailable for the local exclusion", async (t) => {
+	const cwd = workspace(t);
+	const empty = realpathSync(mkdtempSync(join(tmpdir(), "gentle-pi-codegraph-nogit-")));
+	const originalPath = process.env.PATH;
+	t.after(() => {
+		process.env.PATH = originalPath;
+		rmSync(empty, { recursive: true, force: true });
+	});
+	const result = await createCodeGraphTool(async (args, options) => {
+		const output = await writeIndex(args, options);
+		process.env.PATH = empty; // git disappears after the workspace check
+		return output;
+	}).execute("test", { operation: "init" }, undefined, undefined, { cwd } as ExtensionContext);
+	process.env.PATH = originalPath;
+
+	assert.match(result.content[0].text, /^indexed\n\n/);
+	assert.match(result.content[0].text, /\.codegraph\/ is not excluded from git locally/);
+	assert.match(result.content[0].text, /keep \.codegraph\/ out of the change/i);
+	assert.equal((result.details as { localExclude?: { status: string } }).localExclude?.status, "failed");
+	assert.deepEqual(excludeLines(cwd), []);
+});
+
+test("CodeGraph excludes a partial index left behind by a failed init without changing the fallback text", async (t) => {
+	const cwd = workspace(t);
+	const result = await createCodeGraphTool(async (args, options) => {
+		await writeIndex(args, options);
+		throw new Error("CodeGraph exited with status 1");
+	}).execute("test", { operation: "init" }, undefined, undefined, { cwd } as ExtensionContext);
+
+	assert.deepEqual(result.content, [{ type: "text", text: "CodeGraph failed to run. Use read, grep, and find for this exploration." }]);
+	assert.equal((result.details as { status: string }).status, "failed");
+	assert.equal((result.details as { localExclude?: { status: string } }).localExclude?.status, "added");
+	assert.equal(gitOutput(cwd, "status", "--porcelain", "--untracked-files=all"), "");
+});

package/tests/command-palette.test.ts

@@ -4,6 +4,8 @@ import { existsSync, readFileSync } from "node:fs";
 import { visibleWidth } from "@earendil-works/pi-tui";
 import { CommandPalette, commandsKey, rankPaletteGroups, type CommandPaletteGroup, type CommandPaletteItem, type CommandPaletteResult, type CommandPaletteTheme } from "../lib/command-palette.ts";
 import { buildCommandPaletteGroups, COMMAND_PALETTE_CATALOG } from "../lib/command-palette-catalog.ts";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import startupBanner from "../extensions/startup-banner.ts";
 
 // Command palette: a pure, curated, grouped overlay component for
 // `/gentle:commands` and its `alt+k` shortcut. These tests drive ranking,
@@ -370,18 +372,26 @@ test("COMMAND_PALETTE_CATALOG matches the curated command set, in order", () =>
 		"gentle:animations",
 		"gentle:vim",
 		"gentle:telemetry",
-		"gentle:banner",
-		"gentle:banner-color",
-		"gentle:toggle-rose",
-		"gentle:toggle-text-logo",
 		"gentle:dev-binary",
 	]);
-	assert.deepEqual(byTitle("Session"), ["gentle:yolo", "gentle:changes", "gentle:agents", "gentle:jobs", "gentle:usage", "gentle:review-session-permission"]);
+	assert.deepEqual(byTitle("Session"), ["gentle:yolo", "gentle:changes", "gentle:agents", "gentle:jobs", "gentle:usage", "gentle:review-session-permission", "gentle:voice", "gentle:design"]);
 	assert.deepEqual(byTitle("Diagnostics"), ["gentle:status", "gentle:doctor"]);
 	assert.equal(byTitle("SDD"), undefined);
 	assert.deepEqual(byTitle("Skills"), ["skill-registry:refresh"]);
 });
 
+// #1664: banner settings live under Customization > Banner; the palette keeps
+// one route while the slash commands stay registered for compatibility.
+test("banner settings have one palette route and keep their slash commands", () => {
+	const banner = ["gentle:banner", "gentle:banner-color", "gentle:toggle-rose", "gentle:toggle-text-logo"];
+	const catalogCommands = COMMAND_PALETTE_CATALOG.flatMap((group) => group.items.map((item) => item.command));
+	for (const command of banner) assert.ok(!catalogCommands.includes(command), `${command} must not appear in the palette`);
+	assert.ok(catalogCommands.includes("gentle:customize"));
+	const registered: string[] = [];
+	startupBanner({ on() {}, registerCommand(name: string) { registered.push(name); }, getCommands: () => [], getAllTools: () => [] } as unknown as ExtensionAPI);
+	for (const command of banner) assert.ok(registered.includes(command), `${command} stays registered`);
+});
+
 test("retired SDD commands are absent from the palette and extension registrations", () => {
 	const retired = ["gentle:sdd-preflight", "gentle-sdd-status", "gentle-sdd-continue", "gentle-sdd-init", "gentle:install-sdd"];
 	const catalogCommands = COMMAND_PALETTE_CATALOG.flatMap((group) => group.items.map((item) => item.command));

package/tests/commit-slice-signal.test.ts

@@ -0,0 +1,162 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { appendFileSync, mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test, { type TestContext } from "node:test";
+import { commitSliceReport, commitSliceToolResult, commitTargetDirectory, isGitCommitCommand } from "../lib/commit-slice-signal.ts";
+
+// Harness roadmap T4 (R1): the ~400-line slice rule lived in the prompt and the
+// model had to estimate line counts. After each parent commit the runtime now
+// reports the authored changed lines on the branch, so slicing reads a number.
+
+function repo(t: TestContext): { dir: string; git: (...args: string[]) => string; commitFile: (path: string, lines: number) => void } {
+	const dir = realpathSync(mkdtempSync(join(tmpdir(), "commit-slice-")));
+	t.after(() => rmSync(dir, { recursive: true, force: true }));
+	const git = (...args: string[]) => execFileSync("git", ["-c", "user.name=Fixture", "-c", "user.email=fixture@example.com", "-c", "commit.gpgsign=false", ...args], { cwd: dir, encoding: "utf8" });
+	const commitFile = (path: string, lines: number) => {
+		mkdirSync(join(dir, path, ".."), { recursive: true });
+		writeFileSync(join(dir, path), Array.from({ length: lines }, (_, i) => `line ${i}`).join("\n") + "\n");
+		git("add", "--", path);
+		git("commit", "-q", "-m", `add ${path}`);
+	};
+	git("init", "-q", "-b", "main");
+	commitFile("README.md", 3);
+	return { dir, git, commitFile };
+}
+
+test("isGitCommitCommand recognizes commits inside shell commands, nothing else", () => {
+	for (const command of ["git commit -m 'feat: x'", "git add -A && git commit -qm x", "cd pkg && git -C . commit --amend --no-edit", "git -c user.name=a commit -m x"]) {
+		assert.equal(isGitCommitCommand(command), true, command);
+	}
+	for (const command of ["git status", "git log --grep commit", "echo git commit", "npm test", "git commit-tree abc"]) {
+		assert.equal(isGitCommitCommand(command), false, command);
+	}
+});
+
+// R1 review advisory: any `echo ... git` segment hid a real commit elsewhere in
+// the command, while text that only mentioned `git commit` counted as one.
+test("isGitCommitCommand counts a git invocation that starts a shell segment, not text that mentions one", () => {
+	for (const command of ["echo 'staging git files' && git commit -m x", "echo git status; git commit -m x", "GIT_AUTHOR_DATE=now git commit -m x", "(cd pkg && git commit -m x)", "git add -A\ngit commit -m x", "git commit -m 'feat: git commit counting'"]) {
+		assert.equal(isGitCommitCommand(command), true, command);
+	}
+	for (const command of ["printf 'run git commit now'", "gh pr create --body \"then git commit -m x\"", "grep -rn 'git commit' docs", "echo \"git commit -m x\""]) {
+		assert.equal(isGitCommitCommand(command), false, command);
+	}
+});
+
+test("commitTargetDirectory follows git -C and a leading cd", () => {
+	assert.equal(commitTargetDirectory("git commit -m x", "/work/repo"), "/work/repo");
+	assert.equal(commitTargetDirectory("git -C ../other commit -m x", "/work/repo"), "/work/other");
+	assert.equal(commitTargetDirectory("cd /tmp/x && git commit -m x", "/work/repo"), "/tmp/x");
+});
+
+// PR #2290 review: only a leading `cd <dir> &&` moved the count, so a commit after
+// `cd <dir>;` or a later `cd` counted the session cwd instead.
+test("commitTargetDirectory follows a cd that precedes the commit through ;, && or ||", () => {
+	assert.equal(commitTargetDirectory("cd /tmp/x; git commit -m x", "/work/repo"), "/tmp/x");
+	assert.equal(commitTargetDirectory("git add -A && cd pkg && git commit -m x", "/work/repo"), "/work/repo/pkg");
+	assert.equal(commitTargetDirectory("cd /tmp/x || exit 1; git commit -m x", "/work/repo"), "/tmp/x");
+	assert.equal(commitTargetDirectory("cd a && cd 'b c'\ngit -C d commit -m x", "/work/repo"), "/work/repo/a/b c/d");
+	assert.equal(commitTargetDirectory("git commit -m x && cd /tmp/x", "/work/repo"), "/work/repo", "a cd after the commit does not move it");
+});
+
+test("a feature branch reports authored changed lines since the default branch, lock files excluded", async (t) => {
+	const { dir, git, commitFile } = repo(t);
+	git("switch", "-q", "-c", "feat/slice");
+	commitFile("src/a.ts", 120);
+	commitFile("pnpm-lock.yaml", 900);
+	commitFile("tests/a.test.ts", 30);
+	const report = await commitSliceReport(dir);
+	assert.match(report ?? "", /^Commit slice: 150 authored changed lines in 3 commits on feat\/slice since main/);
+	assert.match(report ?? "", /250 lines left before the ~400-line slice/);
+});
+
+// PR #2290 review: `--no-renames` counted a moved file as all of its lines deleted
+// and added again; rename detection counts only what the move changed.
+test("a move-only commit counts no authored lines", async (t) => {
+	const { dir, git, commitFile } = repo(t);
+	commitFile("src/old.ts", 120);
+	git("switch", "-q", "-c", "feat/move");
+	git("mv", "src/old.ts", "src/new.ts");
+	git("commit", "-q", "-m", "move src/old.ts");
+	assert.match(await commitSliceReport(dir) ?? "", /^Commit slice: 0 authored changed lines in 1 commit on feat\/move/);
+	git("mv", "src/new.ts", "src/newer.ts");
+	appendFileSync(join(dir, "src/newer.ts"), "line 120\n");
+	git("commit", "-qam", "move and extend src/new.ts");
+	assert.match(await commitSliceReport(dir) ?? "", /^Commit slice: 1 authored changed lines in 2 commits on feat\/move/, "a move that edits counts only the edit");
+});
+
+// PR #2290 review: Git quotes an unusual path in plain numstat output, so the
+// trailing quote hid a lock file from the generated-file filter.
+test("a lock file whose path Git quotes is still excluded", async (t) => {
+	const { dir, git, commitFile } = repo(t);
+	git("switch", "-q", "-c", "feat/quoted");
+	commitFile("packages/caf\u00e9/pnpm-lock.yaml", 900);
+	commitFile("src/a.ts", 10);
+	assert.match(git("-c", "core.quotePath=true", "diff", "--numstat", "main", "HEAD"), /"packages\/caf\\303\\251\/pnpm-lock\.yaml"/, "the fixture path needs quoting");
+	assert.match(await commitSliceReport(dir) ?? "", /^Commit slice: 10 authored changed lines in 2 commits on feat\/quoted/);
+});
+
+test("past ~400 lines the report says to apply the delivery strategy before the next commit", async (t) => {
+	const { dir, git, commitFile } = repo(t);
+	git("switch", "-q", "-c", "feat/big");
+	commitFile("src/big.ts", 450);
+	assert.match(await commitSliceReport(dir) ?? "", /450 authored changed lines in 1 commit on feat\/big since main\b.*Past the ~400-line slice: apply the feature's delivery strategy before the next commit/);
+});
+
+// R1 review advisory: the report ran git synchronously in the parent's
+// tool_result handler, so the interface froze for as long as git took.
+test("the parent keeps running while git computes the report", async (t) => {
+	const { dir, git, commitFile } = repo(t);
+	git("switch", "-q", "-c", "feat/async");
+	commitFile("src/a.ts", 10);
+	let ran = false;
+	setImmediate(() => { ran = true; });
+	const report = await commitSliceReport(dir);
+	assert.equal(ran, true, "the event loop ran while git answered");
+	assert.match(report ?? "", /^Commit slice: 10 authored changed lines in 1 commit on feat\/async/);
+});
+
+// R1 review advisory: a failed or timed-out `git diff` read as an empty diff
+// and reported "0 authored changed lines"; no number beats a wrong one.
+test("a failed diff reports nothing instead of zero lines", async () => {
+	const answers: Record<string, string | undefined> = {
+		"symbolic-ref -q --short HEAD": "feat/slice",
+		"symbolic-ref -q --short refs/remotes/origin/HEAD": "origin/main",
+		"merge-base HEAD origin/main": "base",
+		"rev-list --count base..HEAD": "2",
+		"diff --numstat -z -M base HEAD": "12\t3\tsrc/a.ts\0",
+	};
+	const git = async (args: string[]) => answers[args.join(" ")];
+	assert.match(await commitSliceReport("/repo", git) ?? "", /^Commit slice: 15 authored changed lines in 2 commits/);
+	delete answers["diff --numstat -z -M base HEAD"];
+	assert.equal(await commitSliceReport("/repo", git), undefined);
+});
+
+// R1 review advisory: a background job's result arrives when the job starts,
+// before its commit exists, so its slice line would describe the old HEAD.
+test("only a foreground bash commit carries the slice line", async () => {
+	const git = async (args: string[]) => ({
+		"symbolic-ref -q --short HEAD": "feat/slice",
+		"symbolic-ref -q --short refs/remotes/origin/HEAD": "origin/main",
+		"merge-base HEAD origin/main": "base",
+		"rev-list --count base..HEAD": "1",
+		"diff --numstat -z -M base HEAD": "5\t0\tsrc/a.ts\0",
+	} as Record<string, string>)[args.join(" ")];
+	const event = (toolName: string) => ({ toolName, input: { command: "git commit -m x" }, isError: false, content: [{ type: "text" as const, text: "ok" }], structuredContent: undefined });
+	assert.match(JSON.stringify((await commitSliceToolResult(event("bash"), "/repo", git))?.content), /Commit slice: 5 authored changed lines/);
+	assert.equal(await commitSliceToolResult(event("bash_background"), "/repo", git), undefined);
+	assert.equal(await commitSliceToolResult(event("monitor"), "/repo", git), undefined);
+});
+
+test("commits on the default branch, outside Git, or with nothing ahead report nothing", async (t) => {
+	const { dir, git, commitFile } = repo(t);
+	commitFile("src/direct.ts", 10);
+	assert.equal(await commitSliceReport(dir), undefined, "the default branch has no slice");
+	git("switch", "-q", "-c", "feat/empty");
+	assert.equal(await commitSliceReport(dir), undefined, "nothing ahead of the default branch");
+	const plain = realpathSync(mkdtempSync(join(tmpdir(), "commit-slice-plain-")));
+	t.after(() => rmSync(plain, { recursive: true, force: true }));
+	assert.equal(await commitSliceReport(plain), undefined, "outside Git");
+});