gentle-pi 3.2.1 → 3.4.0

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

@@ -0,0 +1,435 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import askUserQuestion from "../extensions/ask-user-question.ts";
+
+/** Plain theme fake: identity styling keeps rendered assertions readable. */
+interface Theme {
+	fg(color: string, text: string): string;
+	bg?(color: string, text: string): string;
+	bold?(text: string): string;
+}
+
+const theme: Theme = {
+	fg: (_color: string, text: string) => text,
+	bg: (_color: string, text: string) => text,
+	bold: (text: string) => text,
+};
+
+interface Renderable {
+	render(width: number): string[];
+	handleInput?(data: string): void;
+}
+
+type CustomFactory = (
+	tui: { requestRender(): void },
+	theme: Theme,
+	keybindings: unknown,
+	done: (value: unknown) => void,
+) => Renderable;
+
+interface ToolResult {
+	content: Array<{ type: string; text: string }>;
+	details: Record<string, unknown>;
+}
+
+interface RegisteredTool {
+	name: string;
+	label: string;
+	description?: string;
+	renderShell?: string;
+	promptGuidelines?: string[];
+	parameters: {
+		additionalProperties?: boolean;
+		properties?: {
+			questions?: {
+				minItems?: number;
+				maxItems?: number;
+				items?: { additionalProperties?: boolean; properties?: Record<string, unknown> };
+			};
+		};
+	};
+	executionMode?: string;
+	execute(...args: unknown[]): Promise<ToolResult>;
+	renderCall(args: unknown, theme: Theme): Renderable;
+	renderResult(result: unknown, options: unknown, theme: Theme): Renderable;
+}
+
+interface LifecycleEvent {
+	channel: string;
+	data: { active: boolean };
+}
+
+/** One fake extension slot: Pi keys tools per extension by name (`loader.js:240`). */
+interface ExtensionSlot {
+	path: string;
+	tools: Map<string, RegisteredTool>;
+}
+
+const OURS_PATH = "gentle-pi/extensions/ask-user-question.ts";
+
+function registerQuestionTool(slot?: ExtensionSlot): { tool: RegisteredTool; slot: ExtensionSlot; emitted: LifecycleEvent[] } {
+	const target: ExtensionSlot = slot ?? { path: OURS_PATH, tools: new Map() };
+	const emitted: LifecycleEvent[] = [];
+	const pi = {
+		registerTool(tool: RegisteredTool) {
+			target.tools.set(tool.name, tool);
+		},
+		events: {
+			emit(channel: string, data: { active: boolean }) {
+				emitted.push({ channel, data });
+			},
+		},
+	};
+	askUserQuestion(pi as never);
+	const tool = target.tools.get("ask_user_question");
+	if (!tool) throw new Error("ask_user_question must register");
+	return { tool, slot: target, emitted };
+}
+
+function tuiContext(inputs: readonly string[], rendered?: { value: string }) {
+	return {
+		mode: "tui",
+		ui: {
+			custom: async (factory: CustomFactory) => {
+				let result: unknown;
+				const component = factory({ requestRender() {} }, theme, {}, (value) => {
+					result = value;
+				});
+				if (rendered) rendered.value = component.render(100).join("\n");
+				for (const input of inputs) component.handleInput?.(input);
+				return result;
+			},
+		},
+	};
+}
+
+function run(tool: RegisteredTool, params: unknown, ctx: unknown): Promise<ToolResult> {
+	return tool.execute("call", params, new AbortController().signal, undefined, ctx);
+}
+
+const option = (label: string, description = `${label} description`, preview?: string) =>
+	preview === undefined ? { label, description } : { label, description, preview };
+
+const single = () => [
+	{ question: "Proceed?", header: "Proceed", options: [option("Alpha"), option("Beta")] },
+];
+
+test("ask_user_question opts out of the painted shell and pins the schema limits", () => {
+	const { tool } = registerQuestionTool();
+	const questions = tool.parameters.properties?.questions;
+
+	assert.equal(tool.renderShell, "self");
+	assert.equal(tool.name, "ask_user_question");
+	assert.equal(tool.label, "Ask User Question");
+	assert.equal(tool.executionMode, "sequential");
+	assert.equal(tool.parameters.additionalProperties, false);
+	assert.equal(questions?.minItems, 1);
+	assert.equal(questions?.maxItems, 4);
+	assert.equal(questions?.items?.additionalProperties, false);
+	assert.deepEqual(Object.keys(questions?.items?.properties ?? {}).sort(), ["header", "multiSelect", "options", "question"]);
+});
+
+test("ask_user_question guides the model toward the supported contract", () => {
+	const { tool } = registerQuestionTool();
+	const guidelines = (tool.promptGuidelines ?? []).join(" ");
+
+	assert.match(tool.description ?? "", /one to four structured questions/i);
+	assert.match(guidelines, /at most 16 characters/);
+	assert.match(guidelines, /at most 60 characters/);
+	assert.match(guidelines, /preview/);
+	assert.match(guidelines, /multiSelect/);
+	assert.match(guidelines, /Type something\./);
+	assert.match(guidelines, /Never use this tool for decisions that must not be delegated to the user\./);
+});
+
+test("ask_user_question rejects invalid parameters before mounting any UI", async () => {
+	const { tool, emitted } = registerQuestionTool();
+	let customCalls = 0;
+	const ctx = {
+		mode: "tui",
+		ui: {
+			custom: async () => {
+				customCalls++;
+				return undefined;
+			},
+		},
+	};
+
+	const result = await run(tool, { questions: [] }, ctx);
+
+	assert.equal(result.content[0]?.text, "Invalid questionnaire: At least one question is required.");
+	assert.equal(result.details.errorKind, "no_questions");
+	assert.deepEqual(result.details.error, { code: "no_questions", message: "At least one question is required." });
+	assert.equal(customCalls, 0, "invalid input never reaches ctx.ui.custom");
+	assert.deepEqual(emitted, [], "invalid input emits no lifecycle event");
+});
+
+test("ask_user_question stays unavailable outside the interactive TUI", async () => {
+	const { tool, emitted } = registerQuestionTool();
+	let customCalls = 0;
+	const ctx = {
+		mode: "print",
+		ui: {
+			custom: async () => {
+				customCalls++;
+				return undefined;
+			},
+		},
+	};
+
+	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(customCalls, 0);
+	assert.deepEqual(emitted, []);
+});
+
+test("ask_user_question commits a single-select answer end-to-end", async () => {
+	const { tool, emitted } = registerQuestionTool();
+	const rendered = { value: "" };
+
+	const result = await run(tool, { questions: single() }, tuiContext(["\r"], rendered));
+
+	assert.match(rendered.value, /\[1\/1\]/);
+	assert.match(rendered.value, /▸ Proceed/);
+	assert.match(rendered.value, /Alpha/);
+	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 mounts through ctx.ui.custom without an overlay option", async () => {
+	const { tool } = registerQuestionTool();
+	let customArgCount = -1;
+	const ctx = {
+		mode: "tui",
+		ui: {
+			custom: async (...args: unknown[]) => {
+				customArgCount = args.length;
+				const factory = args[0] as CustomFactory;
+				let result: unknown;
+				const component = factory({ requestRender() {} }, theme, {}, (value) => {
+					result = value;
+				});
+				component.handleInput?.("\r");
+				return result;
+			},
+		},
+	};
+
+	await run(tool, { questions: single() }, ctx);
+
+	assert.equal(customArgCount, 1, "a dock swap passes the factory only; no overlay options");
+});
+
+test("ask_user_question mounts exactly one active question and switches with Tab", async () => {
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "First?", header: "First", options: [option("Alpha"), option("Beta")] },
+		{ question: "Second?", header: "Second", options: [option("Gamma"), option("Delta")] },
+	];
+	let component: Renderable | undefined;
+	const pending = run(tool, { questions }, {
+		mode: "tui",
+		ui: {
+			custom: (factory: CustomFactory) => new Promise((resolve) => {
+				component = factory({ requestRender() {} }, theme, {}, resolve);
+			}),
+		},
+	});
+
+	assert.ok(component, "the tool mounts the questionnaire component");
+	const first = component!.render(100).join("\n");
+	assert.match(first, /\[1\/2\]/);
+	assert.match(first, /▸ First/);
+	assert.match(first, /❯ Alpha/);
+	assert.doesNotMatch(first, /Gamma/);
+	assert.doesNotMatch(first, /Second\?/);
+
+	component!.handleInput?.("\t");
+	const second = component!.render(100).join("\n");
+	assert.match(second, /\[2\/2\]/);
+	assert.match(second, /▸ Second/);
+	assert.match(second, /❯ Gamma/);
+	assert.doesNotMatch(second, /First\?/);
+
+	component!.handleInput?.("\x1b"); // cancel to settle the tool
+	await pending;
+});
+
+test("ask_user_question echoes an option preview beside the answer", async () => {
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "Proceed?", header: "Proceed", options: [option("Alpha", "First choice", "Preview A"), option("Beta")] },
+	];
+
+	const result = await run(tool, { questions }, tuiContext(["\r"]));
+
+	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 commits a multiSelect answer with every toggled option", async () => {
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "Pick?", header: "Pick", options: [option("One"), option("Two")], multiSelect: true },
+	];
+
+	const result = await run(tool, { questions }, tuiContext([" ", "\r"]));
+
+	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 commits a free-text custom answer", async () => {
+	const { tool } = registerQuestionTool();
+
+	const result = await run(
+		tool,
+		{ questions: single() },
+		tuiContext(["\x1b[B", "\x1b[B", "\r", "custom text", "\r"]),
+	);
+
+	assert.equal(result.content[0]?.text, "1. Proceed? — (custom) custom text");
+	assert.deepEqual(result.details.answers, [
+		{ questionIndex: 0, question: "Proceed?", kind: "custom", answer: "custom text" },
+	]);
+});
+
+test("ask_user_question keeps toggled options in a multiSelect custom answer", async () => {
+	const { tool } = registerQuestionTool();
+	const questions = [
+		{ question: "Pick?", header: "Pick", options: [option("One"), option("Two")], multiSelect: true },
+	];
+
+	// Toggle One, move to the custom row, open the editor, type, and submit.
+	const result = await run(
+		tool,
+		{ questions },
+		tuiContext([" ", "\x1b[B", "\x1b[B", "\r", "free note", "\r"]),
+	);
+
+	assert.equal(result.content[0]?.text, "1. Pick? — (custom) free note — selected: One");
+	assert.deepEqual(result.details.answers, [
+		{ questionIndex: 0, question: "Pick?", kind: "custom", answer: "free note", selected: ["One"] },
+	]);
+
+	const rendered = tool.renderResult(result, { expanded: false }, theme).render(200).join("\n");
+	assert.equal(rendered.trimEnd(), "✓ Pick? — (custom) free note — selected: One");
+});
+
+test("ask_user_question reports cancellation without answers", async () => {
+	const { tool, emitted } = registerQuestionTool();
+
+	const result = await run(tool, { questions: single() }, tuiContext(["\x1b"]));
+
+	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 settles its lifecycle after a custom UI error", async () => {
+	const { tool, emitted } = registerQuestionTool();
+	const failure = new Error("custom UI failed");
+
+	await assert.rejects(
+		() => run(tool, { questions: single() }, { mode: "tui", ui: { custom: async () => { throw failure; } } }),
+		(error: unknown) => error === failure,
+	);
+
+	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 owns an exclusive tool name across extensions", () => {
+	// Live-verified against the installed Pi runtime: tool names are exclusive
+	// across extensions. Loading two extensions that register
+	// `ask_user_question` aborts the whole load with a hard error
+	// (`Tool "ask_user_question" conflicts with <other extension>`; the runtime
+	// exits non-zero) -- there is no precedence, override, or silent shadowing.
+	// This fake registry is a per-extension Map and cannot reproduce Pi's
+	// cross-extension load error, so it pins the part it can: our single
+	// registration owns the name within its own extension, and the runtime, not
+	// resource order, enforces exclusivity outside it. The competing
+	// `@juicesharp/rpiv-ask-user-question` package must be removed from the
+	// user's settings before this extension can load.
+	const ours: ExtensionSlot = { path: OURS_PATH, tools: new Map() };
+	const registration = registerQuestionTool(ours);
+
+	assert.equal(ours.tools.get("ask_user_question"), registration.tool, "the first-party extension owns its name");
+	assert.equal(registration.tool.name, "ask_user_question");
+	assert.equal(registration.tool.label, "Ask User Question");
+});
+
+test("re-registering inside one extension overwrites its own tool entry", () => {
+	const slot: ExtensionSlot = { path: OURS_PATH, tools: new Map() };
+	registerQuestionTool(slot);
+	const first = slot.tools.get("ask_user_question");
+	registerQuestionTool(slot);
+	const second = slot.tools.get("ask_user_question");
+
+	assert.equal(slot.tools.size, 1, "the extension map is keyed by tool name");
+	assert.notEqual(first, second, "a later registration replaces the same-name entry");
+});
+
+test("ask_user_question renderCall summarizes the questions and option labels", () => {
+	const { tool } = registerQuestionTool();
+	const rendered = tool.renderCall({ questions: single() }, theme).render(100).join("\n");
+
+	assert.match(rendered, /ask_user_question/);
+	assert.match(rendered, /1\. Proceed \(Alpha, Beta\)/);
+});
+
+test("ask_user_question renderCall truncates an oversized summary", () => {
+	const { tool } = registerQuestionTool();
+	const labels = [option("a".repeat(60)), option("b".repeat(60)), option("c".repeat(60))];
+	const rendered = tool.renderCall(
+		{ questions: [{ question: "Long?", header: "Long", options: labels }] },
+		theme,
+	).render(200).join("\n");
+
+	assert.match(rendered, /…\s*$/);
+});
+
+test("ask_user_question renderResult renders answered and cancelled rows", () => {
+	const { tool } = registerQuestionTool();
+	const answered = tool.renderResult(
+		{
+			content: [],
+			details: {
+				answers: [
+					{ questionIndex: 0, question: "Proceed?", kind: "option", answer: "Beta" },
+					{ questionIndex: 1, question: "Pick?", kind: "multi", answer: null, selected: ["One", "Two"] },
+					{ questionIndex: 2, question: "Explain?", kind: "custom", answer: "because" },
+				],
+			},
+		},
+		{ expanded: false },
+		theme,
+	).render(200).join("\n");
+	assert.match(answered, /✓ Proceed\? — Beta/);
+	assert.match(answered, /✓ Pick\? — One, Two/);
+	assert.match(answered, /✓ Explain\? — \(custom\) because/);
+
+	const cancelled = tool.renderResult(
+		{ content: [], details: { cancelled: true } },
+		{ expanded: false },
+		theme,
+	).render(200).join("\n");
+	assert.match(cancelled, /Cancelled/);
+});

package/tests/background-cache-warming.test.ts

@@ -0,0 +1,60 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { readFileSync } from "node:fs";
+import { installBackgroundCacheWarming, type WarmingState } from "../lib/background-cache-warming.ts";
+
+test("native warming decisions use only current owned live background work", () => {
+	let handler: Parameters<Parameters<typeof installBackgroundCacheWarming>[0]["on"]>[1];
+	let state: WarmingState = { sessionId: "parent", ownedTaskIds: new Set(["task"]), tasks: [
+		{ id: "task", parentSessionId: "parent", mode: "background", status: "queued" },
+	] };
+	installBackgroundCacheWarming({ on(event, callback) {
+		assert.equal(event, "cache_warming_decision");
+		handler = callback;
+	} }, () => state);
+	const candidate = { warmCost: 0.01, missCost: 0.1, continuationProbability: 0.15, action: "stop" as const };
+	assert.deepEqual(handler!(candidate), { action: "warm" });
+	state.tasks[0].status = "running";
+	assert.deepEqual(handler!(candidate), { action: "warm" });
+	for (const status of ["waiting", "completed", "failed", "cancelled", "timed_out"] as const) {
+		state.tasks[0].status = status;
+		assert.equal(handler!(candidate), undefined, status);
+	}
+	state.tasks[0].status = "running";
+	for (const patch of [
+		{ sessionId: undefined }, { sessionId: "other" }, { ownedTaskIds: new Set<string>() },
+		{ tasks: [] }, { tasks: [{ ...state.tasks[0], mode: "task" }] },
+	]) {
+		const original = state;
+		state = { ...state, ...patch };
+		assert.equal(handler!(candidate), undefined);
+		state = original;
+	}
+	for (const warmCost of [0.06, 1, NaN, Infinity, -1]) {
+		assert.deepEqual(handler!({ ...candidate, warmCost }), { action: "stop" });
+	}
+	for (const missCost of [0, -1, NaN, Infinity]) {
+		assert.deepEqual(handler!({ ...candidate, missCost }), { action: "stop" });
+	}
+	assert.deepEqual(handler!({ ...candidate, warmCost: 0, missCost: 0.05 }), { action: "warm" });
+	assert.deepEqual(handler!({ ...candidate, warmCost: 0, missCost: 0.049 }), { action: "stop" });
+	state.tasks = [];
+	assert.equal(handler!({ ...candidate, action: "warm" }), undefined, "ordinary idle keeps native action");
+});
+
+// Supplemental architecture guard; the extension lifecycle is exercised in gentle-agents.test.ts.
+test("warming helper has no maintenance capabilities", () => {
+	const helper = readFileSync(new URL("../lib/background-cache-warming.ts", import.meta.url), "utf8");
+	assert.doesNotMatch(helper, /setTimeout|setInterval|sendMessage|sendUserMessage|subagent_|runner\./);
+});
+
+test("background prompt prohibits cache polling and documents explicit native idle opt-in", () => {
+	const prompt = readFileSync(new URL("../assets/orchestrator-delegation.md", import.meta.url), "utf8");
+	assert.match(prompt, /completion or cache maintenance/);
+	assert.match(prompt, /user-requested inspection, relevant scope change, input request, or suspected abnormal behavior/);
+	assert.match(prompt, /Never relaunch equivalent work merely because it is queued or running/);
+	const docs = readFileSync(new URL("../docs/readme-reference.md", import.meta.url), "utf8");
+	assert.match(docs, /"cacheWarming": "idle"/);
+	assert.match(docs, /\$0\.05/);
+	assert.match(docs, /"streaming".*no idle decision/s);
+});

package/tests/background-subagents.test.ts

@@ -530,6 +530,28 @@ function notifyContext(
 	} as unknown as ExtensionContext;
 }
 
+/**
+ * The same minimal context as `notifyContext`, but interactive: `hasUI` is true
+ * and `ui.select` answers the command's no-argument menu. `notifyContext` stays
+ * `hasUI: false` so every existing sub-action test keeps the non-menu path.
+ */
+function selectingContext(
+	cwd: string,
+	notices: Array<{ message: string; type?: string }>,
+	select: (title: string, options: string[]) => Promise<string | undefined>,
+): ExtensionContext {
+	return {
+		cwd,
+		hasUI: true,
+		ui: {
+			notify: (message: string, type?: string) => {
+				notices.push({ message, type });
+			},
+			select,
+		},
+	} as unknown as ExtensionContext;
+}
+
 /** Point the command's global config home at a scratch dir, never at ~/.pi. */
 function scopedEnv(t: TestContext, values: Record<string, string | undefined>): void {
 	const previous = new Map<string, string | undefined>();
@@ -590,6 +612,52 @@ test("no argument reports the effective policy, the deciding default, and the ca
 	);
 });
 
+test("no argument opens a selectable menu and applies the chosen sub-action", async (t) => {
+	const cwd = makeScratch("gp-bg-cmd-select-");
+	const configHome = join(makeScratch("gp-bg-home-"), "gentle-ai");
+	const globalFile = join(configHome, "background-subagents.json");
+	scopedEnv(t, {
+		GENTLE_PI_CONFIG_HOME: configHome,
+		GENTLE_PI_BACKGROUND_SUBAGENTS: undefined,
+	});
+	const command = registeredCommands().get("gentle:background-subagents");
+	assert.ok(command, "gentle:background-subagents must be registered");
+
+	// A dismissed menu (undefined selection) reports nothing and writes nothing.
+	// It runs first so the untouched config home can prove the no-write: a second
+	// scopedEnv save point in one test would restore out of order at teardown.
+	const dismissed: Array<{ message: string; type?: string }> = [];
+	await command!.handler("", selectingContext(cwd, dismissed, async () => undefined));
+	assert.equal(dismissed.length, 0, "a dismissed menu reports nothing");
+	assert.equal(existsSync(globalFile), false, "a dismissed menu writes no file");
+
+	// Choosing "enable" writes the global file and reports exactly once, in the
+	// same shape the direct `enable` sub-action already reports.
+	const notices: Array<{ message: string; type?: string }> = [];
+	await command!.handler(
+		"",
+		selectingContext(cwd, notices, async (title, options) => {
+			assert.equal(title, "Background subagents policy");
+			assert.deepEqual(options, ["status", "enable", "disable"]);
+			return "enable";
+		}),
+	);
+	assert.equal(notices.length, 1, "one invocation reports exactly once");
+	assert.equal(notices[0]!.type, "info");
+	assert.equal(
+		notices[0]!.message,
+		[
+			`background subagents: on (decided by global file ${globalFile}; capability: absent)`,
+			`Wrote on to the global file ${globalFile}.`,
+			"Resolution order (first hit wins): project file, global file, GENTLE_PI_BACKGROUND_SUBAGENTS, built-in default off.",
+		].join("\n"),
+	);
+	assert.deepEqual(JSON.parse(readFileSync(globalFile, "utf8")), {
+		schema: "gentle-pi.background-subagents/v1",
+		policy: "on",
+	});
+});
+
 test("status names the project file that decided and the global file it shadows", async (t) => {
 	const cwd = makeScratch("gp-bg-cmd-project-");
 	const configHome = join(makeScratch("gp-bg-home-"), "gentle-ai");

package/tests/command-palette.test.ts

@@ -32,6 +32,14 @@ function createPalette(groups: readonly CommandPaletteGroup[], theme?: CommandPa
 	return { palette, results };
 }
 
+test("animations is discoverable under Configuration with its live description", () => {
+	const groups = buildCommandPaletteGroups([{ name: "gentle:animations", description: "status|quality|performance|potato" }], {});
+	assert.equal(groups[0]?.title, "Configuration");
+	assert.equal(groups[0]?.items[0]?.command, "gentle:animations");
+	assert.match(groups[0]?.items[0]?.label ?? "", /[Aa]nimation/);
+	assert.equal(groups[0]?.items[0]?.description, "status|quality|performance|potato");
+});
+
 // --- rankPaletteGroups -------------------------------------------------------
 
 test("rankPaletteGroups ranks label-prefix, label-contains, label-subsequence, command-contains, then description-contains", () => {
@@ -336,6 +344,8 @@ test("COMMAND_PALETTE_CATALOG matches the curated command set, in order", () =>
 		"gentle:persona",
 		"gentle:review-mode",
 		"gentle:background-subagents",
+		"gentle:double-esc-cancel",
+		"gentle:animations",
 		"gentle:telemetry",
 		"gentle:banner",
 		"gentle:banner-color",