gentle-pi 4.0.0 → 4.2.0

package/tests/writer-surfaces.test.ts

@@ -0,0 +1,199 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { worktreeGitEnvironment } from "../lib/session-worktree-registry.ts";
+import { canonicalWriterRoot, normalizeSurfaceEntry, overlappingSurfaces, surfacesOverlap, WriterSurfaceRegistry, writerSurfaceConflictMessage } from "../lib/writer-surfaces.ts";
+
+// gentle-shell#1731 T4 (S2, AC6): concurrent writers are admitted only when
+// their `## Allowed edit surfaces` are disjoint. Overlap is conservative: two
+// entries overlap when some path could be covered by both, and an entry also
+// covers everything under it, so uncertainty always reads as overlap.
+
+test("normalizeSurfaceEntry strips list markers, backticks, ./ and trailing slashes", () => {
+	assert.equal(normalizeSurfaceEntry("lib/a.ts"), "lib/a.ts");
+	assert.equal(normalizeSurfaceEntry("- `docs/with space.md`"), "docs/with space.md");
+	assert.equal(normalizeSurfaceEntry("`./lib//a.ts`"), "lib/a.ts");
+	assert.equal(normalizeSurfaceEntry("lib\\nested\\a.ts"), "lib\\nested\\a.ts", "backslashes are kept for the fail-safe check");
+	assert.equal(normalizeSurfaceEntry("src/cafe\u0301.ts"), "src/caf\u00e9.ts", "entries compare in NFC");
+	assert.equal(normalizeSurfaceEntry("lib/./dir/"), "lib/dir");
+	assert.equal(normalizeSurfaceEntry("  1. tests/x.test.ts  "), "tests/x.test.ts");
+});
+
+test("normalizeSurfaceEntry refuses entries it cannot scope", () => {
+	for (const entry of ["", " ", ".", "./", "/abs/a.ts", "~/a.ts", "C:/a.ts", "lib/../a.ts", "``"]) {
+		assert.equal(normalizeSurfaceEntry(entry), undefined, entry);
+	}
+});
+
+test("disjoint files do not overlap", () => {
+	assert.equal(surfacesOverlap("lib/a.ts", "lib/b.ts"), false);
+	assert.equal(surfacesOverlap("lib/a.ts", "tests/a.ts"), false);
+	assert.equal(surfacesOverlap("lib/a.ts", "lib/a.ts.bak"), false);
+	assert.equal(surfacesOverlap("lib/a/b.ts", "lib/b/b.ts"), false);
+});
+
+test("the same file overlaps, whatever its spelling", () => {
+	assert.equal(surfacesOverlap("lib/a.ts", "lib/a.ts"), true);
+	assert.equal(surfacesOverlap("`lib/a.ts`", "./lib/a.ts"), true);
+	assert.equal(surfacesOverlap("- lib/a.ts", "lib//a.ts"), true);
+	assert.equal(surfacesOverlap("lib/A.ts", "lib/a.ts"), true, "case-insensitive filesystems make these one file");
+});
+
+test("a glob covering a file overlaps it", () => {
+	assert.equal(surfacesOverlap("lib/*.ts", "lib/a.ts"), true);
+	assert.equal(surfacesOverlap("lib/a.ts", "lib/*.ts"), true);
+	assert.equal(surfacesOverlap("tests/*.test.ts", "tests/writer-surfaces.test.ts"), true);
+	assert.equal(surfacesOverlap("lib/?.ts", "lib/a.ts"), true);
+	assert.equal(surfacesOverlap("lib/[ab].ts", "lib/b.ts"), true);
+	assert.equal(surfacesOverlap("lib/[!a].ts", "lib/b.ts"), true);
+	assert.equal(surfacesOverlap("lib/{a,b}.ts", "lib/b.ts"), true);
+	assert.equal(surfacesOverlap("lib/*.ts", "lib/a.md"), false);
+	assert.equal(surfacesOverlap("lib/{a,b}.ts", "lib/c.ts"), false);
+	assert.equal(surfacesOverlap("lib/*.ts", "tests/a.ts"), false);
+});
+
+test("a directory glob or bare directory covers anything under it", () => {
+	assert.equal(surfacesOverlap("lib/**", "lib/a.ts"), true);
+	assert.equal(surfacesOverlap("lib/**", "lib/deep/nested/a.ts"), true);
+	assert.equal(surfacesOverlap("lib/a.ts", "lib/**"), true);
+	assert.equal(surfacesOverlap("lib/**/*.ts", "lib/x/y.md"), true, "after ** the rest may sit under the other entry");
+	assert.equal(surfacesOverlap("lib", "lib/a.ts"), true);
+	assert.equal(surfacesOverlap("lib/", "lib/a.ts"), true);
+	assert.equal(surfacesOverlap("**/*.ts", "docs/a.md"), true);
+	assert.equal(surfacesOverlap("lib/**", "tests/a.ts"), false);
+	assert.equal(surfacesOverlap("lib/**", "libs/a.ts"), false);
+});
+
+test("two globs overlap unless their literal affixes prove them disjoint", () => {
+	assert.equal(surfacesOverlap("lib/*.ts", "lib/*.md"), false);
+	assert.equal(surfacesOverlap("lib/a*.ts", "lib/b*.ts"), false);
+	assert.equal(surfacesOverlap("lib/a*", "lib/*b"), true);
+	assert.equal(surfacesOverlap("lib/*.ts", "lib/x*"), true);
+	assert.equal(surfacesOverlap("lib/**", "lib/*.md"), true);
+	assert.equal(surfacesOverlap("lib/*/a.ts", "lib/x/*.ts"), true);
+	assert.equal(surfacesOverlap("lib/*/a.ts", "tests/*/a.ts"), false);
+});
+
+test("uncertain entries are treated as overlapping", () => {
+	assert.equal(surfacesOverlap("lib/../tests/a.ts", "docs/b.md"), true, "unscopable entry");
+	assert.equal(surfacesOverlap(".", "docs/b.md"), true, "repository root");
+	assert.equal(surfacesOverlap("lib/@(a|b).ts", "lib/c.ts"), true, "extglob syntax is not interpreted");
+	assert.equal(surfacesOverlap("lib/x[y", "lib/xzzy"), true, "an unclosed class falls back to affixes");
+	assert.equal(surfacesOverlap("lib/{a,{b,c}}.ts", "lib/d.ts"), true, "nested braces are not interpreted");
+});
+
+// Verify B1: a brace group spanning `/` must never be split into segments.
+test("a brace group spanning a slash overlaps everything", () => {
+	assert.equal(surfacesOverlap("lib/{foo.ts,bar/baz.ts}", "lib/bar/baz.ts"), true);
+	assert.equal(surfacesOverlap("src/{a,b/c}.ts", "src/b/c.ts"), true);
+	assert.equal(surfacesOverlap("src/b/c.ts", "src/{a,b/c}.ts"), true);
+	assert.equal(surfacesOverlap("lib/{x,y/z}/w.ts", "docs/a.md"), true, "fail safe even across unrelated roots");
+	assert.equal(surfacesOverlap("lib/a}.ts", "lib/b.ts"), true, "an unbalanced brace is not interpreted");
+	const registry = new WriterSurfaceRegistry();
+	registry.claim("task-a", "/repo", ["lib/{foo.ts,bar/baz.ts}"]);
+	assert.deepEqual(registry.conflicts("/repo", ["lib/bar/baz.ts"]).map(conflict => conflict.taskId), ["task-a"]);
+});
+
+// Verify M1: lowercasing and class syntax (negation, POSIX classes) are never
+// interpreted; any bracket in an entry overlaps everything.
+test("any bracket class overlaps everything", () => {
+	assert.equal(surfacesOverlap("src/[^a].ts", "src/A.ts"), true);
+	assert.equal(surfacesOverlap("src/[!a-z].ts", "src/B.ts"), true);
+	assert.equal(surfacesOverlap("src/[[:alpha:]].ts", "src/b.ts"), true);
+	assert.equal(surfacesOverlap("lib/[ab].ts", "lib/c.ts"), true);
+	assert.equal(surfacesOverlap("lib/[a/b].ts", "docs/x.md"), true);
+});
+
+// Second verify (A1 fail-safe additions): a backslash may be an escape or a
+// separator, so the entry overlaps everything.
+test("any backslash overlaps everything", () => {
+	assert.equal(surfacesOverlap("src/foo\\*", "src/foo?"), true);
+	assert.equal(surfacesOverlap("lib\\a.ts", "docs/x.md"), true);
+	assert.equal(surfacesOverlap("docs/x.md", "lib\\a.ts"), true);
+});
+
+test("Unicode spellings compare in NFC and non-ASCII never meets a wildcard regex", () => {
+	assert.equal(surfacesOverlap("src/caf\u00e9.ts", "src/cafe\u0301.ts"), true, "NFC vs NFD is one file");
+	assert.equal(surfacesOverlap("src/?.ts", "src/\u{1F600}.ts"), true, "an astral character is one path character");
+	assert.equal(surfacesOverlap("src/\u{1F600}*.ts", "src/\u{1F600}x.ts"), true);
+	assert.equal(surfacesOverlap("src/caf\u00e9.ts", "src/cafe.ts"), false, "distinct literals stay disjoint");
+});
+
+// Second verify A1: the registry key is the canonical worktree root, so a
+// subdirectory cwd, the root itself and a symlinked spelling share one key.
+test("canonicalWriterRoot keys one worktree once and separate worktrees apart", (t) => {
+	const base = realpathSync(mkdtempSync(join(tmpdir(), "writer-root-")));
+	t.after(() => rmSync(base, { recursive: true, force: true }));
+	const repo = join(base, "repo");
+	mkdirSync(join(repo, "sub"), { recursive: true });
+	const git = (...args: string[]) => execFileSync("git", ["-C", repo, ...args], { env: worktreeGitEnvironment(), stdio: "ignore" });
+	git("init", "-q");
+	writeFileSync(join(repo, "sub", "a.ts"), "");
+	git("add", ".");
+	git("-c", "user.name=t", "-c", "user.email=t@example.invalid", "commit", "-q", "-m", "init");
+	const feature = join(base, "feature");
+	git("worktree", "add", "-q", feature);
+	const link = join(base, "link");
+	symlinkSync(repo, link);
+	assert.equal(canonicalWriterRoot(join(repo, "sub")), repo, "a subdirectory cwd keys to its worktree root");
+	assert.equal(canonicalWriterRoot(repo), repo);
+	assert.equal(canonicalWriterRoot(join(link, "sub")), repo, "a symlinked spelling keys to the real root");
+	assert.equal(canonicalWriterRoot(feature), feature, "a linked worktree keys to itself");
+	const registry = new WriterSurfaceRegistry();
+	registry.claim("task-a", canonicalWriterRoot(join(repo, "sub")), ["lib/a.ts"]);
+	assert.deepEqual(registry.conflicts(canonicalWriterRoot(link), ["lib/a.ts"]).map(conflict => conflict.taskId), ["task-a"]);
+	assert.deepEqual(registry.conflicts(canonicalWriterRoot(feature), ["lib/a.ts"]), [], "different worktrees never conflict");
+	const plain = join(base, "plain");
+	mkdirSync(plain);
+	symlinkSync(plain, join(base, "plain-link"));
+	assert.equal(canonicalWriterRoot(join(base, "plain-link"), () => undefined), plain, "without Git the key is the realpath");
+	assert.equal(canonicalWriterRoot(join(base, "missing"), () => undefined), join(base, "missing"), "an unresolvable path keeps its resolved spelling");
+	assert.equal(canonicalWriterRoot("/repo/sub", () => ({ root: "/repo", commonDir: "/repo/.git" })), "/repo", "an injected resolver decides the root");
+});
+
+// Like minimatch, `**` is a globstar only as a whole segment; inside a segment
+// (`src/**.ts`) it matches within that one segment.
+test("`**` inside a segment stays single-segment", () => {
+	assert.equal(surfacesOverlap("src/**.ts", "src/a.ts"), true);
+	assert.equal(surfacesOverlap("src/**.ts", "src/a/b.ts"), false);
+	assert.equal(surfacesOverlap("src/**", "src/a/b.ts"), true);
+});
+
+test("overlappingSurfaces lists every overlapping pair; an empty list claims everything", () => {
+	assert.deepEqual(overlappingSurfaces(["lib/a.ts", "docs/x.md"], ["lib/**", "tests/a.ts"]), [["lib/a.ts", "lib/**"]]);
+	assert.deepEqual(overlappingSurfaces(["lib/a.ts"], ["lib/b.ts", "tests/b.ts"]), []);
+	assert.deepEqual(overlappingSurfaces([], ["lib/b.ts"]), [[".", "lib/b.ts"]]);
+});
+
+test("the registry reports live overlapping writers in the same root only and releases them", () => {
+	const registry = new WriterSurfaceRegistry();
+	registry.claim("task-a", "/repo", ["lib/a.ts", "tests/a.test.ts"]);
+	registry.claim("task-b", "/repo", ["lib/b.ts"]);
+	registry.claim("task-c", "/repo-worktrees/feature", ["lib/a.ts"]);
+	assert.deepEqual(registry.conflicts("/repo", ["docs/x.md"]), []);
+	assert.deepEqual(registry.conflicts("/repo", ["lib/*.ts"]), [
+		{ taskId: "task-a", root: "/repo", pairs: [["lib/*.ts", "lib/a.ts"]] },
+		{ taskId: "task-b", root: "/repo", pairs: [["lib/*.ts", "lib/b.ts"]] },
+	]);
+	assert.deepEqual(registry.conflicts("/elsewhere", ["lib/a.ts"]), [], "different worktree roots never conflict");
+	assert.deepEqual(registry.conflicts("/repo/", ["lib/b.ts"]).map(conflict => conflict.taskId), ["task-b"], "roots compare resolved");
+	assert.equal(registry.release("task-b"), true);
+	assert.equal(registry.release("task-b"), false, "release is idempotent");
+	assert.deepEqual(registry.conflicts("/repo", ["lib/b.ts"]), []);
+	assert.equal(registry.size, 2);
+});
+
+test("the conflict message names the live task, the overlapping entries and the ways forward", () => {
+	const message = writerSurfaceConflictMessage([{ taskId: "task-a", root: "/repo", pairs: [["lib/*.ts", "lib/a.ts"]] }]);
+	assert.match(message, /task task-a/);
+	assert.match(message, /`lib\/\*\.ts` overlaps `lib\/a\.ts`/);
+	assert.match(message, /\/repo/);
+	assert.match(message, /wait for/i);
+	assert.match(message, /narrow `## Allowed edit surfaces`/);
+	assert.match(message, /isolated worktree/);
+	const many = writerSurfaceConflictMessage([{ taskId: "t", root: "/repo", pairs: Array.from({ length: 8 }, (_, index) => [`a${index}`, `a${index}`] as [string, string]) }]);
+	assert.match(many, /and 3 more/, "long overlap lists stay bounded");
+});

package/tests/yolo-customize.test.ts

@@ -68,7 +68,7 @@ function fixture(t: test.TestContext, order = "owner-first", env: NodeJS.Process
 		},
 	} as unknown as ExtensionContext;
 	let controller: yolo.YoloSessionController | undefined;
-	const owner = () => { controller = yolo.registerYoloSessionPolicy(pi, env); };
+	const owner = () => { controller = yolo.registerYoloSessionPolicy(pi, { ...env, GENTLE_PI_CONFIG_HOME: home }); };
 	const shell = () => gentleShell(pi, { ...env, GENTLE_PI_CONFIG_HOME: home, GENTLE_PI_SHELL_CHANGES_WATCH_MS: "off" }, {
 		fetch: async () => { assert.fail("network disabled"); }, activeProfile: () => undefined, devBinary: () => undefined,
 	});
@@ -111,6 +111,21 @@ async function settle(check: () => boolean) {
 }
 function text(view: View) { return view.render(140).map(stripAnsi).join("\n"); }
 
+test("Customize selects Auto for this session and saves either elevated default without changing current mode", async t => {
+ const h=fixture(t,"owner-first",{},true);const open=await h.open();const view=h.view();selectYolo(view);
+ view.handleInput("j");view.handleInput("j");view.render(140);
+ assert.match(text(view),/Session permissions: AUTO/);
+ await h.apply("\r");assert.equal(await h.controller().mode(h.ctx),"auto");
+ view.handleInput("j");view.handleInput("j");view.handleInput("j");view.render(140);
+ assert.match(text(view),/Default permissions: AUTO/);
+ await h.apply("\r");assert.equal(h.controller().defaultMode(),"auto");assert.equal(await h.controller().mode(h.ctx),"auto");
+ view.handleInput("j");view.render(140);await h.apply("\r");
+ assert.equal(h.controller().defaultMode(),"yolo");assert.equal(await h.controller().mode(h.ctx),"auto");
+ assert.equal(JSON.parse(readFileSync(join(h.home,"permission-mode.json"),"utf8")).mode,"yolo");
+ for(const width of [1,20,60,140])assert.ok(view.render(width).every(line=>visibleWidth(line)<=width));
+ open.close();await open.result;
+});
+
 for (const order of ["owner-first", "shell-first"]) test(`Editor YOLO menu and slash share one owner (${order})`, async t => {
 	const h = fixture(t, order, {}, true);
 	for (const name of ["vim-policy.json", "visual-settings.json", "visual-profiles.json", "runtime-guardrails.json", "history-capture-policy.json", "agent-profiles.json"]) writeFileSync(join(h.home, name), "{}\n");
@@ -187,11 +202,11 @@ test("off wins over pending menu on; child/headless/RPC cannot acquire adapter a
 	assert.equal(await h.controller().active(h.ctx), false);
 	open.close(); await open.result;
 	assert.equal(typeof yolo.discoverYoloUiAdapter, "function");
-	for (const variant of ["child", "headless", "rpc", "missing-clone"]) {
+	for (const variant of ["child", "headless", "rpc", "missing-workspace"]) {
 		const f = fixture(t, "owner-first", variant === "child" ? { GENTLE_PI_AGENTS_CHILD: "1" } : {});
 		if (variant === "headless") Object.assign(f.ctx, { hasUI: false });
 		if (variant === "rpc") Object.assign(f.ctx, { mode: "rpc" });
-		if (variant === "missing-clone") Object.assign(f.ctx, { cwd: "/" });
+		if (variant === "missing-workspace") Object.assign(f.ctx, { cwd: "/nonexistent-gentle-workspace" });
 		const adapter = await yolo.discoverYoloUiAdapter(f.pi, f.ctx);
 		if (adapter) { assert.equal(await adapter.read(), "UNAVAILABLE"); await adapter.toggle(); adapter.dispose(); }
 		assert.equal(await f.controller().active(f.ctx), false, variant);

package/tests/yolo-mode-runtime.test.ts

@@ -12,10 +12,17 @@ import { loadExtensionFromFactory } from "../node_modules/@earendil-works/pi-cod
 import { discoverYoloUiAdapter, registerYoloSessionPolicy, YOLO_STATUS_KEY, YOLO_STATUS_TEXT } from "../lib/yolo-session-policy.ts";
 import { createGentleAiExtension } from "../extensions/gentle-ai.ts";
 
-test("complete Gentle AI extension registers and executes YOLO through the actual SDK loader", async () => {
+// An empty env would resolve the developer's real ~/.pi/gentle-ai and inherit its persisted mode default.
+function isolatedEnv(t: test.TestContext): NodeJS.ProcessEnv {
+	const home = mkdtempSync(join(tmpdir(), "yolo-runtime-config-"));
+	t.after(() => rmSync(home, { recursive: true, force: true }));
+	return { GENTLE_PI_CONFIG_HOME: home };
+}
+
+test("complete Gentle AI extension registers and executes YOLO through the actual SDK loader", async t => {
 	const cwd = process.cwd();
 	const runtime = createExtensionRuntime();
-	const extension = await loadExtensionFromFactory(createGentleAiExtension({ nativeReviewCli: null, candidateViews: null, processEnv: {} }), cwd, createEventBus(), runtime);
+	const extension = await loadExtensionFromFactory(createGentleAiExtension({ nativeReviewCli: null, candidateViews: null, processEnv: isolatedEnv(t) }), cwd, createEventBus(), runtime);
 	assert.equal(extension.handlers.get("session_start")?.length, 1, "original startup hook remains the sole handler");
 	assert.equal(extension.handlers.get("session_shutdown")?.length, 1, "original shutdown hook remains the sole handler");
 	const runner = new ExtensionRunner([extension], runtime, cwd, SessionManager.inMemory(cwd), {} as never);
@@ -40,8 +47,9 @@ test("complete Gentle AI extension registers and executes YOLO through the actua
 // Actual SDK factory loader, context/command runner and in-memory SessionManager.
 // Lifecycle events are dispatched through the real runner; the terminal UI is stubbed.
 // No providers, persisted sessions, global assets or real tool execution are needed.
-test("SDK-loaded YOLO command resets across actual runner lifecycle dispatch and extension replacement", async () => {
+test("SDK-loaded YOLO command resets across actual runner lifecycle dispatch and extension replacement", async t => {
 	const cwd = process.cwd();
+	const env = isolatedEnv(t);
 	const manager = SessionManager.inMemory(cwd);
 	const statuses = new Map<string, string | undefined>();
 	const widgets = new Map<string, unknown>();
@@ -53,7 +61,7 @@ test("SDK-loaded YOLO command resets across actual runner lifecycle dispatch and
 	const load = async () => {
 		const runtime = createExtensionRuntime();
 		const extension = await loadExtensionFromFactory((pi) => {
-			const yolo = registerYoloSessionPolicy(pi, {});
+			const yolo = registerYoloSessionPolicy(pi, env);
 			// Match production ownership: the host's existing hooks reset the controller.
 			pi.on("session_start", (_event, ctx) => yolo.reset(ctx));
 			pi.on("session_shutdown", (_event, ctx) => yolo.reset(ctx));
@@ -111,12 +119,32 @@ for (const shellFirst of [false, true]) test(`SDK loads both extensions on one b
 	const statuses = new Map<string, string | undefined>();
 	const notices: string[] = [];
 	let renders = 0;
+	const renderWaiters = new Set<() => void>();
+	const text = () => view!.render(140).map(stripAnsi).join("\n");
+	// Footer publication precedes the asynchronous authority snapshot refresh.
+	// Observe the requested menu render, not elapsed time after setStatus.
+	const rendered = (expected: RegExp) => new Promise<void>((resolve, reject) => {
+		const check = () => {
+			if (!view || !expected.test(text())) return;
+			clearTimeout(deadline);
+			renderWaiters.delete(check);
+			resolve();
+		};
+		const deadline = setTimeout(() => {
+			renderWaiters.delete(check);
+			reject(new Error(`Menu did not request a render matching ${expected}:\n${text()}`));
+		}, 1_000);
+		renderWaiters.add(check);
+	});
 	runner.setUIContext({
 		theme, getAllThemes: () => [{ name: "dark" }], getTheme: () => theme,
 		notify: (text: string) => notices.push(text), setStatus: (key: string, text?: string) => statuses.set(key, text), setWidget() {},
 		custom(factory: (tui: unknown, theme: unknown, keys: unknown, done: () => void) => Component) {
 			return new Promise<void>(resolve => {
-				view = factory({ terminal: { rows: 30 }, requestRender: () => { renders++; } }, theme, {}, resolve);
+				view = factory({ terminal: { rows: 30 }, requestRender: () => {
+					renders++;
+					for (const check of [...renderWaiters]) check();
+				} }, theme, {}, resolve);
 				opened();
 			});
 		},
@@ -132,15 +160,14 @@ for (const shellFirst of [false, true]) test(`SDK loads both extensions on one b
 	await ready; assert.ok(view);
 	for (let i = 0; i < 3; i++) view.handleInput?.("j");
 	view.handleInput?.("\x1b[C"); view.handleInput?.("j"); view.handleInput?.("j");
-	const text = () => view!.render(140).map(stripAnsi).join("\n");
 	assert.match(text(), /YOLO: OFF · session only/);
+	const onRendered = rendered(/YOLO: ON/);
 	view.handleInput?.("\r");
-	for (let i = 0; i < 100 && statuses.get(YOLO_STATUS_KEY) !== YOLO_STATUS_TEXT; i++) await new Promise(resolve => setTimeout(resolve, 10));
+	await onRendered;
 	assert.equal(statuses.get(YOLO_STATUS_KEY), YOLO_STATUS_TEXT);
-	await new Promise(resolve => setTimeout(resolve, 30));
 	assert.match(text(), /YOLO: ON/);
-	await command.handler("disable", ctx);
-	await new Promise(resolve => setTimeout(resolve, 30));
+	await Promise.all([rendered(/YOLO: OFF/), command.handler("disable", ctx)]);
+	assert.equal(statuses.get(YOLO_STATUS_KEY), undefined);
 	assert.match(text(), /YOLO: OFF/);
 	for (const width of [1, 20, 45, 60, 140]) assert.ok(view.render(width).every(line => visibleWidth(line) <= width));
 	const adapter = await discoverYoloUiAdapter({

package/tests/yolo-mode.test.ts

@@ -13,7 +13,17 @@ const USAGE = "Use /gentle:yolo enable|disable|status. State unchanged.";
 const STALE_MENU = "YOLO unchanged — the session changed while the menu was open.";
 const menuTitle = (state: "ON" | "OFF") => `🚀 Gentle YOLO 🔥 — full speed, destructive actions still ask (current: ${state})`;
 
-export function harness(env: NodeJS.ProcessEnv = {}) {
+// An empty env would resolve the developer's real ~/.pi/gentle-ai and inherit its persisted mode default.
+const isolatedConfigHomes: string[] = [];
+process.once("exit", () => { for (const home of isolatedConfigHomes) rmSync(home, { recursive: true, force: true }); });
+function isolatedConfigHome(): string {
+	const home = mkdtempSync(join(tmpdir(), "yolo-config-"));
+	isolatedConfigHomes.push(home);
+	return home;
+}
+
+export function harness(overrides: NodeJS.ProcessEnv = {}) {
+	const env: NodeJS.ProcessEnv = { GENTLE_PI_CONFIG_HOME: isolatedConfigHome(), ...overrides };
 	const commands = new Map<string, { handler: (args: string, ctx: ExtensionContext) => Promise<void> }>();
 	const handlers = new Map<string, Array<(event: unknown, ctx: ExtensionContext) => unknown>>();
 	const tools: string[] = [];
@@ -132,12 +142,12 @@ test("revocation wins over an activation still awaiting Git identity", async ()
 	}
 });
 
-test("child, headless, RPC and unidentified repository cannot activate", async () => {
-	for (const variant of ["child", "headless", "rpc", "no-repository"]) {
+test("child, headless, RPC and nonexistent workspace cannot activate", async () => {
+	for (const variant of ["child", "headless", "rpc", "no-workspace"]) {
 		const h = harness(variant === "child" ? { GENTLE_PI_AGENTS_CHILD: "1" } : {});
 		if (variant === "headless") Object.assign(h.ctx, { hasUI: false });
 		if (variant === "rpc") Object.assign(h.ctx, { mode: "rpc" });
-		if (variant === "no-repository") Object.assign(h.ctx, { cwd: "/" });
+		if (variant === "no-workspace") Object.assign(h.ctx, { cwd: "/nonexistent-gentle-workspace" });
 		await h.command("enable"); assert.notEqual(h.statuses.get("gentle:yolo"), ON_TEXT);
 		h.setSelect(async () => "enable");
 		await h.command(""); assert.notEqual(h.statuses.get("gentle:yolo"), ON_TEXT, `${variant} menu enable fails closed`);
@@ -182,7 +192,12 @@ test("active YOLO waives only ordinary push after full destructive/guard evaluat
 	await h.command("enable");
 	assert.equal(await call("git push origin main"), undefined);
 	assert.equal(h.confirmations(), 1);
-	for (const command of ["git push origin main && rm -rf ./data", `sh -c "psql -c 'DROP TABLE users'"`, "git push origin main && git rebase main", "git push --force origin main", "git push origin main && npm publish", "git -C /other push origin main", "sh -c 'git push origin main'"]) {
+	// gentle-shell#2172: reversible compound delivery is waived too.
+	for (const command of ["git commit -m 'fix: x' && git push -u origin feature/x", "git push origin main && gh pr create --fill", "git -C /other push origin main", "git rebase origin/main && git push"]) {
+		assert.equal(await call(command), undefined, command);
+	}
+	assert.equal(h.confirmations(), 1, "waived commands never reach the confirmation dialog");
+	for (const command of ["git push origin main && rm -rf ./data", `sh -c "psql -c 'DROP TABLE users'"`, "git push origin main && git rebase -i main", "git push --force origin main", "git push origin main && npm publish", "git push origin :main", "sh -c 'git push origin main'"]) {
 		assert.ok(await call(command), command);
 	}
 	await h.command("disable"); assert.ok(await call("git push origin main"));
@@ -259,3 +274,21 @@ test("a session replaced while the menu is open cannot receive the enable choice
 	await h.command("");
 	assert.equal(h.notices.at(-1), "YOLO OFF");
 });
+
+test("bash_background goes through the same command confirmation and YOLO waiver as bash", async () => {
+	const h = harness();
+	const call = (command: string) => h.emit("tool_call", { toolName: "bash_background", input: { command } });
+	assert.deepEqual(await call("git push origin main"), { block: true, reason: "Gentle AI safety policy blocked the command because it was not confirmed." });
+	await h.command("enable");
+	assert.equal(await call("git push origin main"), undefined);
+	assert.ok(await call("git push origin main && rm -rf ./data"), "YOLO never waives a destructive command");
+});
+
+test("monitor goes through the same command confirmation and YOLO waiver as bash", async () => {
+	const h = harness();
+	const call = (command: string) => h.emit("tool_call", { toolName: "monitor", input: { command, timeout_seconds: 60 } });
+	assert.deepEqual(await call("git push origin main"), { block: true, reason: "Gentle AI safety policy blocked the command because it was not confirmed." });
+	await h.command("enable");
+	assert.equal(await call("git push origin main"), undefined);
+	assert.ok(await call("git push origin main && rm -rf ./data"), "YOLO never waives a destructive command");
+});

package/tests/yolo-session-policy.test.ts

@@ -42,7 +42,7 @@ test("legacy hosts without an event bus retain command registration but no menu
 	const commands: string[] = [];
 	const pi = { registerCommand: (name: string) => commands.push(name) } as unknown as ExtensionAPI;
 	assert.ok(registerYoloSessionPolicy(pi, {}));
-	assert.deepEqual(commands, ["gentle:yolo"], "bare yolo command is not registered");
+	assert.deepEqual(commands, ["gentle:mode", "gentle:yolo"], "bare commands are not registered");
 	assert.equal(await discoverYoloUiAdapter(pi, {} as ExtensionContext), undefined);
 });