@adeildo/pi-ask-permission 4.0.0

package/src/pi/events.ts

@@ -0,0 +1,260 @@
+import type { FeatureScope } from "@adeildo/pi-kit";
+import {
+	type ExtensionAPI,
+	type ExtensionContext,
+	isToolCallEventType,
+	type ToolCallEvent,
+} from "@earendil-works/pi-coding-agent";
+
+import { SCOPE_LABEL } from "#core/always-yes.ts";
+import type { DialogAnswer } from "#core/answer.ts";
+import { noUIMode } from "#core/config/patterns.ts";
+import {
+	type Call,
+	decide,
+	describeCall,
+	gateLayers,
+	type Layer,
+	type Verdict,
+} from "#core/decide.ts";
+import { judgeGate } from "#core/judge/gate.ts";
+import { judgeVerdictText, remember, warnOnce } from "#core/judge/report.ts";
+import type { CallDescriptor } from "#core/tools.ts";
+import { NAME } from "#identity";
+import { announce, type Decided } from "#pi/api.ts";
+import { clearModeStatus, renderModeStatus } from "#pi/mode.ts";
+import { type FileChange, type PendingWrites, previewEdit, previewWrite } from "#pi/preview.ts";
+import { restoreSession } from "#pi/session-entries.ts";
+import {
+	loadSessionConfig,
+	openAlwaysYes,
+	noteJudgeFailure,
+	rememberAlwaysYes,
+	resetJudgeHealth,
+	type SessionState,
+} from "#pi/session.ts";
+import { AskDialog } from "#ui/dialog.ts";
+import { appendJudgeEntry } from "#ui/judge-entry.ts";
+import { askViaSelector } from "#ui/selector.ts";
+import { notifyJudgePolicyWarning } from "#ui/settings/status.ts";
+
+const JUDGE_STATUS = `${NAME}:judge`;
+const TYPING_STATUS = "waiting for you to finish typing";
+
+export function registerEvents(scope: FeatureScope, state: SessionState): void {
+	scope.on("session_start", (_event, ctx) => {
+		loadSessionConfig(scope, state, ctx);
+		openAlwaysYes(state, ctx);
+		restoreSession(state, ctx);
+		notifyJudgePolicyWarning(state.config, ctx);
+		renderModeStatus(ctx, state.mode, state.config.workspace.outside);
+		state.typing.start(ctx);
+	});
+
+	scope.on("session_tree", (_event, ctx) => {
+		restoreSession(state, ctx);
+		renderModeStatus(ctx, state.mode, state.config.workspace.outside);
+	});
+
+	scope.on("session_shutdown", (_event, ctx) => {
+		clearModeStatus(ctx);
+		state.typing.stop();
+	});
+
+	scope.on("tool_call", async (event, ctx) => {
+		const call = describeCall(
+			event.toolName,
+			event.input,
+			ctx.cwd,
+			state.config,
+			state.customTools,
+		);
+		const outcome = await gate(scope, state, ctx, call, event);
+
+		announce(scope, {
+			toolCallId: event.toolCallId,
+			toolName: call.toolName,
+			summary: call.target.summary,
+			...outcome,
+		});
+		if (outcome.action === "block") return { block: true, reason: outcome.reason };
+
+		if (outcome.note) {
+			if (state.config.notes === "message") sendNote(scope, outcome.note, call.toolName);
+			else state.pendingNotes.set(event.toolCallId, outcome.note);
+		}
+		return undefined;
+	});
+
+	scope.on("tool_result", (event) => {
+		for (const [path, write] of state.pendingWrites) {
+			if (write.toolCallId === event.toolCallId) state.pendingWrites.delete(path);
+		}
+
+		const note = state.pendingNotes.get(event.toolCallId);
+		if (!note) return undefined;
+
+		state.pendingNotes.delete(event.toolCallId);
+		return { content: [...event.content, { type: "text", text: noteBlock(note) }] };
+	});
+}
+
+type Outcome = Pick<Decided, "action" | "by" | "reason" | "note">;
+
+async function gate(
+	pi: ExtensionAPI,
+	state: SessionState,
+	ctx: ExtensionContext,
+	call: Call,
+	event: ToolCallEvent,
+): Promise<Outcome> {
+	const judge: Layer = { name: "judge", decide: (next) => runJudge(state, pi, ctx, next) };
+	const decision = await decide(call, [...gateLayers(state), judge]);
+
+	if (decision.action === "allow") return { action: "allow", by: decision.by };
+	if (decision.action === "block")
+		return { action: "block", by: decision.by, reason: decision.reason };
+
+	if (!ctx.hasUI) {
+		if (noUIMode(state.config, call.toolName) === "allow") return { action: "allow", by: "no UI" };
+		return { action: "block", by: "no UI", reason: `${NAME}: no UI to approve "${call.toolName}"` };
+	}
+
+	const change = await previewChange(ctx, event, state.pendingWrites);
+	if (change && "error" in change)
+		return { action: "block", by: "edit check", reason: change.error };
+
+	await state.typing.waitUntilQuiet(ctx.signal, (waiting) => {
+		ctx.ui.setStatus(NAME, waiting ? TYPING_STATUS : undefined);
+	});
+
+	state.typing.pause();
+	const answer = await ask(ctx, call.toolName, call.target, change?.diff).finally(() =>
+		state.typing.resume(),
+	);
+
+	if (answer.decision === "deny") {
+		return { action: "block", by: "you", reason: denyReason(answer.note), note: answer.note };
+	}
+
+	if (answer.remember) {
+		const scope = answer.scope ?? "session";
+		rememberAlwaysYes(pi, state, ctx, scope, call.toolName, answer.remember);
+		ctx.ui.notify(
+			`${NAME}: always yes for ${call.toolName} \u00b7 ${answer.remember} (${SCOPE_LABEL[scope]})`,
+			"info",
+		);
+	}
+
+	if (change)
+		state.pendingWrites.set(change.path, { toolCallId: event.toolCallId, after: change.after });
+	return { action: "allow", by: "you", note: answer.note };
+}
+
+function previewChange(
+	ctx: ExtensionContext,
+	event: ToolCallEvent,
+	pending: PendingWrites,
+): Promise<FileChange | undefined> {
+	if (isToolCallEventType("edit", event)) return previewEdit(ctx, event.input, pending);
+	if (isToolCallEventType("write", event)) return previewWrite(ctx, event.input, pending);
+	return Promise.resolve(undefined);
+}
+
+async function runJudge(
+	state: SessionState,
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	call: Call,
+): Promise<Verdict | undefined> {
+	if (Date.now() < state.judgeHealth.retryAt) return undefined;
+
+	const outcome = await judgeGate({
+		config: state.config,
+		ctx,
+		toolName: call.toolName,
+		target: call.target,
+		rawInput: call.input,
+		cache: state.judgeCache,
+		onStatus: (status) => ctx.ui.setStatus(JUDGE_STATUS, status),
+	});
+	if (!outcome) return undefined;
+
+	const record = outcome.record;
+	remember(record, state.judgeLog);
+	appendJudgeEntry(pi, record);
+
+	if (record.error) {
+		warnOnce(ctx, state.judgeWarned, record);
+		noteJudgeFailure(state, ctx);
+	} else {
+		resetJudgeHealth(state);
+	}
+
+	if (outcome.action === "deny") {
+		return { action: "block", reason: `${NAME}: ${outcome.reason}` };
+	}
+
+	if (outcome.action === "allow") {
+		if (state.config.judge.rememberApprovals) {
+			const level = call.target.levels.at(-1);
+			if (level !== undefined) rememberAlwaysYes(pi, state, ctx, "session", call.toolName, level);
+		}
+		return { action: "allow" };
+	}
+
+	if (state.config.judge.dryRun && !record.error) {
+		ctx.ui.notify(`${NAME}: judge (dry run) ${judgeVerdictText(record)}`, "info");
+	}
+
+	return undefined;
+}
+
+async function ask(
+	ctx: ExtensionContext,
+	toolName: string,
+	target: CallDescriptor,
+	diff: string | undefined,
+): Promise<DialogAnswer> {
+	if (ctx.mode === "tui") {
+		try {
+			const answer = await ctx.ui.custom<DialogAnswer>(
+				(tui, theme, keybindings, done) =>
+					new AskDialog({
+						theme,
+						toolName,
+						target,
+						diff,
+						keybindings,
+						requestRender: () => tui.requestRender(),
+						complete: done,
+					}),
+			);
+			if (answer) return answer;
+		} catch {
+			// The plain selector, not an open gate.
+		}
+	}
+
+	return askViaSelector(ctx, toolName, target);
+}
+
+function sendNote(pi: ExtensionAPI, note: string, toolName: string): void {
+	void pi.sendMessage(
+		{
+			customType: NAME,
+			content: noteBlock(note),
+			display: true,
+			details: { toolName },
+		},
+		{ deliverAs: "steer" },
+	);
+}
+
+function noteBlock(note: string): string {
+	return `[${NAME}] the user approved this call and added:\n${note}`;
+}
+
+function denyReason(note?: string): string {
+	return note ? `${NAME}: denied by the user.\n${note}` : `${NAME}: denied by the user.`;
+}

package/src/pi/mode.ts

@@ -0,0 +1,48 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import type { OutsideScope } from "#core/config/schema.ts";
+import { MODE_DESCRIPTION, MODE_LABEL, type PermissionMode } from "#core/mode.ts";
+import { NAME } from "#identity";
+import { record } from "#pi/session-entries.ts";
+import type { SessionState } from "#pi/session.ts";
+
+export const MODE_STATUS = `${NAME}:mode`;
+
+export function setSessionMode(
+	pi: ExtensionAPI,
+	state: SessionState,
+	mode: PermissionMode,
+	ctx: ExtensionContext,
+	announce = true,
+): void {
+	if (mode !== state.mode) record(pi, { kind: "mode", mode });
+	state.mode = mode;
+	renderModeStatus(ctx, mode, state.config.workspace.outside);
+
+	if (announce) {
+		ctx.ui.notify(`${NAME}: ${MODE_LABEL[mode]} \u00b7 ${MODE_DESCRIPTION[mode]}`, "info");
+	}
+}
+
+export function clearModeStatus(ctx: ExtensionContext): void {
+	if (!ctx.hasUI) return;
+	ctx.ui.setStatus(MODE_STATUS, undefined);
+}
+
+export function renderModeStatus(
+	ctx: ExtensionContext,
+	mode: PermissionMode,
+	outside: OutsideScope,
+): void {
+	if (mode === "manual") {
+		clearModeStatus(ctx);
+		return;
+	}
+	if (!ctx.hasUI) return;
+
+	const anywhere = outside === "allow";
+	const arrow = mode === "auto" ? "\u23f5\u23f5" : "\u23f5";
+	const color = anywhere ? "error" : "warning";
+	const label = anywhere ? `${MODE_LABEL[mode]} \u00b7 anywhere` : MODE_LABEL[mode];
+	ctx.ui.setStatus(MODE_STATUS, ctx.ui.theme.fg(color, `${arrow} ${label}`));
+}

package/src/pi/preview.ts

@@ -0,0 +1,82 @@
+import { constants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+import {
+	createEditToolDefinition,
+	type EditToolInput,
+	type ExtensionContext,
+	type ExtensionToolContext,
+	generateDiffString,
+	type WriteToolInput,
+} from "@earendil-works/pi-coding-agent";
+
+import { describe } from "#util/primitives.ts";
+
+export type FileChange = { error: string } | { path: string; after: string; diff: string };
+
+/** Approved edits and writes that have not run yet, by absolute path. */
+export type PendingWrites = Map<string, { toolCallId: string; after: string }>;
+
+// pi's own edit tool, run with a writeFile that keeps the result, so the preview and the
+// error are exactly what the real call would produce.
+export async function previewEdit(
+	ctx: ExtensionContext,
+	input: EditToolInput,
+	pending: PendingWrites,
+): Promise<FileChange> {
+	let before = "";
+	let written: { path: string; after: string } | undefined;
+
+	const dryRun = createEditToolDefinition(ctx.cwd, {
+		operations: {
+			access: (path) =>
+				pending.has(path) ? Promise.resolve() : access(path, constants.R_OK | constants.W_OK),
+			readFile: async (path) => {
+				const content = pending.get(path)?.after ?? (await readFile(path, "utf8"));
+				before = content;
+				return Buffer.from(content);
+			},
+			writeFile: async (path, content) => {
+				written = { path, after: content };
+			},
+		},
+	});
+
+	try {
+		await dryRun.execute("preview", input, ctx.signal, undefined, previewContext(ctx));
+	} catch (error) {
+		return { error: describe(error) };
+	}
+	if (!written) return { error: "the edit changed nothing" };
+	return { ...written, diff: generateDiffString(before, written.after).diff };
+}
+
+/**
+ * A tool runs with a context that can call other tools. The preview runs from a `tool_call` handler,
+ * which has none, and a dry run must not start real calls, so it gets no tools and any call fails
+ * the preview. The session context stays the prototype, so its getters keep reading live state.
+ */
+function previewContext(ctx: ExtensionContext): ExtensionToolContext {
+	return Object.assign(Object.create(ctx) as ExtensionContext, {
+		tools: [],
+		executeTool: (name: string) => Promise.reject(new Error(`a preview cannot call ${name}`)),
+	});
+}
+
+export async function previewWrite(
+	ctx: ExtensionContext,
+	input: WriteToolInput,
+	pending: PendingWrites,
+): Promise<FileChange> {
+	const path = absolute(input.path, ctx.cwd);
+	const before = pending.get(path)?.after ?? (await readFile(path, "utf8").catch(() => ""));
+	return { path, after: input.content, diff: generateDiffString(before, input.content).diff };
+}
+
+function absolute(path: string, cwd: string): string {
+	if (path === "~") return homedir();
+	if (path.startsWith("~/")) return join(homedir(), path.slice(2));
+	return resolve(cwd, path);
+}

package/src/pi/provider.ts

@@ -0,0 +1,11 @@
+import type { FeatureScope } from "@adeildo/pi-kit";
+
+import { TYPESAFE_BASE_URL, TYPESAFE_PROVIDER } from "#core/judge/backends/jev.ts";
+
+export function registerTypesafeProvider(scope: FeatureScope): void {
+	scope.registerProvider(TYPESAFE_PROVIDER, {
+		name: "TypeSafe (Jev)",
+		baseUrl: TYPESAFE_BASE_URL,
+		apiKey: "$TYPESAFE_API_KEY",
+	});
+}

package/src/pi/session-entries.ts

@@ -0,0 +1,74 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { isPermissionMode, type PermissionMode } from "#core/mode.ts";
+import { NAME } from "#identity";
+import type { SessionState } from "#pi/session.ts";
+import { isRecord } from "#util/primitives.ts";
+
+export const SESSION_ENTRY = `${NAME}:session`;
+
+export type SessionEntry =
+	| { kind: "mode"; mode: PermissionMode }
+	| { kind: "always-yes"; toolName: string; level: string }
+	| { kind: "forget-always-yes" };
+
+interface SessionSnapshot {
+	mode: PermissionMode;
+	alwaysYes: { toolName: string; level: string }[];
+}
+
+export function record(pi: ExtensionAPI, entry: SessionEntry): void {
+	pi.appendEntry(SESSION_ENTRY, entry);
+}
+
+export function replay(branch: readonly unknown[], startMode: PermissionMode): SessionSnapshot {
+	const snapshot: SessionSnapshot = { mode: startMode, alwaysYes: [] };
+
+	for (const item of branch) {
+		const entry = sessionEntry(item);
+		switch (entry?.kind) {
+			case "mode":
+				snapshot.mode = entry.mode;
+				break;
+			case "always-yes":
+				snapshot.alwaysYes.push({ toolName: entry.toolName, level: entry.level });
+				break;
+			case "forget-always-yes":
+				snapshot.alwaysYes = [];
+				break;
+		}
+	}
+	return snapshot;
+}
+
+export function restoreSession(state: SessionState, ctx: ExtensionContext): void {
+	const snapshot = replay(ctx.sessionManager.getBranch(), state.config.mode);
+
+	state.mode = snapshot.mode;
+	state.alwaysYes.forget("session");
+	for (const { toolName, level } of snapshot.alwaysYes) {
+		state.alwaysYes.add("session", toolName, level);
+	}
+}
+
+function sessionEntry(item: unknown): SessionEntry | undefined {
+	if (!isRecord(item) || item.type !== "custom" || item.customType !== SESSION_ENTRY) {
+		return undefined;
+	}
+
+	const data = item.data;
+	if (!isRecord(data)) return undefined;
+
+	if (data.kind === "mode" && isPermissionMode(data.mode)) {
+		return { kind: "mode", mode: data.mode };
+	}
+	if (data.kind === "always-yes" && isText(data.toolName) && isText(data.level)) {
+		return { kind: "always-yes", toolName: data.toolName, level: data.level };
+	}
+	if (data.kind === "forget-always-yes") return { kind: "forget-always-yes" };
+	return undefined;
+}
+
+function isText(value: unknown): value is string {
+	return typeof value === "string" && value !== "";
+}

package/src/pi/session.ts

@@ -0,0 +1,129 @@
+import { type FeatureScope } from "@adeildo/pi-kit";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { AlwaysYes, savedFileExists, type Scope } from "#core/always-yes.ts";
+import { defaultConfig, type PermissionConfig } from "#core/config/schema.ts";
+import { migrateConfig, readConfig, writeConfig } from "#core/config/settings.ts";
+import { globalAlwaysYesPath, projectAlwaysYesPath } from "#core/config/store.ts";
+import type { JudgeOutcome, JudgeRecord } from "#core/judge/types.ts";
+import type { PermissionMode } from "#core/mode.ts";
+import type { ToolAdapter } from "#core/tools.ts";
+import { NAME } from "#identity";
+import type { PendingWrites } from "#pi/preview.ts";
+import { record } from "#pi/session-entries.ts";
+import { TypingMonitor } from "#ui/typing.ts";
+
+const JUDGE_FAILURE_LIMIT = 2;
+const JUDGE_RETRY_MS = 60_000;
+
+export interface JudgeHealth {
+	failures: number;
+	retryAt: number;
+}
+
+export interface SessionState {
+	config: PermissionConfig;
+	mode: PermissionMode;
+	alwaysYes: AlwaysYes;
+	pendingNotes: Map<string, string>;
+	judgeCache: Map<string, JudgeOutcome>;
+	judgeLog: JudgeRecord[];
+	judgeWarned: Set<string>;
+	judgeHealth: JudgeHealth;
+	typing: TypingMonitor;
+	customTools: Map<string, Partial<ToolAdapter>>;
+	pendingWrites: PendingWrites;
+}
+
+export function createSession(): SessionState {
+	const config = defaultConfig();
+
+	return {
+		config,
+		mode: config.mode,
+		alwaysYes: new AlwaysYes(),
+		pendingNotes: new Map(),
+		judgeCache: new Map(),
+		judgeLog: [],
+		judgeWarned: new Set(),
+		judgeHealth: { failures: 0, retryAt: 0 },
+		typing: new TypingMonitor(),
+		customTools: new Map(),
+		pendingWrites: new Map(),
+	};
+}
+
+export function resetJudgeHealth(state: SessionState): void {
+	state.judgeHealth.failures = 0;
+	state.judgeHealth.retryAt = 0;
+}
+
+export function noteJudgeFailure(state: SessionState, ctx: ExtensionContext): void {
+	state.judgeHealth.failures++;
+	if (state.judgeHealth.failures < JUDGE_FAILURE_LIMIT) return;
+
+	state.judgeHealth.failures = 0;
+	state.judgeHealth.retryAt = Date.now() + JUDGE_RETRY_MS;
+	ctx.ui.notify(
+		`${NAME}: judge paused for ${JUDGE_RETRY_MS / 1000}s after repeated failures; run /perm judge test`,
+		"warning",
+	);
+}
+
+// Read at every session start, so an edit to the shared settings applies from the next session.
+export function loadSessionConfig(
+	scope: FeatureScope,
+	state: SessionState,
+	ctx: ExtensionContext,
+): void {
+	for (const warning of migrateConfig(scope)) ctx.ui.notify(`${NAME}: ${warning}`, "warning");
+
+	state.config = readConfig(scope);
+	state.typing.stop();
+	state.typing = new TypingMonitor(state.config.typing.pause, state.config.typing.maxWait);
+}
+
+export function saveConfig(scope: FeatureScope, state: SessionState, ctx: ExtensionContext): void {
+	const error = writeConfig(scope, state.config);
+	if (error) ctx.ui.notify(`${NAME}: could not save the settings: ${error}`, "error");
+}
+
+export function openAlwaysYes(state: SessionState, ctx: ExtensionContext): void {
+	const project = projectAlwaysYesPath(ctx.cwd);
+	const trusted = ctx.isProjectTrusted();
+	const warnings = state.alwaysYes.open({
+		global: globalAlwaysYesPath(),
+		project: trusted ? project : undefined,
+	});
+
+	for (const warning of warnings) ctx.ui.notify(`${NAME}: ${warning}`, "warning");
+	if (!trusted && savedFileExists(project)) {
+		ctx.ui.notify(`${NAME}: ${project} skipped, this project is not trusted`, "warning");
+	}
+}
+
+export function rememberAlwaysYes(
+	pi: ExtensionAPI,
+	state: SessionState,
+	ctx: ExtensionContext,
+	scope: Scope,
+	toolName: string,
+	level: string,
+): void {
+	if (scope === "session") record(pi, { kind: "always-yes", toolName, level });
+	const problem = state.alwaysYes.add(scope, toolName, level);
+	if (problem) ctx.ui.notify(`${NAME}: could not save always yes: ${problem}`, "warning");
+}
+
+export function forgetAlwaysYes(
+	pi: ExtensionAPI,
+	state: SessionState,
+	ctx: ExtensionContext,
+	scope: Scope | "all",
+): number {
+	if (scope === "session" || scope === "all") record(pi, { kind: "forget-always-yes" });
+	const { removed, errors } = state.alwaysYes.forget(scope);
+	for (const error of errors)
+		ctx.ui.notify(`${NAME}: could not delete always yes: ${error}`, "error");
+	return removed;
+}

package/src/ui/clipboard.ts

@@ -0,0 +1,51 @@
+import { randomUUID } from "node:crypto";
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+interface ClipboardImage {
+	bytes: Uint8Array;
+	mimeType: string;
+}
+
+interface ClipboardReader {
+	readClipboardImage: () => Promise<ClipboardImage | null>;
+	readClipboardText: () => Promise<string | null>;
+	extensionForImageMimeType: (mimeType: string) => string | null;
+}
+
+let loaded: Promise<ClipboardReader | null> | undefined;
+
+function loadClipboard(): Promise<ClipboardReader | null> {
+	loaded ??= (async () => {
+		try {
+			const root = import.meta.resolve("@earendil-works/pi-coding-agent");
+			const images = await import(new URL("./utils/clipboard-image.js", root).href);
+			const text = await import(new URL("./utils/clipboard.js", root).href);
+			return {
+				readClipboardImage: images.readClipboardImage,
+				extensionForImageMimeType: images.extensionForImageMimeType,
+				readClipboardText: text.readClipboardText,
+			};
+		} catch {
+			return null;
+		}
+	})();
+
+	return loaded;
+}
+
+export async function readClipboard(): Promise<string | null> {
+	const clipboard = await loadClipboard();
+	if (!clipboard) return null;
+
+	const image = await clipboard.readClipboardImage();
+	if (image) {
+		const extension = clipboard.extensionForImageMimeType(image.mimeType) ?? "png";
+		const path = join(tmpdir(), `pi-ask-permission-${randomUUID()}.${extension}`);
+		writeFileSync(path, Buffer.from(image.bytes));
+		return path;
+	}
+
+	return clipboard.readClipboardText();
+}

package/src/ui/decision-options.ts

@@ -0,0 +1,23 @@
+export interface Choice {
+	key: string;
+	decision: "allow" | "deny";
+	always: boolean;
+	label: string;
+	tone: "success" | "warning" | "error";
+}
+
+export const CHOICES: Choice[] = [
+	{ key: "1", decision: "allow", always: false, label: "yes", tone: "success" },
+	{ key: "2", decision: "allow", always: true, label: "always yes", tone: "warning" },
+	{ key: "3", decision: "deny", always: false, label: "deny", tone: "error" },
+];
+
+export const FALLBACK_CHOICES: (Choice & { note: boolean })[] = CHOICES.flatMap((option, index) => [
+	{ ...option, key: String(index * 2 + 1), note: false },
+	{
+		...option,
+		key: String(index * 2 + 2),
+		note: true,
+		label: `${option.label}, ${option.decision === "allow" ? "with a note" : "with a reason"}`,
+	},
+]);