@tiagojct/subsub 0.20.0 → 0.22.0

package/src/subsub.ts

@@ -15,9 +15,9 @@
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, extname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Bridge, type ServerSpec } from "./bridge.ts";
 import {
@@ -43,7 +43,13 @@ import { applyEdits, checkLiteratureNote, field, frontMatter, itemKeyOf, missing
 import { buildPolicy, isSecret, judgePath, normalizeToolPath, realish, within } from "./paths.ts";
 import { describeArgs, formatPreview, isEmptyPreview } from "./preview.ts";
 import { perMinuteWait, providerTrouble, TROUBLE_TEXT, TROUBLE_TEXT_PT } from "./keys.ts";
-import { headerLines, type LibraryState, paintPreview, QUOTES, type Scheme, schemeFromAnsi, themeName } from "./look.ts";
+import { headerLines, LIBRARIAN_THEME, type LibraryState, paintPreview, QUOTES, type Scheme, schemeFromAnsi, themeName } from "./look.ts";
+import { footerLines, toolRenderers, usageTotals } from "./chrome.ts";
+import { ApprovalView } from "./dialogs.ts";
+import { allowedFile, listNotes, OPENABLE, openFile } from "./files.ts";
+import { LibraryView, NotesView, type LibraryItem } from "./screens.ts";
+import { glyphs, paintFromTheme, workingFrames } from "./skin.ts";
+import { loadWords, toolWord, type Words } from "./words.ts";
 import { systemAddition } from "./prompt.ts";
 import { logUsage } from "./usage.ts";
 import { gateKind, SERVER_PREFIXES, toolsFor, unavailableReason, outboundProblem } from "./roles.ts";
@@ -153,11 +159,21 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 	let scheme: Scheme | undefined;
 	let modelId = "no model";
 	let headerTui: { requestRender(force?: boolean): void } | undefined;
+	let footerTui: { requestRender(force?: boolean): void } | undefined;
+	/** True once the session started with the look on; the tool renderers are asked before a context exists. */
+	let lookActive = false;
+	let words: Words | undefined;
+	const redraw = () => {
+		headerTui?.requestRender();
+		footerTui?.requestRender();
+	};
 	const library: LibraryState = { zotero: "checking" };
 	const quote = cfg.quotes === false ? undefined : QUOTES[Math.floor(Math.random() * QUOTES.length)];
 	const lookOn = (ctx: ExtensionContext) => standalone && cfg.look !== false && ctx.mode === "tui";
 	/** True under `subsub web`: pi runs in RPC mode and the web view shows the state that the terminal header shows. */
 	const webView = process.env.SUBSUB_WEB === "1";
+	/** The state of the library goes to the client as a status text: for the web view and for the full-screen terminal client (subsub tui). */
+	const sideChannel = webView || process.env.SUBSUB_TUI === "1";
 	let lastError: string | undefined;
 	/** The last provider or tool error of the session, for /feedback. */
 	let recentError: string | undefined;
@@ -168,7 +184,7 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 	let webCtx: ExtensionContext | undefined;
 	function emitWeb(): void {
 		const ctx = webCtx;
-		if (!webView || !ctx || ctx.mode !== "rpc") return;
+		if (!sideChannel || !ctx || ctx.mode !== "rpc") return;
 		const down = bridge ? Object.keys(bridge.errors) : ["zotero", "scholar"];
 		const state = {
 			mode,
@@ -190,21 +206,123 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 	function applyTheme(ctx: ExtensionContext): void {
 		if (!lookOn(ctx) || cfg.themes === false) return;
 		scheme ??= schemeFromAnsi(ctx.ui.theme.getFgAnsi("text"), ctx.ui.theme.name);
-		const name = themeName(scheme, cfg.themes || undefined);
+		// The Librarian has its own plate (madder); a theme named in the settings applies to both modes unless themes.librarian says otherwise.
+		const base = mode === "librarian" ? (cfg.themesLibrarian ?? cfg.themes ?? LIBRARIAN_THEME) : cfg.themes || undefined;
+		const name = themeName(scheme, base, ctx.ui.theme.getColorMode?.());
 		const theme = name ? ctx.ui.getTheme(name) : undefined;
 		// A Theme object (not a name) changes the theme for this run only; the saved setting stays.
 		if (theme) ctx.ui.setTheme(theme);
+		// The working indicator takes the accent of the mode.
+		const mark = paintFromTheme(ctx.ui.theme).mark;
+		ctx.ui.setWorkingIndicator?.({ frames: workingFrames(glyphs(), Boolean(process.env.SUBSUB_REDUCE_MOTION && process.env.SUBSUB_REDUCE_MOTION !== "0")).map(mark), intervalMs: 160 });
+	}
+
+	/**
+	 * Ask the user to approve a change. With the look on, the preview opens as an overlay with its own keys (see dialogs.ts); otherwise, and over RPC,
+	 * it is pi's confirm dialog. Only a yes counts: anything else, including an overlay that cannot open, is a no.
+	 */
+	async function approve(ctx: ExtensionContext, title: string, body: string): Promise<boolean> {
+		if (lookOn(ctx) && typeof ctx.ui.custom === "function") {
+			const answer = await ctx.ui.custom<boolean>(
+				(tui, theme, _keys, done) =>
+					new ApprovalView({ title, body, lang, paint: paintFromTheme(theme), glyphs: glyphs(), done, rows: () => tui.terminal?.rows ?? 24, redraw: () => tui.requestRender() }),
+				{ overlay: true, overlayOptions: { width: "92%", minWidth: 40, maxHeight: "92%", anchor: "center", margin: 1 } },
+			);
+			return answer === true;
+		}
+		return (await ctx.ui.confirm(title, body)) === true;
+	}
+
+	/** The notes and library screens cover the terminal: the conversation is behind them and comes back when they close. */
+	const OVERLAY = { overlay: true, overlayOptions: { width: "100%", maxHeight: "100%", anchor: "top-left", margin: 0 } } as const;
+
+	/** True when the terminal look can show a screen of its own; otherwise says where the same thing is. */
+	function screenOk(ctx: ExtensionContext): boolean {
+		if (lookOn(ctx) && typeof ctx.ui.custom === "function") return true;
+		ctx.ui.notify(L("Sub-Sub: this screen is part of the terminal look. In subsub web, use the Notes button and the library search.", "Sub-Sub: este ecrã faz parte do aspeto do terminal. Em subsub web, use o botão Notas e a pesquisa na biblioteca."), "info");
+		return false;
+	}
+
+	/** /notes: the notes in the Sub-Sub folder, newest first; the note under the cursor shows beside the list. */
+	async function openNotes(ctx: ExtensionContext): Promise<void> {
+		if (!screenOk(ctx)) return;
+		const root = cfg.vault ?? ctx.cwd;
+		const notes = listNotes(root);
+		const { Markdown } = await import("@earendil-works/pi-tui");
+		const { getMarkdownTheme } = await import("@earendil-works/pi-coding-agent");
+		await ctx.ui.custom<void>(
+			(tui, theme, _keys, done) =>
+				new NotesView({
+					notes,
+					read: (path) => {
+						const file = allowedFile(path, root, cfg.vault);
+						return file && statSync(file).size < 2_000_000 ? readFileSync(file, "utf8") : "";
+					},
+					markdown: (text, width) => new Markdown(text, 1, 0, getMarkdownTheme()).render(width),
+					open: (path) => {
+						const file = allowedFile(path, root, cfg.vault);
+						if (file && OPENABLE.has(extname(file).toLowerCase())) openFile(file, cfg.vault);
+					},
+					done: () => done(),
+					lang,
+					paint: paintFromTheme(theme),
+					glyphs: glyphs(),
+					rows: () => tui.terminal?.rows ?? 24,
+					redraw: () => tui.requestRender(),
+				}),
+			OVERLAY,
+		);
+	}
+
+	/** /library: search as you type; Enter puts /read <item> in the box (the Librarian gets the key), ctrl+n puts /lit-note <item>. */
+	async function openLibrary(ctx: ExtensionContext): Promise<void> {
+		if (!screenOk(ctx)) return;
+		const ref = (it: LibraryItem) => it.citekey || it.key;
+		await ctx.ui.custom<void>(
+			(tui, theme, _keys, done) =>
+				new LibraryView({
+					search: async (query) => {
+						const r = await current().call("zotero_find_items", { query, limit: 25 });
+						if (r.isError) throw new Error(r.text);
+						return ((r.data as { items?: LibraryItem[] })?.items ?? []).filter((it) => it && it.key);
+					},
+					choose: (it) => {
+						ctx.ui.setEditorText(mode === "researcher" ? `/read ${ref(it)}` : ref(it));
+						done();
+					},
+					note: (it) => {
+						ctx.ui.setEditorText(`/lit-note ${ref(it)}`);
+						done();
+					},
+					done: () => done(),
+					lang,
+					paint: paintFromTheme(theme),
+					glyphs: glyphs(),
+					researcher: mode === "researcher",
+					rows: () => tui.terminal?.rows ?? 24,
+					redraw: () => tui.requestRender(),
+				}),
+			OVERLAY,
+		);
+	}
+
+	/** /actions: the buttons of the web view as a list; the choice goes into the box, so the user adds what is missing and presses Enter. */
+	async function openActions(ctx: ExtensionContext): Promise<void> {
+		const w = words ?? (await loadWords());
+		const list = [...(mode === "researcher" ? w.ACTIONS.research : []), ...w.ACTIONS.library].filter((a) => a.needs !== "starbuck" || starbuckEnabled(cfg));
+		const labels = list.map((a) => `${a[lang]}   /${a.cmd}`);
+		const pick = await ctx.ui.select(L("Actions", "Ações"), labels);
+		const a = list[labels.indexOf(pick ?? "")];
+		if (a) ctx.ui.setEditorText(a.cmd.endsWith(" ") ? `/${a.cmd}` : `/${a.cmd} `);
 	}
 
 	function paintFor(ctx: ExtensionContext) {
 		return (text: string) =>
 			ctx.mode === "tui"
-				? paintPreview(
-						text,
-						(x) => ctx.ui.theme.fg("success", x),
-						(x) => ctx.ui.theme.fg("error", x),
-						(x) => ctx.ui.theme.fg("text", x),
-					)
+				? (() => {
+						const p = paintFromTheme(ctx.ui.theme);
+						return paintPreview(text, p.ok, p.strike, p.text);
+					})()
 				: text;
 	}
 
@@ -222,7 +340,7 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 		} catch {
 			library.zotero = "down";
 		}
-		headerTui?.requestRender();
+		redraw();
 		emitWeb();
 	}
 
@@ -241,13 +359,9 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 						library,
 						quote,
 						width,
-						paint: {
-							mark: (x) => th.fg("accent", x),
-							text: (x) => th.fg("text", x),
-							muted: (x) => th.fg("muted", x),
-							dim: (x) => th.fg("dim", x),
-							warn: (x) => th.fg("warning", x),
-						},
+						paint: paintFromTheme(th),
+						lang,
+						glyphs: glyphs(),
 					});
 				},
 				invalidate() {},
@@ -255,12 +369,39 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 		});
 	}
 
+	function setFooter(ctx: ExtensionContext): void {
+		if (!lookOn(ctx)) return;
+		ctx.ui.setFooter((tui) => {
+			footerTui = tui;
+			return {
+				render: (width: number) => {
+					try {
+						const usage = ctx.getContextUsage();
+						const totals = usageTotals(ctx.sessionManager.getEntries());
+						return footerLines(
+							{ mode, lang, library, model: modelId, percent: usage?.percent ?? null, window: usage?.contextWindow, tokens: totals.tokens, cost: totals.cost, down: bridge ? Object.keys(bridge.errors) : [] },
+							width,
+							paintFromTheme(ctx.ui.theme),
+							glyphs(),
+						);
+					} catch {
+						return []; // the context is gone after shutdown
+					}
+				},
+				invalidate() {},
+				dispose() {
+					footerTui = undefined;
+				},
+			};
+		});
+	}
+
 	function status(ctx: ExtensionContext): void {
 		modelId = ctx.model ? `${ctx.model.id}` : "no model";
 		const down = bridge ? Object.keys(bridge.errors) : ["zotero", "scholar"];
 		ctx.ui.setStatus("subsub", `Sub-Sub: ${mode} | ${modelId}${down.length ? ` | not running: ${down.join(", ")}` : ""}`);
 		if (standalone) ctx.ui.setTitle(`Sub-Sub: ${mode}`);
-		headerTui?.requestRender();
+		redraw();
 		webCtx = ctx;
 		emitWeb();
 	}
@@ -296,6 +437,7 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 			}
 		}
 		if (remember) pi.appendEntry(MODE_ENTRY, { mode });
+		applyTheme(ctx);
 		status(ctx);
 	}
 
@@ -320,13 +462,15 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 		const modelChosen = hasModel && hasMessages;
 		// Judge light or dark before Sub-Sub changes the theme.
 		if (lookOn(ctx)) scheme ??= schemeFromAnsi(ctx.ui.theme.getFgAnsi("text"), ctx.ui.theme.name);
-		applyTheme(ctx);
+		lookActive = lookOn(ctx);
+		if (lookActive) words = await loadWords().catch(() => undefined);
 		await applyMode(ctx, restored ?? (pi.getFlag("librarian") ? "librarian" : pi.getFlag("researcher") ? "researcher" : cfg.defaultMode), false, !modelChosen);
 		logUsage(cfg.usageLog, { ev: "session", mode, model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined });
 		if (lookOn(ctx)) {
 			setHeader(ctx);
+			setFooter(ctx);
 			void refreshLibrary();
-		} else if (webView) {
+		} else if (sideChannel) {
 			void refreshLibrary();
 		}
 		if (!ctx.model && !webView) ctx.ui.notify(L("Sub-Sub: no model is connected yet. Type /login and select a provider (or use the model button in subsub web).", "Sub-Sub: ainda não há um modelo ligado. Escreva /login e selecione um fornecedor (ou use o botão do modelo em subsub web)."), "warning");
@@ -358,6 +502,16 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 	});
 
 	pi.on("model_select", async (_event, ctx) => status(ctx));
+	// Plain-word tool lines for Sub-Sub's own tools (the look only); pi's tools keep pi's rows.
+	const rows = toolRenderers({ word: (name) => (words ? toolWord(words, lang, name) : name), lang, glyphs, paint: paintFromTheme });
+	pi.registerToolRenderer?.((toolName, next) => (lookActive && SERVER_PREFIXES.some((p) => toolName.startsWith(p)) ? (rows(toolName) as never) : next()));
+	pi.on("tool_execution_start", async (event, ctx) => {
+		if (lookActive && words && !event.parentToolCallId) ctx.ui.setWorkingMessage?.(`${toolWord(words, lang, event.toolName)}...`);
+	});
+	pi.on("tool_execution_end", async (_event, ctx) => {
+		if (lookActive) ctx.ui.setWorkingMessage?.();
+	});
+	pi.on("turn_end", async () => redraw());
 	// A provider error in plain words (quota, busy, blocked, key); the web view words its own.
 	pi.on("message_end", async (event, ctx) => {
 		const m = event.message as { role?: string; stopReason?: string; errorMessage?: string };
@@ -466,7 +620,7 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 			const verdict = judgePath(target, buildPolicy({ vault: cfg.vault, cwd: ctx.cwd, serverDir: cfg.serverDir, packageDir: PACKAGE_DIR }));
 			if (verdict.ok) return undefined;
 			if (!ctx.hasUI) return { block: true, reason: `Writing ${target} needs ${user}'s approval: ${verdict.why}.` };
-			const ok = await ctx.ui.confirm(`Sub-Sub: ${name} ${target}?`, L(`Asking because ${verdict.why}.`, `Pergunto porque: ${verdict.why}.`));
+			const ok = await approve(ctx, `Sub-Sub: ${name} ${target}?`, L(`Asking because ${verdict.why}.`, `Pergunto porque: ${verdict.why}.`));
 			return ok ? undefined : { block: true, reason: `${user} did not allow writing to that file.` };
 		}
 		if (!ctx.hasUI) {
@@ -478,7 +632,7 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 				const verdict = judgePath(normalizeToolPath(input.output_path, ctx.cwd), buildPolicy({ vault: cfg.vault, cwd: ctx.cwd, serverDir: cfg.serverDir, packageDir: PACKAGE_DIR }));
 				if (!verdict.ok && /protected|hidden/.test(verdict.why)) return { block: true, reason: `Sub-Sub does not write there: ${verdict.why}.` };
 			}
-			const ok = await ctx.ui.confirm(L(`Sub-Sub: run ${name}?`, `Sub-Sub: executar ${name}?`), describeArgs(input));
+			const ok = await approve(ctx, L(`Sub-Sub: run ${name}?`, `Sub-Sub: executar ${name}?`), describeArgs(input));
 			return ok ? undefined : { block: true, reason: `${user} did not approve. Ask what to change.` };
 		}
 		// kind === "preview": the server computes the change first, then the user decides.
@@ -502,7 +656,7 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 		// The dialog may stay open for minutes. Before applying, compute the preview again: if the
 		// library changed meanwhile (an edit in Zotero, new items), show the new preview instead.
 		for (let round = 0; round < 3; round++) {
-			const ok = await ctx.ui.confirm(round ? `${title} ${L("(the library changed; this is the new preview)", "(a biblioteca mudou; esta é a nova pré-visualização)")}` : title, paintFor(ctx)(shown));
+			const ok = await approve(ctx, round ? `${title} ${L("(the library changed; this is the new preview)", "(a biblioteca mudou; esta é a nova pré-visualização)")}` : title, paintFor(ctx)(shown));
 			logUsage(cfg.usageLog, { ev: "change", tool: name, approved: ok });
 			if (!ok) return { block: true, reason: `${user} did not approve this change. Ask what to change; do not retry the same call.` };
 			let again;
@@ -598,7 +752,7 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 			return { block: true, reason: `Model test: Starbuck reports only inside the vault or ${benchOut}.` };
 		}
 		if (!ctx.hasUI) return { block: true, reason: `Writing a Starbuck report to ${dir} needs ${user}'s approval: ${verdict.why}.` };
-		const ok = await ctx.ui.confirm(L(`Sub-Sub: write the Starbuck report to ${dir}?`, `Sub-Sub: escrever o relatório do Starbuck em ${dir}?`), L(`Asking because ${verdict.why}.`, `Pergunto porque: ${verdict.why}.`));
+		const ok = await approve(ctx, L(`Sub-Sub: write the Starbuck report to ${dir}?`, `Sub-Sub: escrever o relatório do Starbuck em ${dir}?`), L(`Asking because ${verdict.why}.`, `Pergunto porque: ${verdict.why}.`));
 		return ok ? undefined : { block: true, reason: `${user} did not allow writing the report there. Ask where to put it (report_dir).` };
 	}
 
@@ -634,22 +788,41 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 		};
 	}
 
+	const switchTo = async (ctx: ExtensionContext, next: Mode): Promise<void> => {
+		await applyMode(ctx, next, true);
+		ctx.ui.notify(
+			next === "librarian"
+				? L("Sub-Sub: Librarian mode. For searches and notes, switch to /researcher.", "Sub-Sub: modo Bibliotecário. Para pesquisas e notas, mude para /researcher.")
+				: L("Sub-Sub: Researcher mode. It searches, writes notes and also changes the library, with a preview.", "Sub-Sub: modo Investigador. Pesquisa, escreve notas e também altera a biblioteca, com pré-visualização."),
+			"info",
+		);
+	};
+
 	pi.registerCommand("librarian", {
 		description: "Sub-Sub: switch to the Librarian (manages the library: tags, imports, metadata, PDFs)",
-		handler: async (_args, ctx) => {
-			await applyMode(ctx, "librarian", true);
-			ctx.ui.notify(L("Sub-Sub: Librarian mode. For searches and notes, switch to /researcher.", "Sub-Sub: modo Bibliotecário. Para pesquisas e notas, mude para /researcher."), "info");
-		},
+		handler: async (_args, ctx) => switchTo(ctx, "librarian"),
 	});
 
 	pi.registerCommand("researcher", {
 		description: "Sub-Sub: switch to the Researcher (searches, notes, reviews, and everything the Librarian does)",
-		handler: async (_args, ctx) => {
-			await applyMode(ctx, "researcher", true);
-			ctx.ui.notify(L("Sub-Sub: Researcher mode. It searches, writes notes and also changes the library, with a preview.", "Sub-Sub: modo Investigador. Pesquisa, escreve notas e também altera a biblioteca, com pré-visualização."), "info");
-		},
+		handler: async (_args, ctx) => switchTo(ctx, "researcher"),
 	});
 
+	// Screens of the terminal look (the web view has its own panels, so these are only for the `subsub` command).
+	if (standalone) {
+		pi.registerCommand("notes", { description: "Sub-Sub: the notes in your Sub-Sub folder", handler: async (_args, ctx) => openNotes(ctx) });
+		pi.registerCommand("library", { description: "Sub-Sub: search your Zotero library as you type", handler: async (_args, ctx) => openLibrary(ctx) });
+		pi.registerCommand("actions", { description: "Sub-Sub: the actions of the web view, as a list", handler: async (_args, ctx) => openActions(ctx) });
+		// Alt works when the terminal sends it as Escape plus the letter; macOS Terminal and iTerm2 do not by default (Option types a symbol), so each also has a function key.
+		const keys = (names: string[], description: string, handler: (ctx: ExtensionContext) => Promise<void> | void) => {
+			for (const k of names) pi.registerShortcut?.(k as never, { description, handler });
+		};
+		keys(["alt+n", "f2"], "Sub-Sub: notes", (ctx) => openNotes(ctx));
+		keys(["alt+l", "f3"], "Sub-Sub: library search", (ctx) => openLibrary(ctx));
+		keys(["alt+a", "f4"], "Sub-Sub: actions", (ctx) => openActions(ctx));
+		keys(["alt+m", "f5"], "Sub-Sub: switch between the Researcher and the Librarian", (ctx) => switchTo(ctx, mode === "researcher" ? "librarian" : "researcher"));
+	}
+
 	pi.registerCommand("subsub", {
 		description: "Sub-Sub: Zotero connection and library overview",
 		handler: async (_args, ctx) => {
@@ -675,7 +848,7 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 					);
 				}
 			}
-			headerTui?.requestRender();
+			redraw();
 			emitWeb();
 			ctx.ui.notify(lines.join("\n"), "info");
 		},
@@ -734,6 +907,11 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 	// A registered command runs before the input hook, so /read checks the mode itself.
 	pi.registerCommand("read", {
 		description: "Sub-Sub: read a paper with guidance; Sub-Sub finds the passages and asks, you write the answers. /read [background|fact|extract|critique] <citekey, DOI, PMID or title words>",
+		getArgumentCompletions: (prefix: string) => {
+			if (/\s/.test(prefix.trim())) return null;
+			const found = Object.keys(PURPOSES).filter((k) => k.startsWith(prefix.trim().toLowerCase()));
+			return found.length ? found.map((k) => ({ value: k, label: L(PURPOSES[k as Purpose][0], PURPOSES[k as Purpose][1]) })) : null;
+		},
 		handler: async (args, ctx) => {
 			if (mode === "librarian") return ctx.ui.notify(researcherOnly("read"), "warning");
 			let { purpose, ref } = readArgs(String(args ?? ""));
@@ -855,7 +1033,7 @@ export async function createSubsub(pi: ExtensionAPI, deps: SubsubDeps = {}): Pro
 				ctx.ui.notify(preview.text, "warning");
 				return;
 			}
-			const ok = await ctx.ui.confirm(L("Sub-Sub: undo?", "Sub-Sub: anular?"), paintFor(ctx)(formatPreview("zotero_undo", preview.data, lang)));
+			const ok = await approve(ctx, L("Sub-Sub: undo?", "Sub-Sub: anular?"), paintFor(ctx)(formatPreview("zotero_undo", preview.data, lang)));
 			if (!ok) return;
 			const res = await current().call("zotero_undo", { ...input, dry_run: false });
 			const d = (res.data ?? {}) as Record<string, unknown>;