gentle-pi 2.4.0 → 2.6.0

package/tests/native-choice-list.test.ts

@@ -0,0 +1,202 @@
+import assert from "node:assert/strict";
+import test, { mock } from "node:test";
+import {
+	KeybindingsManager, stripTerminalSequences, Text, TUI_KEYBINDINGS,
+	type Component, type TuiMouseEvent, visibleWidth,
+} from "@earendil-works/pi-tui";
+import { NativeChoiceList } from "../lib/native-choice-list.ts";
+import {
+	NativePointerScope,
+	type NativePointerRegionCallbacks,
+} from "../lib/native-pointer-region.ts";
+import { createNativeFullscreenInteraction } from "../lib/native-fullscreen-interaction.ts";
+
+const selectedForeground = "\u001b[38;5;39m";
+const hoverBackground = "\u001b[48;5;236m";
+const theme = {
+	selectedPrefix: (text: string) => `${selectedForeground}${text}\u001b[39m`,
+	selectedText: (text: string) => `${selectedForeground}${text}\u001b[39m`,
+	description: (text: string) => `\u001b[38;5;244m${text}\u001b[39m`,
+	hoverBackground: (text: string) => `${hoverBackground}${text}\u001b[49m`,
+};
+
+function event(
+	type: TuiMouseEvent["type"], button: TuiMouseEvent["button"],
+	y: number, width: number, height: number, wheelDelta?: number,
+): TuiMouseEvent {
+	return {
+		type, button, x: 0, y, screenX: 0, screenY: y, width, height,
+		shift: false, alt: false, ctrl: false, wheelDelta,
+	};
+}
+
+function layout(
+	list: NativeChoiceList<{ id: string; label: string; description: string }>, width: number, text: string,
+) {
+	const lines = list.render(width);
+	assert.ok(lines.every((line) => visibleWidth(line) <= width), "ANSI-stripped lines fit the current render width");
+	const row = lines.findIndex((line) => stripTerminalSequences(line).includes(text));
+	assert.ok(row >= 0, "the current wrapped layout locates the requested row");
+	return { lines, row };
+}
+
+test("native choice list presents one hovered wrapped option without changing selection", () => {
+	const list = new NativeChoiceList([
+		{
+			id: "same", label: "Duplicate label",
+			description: "A wrapped description that spans more than one display line at this width.",
+		},
+		{
+			id: "other", label: "Duplicate label",
+			description: "The second item has the same label but a distinct stable identity.",
+		},
+	], theme);
+	const narrow = layout(list, 40, "second item");
+	assert.equal(list.handleMouse(event("move", "none", narrow.row, 40, narrow.lines.length))?.render, true);
+	const narrowHover = list.render(40);
+	assert.ok(
+		narrowHover.every((line, index) => index >= narrow.row - 1 || !line.includes(hoverBackground)),
+		"only the hovered option rows have a background",
+	);
+	assert.ok(
+		narrowHover.some((line) => line.includes(selectedForeground) && !line.includes(hoverBackground)),
+		"keyboard selection has a distinct foreground",
+	);
+	assert.equal(list.handleMouse(event("move", "none", narrow.row, 40, narrow.lines.length))?.render, false);
+	assert.equal(list.getSelectedItem()?.id, "same");
+
+	const wider = layout(list, 56, "second item");
+	assert.doesNotMatch(
+		wider.lines.join("\n"),
+		new RegExp(hoverBackground.replace(/[\[\]]/g, "\\$&")), "resize clears hover",
+	);
+	assert.equal(list.handleMouse(event("move", "none", wider.row, 56, wider.lines.length))?.render, true);
+	const hovered = list.render(56);
+	assert.ok(hovered.some((line) => line.includes(hoverBackground)), "real SGR background marks the second option");
+	const firstRow = hovered.findIndex((line) => stripTerminalSequences(line).includes("Duplicate label"));
+	assert.ok(firstRow >= 0);
+	list.handleMouse(event("move", "none", firstRow, 56, hovered.length));
+	const selectedHover = list.render(56)[firstRow];
+	assert.ok(
+		selectedHover?.includes(selectedForeground) && selectedHover.includes(hoverBackground),
+		"selected and hovered styles combine",
+	);
+	list.invalidate();
+	assert.doesNotMatch(list.render(56).join("\n"), new RegExp(hoverBackground.replace(/[\[\]]/g, "\\$&")));
+});
+
+test("native choice list ignores Kitty key releases", () => {
+	const list = new NativeChoiceList(
+		[{ id: "first", label: "First" }, { id: "second", label: "Second" }],
+		theme, new KeybindingsManager(TUI_KEYBINDINGS),
+	);
+	const selected: string[] = [];
+	let cancelled = 0;
+	list.onSelect = (item) => selected.push(item.id);
+	list.onCancel = () => { cancelled++; };
+	list.handleInput("\u001b[B");
+	list.handleInput("\r");
+	assert.deepEqual(selected, ["second"], "legacy arrow and Enter use semantic bindings");
+	list.setSelectedIndex(0);
+	selected.length = 0;
+	list.handleInput("\u001b[1;1:3B");
+	assert.equal(list.getSelectedItem()?.id, "first", "Kitty arrow release does not navigate");
+	list.handleInput("\u001b[1;1:1B");
+	assert.equal(list.getSelectedItem()?.id, "second", "Kitty arrow press navigates");
+	list.setSelectedIndex(0);
+	list.handleInput("\u001b[1;1:2B");
+	assert.equal(list.getSelectedItem()?.id, "second", "Kitty arrow repeat still navigates");
+	list.handleInput("\u001b[13;1:3u");
+	list.handleInput("\u001b[27;1:3u");
+	assert.deepEqual([selected, cancelled], [[], 0], "Kitty confirm and cancel releases do not activate callbacks");
+	list.handleInput("\u001b[13;1:1u");
+	list.handleInput("\u001b[27;1:1u");
+	assert.deepEqual([selected, cancelled], [["second"], 1], "Kitty confirm and cancel presses still activate");
+});
+
+test("root observer clears hover and disabled controls ignore every input", () => {
+	const list = new NativeChoiceList([
+		{ id: "first", label: "First choice", description: "First detail." },
+		{ id: "second", label: "Second choice", description: "Second detail." },
+	], theme);
+	let renders = 0;
+	let selected = 0;
+	let cancelled = 0;
+	list.onSelect = () => { selected++; };
+	list.onCancel = () => { cancelled++; };
+	const root = createNativeFullscreenInteraction({
+		keyboardTarget: list, requestRender: () => { renders++; },
+		mouseObserver: list.createMouseObserver(() => { renders++; }),
+	});
+	root.addChild(new Text("Header", 0, 0));
+	root.addChild(list);
+	root.addChild(new Text("Footer", 0, 0));
+	const lines = root.render(48);
+	const firstRow = lines.findIndex((line) => stripTerminalSequences(line).includes("First"));
+	const secondRow = lines.findIndex((line) => stripTerminalSequences(line).includes("Second"));
+	assert.ok(firstRow >= 0 && secondRow >= 0);
+	root.handleMouse(event("move", "none", secondRow, 48, lines.length));
+	assert.match(root.render(48).join("\n"), new RegExp(hoverBackground.replace(/[\[\]]/g, "\\$&")));
+	root.handleMouse(event("move", "none", 0, 48, lines.length));
+	assert.doesNotMatch(root.render(48).join("\n"), new RegExp(hoverBackground.replace(/[\[\]]/g, "\\$&")));
+	assert.equal(renders, 1);
+	root.handleMouse(event("move", "none", 0, 48, lines.length));
+	assert.equal(renders, 1);
+	list.handleMouse(event("move", "none", secondRow, 48, lines.length));
+	list.setDisabled(true);
+	assert.doesNotMatch(
+		root.render(48).join("\n"),
+		new RegExp(hoverBackground.replace(/[\[\]]/g, "\\$&")), "disabling clears hover",
+	);
+	const before = list.getSelectedItem()?.id;
+	for (const [type, button, delta] of [
+		["move", "none"], ["press", "left"],
+		["click", "left"], ["wheel", "none", 1],
+	] as const) {
+		assert.equal(
+			root.handleMouse(event(type, button, firstRow, 48, lines.length, delta)), undefined,
+		);
+	}
+	for (const input of ["\r", "\u001b"]) list.handleInput(input);
+	assert.deepEqual(
+		[list.getSelectedItem()?.id, selected, cancelled], [before, 0, 0],
+		"disabled mouse and keyboard events cannot mutate or activate",
+	);
+});
+
+test("empty native choice lists do not activate phantom selections", () => {
+	const list = new NativeChoiceList([], theme);
+	let selected = 0;
+	let cancelled = 0;
+	list.onSelect = () => { selected++; };
+	list.onCancel = () => { cancelled++; };
+	list.handleInput("\r");
+	list.handleInput("\u001b");
+	assert.equal(selected, 0);
+	assert.equal(cancelled, 1);
+});
+
+test("native choice list composes rows through the shared pointer scope", () => {
+	const originalWrap = NativePointerScope.prototype.wrap;
+	let wraps = 0;
+	const spy = mock.method(NativePointerScope.prototype, "wrap", function (
+		this: NativePointerScope, child: Component, callbacks: NativePointerRegionCallbacks,
+	) {
+		wraps++;
+		return originalWrap.call(this, child, callbacks);
+	});
+	try {
+		const list = new NativeChoiceList([
+			{ id: "first", label: "First" },
+			{ id: "second", label: "Second" },
+		], theme);
+		const lines = list.render(40);
+		assert.equal(wraps, 2, "each choice row uses the composable shared pointer primitive");
+		const second = lines.findIndex((line) => line.includes("Second"));
+		assert.ok(second >= 0);
+		assert.equal(list.handleMouse(event("move", "none", second, 40, lines.length))?.render, true);
+		assert.equal(list.getSelectedItem()?.id, "first", "hover remains distinct from keyboard selection");
+	} finally {
+		spy.mock.restore();
+	}
+});

package/tests/native-fullscreen-interaction.test.ts

@@ -0,0 +1,125 @@
+import assert from "node:assert/strict";
+import test, { mock } from "node:test";
+import { Container, MouseRegion, type TuiMouseEvent, SelectList, Text } from "@earendil-works/pi-tui";
+import { createNativeFullscreenInteraction } from "../lib/native-fullscreen-interaction.ts";
+
+const items = [
+	{ value: "first", label: "First option", description: "A description keeps the list layout realistic." },
+	{ value: "second", label: "Second option", description: "A second description verifies the target row." },
+];
+
+const theme = {
+	selectedPrefix: (text: string) => text,
+	selectedText: (text: string) => text,
+	description: (text: string) => text,
+	scrollInfo: (text: string) => text,
+	noMatch: (text: string) => text,
+};
+
+function mouse(
+	type: TuiMouseEvent["type"],
+	button: TuiMouseEvent["button"],
+	y: number,
+	height: number,
+	wheelDelta?: number,
+): TuiMouseEvent {
+	return {
+		type,
+		button,
+		x: 0,
+		y,
+		screenX: 0,
+		screenY: y,
+		width: 80,
+		height,
+		shift: false,
+		alt: false,
+		ctrl: false,
+		wheelDelta,
+	};
+}
+
+test("native fullscreen interaction preserves observer order and native dispatch identity", () => {
+	const order: string[] = [];
+	const root = createNativeFullscreenInteraction({
+		keyboardTarget: new Text("keyboard", 0, 0),
+		requestRender() {},
+		mouseObserver: { beforeMouse: () => order.push("before"), afterMouse: () => order.push("after") },
+	});
+	root.addChild(new Text("before child", 0, 0));
+	root.addChild(new MouseRegion(new Text("native child", 0, 0), () => {
+		order.push("native child");
+		return { handled: true, focus: true };
+	}));
+	root.addChild(new Text("after child", 0, 0));
+	const lines = root.render(80);
+	const row = lines.findIndex((line) => line.includes("native child"));
+	assert.ok(row >= 0);
+	const nativeHandleMouse = Container.prototype.handleMouse;
+	let nativeResult: ReturnType<typeof nativeHandleMouse>;
+	const spy = mock.method(Container.prototype, "handleMouse", function (this: Container, event: TuiMouseEvent) {
+		nativeResult = nativeHandleMouse.call(this, event);
+		return nativeResult;
+	});
+	try {
+		const result = root.handleMouse(mouse("press", "left", row, lines.length));
+		assert.deepEqual(order, ["before", "native child", "after"]);
+		assert.equal(result, nativeResult, "the observer returns the exact native Container result");
+		assert.equal(result?.focusTarget, root, "native focus ownership remains with the root");
+	} finally {
+		spy.mock.restore();
+	}
+});
+
+test("native fullscreen interaction preserves Container geometry and SelectList behavior", () => {
+	const list = new SelectList(items, items.length, theme);
+	const selected: string[] = [];
+	let renders = 0;
+	list.onSelect = (item) => selected.push(item.value);
+	const root = createNativeFullscreenInteraction({
+		keyboardTarget: list,
+		requestRender: () => { renders++; },
+	});
+	root.addChild(new Text("A long header wraps before the SelectList and must not define hit rows.", 1, 0));
+	root.addChild(list);
+
+	assert.ok(root instanceof Container);
+	assert.ok(root.render(20).length > items.length, "the narrow render includes a wrapped header");
+	const lines = root.render(80);
+	const secondRow = lines.findIndex((line) => line.includes("Second option"));
+	assert.ok(secondRow >= 0, "the test locates the actual rendered SelectList row");
+
+	const wheel = root.handleMouse(mouse("wheel", "none", secondRow, lines.length, 1));
+	assert.equal(wheel?.handled, true);
+	assert.equal(wheel?.render, true);
+	assert.deepEqual(selected, [], "wheel never activates an option");
+	assert.equal(
+		root.handleMouse(mouse("wheel", "none", secondRow, lines.length, 1))?.render,
+		false,
+		"wheel clamps at the final item",
+	);
+	assert.equal(root.handleMouse(mouse("move", "none", secondRow, lines.length)), undefined);
+	assert.equal(list.getSelectedItem()?.value, "second", "move does not change native selection");
+
+	root.handleInput("\u001b[A");
+	assert.equal(renders, 1, "keyboard input forwards to the native control and requests a render");
+	assert.equal(list.getSelectedItem()?.value, "first", "keyboard selection remains independent of pointer movement");
+	assert.deepEqual(selected, [], "keyboard navigation does not activate an option");
+
+	const press = root.handleMouse(mouse("press", "left", secondRow, lines.length));
+	assert.equal(press?.handled, true);
+	assert.equal(press?.focus, true);
+	assert.equal(press?.focusTarget, root, "the root remains the keyboard focus owner");
+	assert.deepEqual(selected, [], "press never activates an option");
+	assert.equal(root.handleMouse(mouse("release", "left", secondRow, lines.length)), undefined);
+	assert.equal(root.handleMouse(mouse("click", "right", secondRow, lines.length)), undefined);
+	assert.equal(root.handleMouse(mouse("click", "left", lines.length, lines.length)), undefined);
+
+	root.handleInput("\r");
+	assert.equal(renders, 2, "Enter renders after activating the focused native item");
+	assert.deepEqual(selected, ["second"], "Enter activates the item selected by press");
+
+	const click = root.handleMouse(mouse("click", "left", secondRow, lines.length));
+	assert.equal(click?.handled, true);
+	assert.deepEqual(selected, ["second", "second"]);
+});

package/tests/native-pointer-region.test.ts

@@ -0,0 +1,245 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Box, Container, Text, type Component, type TuiMouseEvent } from "@earendil-works/pi-tui";
+import { createNativePointerScope } from "../lib/native-pointer-region.ts";
+
+function mouse(
+	type: TuiMouseEvent["type"], button: TuiMouseEvent["button"], y: number, height: number,
+): TuiMouseEvent {
+	return {
+		type, button, x: 0, y, screenX: 0, screenY: y, width: 40, height,
+		shift: false, alt: false, ctrl: false,
+	};
+}
+
+function dispatch(
+	root: Container,
+	observer: ReturnType<ReturnType<typeof createNativePointerScope>["createMouseObserver"]>,
+	event: TuiMouseEvent,
+) {
+	observer.beforeMouse(event);
+	try {
+		return root.handleMouse(event);
+	} finally {
+		observer.afterMouse(event);
+	}
+}
+
+type PublicCustomFactory = Parameters<ExtensionContext["ui"]["custom"]>[0];
+type PublicCustomOptions = NonNullable<Parameters<ExtensionContext["ui"]["custom"]>[1]>;
+
+// Typed callback harness, not proof of physical terminal overlay UX.
+async function mountOverlay(
+	factory: PublicCustomFactory,
+	options: PublicCustomOptions,
+): Promise<Component & { dispose?(): void }> {
+	assert.equal(options.overlay, true, "the public custom factory receives overlay mode");
+	return factory(
+		{} as Parameters<PublicCustomFactory>[0],
+		{} as Parameters<PublicCustomFactory>[1],
+		{} as Parameters<PublicCustomFactory>[2],
+		() => {},
+	);
+}
+
+test("pointer regions give a public Text hover, press, and click behavior without implicit focus", () => {
+	const scope = createNativePointerScope();
+	const calls: string[] = [];
+	const region = scope.wrap(new Text("Open editor", 0, 0), {
+		onHover: () => {
+			calls.push("hover");
+			return { handled: true, render: true };
+		},
+		onPress: () => {
+			calls.push("press");
+			return { handled: true };
+		},
+		onClick: () => {
+			calls.push("click");
+			return { handled: true };
+		},
+		onWheel: () => {
+			calls.push("wheel");
+			return { handled: true };
+		},
+	});
+	const root = new Container();
+	root.addChild(region);
+	const height = root.render(40).length;
+	const observer = scope.createMouseObserver();
+
+	assert.equal(dispatch(root, observer, mouse("move", "none", 0, height))?.render, true);
+	const press = dispatch(root, observer, mouse("press", "left", 0, height));
+	assert.equal(press?.handled, true);
+	assert.equal(press?.focus, undefined, "a Text region never claims keyboard focus by itself");
+	assert.equal(dispatch(root, observer, mouse("click", "left", 0, height))?.handled, true);
+	assert.equal(dispatch(root, observer, mouse("wheel", "none", 0, height))?.handled, true);
+	assert.deepEqual(calls, ["hover", "press", "click", "wheel"]);
+});
+
+test("pointer scopes clear hover only through observed lifecycle boundaries", () => {
+	const scope = createNativePointerScope();
+	const states: string[] = [];
+	const region = scope.wrap(new Text("Hover me", 0, 0), {
+		onHover: () => {
+			states.push("hover");
+			return { handled: true, render: true };
+		},
+		onLeave: () => states.push("leave"),
+	});
+	const root = new Container();
+	root.addChild(region);
+	const observer = scope.createMouseObserver();
+	const height = root.render(40).length;
+
+	dispatch(root, observer, mouse("move", "none", 0, height));
+	dispatch(root, observer, mouse("move", "none", height, height + 1));
+	assert.deepEqual(states, ["hover", "leave"], "an in-root empty move clears hover");
+
+	dispatch(root, observer, mouse("move", "none", 0, height));
+	region.render(30);
+	assert.deepEqual(states, ["hover", "leave", "hover", "leave"], "resize clears hover");
+
+	dispatch(root, observer, mouse("move", "none", 0, height));
+	region.invalidate();
+	region.setDisabled(true);
+	region.dispose();
+	scope.dispose();
+	dispatch(root, observer, mouse("move", "none", 0, height));
+	assert.deepEqual(
+		states,
+		["hover", "leave", "hover", "leave", "hover", "leave"],
+		"invalidate, disable, disposal, and late events cannot retain or restore hover",
+	);
+});
+
+test("a consuming public Box child keeps its exact native target and focus without outer callbacks", () => {
+	const scope = createNativePointerScope();
+	let outerClicks = 0;
+	const child: Component = {
+		render: () => ["native child"],
+		invalidate() {},
+		handleMouse: () => ({ handled: true, focus: true, render: true }),
+	};
+	const box = new Box(0, 0);
+	box.addChild(child);
+	const region = scope.wrap(box, {
+		onClick: () => {
+			outerClicks++;
+			return { handled: true };
+		},
+	});
+	const root = new Container();
+	root.addChild(region);
+	const height = root.render(40).length;
+	const result = dispatch(root, scope.createMouseObserver(), mouse("click", "left", 0, height));
+
+	assert.equal(result?.target.component, child);
+	assert.equal(result?.focusTarget, child);
+	assert.equal(outerClicks, 0, "a consumed child prevents outer pointer callbacks");
+});
+
+test("the same composed region can open an input entry point without answering on press", () => {
+	const scope = createNativePointerScope();
+	let opened = 0;
+	const panel = new Container();
+	panel.addChild(scope.wrap(new Text("Open input", 0, 0), {
+		onPress: () => ({ handled: true }),
+		onClick: () => {
+			opened++;
+			return { handled: true };
+		},
+	}));
+	const root = new Container();
+	root.addChild(panel);
+	const height = root.render(40).length;
+	const observer = scope.createMouseObserver();
+
+	assert.equal(dispatch(root, observer, mouse("press", "left", 0, height))?.handled, true);
+	assert.equal(opened, 0, "press can prepare a control but cannot answer it");
+	assert.equal(dispatch(root, observer, mouse("click", "left", 0, height))?.handled, true);
+	assert.equal(opened, 1, "a caller-owned callback opens the input entry point");
+});
+
+test("a typed public custom overlay factory composes pointer content and disposes late events", async () => {
+	let opened = 0;
+	let leaves = 0;
+	const component = await mountOverlay(() => {
+		const scope = createNativePointerScope();
+		const panel = new Container();
+		panel.addChild(scope.wrap(new Text("Open overlay input", 0, 0), {
+			onHover: () => ({ handled: true, render: true }),
+			onLeave: () => { leaves++; },
+			onClick: () => {
+				opened++;
+				return { handled: true };
+			},
+		}));
+		const observer = scope.createMouseObserver();
+		return {
+			render: (width) => panel.render(width),
+			handleMouse: (event) => {
+				observer.beforeMouse(event);
+				try {
+					return panel.handleMouse(event);
+				} finally {
+					observer.afterMouse(event);
+				}
+			},
+			invalidate: () => panel.invalidate(),
+			dispose: () => scope.dispose(),
+		};
+	}, { overlay: true });
+	const height = component.render(40).length;
+	const hover = component.handleMouse?.(mouse("move", "none", 0, height));
+	const click = component.handleMouse?.(mouse("click", "left", 0, height));
+
+	assert.equal(hover?.render, true);
+	assert.equal(click?.focus, undefined, "overlay content does not claim focus without a caller result");
+	assert.equal(opened, 1, "the factory-returned component routes a native click to its callback");
+	component.dispose?.();
+	assert.equal(component.handleMouse?.(mouse("click", "left", 0, height)), undefined);
+	assert.deepEqual([opened, leaves], [1, 1], "disposal clears hover and rejects late overlay events");
+});
+
+test("scopes apply disabled and disposed state to later Text regions", () => {
+	const calls: string[] = [];
+	const disabled = createNativePointerScope();
+	disabled.setDisabled(true);
+	const disabledRoot = new Container();
+	disabledRoot.addChild(disabled.wrap(new Text("Disabled", 0, 0), {
+		onClick: () => {
+			calls.push("disabled");
+			return { handled: true };
+		},
+	}));
+	const disabledHeight = disabledRoot.render(40).length;
+	const disabledClick = dispatch(
+		disabledRoot, disabled.createMouseObserver(), mouse("click", "left", 0, disabledHeight),
+	);
+	disabled.setDisabled(false);
+	const reenabledClick = dispatch(
+		disabledRoot, disabled.createMouseObserver(), mouse("click", "left", 0, disabledHeight),
+	);
+
+	const disposed = createNativePointerScope();
+	disposed.dispose();
+	const disposedRoot = new Container();
+	disposedRoot.addChild(disposed.wrap(new Text("Disposed", 0, 0), {
+		onClick: () => {
+			calls.push("disposed");
+			return { handled: true };
+		},
+	}));
+	const disposedHeight = disposedRoot.render(40).length;
+	const disposedClick = dispatch(
+		disposedRoot, disposed.createMouseObserver(), mouse("click", "left", 0, disposedHeight),
+	);
+
+	assert.deepEqual(
+		[disabledClick?.handled, reenabledClick?.handled, disposedClick?.handled, calls],
+		[undefined, true, undefined, ["disabled"]],
+		"later regions inherit scope disable/disposal while a live scope can be re-enabled",
+	);
+});

package/tests/native-review-capability-contract.test.ts

@@ -167,11 +167,37 @@ test("2.6.0 repeats 2.5.0 because the negotiated lane Pi consumes is unchanged",
 	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["2.5.0"] as Record<string, boolean>);
 });
 
+test("2.7.0 repeats 2.6.0 because the negotiated lane Pi consumes is unchanged", () => {
+	// Ground-truthed against the published v2.7.0 binary installed from its
+	// signed archive: the v2 lane still advertises capabilities/v2.5 and
+	// answers status/v7, consent/v3, and the `start/v4` continuation, all
+	// already decoded. `review mode status --json` and `review validate --gate
+	// pre-commit` were re-run against the binary and still answer
+	// `gentle-ai.rdd-mode-status/v1` and `gentle-ai.review-gate-result/v1`
+	// respectively. riskEvidence and hint stay dark: still not proven to reach
+	// the negotiated START path Pi consumes.
+	const contract = NATIVE_CLI_CONTRACTS["2.7.0"] as Record<string, boolean>;
+	assert.equal(contract.riskEvidence, false);
+	assert.equal(contract.hint, false);
+	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["2.6.0"] as Record<string, boolean>);
+});
+
+test("2.8.0 repeats 2.7.0 because the negotiated lane Pi consumes is unchanged", () => {
+	// Ground-truthed against the published v2.8.0 linux/amd64 binary from its
+	// signed release archive: capabilities/v2.5 still advertises protocol minor
+	// 5 with status/v7, consent/v3, and start/v4 schemas. riskEvidence and hint
+	// remain dark because neither is proven to reach Pi's negotiated START path.
+	const contract = NATIVE_CLI_CONTRACTS["2.8.0"] as Record<string, boolean>;
+	assert.equal(contract.riskEvidence, false);
+	assert.equal(contract.hint, false);
+	assert.deepEqual(contract, NATIVE_CLI_CONTRACTS["2.7.0"] as Record<string, boolean>);
+});
+
 test("no shipped version key was added beyond the pin bump", () => {
 	// Rows are promises to consumers, so a new key only ever appears in a
 	// dedicated commit alongside a pin bump, never as a side effect. v2.2.4 and
 	// v2.3.0 shipped upstream while Pi stayed on 2.2.3 and were never pinned,
 	// so they get no row: a row asserts ground truth measured against a binary
 	// Pi actually ran, and the table only has to be ascending, not gapless.
-	assert.deepEqual(Object.keys(NATIVE_CLI_CONTRACTS), [...DARK_VERSIONS, "2.2.0", "2.2.1", "2.2.2", "2.2.3", "2.4.0", "2.5.0-rc.3", "2.5.0", "2.6.0"]);
+	assert.deepEqual(Object.keys(NATIVE_CLI_CONTRACTS), [...DARK_VERSIONS, "2.2.0", "2.2.1", "2.2.2", "2.2.3", "2.4.0", "2.5.0-rc.3", "2.5.0", "2.6.0", "2.7.0", "2.8.0"]);
 });