gentle-pi 3.7.0 → 4.0.0

package/tests/stats-view.test.ts

@@ -0,0 +1,202 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { visibleWidth, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { stripAnsi } from "../lib/terminal-theme.ts";
+import { createStatsLoader, type CurrentSessionStats, type SessionRecord } from "../lib/stats-collector.ts";
+import { StatsView, type StatsViewDeps } from "../lib/stats-view.ts";
+
+// The /gentle:stats panel: Overview / Models / Session tabs over the
+// collector, with range and scope toggles, q/esc close, and a clickable
+// footer. Rendered against the collector fixtures with a fixed clock.
+
+const SESSIONS = fileURLToPath(new URL("./fixtures/stats/sessions", import.meta.url));
+const NOW = Date.parse("2026-10-01T12:00:00.000Z");
+const ROWS = 40;
+const plainTheme = { fg: (_role: string, text: string) => text };
+// Zero-width role markers: one 256-color SGR per role, so widths stay honest.
+const ROLES = ["accent", "borderMuted"];
+const roleCode = (role: string) => `\x1b[38;5;${ROLES.indexOf(role) + 1}m`;
+const roleTheme = { fg: (role: string, text: string) => `${roleCode(role)}${text}\x1b[39m` };
+const CURRENT: CurrentSessionStats = {
+	totals: { input: 10, output: 5, cacheRead: 100, cacheWrite: 20, total: 135, cost: 0.125 },
+	messages: 1,
+	model: "claude-opus-5-5",
+	durationMs: 30 * 60 * 1000,
+	lines: { added: 2, removed: 1 },
+};
+
+function makeView(overrides: Partial<StatsViewDeps> = {}) {
+	const events: string[] = [];
+	const view = new StatsView({
+		theme: plainTheme,
+		rows: ROWS,
+		cwd: "/work/alpha",
+		now: () => NOW,
+		dayKey: (ms) => new Date(ms).toISOString().slice(0, 10),
+		load: () => createStatsLoader().load(SESSIONS),
+		current: () => CURRENT,
+		onClose: () => events.push("close"),
+		requestRender: () => events.push("render"),
+		...overrides,
+	});
+	return { view, events };
+}
+
+async function ready(overrides: Partial<StatsViewDeps> = {}) {
+	const made = makeView(overrides);
+	await made.view.load();
+	return made;
+}
+
+const plain = (view: StatsView, width = 100) => view.render(width).map(stripAnsi);
+const joined = (view: StatsView, width = 100) => plain(view, width).join("\n");
+
+function assertFits(view: StatsView, width: number) {
+	const lines = view.render(width);
+	assert.equal(lines.length, ROWS);
+	for (const line of lines) assert.equal(visibleWidth(line), width, `"${stripAnsi(line)}" is not ${width} wide`);
+}
+
+function click(view: StatsView, width: number, y: number, label: string) {
+	const lines = plain(view, width);
+	const x = lines[y].indexOf(label);
+	assert.ok(x >= 0, `"${label}" not on row ${y}: ${lines[y]}`);
+	const event: TuiMouseEvent = { type: "click", button: "left", x, y, screenX: x, screenY: y, width, height: ROWS, shift: false, alt: false, ctrl: false };
+	return view.handleMouse(event);
+}
+
+test("StatsView shows a loading state, then the overview once sessions load", async () => {
+	let resolve!: (sessions: SessionRecord[]) => void;
+	const { view, events } = makeView({ load: () => new Promise((done) => { resolve = done; }) });
+	const loading = view.load();
+	assert.match(joined(view), /Loading local sessions…/);
+	resolve(await createStatsLoader().load(SESSIONS));
+	await loading;
+	assert.ok(events.includes("render"));
+	const text = joined(view);
+	assert.doesNotMatch(text, /Loading/);
+	assert.match(text, /✿ Stats/);
+	assert.match(text, /\[× Close\]/);
+	assert.match(text, /Overview/);
+	assert.match(text, /All time · All projects/);
+});
+
+test("Overview pins every headline figure from the fixtures", async () => {
+	const { view } = await ready();
+	const text = joined(view);
+	assert.match(text, /Favorite model +claude-opus-5-5/);
+	assert.match(text, /Total tokens +2\.8k/);
+	assert.match(text, /Sessions +3/);
+	assert.match(text, /Longest session +2h00m/);
+	assert.match(text, /Active days +4\/31/);
+	assert.match(text, /Longest streak +3 days/);
+	assert.match(text, /Most active day +Sep 28/);
+	assert.match(text, /Current streak +3 days/);
+	assert.match(text, /in 810 · out 740 · cache read 1\.0k · cache write 200/);
+	assert.match(text, /Cost +\$2\.05/);
+	assert.match(text, /Don Quixote/);
+	assert.match(text, /Less .* More/);
+	assert.match(text, /Mon/);
+	assert.match(text, /Local Pi sessions on this machine · subagent runs not included/);
+	assertFits(view, 100);
+});
+
+test("the heatmap shades days with theme roles and leaves future days blank", async () => {
+	const { view } = await ready({ theme: roleTheme });
+	const text = view.render(100).join("\n");
+	const heat = text.split("\n").slice(4, 11).join("\n");
+	assert.ok(heat.includes(`${roleCode("accent")}█`), "the busiest day takes the strongest shade");
+	assert.ok(heat.includes(`${roleCode("accent")}░`), "a light day takes the faintest shade");
+	assert.ok(heat.includes(`${roleCode("borderMuted")}·`), "idle days stay visible as dots");
+	// 96 content cells hold 46 two-cell weeks after the 4-cell weekday label.
+	const x = 2 + 4 + (Math.floor((96 - 4) / 2) - 1) * 2;
+	const thisWeek = stripAnsi(text).split("\n").slice(4, 11).map((line) => line[x]);
+	assert.deepEqual(thisWeek, ["█", "░", "░", "·", " ", " ", " "], "Mon–Thu of this week are drawn, Fri–Sun are still blank");
+	assert.doesNotMatch(text, /#[0-9a-f]{6}|\x1b\[38;2/i, "no hardcoded colors");
+});
+
+test("range and scope toggles re-aggregate and relabel the panel", async () => {
+	const { view, events } = await ready();
+	view.handleInput("r");
+	assert.match(joined(view), /Last 7 days · All projects/);
+	assert.match(joined(view), /Total tokens +1\.8k/);
+	assert.match(joined(view), /Active days +3\/7/);
+	view.handleInput("r");
+	assert.match(joined(view), /Last 30 days/);
+	view.handleInput("r");
+	assert.match(joined(view), /All time/);
+	view.handleInput("s");
+	assert.match(joined(view), /All time · This project/);
+	assert.match(joined(view), /Sessions +2/);
+	assert.ok(events.filter((event) => event === "render").length >= 4);
+});
+
+test("tabs switch with Tab, shift+Tab, arrows, and digits", async () => {
+	const { view } = await ready();
+	view.handleInput("\t");
+	let text = joined(view);
+	assert.match(text, /claude-opus-5-5 .*53% .*1\.4k .*\$0\.800 .*3/);
+	assert.match(text, /gpt-5\.5 .*36%/);
+	assert.match(text, /gpt-6\.1-sol .*11%/);
+	view.handleInput("\x1b[C");
+	text = joined(view);
+	assert.match(text, /Model +claude-opus-5-5/);
+	assert.match(text, /Cost +\$0\.125/);
+	assert.match(text, /Duration +30m00s/);
+	assert.match(text, /Lines +\+2 −1/);
+	assert.match(text, /135 total · in 10 · out 5 · cache read 100 · cache write 20/);
+	view.handleInput("\x1b[Z");
+	assert.match(joined(view), /Share/);
+	view.handleInput("1");
+	assert.match(joined(view), /Favorite model/);
+	view.handleInput("\x1b[D");
+	assert.match(joined(view), /Duration/);
+	view.handleInput("2");
+	assert.match(joined(view), /Share/);
+});
+
+test("q and esc close exactly once", async () => {
+	const { view, events } = await ready();
+	view.handleInput("q");
+	view.handleInput("q");
+	view.handleInput("\x1b");
+	assert.equal(events.filter((event) => event === "close").length, 1);
+	const escaped = await ready();
+	escaped.view.handleInput("\x1b");
+	assert.equal(escaped.events.filter((event) => event === "close").length, 1);
+});
+
+test("empty and failing loads render a calm state without throwing", async () => {
+	const empty = await ready({ load: async () => [] });
+	assert.match(joined(empty.view), /No usage recorded yet/);
+	empty.view.handleInput("2");
+	assert.match(joined(empty.view), /No usage recorded yet/);
+	assertFits(empty.view, 100);
+	const failed = await ready({ load: async () => { throw new Error("disk on fire"); } });
+	assert.match(joined(failed.view), /Could not read local sessions: disk on fire/);
+	assertFits(failed.view, 100);
+});
+
+test("narrow terminals keep every line inside the frame", async () => {
+	const { view } = await ready();
+	for (const tab of ["1", "2", "3"]) {
+		view.handleInput(tab);
+		assertFits(view, 48);
+		assertFits(view, 120);
+	}
+});
+
+test("clickable header and footer controls switch tabs, toggle filters, and close", async () => {
+	const { view, events } = await ready();
+	const width = 100;
+	assert.deepEqual(click(view, width, 1, "Models"), { handled: true, render: true });
+	assert.match(joined(view), /Share/);
+	const footer = ROWS - 2;
+	click(view, width, footer, "r range");
+	assert.match(joined(view), /Last 7 days/);
+	click(view, width, footer, "s scope");
+	assert.match(joined(view), /This project/);
+	click(view, width, 0, "[× Close]");
+	assert.equal(events.filter((event) => event === "close").length, 1);
+});

package/tests/telemetry-trigger.test.ts

@@ -1,5 +1,8 @@
 import assert from "node:assert/strict";
-import test from "node:test";
+import test, { after, before } from "node:test";
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { __testing, createGentleAiExtension } from "../extensions/gentle-ai.ts";
 import type { ExecFileAdapter, ExecFileResult } from "../lib/native-review-cli.ts";
@@ -22,6 +25,36 @@ import {
 // and the foreground /gentle:telemetry slash command relay.
 // ---------------------------------------------------------------------------
 
+let fixtureRoot: string | undefined;
+let fixtureCwd: string;
+const fixtureEnvironment: NodeJS.ProcessEnv = {};
+const previousEnvironment = new Map<string, string | undefined>();
+before(() => {
+	fixtureRoot = mkdtempSync(join(tmpdir(), "gentle-pi-telemetry-fixture-"));
+	fixtureCwd = join(fixtureRoot, "project");
+	const home = join(fixtureRoot, "home");
+	mkdirSync(fixtureCwd);
+	mkdirSync(home);
+	Object.assign(fixtureEnvironment, {
+		HOME: home, USERPROFILE: home,
+		GENTLE_PI_CONFIG_HOME: join(home, "config"),
+		GENTLE_PI_AGENT_HOME: join(home, "agents"),
+		PI_CODING_AGENT_DIR: join(home, "pi"),
+		XDG_CONFIG_HOME: join(home, "xdg"),
+	});
+	for (const [key, value] of Object.entries(fixtureEnvironment)) {
+		previousEnvironment.set(key, process.env[key]);
+		process.env[key] = value;
+	}
+});
+after(() => {
+	for (const [key, value] of previousEnvironment) {
+		if (value === undefined) delete process.env[key];
+		else process.env[key] = value;
+	}
+	if (fixtureRoot !== undefined) rmSync(fixtureRoot, { recursive: true, force: true });
+});
+
 interface FakeSpawnRecord {
 	command: string;
 	args: string[];
@@ -172,13 +205,20 @@ function buildExtensionHarness(overrides: Parameters<typeof createGentleAiExtens
 		registerTool() {},
 		events: { emit() {} },
 	} as unknown as ExtensionAPI;
-	createGentleAiExtension({ nativeReviewCli: null, ...overrides })(pi);
+	createGentleAiExtension({
+		nativeReviewCli: null,
+		resolveTelemetryTriggerBinary: () => assert.fail("Telemetry fixtures must inject a binary resolver"),
+		telemetryTriggerSpawn: () => assert.fail("Telemetry fixtures must inject a spawn mock"),
+		telemetryExecFileAdapter: async () => assert.fail("Telemetry fixtures must inject an exec adapter"),
+		...overrides,
+		processEnv: { ...fixtureEnvironment, GENTLE_PI_AGENTS_CHILD: "0", ...overrides.processEnv },
+	})(pi);
 	return { handlers, commands };
 }
 
-function fakeContext(cwd: string, notifications: Array<{ message: string; severity: string }>): ExtensionContext {
+function fakeContext(notifications: Array<{ message: string; severity: string }>): ExtensionContext {
 	return {
-		cwd,
+		cwd: fixtureCwd,
 		hasUI: true,
 		ui: {
 			notify(message: string, severity: string) {
@@ -202,7 +242,7 @@ test("activation: spawns the telemetry trigger exactly once for a primary sessio
 	const beforeAgentStart = handlers.get("before_agent_start");
 	assert.equal(typeof beforeAgentStart, "function");
 	const notifications: Array<{ message: string; severity: string }> = [];
-	const ctx = fakeContext("/work/project", notifications);
+	const ctx = fakeContext(notifications);
 
 	// A primary-session event carries no agent name at all.
 	await beforeAgentStart!({ systemPrompt: "" }, ctx);
@@ -210,14 +250,17 @@ test("activation: spawns the telemetry trigger exactly once for a primary sessio
 
 	assert.equal(fake.calls.length, 1, "the trigger must be attempted at most once per process");
 	const [call] = fake.calls;
+	assert.equal(call.options.env.GENTLE_PI_AGENTS_CHILD, "0");
+	assert.equal(call.options.env.HOME, fixtureEnvironment.HOME);
+	assert.equal(call.options.env.GENTLE_PI_AGENTS_PARENT_PERMISSION_FD, undefined);
 	assert.deepEqual(call.args, ["telemetry", "trigger", "--json"]);
-	assert.equal(call.options.cwd, "/work/project");
+	assert.equal(call.options.cwd, fixtureCwd);
 	assert.equal(call.options.detached, true);
 	assert.equal(call.options.windowsHide, true);
 	assert.equal(call.options.stdio, "ignore");
 });
 
-test("activation: never spawns for a named or SDD agent event", async (t) => {
+test("activation: never spawns for named agents, even with legacy prompt text", async (t) => {
 	t.after(() => __testing.resetTelemetryTriggerGuardForTesting());
 	__testing.resetTelemetryTriggerGuardForTesting();
 	const fake = fakeSpawn();
@@ -227,12 +270,27 @@ test("activation: never spawns for a named or SDD agent event", async (t) => {
 	});
 	const beforeAgentStart = handlers.get("before_agent_start");
 	const notifications: Array<{ message: string; severity: string }> = [];
-	const ctx = fakeContext("/work/project", notifications);
+	const ctx = fakeContext(notifications);
 
 	await beforeAgentStart!({ agentName: "review-risk", systemPrompt: "" }, ctx);
-	await beforeAgentStart!({ systemPrompt: "SDD apply executor" }, ctx);
+	await beforeAgentStart!({ agentName: "gentle-ai-worker", systemPrompt: "SDD apply executor" }, ctx);
 
-	assert.equal(fake.calls.length, 0, "named/SDD agents must never trigger the nudge");
+	assert.equal(fake.calls.length, 0, "named agents must never trigger the nudge");
+});
+
+test("activation: a child session neither spawns telemetry nor appends the primary harness", async (t) => {
+	t.after(() => __testing.resetTelemetryTriggerGuardForTesting());
+	__testing.resetTelemetryTriggerGuardForTesting();
+	const fake = fakeSpawn();
+	const { handlers } = buildExtensionHarness({
+		resolveTelemetryTriggerBinary: () => "/opt/gentle-ai/gentle-ai",
+		telemetryTriggerSpawn: fake.spawn,
+		processEnv: { GENTLE_PI_AGENTS_CHILD: "1" },
+	});
+	const event = { systemPrompt: "base", systemPromptOptions: { appendSystemPrompt: "Child instructions" } };
+	assert.equal(await handlers.get("before_agent_start")!(event, fakeContext([])), undefined);
+	assert.equal(fake.calls.length, 0);
+	assert.equal(event.systemPromptOptions.appendSystemPrompt, "Child instructions");
 });
 
 test("activation: a missing binary or spawn error never affects activation", async (t) => {
@@ -245,12 +303,15 @@ test("activation: a missing binary or spawn error never affects activation", asy
 	});
 	const beforeAgentStart = handlers.get("before_agent_start");
 	const notifications: Array<{ message: string; severity: string }> = [];
-	const ctx = fakeContext("/work/project", notifications);
-
-	// Must resolve cleanly and produce the ordinary orchestrator prompt fields,
-	// never throw or notify about the missing binary.
-	const outcome = await beforeAgentStart!({ systemPrompt: "base" }, ctx);
-	assert.equal(typeof outcome, "object");
+	const ctx = fakeContext(notifications);
+
+	// Must resolve cleanly and produce the ordinary orchestrator prompt fields
+	// in appendSystemPrompt (never a returned systemPrompt), and never throw
+	// or notify about the missing binary.
+	const event = { systemPrompt: "base", systemPromptOptions: { appendSystemPrompt: "" } };
+	const outcome = await beforeAgentStart!(event, ctx);
+	assert.equal(outcome, undefined, "the handler must not return a replacement systemPrompt");
+	assert.match(event.systemPromptOptions.appendSystemPrompt, /el Gentleman/);
 	assert.equal(notifications.length, 0);
 });
 
@@ -284,7 +345,7 @@ test("/gentle:telemetry relays a status --json payload", async () => {
 	const command = commands.get("gentle:telemetry");
 	assert.ok(command, "gentle:telemetry must be registered");
 	const notifications: Array<{ message: string; severity: string }> = [];
-	await command!.handler("", fakeContext("/work/project", notifications));
+	await command!.handler("", fakeContext(notifications));
 
 	assert.equal(requests.length, 1);
 	assert.deepEqual(requests[0].arguments, ["telemetry", "status", "--json"]);
@@ -308,7 +369,7 @@ test("/gentle:telemetry disable prints a one-line confirmation", async () => {
 	});
 	const command = commands.get("gentle:telemetry");
 	const notifications: Array<{ message: string; severity: string }> = [];
-	await command!.handler("disable", fakeContext("/work/project", notifications));
+	await command!.handler("disable", fakeContext(notifications));
 
 	assert.deepEqual(notifications, [{ message: "Gentle AI telemetry disabled.", severity: "info" }]);
 });
@@ -328,7 +389,7 @@ test("/gentle:telemetry relays a typed non-zero failure", async () => {
 	});
 	const command = commands.get("gentle:telemetry");
 	const notifications: Array<{ message: string; severity: string }> = [];
-	await command!.handler("preview", fakeContext("/work/project", notifications));
+	await command!.handler("preview", fakeContext(notifications));
 
 	assert.equal(notifications.length, 1);
 	assert.equal(notifications[0].severity, "error");
@@ -343,7 +404,7 @@ test("/gentle:telemetry rejects an unknown sub-action without calling the binary
 	});
 	const command = commands.get("gentle:telemetry");
 	const notifications: Array<{ message: string; severity: string }> = [];
-	await command!.handler("frobnicate", fakeContext("/work/project", notifications));
+	await command!.handler("frobnicate", fakeContext(notifications));
 
 	assert.equal(requests.length, 0);
 	assert.equal(notifications.length, 1);

package/tests/theme-customization.test.ts

@@ -0,0 +1,72 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { sourcePalettePreview } from "../lib/theme-customization.ts";
+import { colorToRgb, parseColor } from "@earendil-works/pi-tui";
+
+test("Pi 0.99.1 source palette matches the public host OKHSL conversion", () => {
+	const source = new URL("../node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/theme/dark.json", import.meta.url);
+	const document = JSON.parse(readFileSync(source, "utf8"));
+	const accent = document.vars[document.colors.accent];
+	const text = document.vars[document.colors.text];
+	assert.match(accent, /^okhsl\(/);
+	assert.match(text, /^okhsl\(/);
+	const a = colorToRgb(parseColor(accent));
+	const b = colorToRgb(parseColor(text));
+	assert.equal(sourcePalettePreview("dark", source.pathname).sample,
+		`\x1b[48;2;${a.r};${a.g};${a.b}m  \x1b[0m \x1b[38;2;${b.r};${b.g};${b.b}mAa  sample text\x1b[0m`);
+});
+
+test("OKHSL extremes have exact RGB values and unsupported colors fail closed", (t) => {
+	const root = mkdtempSync(join(tmpdir(), "theme-preview-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const source = join(root, "theme.json");
+	const write = (accent: unknown) => writeFileSync(source, JSON.stringify({ name: "dark", colors: { accent, text: "okhsl(120 0% 100%)" } }));
+	write("okhsl(0 0% 0%)");
+	assert.equal(sourcePalettePreview("dark", source).sample,
+		"\x1b[48;2;0;0;0m  \x1b[0m \x1b[38;2;255;255;255mAa  sample text\x1b[0m");
+	for (const invalid of ["okhsl(0 101% 50%)", "okhsl(0 10% -1%)", "okhsl(NaN 10% 50%)", "okhsl(0 10% 50%)suffix", "rgb(1 2 3)", "red", "", {}, 256]) {
+		write(invalid);
+		assert.throws(() => sourcePalettePreview("dark", source));
+	}
+});
+
+test("installed source palette resolves vars without activating a theme", (t) => {
+	const root = mkdtempSync(join(tmpdir(), "theme-preview-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const source = join(root, "theme.json");
+	const document = JSON.parse(readFileSync(new URL("../node_modules/@earendil-works/pi-coding-agent/dist/modes/interactive/theme/dark.json", import.meta.url), "utf8"));
+	writeFileSync(source, JSON.stringify({ ...document, name: "dark", vars: { ...document.vars, previewAccent: "#123456" }, colors: { ...document.colors, accent: "previewAccent" } }));
+	const alias = join(root, "alias.json");
+	symlinkSync(source, alias);
+	const preview = sourcePalettePreview("dark", alias);
+	assert.match(preview.title, /dark.*source palette/);
+	assert.match(preview.sample, /48;2;18;52;86m/); // The accent swatch is a background; text is foreground.
+	assert.match(preview.sample, /38;2;/);
+	assert.match(preview.sample, /sample text/);
+});
+
+test("preview fails closed for missing, mismatched, malformed and oversized sources", (t) => {
+	const root = mkdtempSync(join(tmpdir(), "theme-preview-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const path = join(root, "theme.json");
+	assert.throws(() => sourcePalettePreview("dark", undefined));
+	writeFileSync(path, JSON.stringify({ name: "wrong", colors: { accent: "#abcdef", text: "#000000" } }));
+	assert.throws(() => sourcePalettePreview("dark", path));
+	writeFileSync(path, "not json");
+	assert.throws(() => sourcePalettePreview("dark", path));
+	writeFileSync(path, " ".repeat(256_001));
+	assert.throws(() => sourcePalettePreview("dark", path));
+});
+
+test("source palette supports indexed colors and rejects unresolved references", (t) => {
+	const root = mkdtempSync(join(tmpdir(), "theme-preview-"));
+	t.after(() => rmSync(root, { recursive: true, force: true }));
+	const path = join(root, "theme.json");
+	writeFileSync(path, JSON.stringify({ name: "dark", colors: { accent: 42, text: 255 } }));
+	assert.match(sourcePalettePreview("dark", path).sample, /48;5;42m.*38;5;255m/);
+	writeFileSync(path, JSON.stringify({ name: "dark", vars: { a: "b", b: "a" }, colors: { accent: "a", text: "#ffffff" } }));
+	assert.throws(() => sourcePalettePreview("dark", path));
+});

package/tests/vim-editor-adapter-host-resolution.test.ts

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { spawnSync } from "node:child_process";
+import { copyFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// A git install (`pi install git:...`) has no node_modules next to the
+// extension: Pi aliases ES imports of host packages, but nothing else
+// resolves them (#1586). Reproduce that layout with an ESM-only alias.
+test("vim adapter loads without an extension-local pi-tui and fails closed without a verified version", (t) => {
+  const root = mkdtempSync(join(tmpdir(), "gentle-vim-host-resolution-"));
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  mkdirSync(join(root, "lib"));
+  copyFileSync(fileURLToPath(new URL("../lib/vim-editor-adapter.ts", import.meta.url)), join(root, "lib", "vim-editor-adapter.ts"));
+  const tuiUrl = import.meta.resolve("@earendil-works/pi-tui");
+  writeFileSync(join(root, "alias-hooks.mjs"), `export async function resolve(specifier, context, next) {
+  if (specifier === "@earendil-works/pi-tui") return { url: ${JSON.stringify(tuiUrl)}, shortCircuit: true };
+  return next(specifier, context);
+}
+`);
+  writeFileSync(join(root, "register.mjs"), `import { register } from "node:module";
+register("./alias-hooks.mjs", import.meta.url);
+`);
+  writeFileSync(join(root, "probe.mjs"), `import { Editor } from "@earendil-works/pi-tui";
+const { createVimEditorAdapter } = await import("./lib/vim-editor-adapter.ts");
+const editor = new Editor({ terminal: { rows: 24 }, requestRender() {} }, { borderColor: (s) => s });
+let unverified = "admitted";
+try { createVimEditorAdapter(editor, "0.99.1"); } catch (error) { unverified = error.message; }
+const verified = typeof createVimEditorAdapter(editor, "0.99.1", Editor, "0.99.1").move;
+process.stdout.write(JSON.stringify({ unverified, verified }));
+`);
+  const result = spawnSync(process.execPath, ["--experimental-strip-types", "--import", pathToFileURL(join(root, "register.mjs")).href, join(root, "probe.mjs")], { cwd: root, encoding: "utf8" });
+  assert.equal(result.status, 0, result.stderr);
+  assert.deepEqual(JSON.parse(result.stdout), { unverified: "Unsupported Pi editor layout/version", verified: "function" });
+});