gentle-pi 3.4.0 → 3.5.0

package/tests/ask-user-question.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import askUserQuestion from "../extensions/ask-user-question.ts";
+import askUserQuestion, { askMultiSelect } from "../extensions/ask-user-question.ts";
 
 /** Plain theme fake: identity styling keeps rendered assertions readable. */
 interface Theme {
@@ -107,6 +107,38 @@ function run(tool: RegisteredTool, params: unknown, ctx: unknown): Promise<ToolR
 	return tool.execute("call", params, new AbortController().signal, undefined, ctx);
 }
 
+const INTERACTIVE_HOST_ENV = "GENTLE_SHELL_INTERACTIVE_HOST";
+
+/** Fake interactive-RPC-host ctx: scripted `select` answers, one per call. */
+function rpcHostContext(selectAnswers: readonly (string | undefined)[]) {
+	const selectCalls: Array<{ title: string; options: string[] }> = [];
+	let index = 0;
+	return {
+		ctx: {
+			mode: "rpc",
+			hasUI: true,
+			ui: {
+				select: async (title: string, options: string[]) => {
+					selectCalls.push({ title, options });
+					const answer = selectAnswers[index];
+					index += 1;
+					return answer;
+				},
+			},
+		},
+		selectCalls,
+	};
+}
+
+function withInteractiveHostEnv(t: { after(fn: () => void): void }): void {
+	const previous = process.env[INTERACTIVE_HOST_ENV];
+	process.env[INTERACTIVE_HOST_ENV] = "1";
+	t.after(() => {
+		if (previous === undefined) delete process.env[INTERACTIVE_HOST_ENV];
+		else process.env[INTERACTIVE_HOST_ENV] = previous;
+	});
+}
+
 const option = (label: string, description = `${label} description`, preview?: string) =>
 	preview === undefined ? { label, description } : { label, description, preview };
 
@@ -185,6 +217,200 @@ test("ask_user_question stays unavailable outside the interactive TUI", async ()
 	assert.deepEqual(emitted, []);
 });
 
+test("ask_user_question stays unavailable on a plain rpc host without the interactive-host variable", async (t) => {
+	const { tool, emitted } = registerQuestionTool();
+	let selectCalls = 0;
+	const ctx = {
+		mode: "rpc",
+		hasUI: true,
+		ui: { select: async () => { selectCalls++; return undefined; } },
+	};
+	t.after(() => { delete process.env[INTERACTIVE_HOST_ENV]; });
+	delete process.env[INTERACTIVE_HOST_ENV];
+
+	const result = await run(tool, { questions: single() }, ctx);
+
+	assert.match(result.content[0]?.text ?? "", /unavailable outside the interactive TUI/);
+	assert.equal(result.details.errorKind, "unavailable_outside_tui");
+	assert.equal(selectCalls, 0);
+	assert.deepEqual(emitted, []);
+});
+
+test("ask_user_question resolves a single-select answer through RPC dialogs on an interactive host", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool, emitted } = registerQuestionTool();
+	const { ctx, selectCalls } = rpcHostContext(["Alpha"]);
+
+	const result = await run(tool, { questions: single() }, ctx);
+
+	assert.equal(selectCalls.length, 1);
+	assert.equal(selectCalls[0]?.title, "Proceed: Proceed?");
+	assert.deepEqual(selectCalls[0]?.options, ["Alpha", "Beta"]);
+	assert.equal(result.content[0]?.text, "1. Proceed? — Alpha");
+	assert.deepEqual(result.details.answers, [
+		{ questionIndex: 0, question: "Proceed?", kind: "option", answer: "Alpha" },
+	]);
+	assert.deepEqual(emitted, [
+		{ channel: "gentle-pi:ask-user-question:blocked", data: { active: true } },
+		{ channel: "gentle-pi:ask-user-question:blocked", data: { active: false } },
+	]);
+});
+
+test("ask_user_question echoes an option preview through RPC dialogs", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "Proceed?", header: "Proceed", options: [option("Alpha", "First choice", "Preview A"), option("Beta")] },
+	];
+	const { ctx } = rpcHostContext(["Alpha"]);
+
+	const result = await run(tool, { questions }, ctx);
+
+	assert.equal(result.content[0]?.text, "1. Proceed? — Alpha\n   selected preview: Preview A");
+	assert.deepEqual(result.details.answers, [
+		{ questionIndex: 0, question: "Proceed?", kind: "option", answer: "Alpha", preview: "Preview A" },
+	]);
+});
+
+test("ask_user_question loops select with a trailing Done entry for a multiSelect question on an interactive host", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "Pick?", header: "Pick", options: [option("One"), option("Two")], multiSelect: true },
+	];
+	const { ctx, selectCalls } = rpcHostContext(["[ ] One", "Done"]);
+
+	const result = await run(tool, { questions }, ctx);
+
+	assert.deepEqual(selectCalls[0]?.options, ["[ ] One", "[ ] Two", "Done"]);
+	assert.deepEqual(selectCalls[1]?.options, ["[x] One", "[ ] Two", "Done"]);
+	assert.equal(result.content[0]?.text, "1. Pick? — selected: One");
+	assert.deepEqual(result.details.answers, [
+		{ questionIndex: 0, question: "Pick?", kind: "multi", answer: null, selected: ["One"] },
+	]);
+});
+
+test("ask_user_question multiSelect finishes once every option is toggled without needing Done", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "Pick?", header: "Pick", options: [option("One"), option("Two")], multiSelect: true },
+	];
+	const { ctx, selectCalls } = rpcHostContext(["[ ] One", "[ ] Two"]);
+
+	const result = await run(tool, { questions }, ctx);
+
+	assert.equal(selectCalls.length, 2, "bounded by the safety cap, but finished early once fully toggled");
+	assert.deepEqual(result.details.answers, [
+		{ questionIndex: 0, question: "Pick?", kind: "multi", answer: null, selected: ["One", "Two"] },
+	]);
+});
+
+test("ask_user_question multiSelect toggle/untoggle/toggle sequence still selects correctly after Done", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "Pick?", header: "Pick", options: [option("One"), option("Two")], multiSelect: true },
+	];
+	// Toggle One on, then off, then on again, then explicit Done: four rounds,
+	// one more than the old options.length + 1 = 3 round bound, so an
+	// un-toggle must never count against the loop's budget.
+	const { ctx, selectCalls } = rpcHostContext(["[ ] One", "[x] One", "[ ] One", "Done"]);
+
+	const result = await run(tool, { questions }, ctx);
+
+	assert.equal(selectCalls.length, 4);
+	assert.deepEqual(result.details.answers, [
+		{ questionIndex: 0, question: "Pick?", kind: "multi", answer: null, selected: ["One"] },
+	]);
+});
+
+test("ask_user_question multiSelect cancels once the safety cap is hit without Done", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "Pick?", header: "Pick", options: [option("One"), option("Two")], multiSelect: true },
+	];
+	// Toggle only "One" back and forth forever: "Two" never toggles, so the
+	// loop never auto-finishes, and Done is never picked. It must hit the
+	// hard safety cap and refuse to commit whatever was toggled at that point.
+	const selectAnswers = Array.from({ length: 32 }, (_, round) => (round % 2 === 0 ? "[ ] One" : "[x] One"));
+	const { ctx, selectCalls } = rpcHostContext(selectAnswers);
+
+	const result = await run(tool, { questions }, ctx);
+
+	assert.equal(selectCalls.length, 32, "every round of the safety cap must be spent before giving up");
+	assert.equal(result.content[0]?.text, "User cancelled the questionnaire");
+	assert.deepEqual(result.details, { cancelled: true });
+});
+
+test("askMultiSelect scales its round cap so a 40-option question can toggle every option and still reach Done", async () => {
+	// The shipped `ask_user_question` tool schema caps authored options at 4
+	// (`lib/questionnaire/schema.ts`'s `MAX_OPTIONS`), so this exercises
+	// `askMultiSelect` directly rather than through the schema-validated tool,
+	// the same way a future caller with more options would.
+	const labels = Array.from({ length: 40 }, (_, index) => `Option ${index + 1}`);
+	const question = { question: "Pick?", header: "Pick", options: labels.map((label) => option(label)), multiSelect: true };
+	// Toggle the first 39 options on, one per round, then an explicit Done:
+	// 40 rounds total, past the old flat 32-round cap but inside the new
+	// `Math.max(32, options.length + 2)` = 42 bound.
+	const toggleAnswers = labels.slice(0, 39).map((label) => `[ ] ${label}`);
+	const { ctx, selectCalls } = rpcHostContext([...toggleAnswers, "Done"]);
+
+	const answer = await askMultiSelect(ctx as never, question as never);
+
+	assert.equal(selectCalls.length, 40, "every toggle plus the explicit Done fits inside the scaled cap");
+	assert.deepEqual(answer, { questionIndex: -1, question: "Pick?", kind: "multi", answer: null, selected: labels.slice(0, 39) });
+});
+
+test("ask_user_question multiSelect cancels on an unrecognised host answer instead of committing a partial state", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "Pick?", header: "Pick", options: [option("One"), option("Two")], multiSelect: true },
+	];
+	// "One" gets toggled on first, then the host answers with something that
+	// matches none of the current round's options: the loop must cancel the
+	// whole questionnaire, never commit the partial "One" toggle.
+	const { ctx, selectCalls } = rpcHostContext(["[ ] One", "not a real option"]);
+
+	const result = await run(tool, { questions }, ctx);
+
+	assert.equal(selectCalls.length, 2);
+	assert.equal(result.content[0]?.text, "User cancelled the questionnaire");
+	assert.deepEqual(result.details, { cancelled: true });
+});
+
+test("ask_user_question cancels through RPC dialogs like the TUI path when select returns undefined", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool, emitted } = registerQuestionTool();
+	const { ctx } = rpcHostContext([undefined]);
+
+	const result = await run(tool, { questions: single() }, ctx);
+
+	assert.equal(result.content[0]?.text, "User cancelled the questionnaire");
+	assert.deepEqual(result.details, { cancelled: true });
+	assert.deepEqual(emitted, [
+		{ channel: "gentle-pi:ask-user-question:blocked", data: { active: true } },
+		{ channel: "gentle-pi:ask-user-question:blocked", data: { active: false } },
+	]);
+});
+
+test("ask_user_question cancels a questionnaire through RPC dialogs on a later question", async (t) => {
+	withInteractiveHostEnv(t);
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "First?", header: "First", options: [option("Alpha"), option("Beta")] },
+		{ question: "Second?", header: "Second", options: [option("Gamma"), option("Delta")] },
+	];
+	const { ctx, selectCalls } = rpcHostContext(["Alpha", undefined]);
+
+	const result = await run(tool, { questions }, ctx);
+
+	assert.equal(selectCalls.length, 2, "the first question is answered before the cancel is observed");
+	assert.deepEqual(result.details, { cancelled: true });
+});
+
 test("ask_user_question commits a single-select answer end-to-end", async () => {
 	const { tool, emitted } = registerQuestionTool();
 	const rendered = { value: "" };

package/tests/gentle-agents.test.ts

@@ -379,6 +379,96 @@ for (const mode of ["print", "tui", "rpc"] as const) {
 	});
 }
 
+/** Controllable fake for `AgentsDeps.schedule`: records every scheduled callback instead of running it, so a test can fire the RPC publisher's coalescing window deterministically. */
+function fakeScheduler() {
+	const pending: Array<{ id: number; fn: () => void }> = [];
+	let nextId = 0;
+	return {
+		schedule: (fn: () => void, _ms: number) => {
+			const id = nextId++;
+			pending.push({ id, fn });
+			return () => {
+				const index = pending.findIndex((entry) => entry.id === id);
+				if (index !== -1) pending.splice(index, 1);
+			};
+		},
+		flushAll: () => {
+			const due = pending.splice(0, pending.length);
+			for (const entry of due) entry.fn();
+		},
+	};
+}
+
+for (const scenario of [
+	{ label: "an interactive RPC host", mode: "rpc", env: { PATH: "/bin", GENTLE_SHELL_INTERACTIVE_HOST: "1" }, expectPublish: true },
+	{ label: "plain RPC without the interactive-host variable", mode: "rpc", env: { PATH: "/bin" }, expectPublish: false },
+	{ label: "TUI", mode: "tui", env: { PATH: "/bin" }, expectPublish: false },
+] as const) {
+	test(`gentle-agents publishes the live activity payload through setWidget only on ${scenario.label}`, async (t) => {
+		const h = fakePi();
+		const runtime = deps();
+		const scheduler = fakeScheduler();
+		runtime.deps.schedule = scheduler.schedule;
+		runtime.deps.env = scenario.env;
+		gentleAgents(h.pi, {}, runtime.deps);
+		const { ctx } = fakeContext();
+		Object.assign(ctx, { mode: scenario.mode, hasUI: scenario.mode === "tui" || scenario.mode === "rpc" });
+		const setWidget = t.mock.method(ctx.ui, "setWidget");
+
+		await h.fire("session_start", ctx);
+		scheduler.flushAll(); // consume the publisher's own start-time frame, if any
+		setWidget.mock.resetCalls();
+
+		await h.tools.get("subagent_run")!.execute("control", { agent: "explore", task: "Map", mode: "background" }, undefined, undefined, ctx);
+		scheduler.flushAll();
+
+		// The TUI card's own setWidget call always carries a component-factory
+		// function, never an array; only the RPC publisher pushes an array.
+		const activityCalls = setWidget.mock.calls.filter((call) => call.arguments[0] === "gentle-agents" && Array.isArray(call.arguments[1]));
+		if (!scenario.expectPublish) {
+			assert.deepEqual(activityCalls, [], "no array-shaped setWidget push outside an interactive RPC host");
+			return;
+		}
+		assert.equal(activityCalls.length, 1, "one push per coalescing window");
+		// The fake `ui.setWidget` types `content` as the TUI-only component factory;
+		// the RPC publisher instead calls it with a plain `string[]` (real pi's
+		// RPC-mode contract), which needs an unknown-mediated cast here.
+		const [key, lines] = activityCalls[0]!.arguments as unknown as [string, string[]];
+		assert.equal(key, "gentle-agents");
+		assert.equal(lines.length, 1);
+		const activity = JSON.parse(lines[0]!) as { schema: string; tasks: Array<{ summary: { id: string } }> };
+		assert.equal(activity.schema, "gentle-agents.activity/v1");
+		assert.ok(activity.tasks.some((task) => typeof task.summary.id === "string" && task.summary.id.length > 0), "the newly launched task must be in the payload");
+	});
+}
+
+test("gentle-agents notifies once, deduplicated, when the RPC activity publisher's setWidget throws", async (t) => {
+	const h = fakePi();
+	const runtime = deps();
+	const scheduler = fakeScheduler();
+	runtime.deps.schedule = scheduler.schedule;
+	runtime.deps.env = { PATH: "/bin", GENTLE_SHELL_INTERACTIVE_HOST: "1" };
+	gentleAgents(h.pi, {}, runtime.deps);
+	const { ctx } = fakeContext();
+	Object.assign(ctx, { mode: "rpc", hasUI: true });
+	const notify = t.mock.method(ctx.ui, "notify");
+	// Only the publisher's array-shaped push fails; the TUI card's own
+	// component-factory push (`showWidget`) must stay untouched.
+	ctx.ui.setWidget = ((_key: string, content: unknown) => {
+		if (Array.isArray(content)) throw new Error("boom");
+	}) as typeof ctx.ui.setWidget;
+
+	await h.fire("session_start", ctx);
+	scheduler.flushAll(); // the publisher's own start-time frame fails: one notify
+
+	await h.tools.get("subagent_run")!.execute("control", { agent: "explore", task: "Map", mode: "background" }, undefined, undefined, ctx);
+	scheduler.flushAll(); // a second flush with the same recurring failure must not notify again
+
+	assert.equal(notify.mock.callCount(), 1, "the same recurring setWidget failure is deduplicated to one notify per session");
+	assert.match(String(notify.mock.calls[0]?.arguments[0]), /boom/);
+	assert.equal(notify.mock.calls[0]?.arguments[1], "warning");
+});
+
 test("all nine subagent registrations own their transcript shell", () => {
 	const { pi, tools } = fakePi();
 	gentleAgents(pi, {}, deps().deps);

package/tests/gentle-shell-bin.test.ts

@@ -0,0 +1,188 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+
+// Integration tests for the thin bin/gentle-shell.mjs entry: they run the real
+// file via spawnSync with an isolated HOME and a fake pi script standing in for
+// the real @earendil-works/pi-coding-agent runtime, so the launcher's own logic
+// (already covered at the unit level in tests/gentle-shell-launcher.test.ts)
+// gets exercised end-to-end through real argv, env, and child-process wiring.
+
+const binUrl = new URL("../bin/gentle-shell.mjs", import.meta.url);
+const binPath = fileURLToPath(binUrl);
+const packageRoot = dirname(dirname(binPath));
+
+function fixture(t: test.TestContext) {
+	const root = mkdtempSync(join(tmpdir(), "gentle-shell-bin-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const home = join(root, "home");
+	mkdirSync(home, { recursive: true });
+	const piScript = join(root, "fake-pi.mjs");
+	writePiScript(piScript, "0.85.1");
+	const gentleShellHome = join(root, "gentle-shell-home");
+	const env: NodeJS.ProcessEnv = {
+		...process.env,
+		HOME: home,
+		USERPROFILE: home,
+		GENTLE_SHELL_HOME: gentleShellHome,
+		GENTLE_SHELL_PI: piScript,
+	};
+	return { root, home, gentleShellHome, piScript, env };
+}
+
+function writePiScript(path: string, version: string) {
+	writeFileSync(
+		path,
+		[
+			"#!/usr/bin/env node",
+			"const args = process.argv.slice(2);",
+			`if (args.includes("--version")) { console.log(${JSON.stringify(version)}); process.exit(0); }`,
+			"console.log(JSON.stringify({",
+			"  args,",
+			"  PI_CODING_AGENT_DIR: process.env.PI_CODING_AGENT_DIR,",
+			"  GENTLE_PI_AGENT_HOME: process.env.GENTLE_PI_AGENT_HOME,",
+			"}));",
+			"process.exit(0);",
+			"",
+		].join("\n"),
+	);
+	chmodSync(path, 0o755);
+}
+
+function run(env: NodeJS.ProcessEnv, args: string[]) {
+	return spawnSync(process.execPath, [binPath, ...args], { encoding: "utf8", env });
+}
+
+test("--help exits 0 and prints usage", (t) => {
+	const f = fixture(t);
+	const result = run(f.env, ["--help"]);
+	assert.equal(result.status, 0, result.stderr);
+	assert.match(result.stdout, /Usage: gentle-shell/);
+});
+
+test("home with no args prints the default isolated home", (t) => {
+	const f = fixture(t);
+	const result = run(f.env, ["home"]);
+	assert.equal(result.status, 0, result.stderr);
+	assert.equal(result.stdout.trim(), `isolated ${f.gentleShellHome}`);
+});
+
+test("home link persists and a later home reflects it", (t) => {
+	const f = fixture(t);
+	const save = run(f.env, ["home", "link"]);
+	assert.equal(save.status, 0, save.stderr);
+	const configPath = join(f.home, ".gentle-shell", "config.json");
+	assert.deepEqual(JSON.parse(readFileSync(configPath, "utf8")), { home: "link" });
+	const check = run(f.env, ["home"]);
+	assert.equal(check.status, 0, check.stderr);
+	assert.match(check.stdout, /^link /);
+});
+
+test("home <path> persists a custom directory", (t) => {
+	const f = fixture(t);
+	const target = join(f.root, "custom-home");
+	const save = run(f.env, ["home", target]);
+	assert.equal(save.status, 0, save.stderr);
+	const configPath = join(f.home, ".gentle-shell", "config.json");
+	assert.deepEqual(JSON.parse(readFileSync(configPath, "utf8")), { home: target });
+	const check = run(f.env, ["home"]);
+	assert.equal(check.stdout.trim(), `path ${target}`);
+});
+
+test("first isolated run bootstraps the home, writes fullscreen, and prints the hint once", (t) => {
+	const f = fixture(t);
+	assert.equal(existsSync(f.gentleShellHome), false);
+
+	const first = run(f.env, []);
+	assert.equal(first.status, 0, first.stderr);
+	assert.match(first.stderr, /using a separate home at/);
+	assert.match(first.stderr, /gentle-shell --link/);
+	const settings = JSON.parse(readFileSync(join(f.gentleShellHome, "settings.json"), "utf8"));
+	assert.equal(settings.tuiMode, "fullscreen");
+
+	const second = run(f.env, []);
+	assert.equal(second.status, 0, second.stderr);
+	assert.doesNotMatch(second.stderr, /using a separate home at/);
+});
+
+test("forwarded args reach pi after the injected extension flags, in order", (t) => {
+	const f = fixture(t);
+	const result = run(f.env, ["--mode", "rpc", "-p", "hi"]);
+	assert.equal(result.status, 0, result.stderr);
+	const payload = JSON.parse(result.stdout);
+	assert.deepEqual(payload.args, [
+		"-e",
+		packageRoot,
+		"--theme",
+		join(packageRoot, "themes"),
+		"--skill",
+		join(packageRoot, "skills"),
+		"--prompt-template",
+		join(packageRoot, "prompts"),
+		"--mode",
+		"rpc",
+		"-p",
+		"hi",
+	]);
+	assert.equal(payload.GENTLE_PI_AGENT_HOME, f.gentleShellHome);
+});
+
+test("--link skips injection and leaves settings.json byte-identical when it already declares gentle-pi", (t) => {
+	const f = fixture(t);
+	const piAgentDir = join(f.root, "pi-agent");
+	mkdirSync(piAgentDir, { recursive: true });
+	const settingsPath = join(piAgentDir, "settings.json");
+	const settingsText = '{"packages":["npm:gentle-pi"],"theme":"kept"}';
+	writeFileSync(settingsPath, settingsText);
+	const env = { ...f.env, PI_CODING_AGENT_DIR: piAgentDir };
+
+	const result = run(env, ["--link", "--mode", "rpc"]);
+	assert.equal(result.status, 0, result.stderr);
+	const payload = JSON.parse(result.stdout);
+	assert.deepEqual(payload.args, ["--mode", "rpc"]);
+	assert.equal(readFileSync(settingsPath, "utf8"), settingsText);
+	assert.equal(payload.PI_CODING_AGENT_DIR, piAgentDir);
+	assert.equal(existsSync(join(piAgentDir, ".gentle-shell")), false);
+});
+
+test("gentle-shell list forwards to pi as a bare subcommand, with no injected extension flags", (t) => {
+	const f = fixture(t);
+	const result = run(f.env, ["list"]);
+	assert.equal(result.status, 0, result.stderr);
+	const payload = JSON.parse(result.stdout);
+	assert.deepEqual(payload.args, ["list"]);
+	assert.equal(payload.PI_CODING_AGENT_DIR, f.gentleShellHome);
+});
+
+test("gentle-shell install npm:<pkg> forwards the subcommand and its argument verbatim", (t) => {
+	const f = fixture(t);
+	const result = run(f.env, ["install", "npm:pi-btw"]);
+	assert.equal(result.status, 0, result.stderr);
+	const payload = JSON.parse(result.stdout);
+	assert.deepEqual(payload.args, ["install", "npm:pi-btw"]);
+	assert.equal(payload.PI_CODING_AGENT_DIR, f.gentleShellHome);
+});
+
+test("a too-old pi exits 1 naming both versions", (t) => {
+	const f = fixture(t);
+	writePiScript(f.piScript, "0.80.0");
+	const result = run(f.env, []);
+	assert.equal(result.status, 1);
+	assert.match(result.stderr, /0\.80\.0/);
+	assert.match(result.stderr, /0\.85\.1/);
+});
+
+test("--version prints three lines", (t) => {
+	const f = fixture(t);
+	const result = run(f.env, ["--version"]);
+	assert.equal(result.status, 0, result.stderr);
+	const lines = result.stdout.trim().split("\n");
+	assert.equal(lines.length, 3);
+	assert.match(lines[0], /^gentle-shell /);
+	assert.match(lines[1], /^pi 0\.85\.1$/);
+	assert.match(lines[2], /^home isolated /);
+});