gentle-pi 4.2.0 → 4.3.0

package/tests/child-safety.test.ts

@@ -1,4 +1,7 @@
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import test from "node:test";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { createChildSafetyExtension } from "../extensions/child-safety.ts";
@@ -59,6 +62,23 @@ test("headless children reject corrected literal forms without prompting", async
 	}
 });
 
+// gentle-pi#2285: removal behind reserved words, in backticks or in eval is still data loss.
+test("children block destruction after reserved words, in backticks and in eval", async () => {
+	for (const primary of [false, true]) {
+		const h = harness(true, primary);
+		const ctx = context(async () => { throw new Error("child must never prompt"); }, false);
+		for (const command of [
+			`if true; then rm -rf data; fi`, `for d in a b; do rm -rf "$d"; done`, "echo `rm -rf data`", `eval 'rm -rf data'`,
+			`if true; then rm -rf ~; fi`, `{ rm -rf data; }`, `while true; do rm -rf data; done`,
+		]) {
+			assert.equal((await h.handlers[0](event(command), ctx) as { block?: boolean })?.block, true, command);
+		}
+		for (const command of [`if [ -f x ]; then echo ok; fi`, `for f in *; do cat "$f"; done`, "echo `date`", `grep "then rm -rf" x`]) {
+			assert.equal(await h.handlers[0](event(command), ctx), undefined, command);
+		}
+	}
+});
+
 test("primary requires fresh confirmation, cancellation and missing UI block", async () => {
 	const h = harness(false, true);
 	const command = `psql -c 'DROP TABLE users'`;
@@ -81,6 +101,25 @@ test("primary requires fresh confirmation, cancellation and missing UI block", a
 	assert.deepEqual(blockers, [true, false, true, false, true, false, true, false]);
 });
 
+// The YOLO temp-scratch waiver is primary-only: children still block it and
+// Normal mode still asks, whatever the targets look like on disk.
+test("temp scratch removal stays blocked in children and confirmed in Normal mode", async () => {
+	const scratch = mkdtempSync(join(tmpdir(), "tmp."));
+	try {
+		const command = `rm -rf ${scratch} /tmp/tmp.8phya1BpFr /tmp/ctx-backstop-pnpm-test.log; cd /tmp && git log --oneline -1`;
+		for (const primary of [false, true]) {
+			const result = await harness(true, primary).handlers[0](event(command), context(async () => { throw new Error("child must never prompt"); }));
+			assert.equal((result as { block?: boolean })?.block, true, `child via ${primary ? "primary" : "safety"} entry`);
+		}
+		const titles: string[] = [];
+		const normal = harness(false, true);
+		assert.equal(await normal.handlers[0](event(command), context(async (title) => { titles.push(title); return true; })), undefined);
+		assert.deepEqual(titles, ["Allow recognized data-loss command?"]);
+	} finally {
+		rmSync(scratch, { recursive: true, force: true });
+	}
+});
+
 test("children block recognized destructive commands sent to bash_background too", async () => {
 	const h = harness(true);
 	const result = await h.handlers[0]({ toolName: "bash_background", input: { command: "echo ok && rm -rf ./data" } }, context(async () => { throw new Error("child must never prompt"); }));

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,10 +372,6 @@ 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"]);
@@ -382,6 +380,18 @@ test("COMMAND_PALETTE_CATALOG matches the curated command set, in order", () =>
 	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");
+});

package/tests/context-backstop.test.ts

@@ -0,0 +1,159 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { 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 type { ContextUsage, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { createGentleAiExtension } from "../extensions/gentle-ai.ts";
+import {
+	CONTEXT_BACKSTOP_FRACTION_ENV,
+	CONTEXT_BACKSTOP_TOKENS_ENV,
+	contextBackstopReached,
+	contextBackstopThreshold,
+} from "../lib/context-backstop.ts";
+
+// Harness roadmap R1: the parent-context backstop was a fixed "~150k tokens" in prompt text, so the model had to
+// estimate its own context. The runtime now measures it against min(absolute cap, fraction x context window) and
+// tells the primary session once per crossing.
+
+test("the threshold is the smaller of the absolute cap and 15% of the context window", () => {
+	assert.equal(contextBackstopThreshold(1_000_000, {}), 150_000, "a large window keeps the absolute cap");
+	assert.equal(contextBackstopThreshold(400_000, {}), 60_000);
+	// Bench gate (T12): a 272k window reaches it near 41k, where delegating the wide task paid off.
+	assert.equal(contextBackstopThreshold(272_000, {}), 40_800);
+	assert.equal(contextBackstopThreshold(200_000, {}), 30_000, "a small window reaches it at 15% of its size");
+	assert.equal(contextBackstopThreshold(128_000, {}), 19_200);
+	for (const unknown of [undefined, null, 0, -1, Number.NaN, Number.POSITIVE_INFINITY]) {
+		assert.equal(contextBackstopThreshold(unknown, {}), 150_000, `window ${unknown} falls back to the cap`);
+	}
+});
+
+test("the cap and the fraction are overridable by environment; invalid values keep the defaults", () => {
+	assert.equal(contextBackstopThreshold(1_000_000, { [CONTEXT_BACKSTOP_TOKENS_ENV]: "100000" }), 100_000);
+	assert.equal(contextBackstopThreshold(4_000_000, { [CONTEXT_BACKSTOP_TOKENS_ENV]: "300000" }), 300_000, "a raised cap applies where the fraction allows it");
+	assert.equal(contextBackstopThreshold(1_000_000, { [CONTEXT_BACKSTOP_FRACTION_ENV]: "0.1" }), 100_000);
+	assert.equal(contextBackstopThreshold(200_000, { [CONTEXT_BACKSTOP_TOKENS_ENV]: "80000", [CONTEXT_BACKSTOP_FRACTION_ENV]: "1" }), 80_000);
+	for (const value of ["", "abc", "0", "-5", "1.5e999"]) {
+		assert.equal(contextBackstopThreshold(1_000_000, { [CONTEXT_BACKSTOP_TOKENS_ENV]: value }), 150_000, `tokens ${JSON.stringify(value)}`);
+	}
+	for (const value of ["", "abc", "0", "-0.5", "1.5"]) {
+		assert.equal(contextBackstopThreshold(200_000, { [CONTEXT_BACKSTOP_FRACTION_ENV]: value }), 30_000, `fraction ${JSON.stringify(value)}`);
+	}
+});
+
+// R1 review advisory: a tiny window or fraction floored the threshold to 0, so an
+// empty context counted as reaching the backstop (and admitted every writer).
+test("the threshold is never below one token, so an empty context never reaches it", () => {
+	assert.equal(contextBackstopThreshold(200_000, { [CONTEXT_BACKSTOP_FRACTION_ENV]: "0.000001" }), 1);
+	assert.equal(contextBackstopThreshold(1, {}), 1);
+	assert.equal(contextBackstopReached({ tokens: 0, contextWindow: 1 }, {}), false);
+	assert.equal(contextBackstopReached({ tokens: 1, contextWindow: 1 }, {}), true);
+});
+
+test("unknown tokens never count as reaching the backstop", () => {
+	assert.equal(contextBackstopReached({ tokens: 150_000, contextWindow: 1_000_000 }, {}), true);
+	assert.equal(contextBackstopReached({ tokens: 149_999, contextWindow: 1_000_000 }, {}), false);
+	assert.equal(contextBackstopReached({ tokens: 19_200, contextWindow: 128_000 }, {}), true);
+	assert.equal(contextBackstopReached({ tokens: 19_199, contextWindow: 128_000 }, {}), false);
+	assert.equal(contextBackstopReached({ tokens: null, contextWindow: 128_000 }, {}), false, "null right after compaction");
+	assert.equal(contextBackstopReached(undefined, {}), false);
+});
+
+type Handler = (event: unknown, ctx: ExtensionContext) => unknown;
+type Patch = { content?: Array<{ type: string; text?: string }>; structuredContent?: unknown; isError?: boolean } | undefined;
+
+function session(t: TestContext, child: boolean) {
+	const cwd = realpathSync(mkdtempSync(join(tmpdir(), "context-backstop-")));
+	const configHome = mkdtempSync(join(tmpdir(), "context-backstop-config-"));
+	const previous = process.env.GENTLE_PI_CONFIG_HOME;
+	process.env.GENTLE_PI_CONFIG_HOME = configHome;
+	t.after(() => {
+		if (previous === undefined) delete process.env.GENTLE_PI_CONFIG_HOME;
+		else process.env.GENTLE_PI_CONFIG_HOME = previous;
+		rmSync(cwd, { recursive: true, force: true });
+		rmSync(configHome, { recursive: true, force: true });
+	});
+	const handlers = new Map<string, Handler>();
+	const pi = { on: (name: string, handler: Handler) => { handlers.set(name, handler); }, events: { on() {}, emit() {} }, registerCommand() {}, registerTool() {} } as unknown as ExtensionAPI;
+	createGentleAiExtension({ nativeReviewCli: null, processEnv: { GENTLE_PI_AGENTS_CHILD: child ? "1" : "0", GENTLE_AI_TELEMETRY: "0" } })(pi);
+	let usage: ContextUsage | undefined = { tokens: 10_000, contextWindow: 1_000_000, percent: 1 };
+	const sessionManager = { getSessionId: () => "session-backstop", getCwd: () => cwd, getEntries: () => [], getBranch: () => [] };
+	const ctx = { cwd, hasUI: false, ui: { notify() {} }, sessionManager, getContextUsage: () => usage } as unknown as ExtensionContext;
+	const setTokens = (tokens: number | null, contextWindow = 1_000_000) => {
+		usage = { tokens, contextWindow, percent: tokens === null ? null : (tokens / contextWindow) * 100 };
+	};
+	const read = (overrides: Record<string, unknown> = {}) => handlers.get("tool_result")!({
+		toolName: "read", toolCallId: "call-read", isError: false, input: { path: "a.ts" },
+		content: [{ type: "text", text: "file body" }], structuredContent: { lines: 1 }, ...overrides,
+	}, ctx) as Promise<Patch>;
+	return { cwd, ctx, handlers, setTokens, read };
+}
+
+test("the primary session gets one notice when its measured context first reaches the backstop", async (t) => {
+	const s = session(t, false);
+	assert.equal(await s.read(), undefined, "below the backstop nothing is appended");
+	s.setTokens(160_000);
+	const crossed = await s.read();
+	assert.equal(crossed?.content?.[0]?.text, "file body", "the tool output is kept first");
+	const notice = crossed?.content?.[1]?.text ?? "";
+	assert.match(notice, /Context backstop/);
+	assert.match(notice, /160,000 tokens/, "measured tokens");
+	assert.match(notice, /16% of the 1,000,000-token context window/, "percent of the window");
+	assert.match(notice, /150,000-token backstop/, "the threshold");
+	assert.match(notice, /delegate the next bounded unit that needs several steps \(its reads, edits, and checks\) with a short handoff/);
+	assert.match(notice, /single small edits and state checks stay inline/);
+	assert.deepEqual(crossed?.structuredContent, { lines: 1 }, "structured content is kept");
+	assert.equal(crossed && "isError" in crossed, false, "the error flag is never altered");
+	assert.equal(await s.read(), undefined, "once per crossing");
+	s.setTokens(null);
+	assert.equal(await s.read(), undefined, "unknown tokens neither notify nor re-arm");
+	s.setTokens(170_000);
+	assert.equal(await s.read(), undefined, "still past the same crossing");
+	s.setTokens(40_000);
+	assert.equal(await s.read(), undefined, "dropping below the backstop re-arms it");
+	s.setTokens(19_200, 128_000);
+	const again = await s.read({ isError: true, structuredContent: undefined });
+	assert.match(again?.content?.[1]?.text ?? "", /19,200 tokens \(15% of the 128,000-token context window\), at or past the 19,200-token backstop/, "a small window reaches it at 15% of its size");
+	assert.equal(again && "structuredContent" in again, false, "absent structured content stays absent");
+	assert.equal(again && "isError" in again, false, "an error result keeps its flag");
+});
+
+test("child sessions never get the notice", async (t) => {
+	const s = session(t, true);
+	s.setTokens(390_000);
+	assert.equal(await s.read(), undefined);
+});
+
+test("a parent commit result carries both the slice line and the backstop notice", async (t) => {
+	const s = session(t, false);
+	const git = (...args: string[]) => execFileSync("git", ["-c", "user.name=Fixture", "-c", "user.email=fixture@example.com", "-c", "commit.gpgsign=false", ...args], { cwd: s.cwd, encoding: "utf8" });
+	git("init", "-q", "-b", "main");
+	writeFileSync(join(s.cwd, "README.md"), "base\n");
+	git("add", "README.md");
+	git("commit", "-q", "-m", "base");
+	git("switch", "-q", "-c", "feat/x");
+	writeFileSync(join(s.cwd, "a.ts"), "one\n");
+	git("add", "a.ts");
+	git("commit", "-q", "-m", "feat: a");
+	s.setTokens(200_000);
+	const result = await s.handlers.get("tool_result")!({
+		toolName: "bash", toolCallId: "call-1", isError: false, input: { command: "git commit -m 'feat: a'" },
+		content: [{ type: "text", text: "[feat/x 1234567] feat: a" }], structuredContent: { exitCode: 0 },
+	}, s.ctx) as Patch;
+	assert.equal(result?.content?.[0]?.text, "[feat/x 1234567] feat: a");
+	assert.match(result?.content?.[1]?.text ?? "", /Commit slice: 1 authored changed lines/);
+	assert.match(result?.content?.[2]?.text ?? "", /Context backstop/);
+	assert.deepEqual(result?.structuredContent, { exitCode: 0 });
+});
+
+test("a parent write result carries the notice after its own bookkeeping", async (t) => {
+	const s = session(t, false);
+	s.setTokens(150_000);
+	const result = await s.handlers.get("tool_result")!({
+		toolName: "write", toolCallId: "call-w", isError: false, input: { path: "src/a.ts" },
+		content: [{ type: "text", text: "Wrote src/a.ts" }],
+	}, s.ctx) as Patch;
+	assert.equal(result?.content?.[0]?.text, "Wrote src/a.ts");
+	assert.match(result?.content?.[1]?.text ?? "", /Context backstop/);
+});