@selesai/code 0.1.19 → 0.2.1

package/dist/extensions/question/schemas.ts

@@ -0,0 +1,69 @@
+// Typebox schemas for the question tool parameters.
+
+import { Type, type TUnsafe } from "typebox";
+
+const OptionSchema = Type.Union([
+	Type.String({ description: "Option label" }),
+	Type.Object({
+		label: Type.String({ description: "Option label shown to the user" }),
+		description: Type.Optional(Type.String({ description: "Optional help text shown under the option" })),
+	}),
+]);
+
+/** Flat { type: "string", enum: [...] } instead of anyOf — Google function-calling rejects unions. */
+export function StringEnum<const T extends readonly string[]>(
+	values: T,
+	options?: { description?: string; default?: T[number] },
+): TUnsafe<T[number]> {
+	return Type.Unsafe<T[number]>({
+		type: "string",
+		enum: [...values],
+		...(options?.description ? { description: options.description } : {}),
+		...(options?.default !== undefined ? { default: options.default } : {}),
+	});
+}
+
+export const QuestionParamsSchema = Type.Object({
+	question: Type.String({ description: "Question to ask the user before continuing" }),
+	title: Type.Optional(Type.String({ description: "Short title for the question UI (deprecated alias of context summary)" })),
+	context: Type.Optional(
+		Type.String({ description: "Relevant context summary shown before the question" }),
+	),
+	options: Type.Optional(
+		Type.Array(OptionSchema, {
+			description: "Optional multiple-choice options. Each option may be a string or { label, description }.",
+		}),
+	),
+	allowMultiple: Type.Optional(
+		Type.Boolean({ description: "Allow selecting multiple options. Default: false" }),
+	),
+	allowFreeform: Type.Optional(
+		Type.Boolean({
+			description: "Allow a custom freeform answer. Defaults to true when no options are provided, false when options exist.",
+		}),
+	),
+	allowComment: Type.Optional(
+		Type.Boolean({ description: "Collect an optional comment after selecting one or more options. Default: false" }),
+	),
+	displayMode: Type.Optional(
+		StringEnum(["overlay", "inline"] as const, {
+			description:
+				"UI rendering mode. 'overlay' shows a centered modal, 'inline' renders in-place. Default: PI_QUESTION_DISPLAY_MODE env var if set, otherwise 'overlay'.",
+		}),
+	),
+	overlayToggleKey: Type.Optional(
+		Type.String({
+			description:
+				"Shortcut for hiding/showing the overlay popup (overlay mode only), e.g. 'alt+o'. Pass 'off' to disable. Default: PI_QUESTION_OVERLAY_TOGGLE_KEY env var if set, otherwise 'alt+o'.",
+		}),
+	),
+	commentToggleKey: Type.Optional(
+		Type.String({
+			description:
+				"Shortcut for toggling the optional comment/extra-context row when allowComment is true, e.g. 'ctrl+g'. Pass 'off' to disable. Default: PI_QUESTION_COMMENT_TOGGLE_KEY env var if set, otherwise 'ctrl+g'.",
+		}),
+	),
+	timeout: Type.Optional(
+		Type.Number({ description: "Auto-dismiss after N milliseconds. Returns null (cancelled) when expired." }),
+	),
+});

package/dist/extensions/question/selection-mode.ts

@@ -0,0 +1,49 @@
+// SelectionMode strategy — isolates single-vs-multi selection behavior.
+
+import type { QuestionOption } from "./types.ts";
+
+export interface QuestionListState {
+	selectedIndex: number;
+	checked: ReadonlySet<number>;
+	options: QuestionOption[];
+}
+
+export interface SelectionMode {
+	readonly multi: boolean;
+	toggle(checked: Set<number>, index: number): void;
+	buildResult(state: QuestionListState): string[];
+	/** Returns whether to toggle (multi) or just select (single), and the new selectedIndex. */
+	handleNumberKey(idx: number, count: number): { toggle: boolean; selectIndex: number };
+}
+
+export const SingleSelect: SelectionMode = {
+	multi: false,
+	toggle() {},
+	buildResult(state) {
+		const label = state.options[state.selectedIndex]?.label;
+		return label ? [label] : [];
+	},
+	handleNumberKey(idx, count) {
+		return { toggle: false, selectIndex: Math.min(idx, count - 1) };
+	},
+};
+
+export const MultiSelect: SelectionMode = {
+	multi: true,
+	toggle(checked, index) {
+		if (index < 0) return;
+		if (checked.has(index)) checked.delete(index);
+		else checked.add(index);
+	},
+	buildResult(state) {
+		const selectedTitles = Array.from(state.checked)
+			.sort((a, b) => a - b)
+			.map((i) => state.options[i]?.label)
+			.filter((t): t is string => !!t);
+		const fallback = state.options[state.selectedIndex]?.label;
+		return selectedTitles.length > 0 ? selectedTitles : fallback ? [fallback] : [];
+	},
+	handleNumberKey(idx, count) {
+		return { toggle: true, selectIndex: Math.min(idx, count - 1) };
+	},
+};

package/dist/extensions/question/shortcuts.ts

@@ -0,0 +1,53 @@
+// Shortcut resolution for overlay-toggle and comment-toggle keys.
+
+import { matchesKey } from "@earendil-works/pi-tui";
+
+import { DISABLED_SHORTCUT, SHORTCUT_DISABLE_VALUES } from "./constants.ts";
+import type { ResolvedShortcut, ResolvedShortcuts } from "./types.ts";
+import { DEFAULT_COMMENT_TOGGLE_KEY, DEFAULT_OVERLAY_TOGGLE_KEY } from "./constants.ts";
+
+export function normalizeShortcutSpec(value: string | null | undefined): string | null | undefined {
+	if (value === undefined) return undefined;
+	if (value === null) return null;
+	const trimmed = value.trim().toLowerCase();
+	if (SHORTCUT_DISABLE_VALUES.has(trimmed)) return null;
+	return trimmed;
+}
+
+export function isValidShortcutSpec(spec: string): boolean {
+	if (!spec) return false;
+	if (!/^[a-z0-9+_\-!@#$%^&*()|~`'":;,./<>?[\]{}=\\]+$/i.test(spec)) return false;
+	if (spec.startsWith("+") || spec.endsWith("+")) return false;
+	if (spec.includes("++")) return false;
+	return true;
+}
+
+export function buildShortcut(spec: string): ResolvedShortcut {
+	return { disabled: false, spec, matches: (data: string) => matchesKey(data, spec as any) };
+}
+
+export function resolveShortcut(
+	paramValue: string | null | undefined,
+	envValue: string | undefined,
+	defaultSpec: string,
+): ResolvedShortcut {
+	for (const raw of [paramValue, envValue, defaultSpec]) {
+		const normalized = normalizeShortcutSpec(raw);
+		if (normalized === undefined) continue;
+		if (normalized === null) return DISABLED_SHORTCUT;
+		if (isValidShortcutSpec(normalized)) return buildShortcut(normalized);
+	}
+	return DISABLED_SHORTCUT;
+}
+
+export function resolveShortcuts(
+	overlayToggleKey: string | null | undefined,
+	overlayEnv: string | undefined,
+	commentToggleKey: string | null | undefined,
+	commentEnv: string | undefined,
+): ResolvedShortcuts {
+	return {
+		overlayToggle: resolveShortcut(overlayToggleKey, overlayEnv, DEFAULT_OVERLAY_TOGGLE_KEY),
+		commentToggle: resolveShortcut(commentToggleKey, commentEnv, DEFAULT_COMMENT_TOGGLE_KEY),
+	};
+}

package/dist/extensions/question/tests/helpers.test.ts

@@ -0,0 +1,178 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+	normalizeOptions,
+	getOptionsFormatError,
+	createFreeformResponse,
+	createSelectionResponse,
+	formatResponseSummary,
+	formatOptionsForMessage,
+	parseDialogSelections,
+	isCancelled,
+	oneLine,
+} from "../helpers.ts";
+
+test("normalizeOptions: string array", () => {
+	assert.deepEqual(normalizeOptions(["a", "b"]), [
+		{ label: "a" },
+		{ label: "b" },
+	]);
+});
+
+test("normalizeOptions: object array", () => {
+	assert.deepEqual(
+		normalizeOptions([{ label: "a", description: "desc" }]),
+		[{ label: "a", description: "desc" }],
+	);
+});
+
+test("normalizeOptions: mixed string and object", () => {
+	assert.deepEqual(normalizeOptions(["a", { label: "b", description: "d" }]), [
+		{ label: "a" },
+		{ label: "b", description: "d" },
+	]);
+});
+
+test("normalizeOptions: empty/undefined", () => {
+	assert.deepEqual(normalizeOptions(undefined), []);
+	assert.deepEqual(normalizeOptions([]), []);
+});
+
+test("normalizeOptions: whitespace-only labels filtered", () => {
+	assert.deepEqual(normalizeOptions(["  ", "a", ""]), [{ label: "a" }]);
+});
+
+test("getOptionsFormatError: rejects JSON-encoded option arrays", () => {
+	assert.match(getOptionsFormatError(['[{"label":"Yes","description":"desc"}]']) ?? "", /JSON-encoded string/);
+});
+
+test("getOptionsFormatError: allows normal string labels", () => {
+	assert.equal(getOptionsFormatError(["Yes", "No"]), null);
+});
+
+test("createFreeformResponse: null/undefined/empty → null", () => {
+	assert.equal(createFreeformResponse(null), null);
+	assert.equal(createFreeformResponse(undefined), null);
+	assert.equal(createFreeformResponse(""), null);
+	assert.equal(createFreeformResponse("   "), null);
+});
+
+test("createFreeformResponse: non-empty → { kind: freeform }", () => {
+	assert.deepEqual(createFreeformResponse("hello"), { kind: "freeform", text: "hello" });
+	assert.deepEqual(createFreeformResponse("  trim  "), { kind: "freeform", text: "trim" });
+});
+
+test("createSelectionResponse: empty → null", () => {
+	assert.equal(createSelectionResponse([]), null);
+	assert.equal(createSelectionResponse(["", "  "]), null);
+});
+
+test("createSelectionResponse: single", () => {
+	assert.deepEqual(createSelectionResponse(["a"]), { kind: "selection", selections: ["a"] });
+});
+
+test("createSelectionResponse: multiple with trim", () => {
+	assert.deepEqual(createSelectionResponse(["  a  ", "b"]), { kind: "selection", selections: ["a", "b"] });
+});
+
+test("createSelectionResponse: with comment", () => {
+	assert.deepEqual(createSelectionResponse(["a"], "note"), {
+		kind: "selection",
+		selections: ["a"],
+		comment: "note",
+	});
+});
+
+test("createSelectionResponse: comment whitespace trimmed", () => {
+	assert.deepEqual(createSelectionResponse(["a"], "  note  "), {
+		kind: "selection",
+		selections: ["a"],
+		comment: "note",
+	});
+});
+
+test("createSelectionResponse: empty comment → no comment field", () => {
+	assert.deepEqual(createSelectionResponse(["a"], "   "), { kind: "selection", selections: ["a"] });
+});
+
+test("formatResponseSummary: freeform → text", () => {
+	assert.equal(formatResponseSummary({ kind: "freeform", text: "hello" }), "hello");
+});
+
+test("formatResponseSummary: selection without comment", () => {
+	assert.equal(formatResponseSummary({ kind: "selection", selections: ["a", "b"] }), "a, b");
+});
+
+test("formatResponseSummary: selection with comment", () => {
+	assert.equal(
+		formatResponseSummary({ kind: "selection", selections: ["a", "b"], comment: "note" }),
+		"a, b — note",
+	);
+});
+
+test("formatOptionsForMessage: 0 options → empty string", () => {
+	assert.equal(formatOptionsForMessage([]), "");
+});
+
+test("formatOptionsForMessage: 1 option", () => {
+	assert.equal(formatOptionsForMessage([{ label: "a" }]), "1. a");
+});
+
+test("formatOptionsForMessage: with description", () => {
+	assert.equal(formatOptionsForMessage([{ label: "a", description: "desc" }]), "1. a — desc");
+});
+
+test("formatOptionsForMessage: multiple", () => {
+	assert.equal(
+		formatOptionsForMessage([{ label: "a" }, { label: "b", description: "d" }]),
+		"1. a\n2. b — d",
+	);
+});
+
+test("parseDialogSelections: basic CSV", () => {
+	assert.deepEqual(parseDialogSelections("a,b,c"), ["a", "b", "c"]);
+});
+
+test("parseDialogSelections: whitespace trimmed", () => {
+	assert.deepEqual(parseDialogSelections(" a , b "), ["a", "b"]);
+});
+
+test("parseDialogSelections: empty → []", () => {
+	assert.deepEqual(parseDialogSelections(""), []);
+});
+
+test("parseDialogSelections: empty entries filtered", () => {
+	assert.deepEqual(parseDialogSelections("a,,b"), ["a", "b"]);
+});
+
+test("isCancelled: null/undefined → true", () => {
+	assert.equal(isCancelled(null), true);
+	assert.equal(isCancelled(undefined), true);
+});
+
+test("isCancelled: falsy non-null → false", () => {
+	assert.equal(isCancelled(""), false);
+	assert.equal(isCancelled(0), false);
+	assert.equal(isCancelled(false), false);
+});
+
+test("oneLine: undefined → empty string", () => {
+	assert.equal(oneLine(undefined), "");
+	assert.equal(oneLine(null), "");
+});
+
+test("oneLine: short → unchanged", () => {
+	assert.equal(oneLine("hello"), "hello");
+});
+
+test("oneLine: long → truncated with …", () => {
+	const long = "a".repeat(120);
+	const result = oneLine(long, 10);
+	assert.equal(result.length, 10);
+	assert.equal(result.endsWith("…"), true);
+});
+
+test("oneLine: whitespace collapsed", () => {
+	assert.equal(oneLine("  hello   world  "), "hello world");
+});

package/dist/extensions/question/tests/question-list.test.ts

@@ -0,0 +1,230 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { Key, matchesKey } from "@earendil-works/pi-tui";
+
+import { QuestionList } from "../question-list.ts";
+import { MultiSelect, SingleSelect } from "../selection-mode.ts";
+import type { KeybindingsManager, Theme } from "@earendil-works/pi-coding-agent";
+import type { ResolvedShortcut } from "../types.ts";
+
+// ---------------------------------------------------------------------------
+// Fakes
+// ---------------------------------------------------------------------------
+
+const fakeTheme: Theme = {
+	fg: (_name: string, s: string) => s,
+	bold: (s: string) => s,
+} as unknown as Theme;
+
+function fakeKeybindings(actions: string[] = []): KeybindingsManager {
+	return {
+		matches: (_data: string, action: string) => actions.includes(action),
+		getKeys: (_action: string) => [],
+	} as unknown as KeybindingsManager;
+}
+
+const enabledShortcut: ResolvedShortcut = {
+	disabled: false,
+	spec: "ctrl+g",
+	matches: (data: string) => matchesKey(data, "ctrl+g"),
+};
+
+const disabledShortcut: ResolvedShortcut = {
+	disabled: true,
+	spec: null,
+	matches: ((_data: string) => false) as (data: string) => false,
+};
+
+const opts = (labels: string[]) => labels.map((label) => ({ label }));
+
+// Terminal data bytes
+const ESC = "\x1b";
+const ENTER = "\r";
+const SPACE = " ";
+const CTRL_J = "\x0a";
+const CTRL_K = "\x0b";
+const UP_ARROW = "\x1b[A";
+const DOWN_ARROW = "\x1b[B";
+const BACKSPACE = "\x7f";
+
+// ---------------------------------------------------------------------------
+// Single-select tests
+// ---------------------------------------------------------------------------
+
+test("SingleSelect: navigate down wraps at end", () => {
+	const list = new QuestionList(opts(["a", "b", "c"]), SingleSelect, false, false, fakeTheme, fakeKeybindings(), disabledShortcut);
+	list.handleInput(CTRL_J); // ctrl+j = vim down
+	assert.equal((list as any).selectedIndex, 1);
+	list.handleInput(CTRL_J);
+	assert.equal((list as any).selectedIndex, 2);
+	list.handleInput(CTRL_J);
+	assert.equal((list as any).selectedIndex, 0); // wraps
+});
+
+test("SingleSelect: navigate up wraps at 0", () => {
+	const list = new QuestionList(opts(["a", "b", "c"]), SingleSelect, false, false, fakeTheme, fakeKeybindings(), disabledShortcut);
+	list.handleInput(CTRL_K); // ctrl+k = vim up
+	assert.equal((list as any).selectedIndex, 2); // wraps to last
+});
+
+test("SingleSelect: confirm on option → onSubmit with [label]", () => {
+	const list = new QuestionList(opts(["a", "b"]), SingleSelect, false, false, fakeTheme, fakeKeybindings(["tui.select.confirm"]), disabledShortcut);
+	let submitted: [string[], boolean] | null = null;
+	list.onSubmit = (selections, commentEnabled) => (submitted = [selections, commentEnabled]);
+	list.handleInput(ENTER);
+	assert.deepEqual(submitted, [["a"], false]);
+});
+
+test("SingleSelect: confirm on freeform row → onEnterFreeform", () => {
+	const list = new QuestionList(opts(["a"]), SingleSelect, true, false, fakeTheme, fakeKeybindings(["tui.select.confirm"]), disabledShortcut);
+	let called = false;
+	list.onEnterFreeform = () => (called = true);
+	// Navigate to freeform row (index 1, since 1 option + 0 comment = freeform at index 1)
+	list.handleInput(CTRL_J);
+	list.handleInput(ENTER);
+	assert.equal(called, true);
+});
+
+test("SingleSelect: confirm on comment-toggle → toggles comment, no submit", () => {
+	const list = new QuestionList(opts(["a"]), SingleSelect, false, true, fakeTheme, fakeKeybindings(["tui.select.confirm"]), disabledShortcut);
+	let submitted = false;
+	list.onSubmit = () => (submitted = true);
+	// Navigate to comment-toggle row (index 1)
+	list.handleInput(CTRL_J);
+	list.handleInput(ENTER);
+	assert.equal(list.isCommentEnabled(), true);
+	assert.equal(submitted, false);
+});
+
+test("SingleSelect: number key selects (no toggle)", () => {
+	const list = new QuestionList(opts(["a", "b", "c"]), SingleSelect, false, false, fakeTheme, fakeKeybindings(), disabledShortcut);
+	list.handleInput("3");
+	assert.equal((list as any).selectedIndex, 2);
+	// No toggle in single-select
+	assert.equal((list as any).checked.size, 0);
+});
+
+test("SingleSelect: escape with search query → clears search", () => {
+	const list = new QuestionList(opts(["a", "b"]), SingleSelect, false, false, fakeTheme, fakeKeybindings(), disabledShortcut);
+	list.handleInput("a"); // type into search
+	assert.equal((list as any).searchQuery, "a");
+	list.handleInput(ESC);
+	assert.equal((list as any).searchQuery, "");
+});
+
+test("SingleSelect: escape without search → not handled by list (cancel is via keybinding)", () => {
+	const list = new QuestionList(opts(["a"]), SingleSelect, false, false, fakeTheme, fakeKeybindings(["tui.select.cancel"]), disabledShortcut);
+	let cancelled = false;
+	list.onCancel = () => (cancelled = true);
+	// In single-select, escape without search query is not handled by the list at all.
+	// The keybinding check for cancel comes AFTER the escape-clears-search check.
+	// Since searchQuery is empty, escape falls through to cancel keybinding check.
+	// With fakeKeybindings matching "tui.select.cancel", it WILL cancel.
+	list.handleInput(ESC);
+	assert.equal(cancelled, true);
+});
+
+// ---------------------------------------------------------------------------
+// Multi-select tests
+// ---------------------------------------------------------------------------
+
+test("MultiSelect: space on option → toggles checked", () => {
+	const list = new QuestionList(opts(["a", "b"]), MultiSelect, false, false, fakeTheme, fakeKeybindings(), disabledShortcut);
+	list.handleInput(SPACE);
+	assert.equal((list as any).checked.has(0), true);
+	list.handleInput(SPACE);
+	assert.equal((list as any).checked.has(0), false);
+});
+
+test("MultiSelect: number key toggles + selects", () => {
+	const list = new QuestionList(opts(["a", "b", "c"]), MultiSelect, false, false, fakeTheme, fakeKeybindings(), disabledShortcut);
+	list.handleInput("2");
+	assert.equal((list as any).checked.has(1), true);
+	assert.equal((list as any).selectedIndex, 1);
+});
+
+test("MultiSelect: confirm with checked items → onSubmit with sorted labels", () => {
+	const list = new QuestionList(opts(["a", "b", "c"]), MultiSelect, false, false, fakeTheme, fakeKeybindings(["tui.select.confirm"]), disabledShortcut);
+	let submitted: [string[], boolean] | null = null;
+	list.onSubmit = (selections, commentEnabled) => (submitted = [selections, commentEnabled]);
+	// Check items 2 and 1 (out of order)
+	list.handleInput("2");
+	list.handleInput("1");
+	list.handleInput(ENTER);
+	assert.deepEqual(submitted, [["a", "b"], false]); // sorted by index
+});
+
+test("MultiSelect: confirm with nothing checked → fallback to highlighted label", () => {
+	const list = new QuestionList(opts(["a", "b"]), MultiSelect, false, false, fakeTheme, fakeKeybindings(["tui.select.confirm"]), disabledShortcut);
+	let submitted: [string[], boolean] | null = null;
+	list.onSubmit = (selections, commentEnabled) => (submitted = [selections, commentEnabled]);
+	list.handleInput(ENTER);
+	assert.deepEqual(submitted, [["a"], false]); // highlighted fallback
+});
+
+test("MultiSelect: confirm with no options → onCancel", () => {
+	const list = new QuestionList([], MultiSelect, false, false, fakeTheme, fakeKeybindings(["tui.select.confirm"]), disabledShortcut);
+	let cancelled = false;
+	list.onCancel = () => (cancelled = true);
+	list.handleInput(ENTER);
+	assert.equal(cancelled, true);
+});
+
+test("MultiSelect: confirm on comment-toggle → toggles comment", () => {
+	const list = new QuestionList(opts(["a"]), MultiSelect, false, true, fakeTheme, fakeKeybindings(["tui.select.confirm"]), disabledShortcut);
+	let submitted = false;
+	list.onSubmit = () => (submitted = true);
+	// Navigate to comment-toggle (index 1)
+	list.handleInput(CTRL_J);
+	list.handleInput(ENTER);
+	assert.equal(list.isCommentEnabled(), true);
+	assert.equal(submitted, false);
+});
+
+test("MultiSelect: confirm on freeform → onEnterFreeform", () => {
+	const list = new QuestionList(opts(["a"]), MultiSelect, true, false, fakeTheme, fakeKeybindings(["tui.select.confirm"]), disabledShortcut);
+	let called = false;
+	list.onEnterFreeform = () => (called = true);
+	// Navigate to freeform row (index 1)
+	list.handleInput(CTRL_J);
+	list.handleInput(ENTER);
+	assert.equal(called, true);
+});
+
+// ---------------------------------------------------------------------------
+// Comment toggle tests (both modes)
+// ---------------------------------------------------------------------------
+
+test("Comment toggle via shortcut: toggles commentEnabled", () => {
+	const list = new QuestionList(opts(["a"]), SingleSelect, false, true, fakeTheme, fakeKeybindings(), enabledShortcut);
+	assert.equal(list.isCommentEnabled(), false);
+	list.handleInput(CTRL_K); // ctrl+k = our comment toggle key... wait, spec is "ctrl+g"
+	// Actually the shortcut spec is "ctrl+g", so we need to send ctrl+g data
+	const CTRL_G = "\x07";
+	list.handleInput(CTRL_G);
+	assert.equal(list.isCommentEnabled(), true);
+	list.handleInput(CTRL_G);
+	assert.equal(list.isCommentEnabled(), false);
+});
+
+test("Comment toggle disabled: does nothing", () => {
+	const list = new QuestionList(opts(["a"]), SingleSelect, false, true, fakeTheme, fakeKeybindings(), disabledShortcut);
+	const CTRL_G = "\x07";
+	list.handleInput(CTRL_G);
+	assert.equal(list.isCommentEnabled(), false);
+});
+
+// ---------------------------------------------------------------------------
+// onSubmit includes commentEnabled flag
+// ---------------------------------------------------------------------------
+
+test("onSubmit passes commentEnabled=true when comment is enabled", () => {
+	const list = new QuestionList(opts(["a", "b"]), SingleSelect, false, true, fakeTheme, fakeKeybindings(["tui.select.confirm"]), enabledShortcut);
+	let submitted: [string[], boolean] | null = null;
+	list.onSubmit = (selections, commentEnabled) => (submitted = [selections, commentEnabled]);
+	const CTRL_G = "\x07";
+	list.handleInput(CTRL_G); // enable comment
+	list.handleInput(ENTER); // confirm
+	assert.deepEqual(submitted, [["a"], true]);
+});