@vanillagreen/pi-qol 1.4.3 → 1.6.0

package/extensions/qol/schedule.ts

@@ -0,0 +1,320 @@
+import { truncateToWidth, type AutocompleteItem } from "@earendil-works/pi-tui";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { ansiGreen } from "./ansi.js";
+import { stringifyError } from "./util.js";
+
+export const SCHEDULE_ENTRY_TYPE = "qol-schedule";
+
+const MAX_TIMER_DELAY_MS = 2_147_000_000;
+const MAX_SCHEDULE_DELAY_MS = 30 * 24 * 60 * 60 * 1000;
+const MAX_ACTIVE_SCHEDULES = 100;
+
+interface ScheduleTimer {
+	unref?: () => void;
+}
+
+export interface ScheduleClock {
+	now(): number;
+	setTimeout(callback: () => void, delayMs: number): ScheduleTimer;
+	clearTimeout(timer: ScheduleTimer): void;
+}
+
+interface ScheduledMessage {
+	createdAt: number;
+	dueAt: number;
+	id: string;
+	message: string;
+	timer?: ScheduleTimer;
+}
+
+type ScheduleEntryAction = "scheduled" | "delivered" | "cancelled" | "failed";
+
+interface ScheduleEntryData {
+	action: ScheduleEntryAction;
+	cancelledAt?: number;
+	createdAt?: number;
+	deliveredAt?: number;
+	dueAt?: number;
+	failedAt?: number;
+	id: string;
+	message?: string;
+}
+
+export type ParsedScheduleCommand =
+	| { kind: "list" }
+	| { kind: "cancel"; all: boolean; id?: string }
+	| { kind: "schedule"; delayMs: number; message: string }
+	| { kind: "usage"; error?: string };
+
+const DEFAULT_CLOCK: ScheduleClock = {
+	now: () => Date.now(),
+	setTimeout: (callback, delayMs) => setTimeout(callback, delayMs),
+	clearTimeout: (timer) => clearTimeout(timer as ReturnType<typeof setTimeout>),
+};
+
+const SCHEDULE_COMPLETIONS: AutocompleteItem[] = [
+	{ value: "list", label: "list", description: "Show pending scheduled messages" },
+	{ value: "cancel ", label: "cancel <id|all>", description: "Cancel one scheduled message or all pending messages" },
+	{ value: "20m ", label: "20m <message>", description: "Send a message after 20 minutes" },
+	{ value: "1h ", label: "1h <message>", description: "Send a message after 1 hour" },
+];
+
+export function getScheduleArgumentCompletions(prefix: string): AutocompleteItem[] | null {
+	const query = prefix.trimStart().toLowerCase();
+	const filtered = SCHEDULE_COMPLETIONS.filter((item) => item.value.toLowerCase().startsWith(query) || (item.label ?? item.value).toLowerCase().startsWith(query));
+	return filtered.length > 0 ? filtered : null;
+}
+
+export function parseDurationMs(input: string): number | undefined {
+	const match = input.trim().toLowerCase().match(/^(\d+(?:\.\d+)?)(ms|s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours|d|day|days)?$/);
+	if (!match) return undefined;
+	const amount = Number(match[1]);
+	if (!Number.isFinite(amount) || amount <= 0) return undefined;
+	const unit = match[2] ?? "m";
+	const multiplier = unit === "ms"
+		? 1
+		: ["s", "sec", "secs", "second", "seconds"].includes(unit)
+			? 1000
+			: ["h", "hr", "hrs", "hour", "hours"].includes(unit)
+				? 60 * 60 * 1000
+				: ["d", "day", "days"].includes(unit)
+					? 24 * 60 * 60 * 1000
+					: 60 * 1000;
+	const delayMs = Math.round(amount * multiplier);
+	if (!Number.isFinite(delayMs) || delayMs <= 0 || delayMs > MAX_SCHEDULE_DELAY_MS) return undefined;
+	return delayMs;
+}
+
+export function parseScheduleCommandArgs(args: string): ParsedScheduleCommand {
+	const trimmed = args.trim();
+	if (!trimmed) return { kind: "list" };
+	const firstSpace = trimmed.search(/\s/);
+	const head = (firstSpace < 0 ? trimmed : trimmed.slice(0, firstSpace)).toLowerCase();
+	const rest = firstSpace < 0 ? "" : trimmed.slice(firstSpace + 1).trim();
+	if (head === "list" || head === "ls" || head === "status") return { kind: "list" };
+	if (head === "cancel" || head === "clear") {
+		if (!rest) return { kind: "usage", error: "Usage: /schedule cancel <id|all>" };
+		if (rest.toLowerCase() === "all") return { kind: "cancel", all: true };
+		return { kind: "cancel", all: false, id: rest };
+	}
+	const delayMs = parseDurationMs(head);
+	if (delayMs === undefined) return { kind: "usage", error: "Usage: /schedule <duration> <message>" };
+	if (!rest) return { kind: "usage", error: "Usage: /schedule <duration> <message>" };
+	return { kind: "schedule", delayMs, message: rest };
+}
+
+export function formatScheduleDuration(ms: number): string {
+	const totalSeconds = Math.max(0, Math.round(ms / 1000));
+	const days = Math.floor(totalSeconds / 86_400);
+	const hours = Math.floor((totalSeconds % 86_400) / 3600);
+	const minutes = Math.floor((totalSeconds % 3600) / 60);
+	const seconds = totalSeconds % 60;
+	const parts: string[] = [];
+	if (days) parts.push(`${days}d`);
+	if (hours) parts.push(`${hours}h`);
+	if (minutes) parts.push(`${minutes}m`);
+	if (seconds || parts.length === 0) parts.push(`${seconds}s`);
+	return parts.slice(0, 2).join(" ");
+}
+
+function previewMessage(message: string, max = 80): string {
+	const singleLine = message.replace(/\s+/g, " ").trim();
+	if (singleLine.length <= max) return singleLine;
+	return `${singleLine.slice(0, Math.max(0, max - 1))}…`;
+}
+
+function formatDueTime(timestamp: number): string {
+	return new Date(timestamp).toLocaleString();
+}
+
+function usageText(): string {
+	return [
+		"Usage: /schedule <duration> <message>",
+		"Examples: /schedule 20m retry the previous request",
+		"          /schedule 1h retry after the rate limit reset",
+		"Manage: /schedule list, /schedule cancel <id|all>",
+	].join("\n");
+}
+
+function dataToJob(data: ScheduleEntryData): ScheduledMessage | undefined {
+	if (data.action !== "scheduled") return undefined;
+	if (!data.id || typeof data.id !== "string") return undefined;
+	if (!data.message || typeof data.message !== "string") return undefined;
+	if (typeof data.createdAt !== "number" || typeof data.dueAt !== "number") return undefined;
+	if (!Number.isFinite(data.createdAt) || !Number.isFinite(data.dueAt)) return undefined;
+	return { createdAt: data.createdAt, dueAt: data.dueAt, id: data.id, message: data.message };
+}
+
+export function createScheduleController(pi: ExtensionAPI, clock: ScheduleClock = DEFAULT_CLOCK) {
+	let onChange: (() => void) | undefined;
+	let sequence = 0;
+	const jobs = new Map<string, ScheduledMessage>();
+
+	const notifyChanged = (): void => {
+		try {
+			onChange?.();
+		} catch {
+			// UI refresh hooks must never break schedule state transitions.
+		}
+	};
+
+	const nextId = (): string => {
+		let id = "";
+		do {
+			sequence += 1;
+			id = `${clock.now().toString(36)}-${sequence.toString(36)}`;
+		} while (jobs.has(id));
+		return id;
+	};
+
+	const appendEntry = (data: ScheduleEntryData): void => {
+		try {
+			pi.appendEntry?.(SCHEDULE_ENTRY_TYPE, data);
+		} catch {
+			// Scheduling still works in-memory if session persistence is unavailable.
+		}
+	};
+
+	const clearJobTimer = (job: ScheduledMessage): void => {
+		if (!job.timer) return;
+		clock.clearTimeout(job.timer);
+		job.timer = undefined;
+	};
+
+	const armJob = (job: ScheduledMessage, ctx: ExtensionContext): void => {
+		clearJobTimer(job);
+		const remaining = Math.max(0, job.dueAt - clock.now());
+		job.timer = clock.setTimeout(() => {
+			if (!jobs.has(job.id)) return;
+			if (clock.now() < job.dueAt) {
+				armJob(job, ctx);
+				return;
+			}
+			void deliver(job, ctx);
+		}, Math.min(remaining, MAX_TIMER_DELAY_MS));
+		job.timer.unref?.();
+	};
+
+	const deliver = async (job: ScheduledMessage, ctx: ExtensionContext): Promise<void> => {
+		if (!jobs.has(job.id)) return;
+		jobs.delete(job.id);
+		clearJobTimer(job);
+		notifyChanged();
+		try {
+			let idle = true;
+			try {
+				idle = ctx.isIdle?.() ?? true;
+			} catch {
+				idle = false;
+			}
+			await Promise.resolve(idle ? pi.sendUserMessage(job.message) : pi.sendUserMessage(job.message, { deliverAs: "followUp" }));
+			appendEntry({ action: "delivered", deliveredAt: clock.now(), id: job.id });
+			if (ctx.hasUI) ctx.ui.notify(`Scheduled message sent (${job.id}).`, "info");
+		} catch (error) {
+			appendEntry({ action: "failed", failedAt: clock.now(), id: job.id, message: stringifyError(error) });
+			if (ctx.hasUI) ctx.ui.notify(`Scheduled message failed (${job.id}): ${stringifyError(error)}`, "error");
+		}
+	};
+
+	const listText = (): string => {
+		const now = clock.now();
+		const pending = [...jobs.values()].sort((a, b) => a.dueAt - b.dueAt);
+		if (pending.length === 0) return "No scheduled messages.";
+		return [
+			"Scheduled messages:",
+			...pending.map((job) => `${job.id} — in ${formatScheduleDuration(job.dueAt - now)} (${formatDueTime(job.dueAt)}) — ${previewMessage(job.message)}`),
+		].join("\n");
+	};
+
+	const schedule = (delayMs: number, message: string, ctx: ExtensionCommandContext): void => {
+		if (jobs.size >= MAX_ACTIVE_SCHEDULES) {
+			ctx.ui.notify(`Too many scheduled messages (${MAX_ACTIVE_SCHEDULES}). Cancel one before adding another.`, "warning");
+			return;
+		}
+		const createdAt = clock.now();
+		const job: ScheduledMessage = { createdAt, dueAt: createdAt + delayMs, id: nextId(), message };
+		jobs.set(job.id, job);
+		appendEntry({ action: "scheduled", createdAt: job.createdAt, dueAt: job.dueAt, id: job.id, message: job.message });
+		armJob(job, ctx);
+		notifyChanged();
+		ctx.ui.notify(`Scheduled ${job.id} in ${formatScheduleDuration(delayMs)} (${formatDueTime(job.dueAt)}): ${previewMessage(message)}`, "info");
+	};
+
+	const cancel = (id: string): boolean => {
+		const job = jobs.get(id);
+		if (!job) return false;
+		clearJobTimer(job);
+		jobs.delete(id);
+		appendEntry({ action: "cancelled", cancelledAt: clock.now(), id });
+		notifyChanged();
+		return true;
+	};
+
+	return {
+		activeCount(): number {
+			return jobs.size;
+		},
+		clearTimers(): void {
+			for (const job of jobs.values()) clearJobTimer(job);
+			const changed = jobs.size > 0;
+			jobs.clear();
+			if (changed) notifyChanged();
+		},
+		async handleCommand(args: string, ctx: ExtensionCommandContext): Promise<void> {
+			const parsed = parseScheduleCommandArgs(args);
+			if (parsed.kind === "usage") {
+				ctx.ui.notify(`${parsed.error ?? "Invalid schedule command"}\n${usageText()}`, "warning");
+				return;
+			}
+			if (parsed.kind === "list") {
+				ctx.ui.notify(`${listText()}\n\n${usageText()}`, "info");
+				return;
+			}
+			if (parsed.kind === "cancel") {
+				if (parsed.all) {
+					const count = jobs.size;
+					for (const job of [...jobs.values()]) cancel(job.id);
+					ctx.ui.notify(`Cancelled ${count} scheduled message(s).`, "info");
+					return;
+				}
+				if (!parsed.id || !cancel(parsed.id)) {
+					ctx.ui.notify(`No scheduled message found for ${parsed.id ?? "<missing id>"}.`, "warning");
+					return;
+				}
+				ctx.ui.notify(`Cancelled scheduled message ${parsed.id}.`, "info");
+				return;
+			}
+			schedule(parsed.delayMs, parsed.message, ctx);
+		},
+		restoreFromBranch(ctx: ExtensionContext): void {
+			for (const job of jobs.values()) clearJobTimer(job);
+			jobs.clear();
+			const branch = ctx.sessionManager.getBranch?.() ?? [];
+			for (const entry of branch as any[]) {
+				if (entry?.type !== "custom" || entry.customType !== SCHEDULE_ENTRY_TYPE) continue;
+				const data = entry.data as ScheduleEntryData | undefined;
+				if (!data || typeof data !== "object") continue;
+				if (data.action === "scheduled") {
+					const job = dataToJob(data);
+					if (job) jobs.set(job.id, job);
+					continue;
+				}
+				if (typeof data.id === "string") jobs.delete(data.id);
+			}
+			for (const job of jobs.values()) armJob(job, ctx);
+			notifyChanged();
+		},
+		renderPreviewLines(width: number): string[] {
+			const pending = [...jobs.values()].sort((a, b) => a.dueAt - b.dueAt);
+			const shown = pending.slice(0, 3).map((job) => {
+				const line = `┃ Scheduled ${formatDueTime(job.dueAt)} — ${previewMessage(job.message, 120)}`;
+				return truncateToWidth(ansiGreen(line), width, "");
+			});
+			if (pending.length > shown.length) shown.push(truncateToWidth(ansiGreen(`┃ Scheduled: +${pending.length - shown.length} more`), width, ""));
+			return shown;
+		},
+		setOnChange(callback: (() => void) | undefined): void {
+			onChange = callback;
+		},
+	};
+}

package/extensions/qol/session-search/component.ts

@@ -105,6 +105,12 @@ function isPrintableInput(data: string): boolean {
 }
 
 export class QolSessionSearchComponent {
+	private readonly done: (action: QolSessionPaletteAction) => void;
+	private readonly tui: { requestRender(): void; terminal?: { rows?: number } };
+	private readonly theme: Theme;
+	private readonly sessions: QolSessionSearchSession[];
+	private readonly cwd: string;
+	private readonly currentModel: QolModelInfo | undefined;
 	private screen: "search" | "messages" | "actions" | "confirmContext" | "confirmFork" | "confirmModel" = "search";
 	private searchState: QolSessionSearchState;
 	private messagesState: QolSessionMessagesState | undefined;
@@ -116,14 +122,20 @@ export class QolSessionSearchComponent {
 
 
 	constructor(
-		private readonly done: (action: QolSessionPaletteAction) => void,
-		private readonly tui: { requestRender(): void; terminal?: { rows?: number } },
-		private readonly theme: Theme,
-		private readonly sessions: QolSessionSearchSession[],
-		private readonly cwd: string,
+		done: (action: QolSessionPaletteAction) => void,
+		tui: { requestRender(): void; terminal?: { rows?: number } },
+		theme: Theme,
+		sessions: QolSessionSearchSession[],
+		cwd: string,
 		initialQuery = "",
-		private readonly currentModel: QolModelInfo | undefined = undefined,
+		currentModel: QolModelInfo | undefined = undefined,
 	) {
+		this.done = done;
+		this.tui = tui;
+		this.theme = theme;
+		this.sessions = sessions;
+		this.cwd = cwd;
+		this.currentModel = currentModel;
 		const query = initialQuery.trim();
 		const scope = defaultSessionSearchScope(cwd);
 		const scopedSessions = this.sessionsForScope(scope);
@@ -878,18 +890,28 @@ export class QolSessionSearchComponent {
 }
 
 export class QolSessionSearchLoadingComponent {
+	private readonly tui: { requestRender(): void };
+	private readonly theme: Theme;
+	private readonly title: string;
+	private readonly message: string;
+	private readonly done: (value: null) => void;
 	private readonly controller = new AbortController();
 	private readonly startedAt = Date.now();
 	private frame = 0;
 	private timer: ReturnType<typeof setInterval> | undefined;
 
 	constructor(
-		private readonly tui: { requestRender(): void },
-		private readonly theme: Theme,
-		private readonly title: string,
-		private readonly message: string,
-		private readonly done: (value: null) => void,
+		tui: { requestRender(): void },
+		theme: Theme,
+		title: string,
+		message: string,
+		done: (value: null) => void,
 	) {
+		this.tui = tui;
+		this.theme = theme;
+		this.title = title;
+		this.message = message;
+		this.done = done;
 		this.timer = setInterval(() => {
 			this.frame += 1;
 			this.tui.requestRender();

package/extensions/qol/status-message.ts

@@ -8,6 +8,7 @@ import {
 	DEFAULT_PERMISSION_GATE_PREVIEW_LINES,
 } from "./constants.js";
 import { currentEditorText } from "./editor.js";
+import { glyphs } from "./glyphs.js";
 import { attachmentLabels } from "./images.js";
 import { permissionGateCommands } from "./permission-gate.js";
 import { autoRenameEnabled } from "./session-rename.js";
@@ -17,9 +18,13 @@ import { boundedSettingNumber, newlineFallbackKey, settingBoolean, settingNumber
 export function statusMessage(ctx: ExtensionContext): string {
 	const labels = attachmentLabels(currentEditorText(ctx), ctx.cwd);
 	const searchShortcut = sessionSearchShortcut(ctx.cwd);
+	const statuslineEnabled = settingBoolean("statusline.enabled", true, ctx.cwd);
+	const statuslineMode = statuslineEnabled
+		? (settingBoolean("replaceFooter", true, ctx.cwd) ? "enabled, replaces footer" : "enabled, footer preserved")
+		: "disabled";
 	return [
 		"Pi QOL status",
-		`Statusline: ${settingBoolean("replaceFooter", true, ctx.cwd) ? "replaces footer" : "footer preserved"}; prompt=${settingBoolean("compactPrompt", true, ctx.cwd) ? "π compact" : "default chrome"}`,
+		`Statusline: ${statuslineMode}; prompt=${settingBoolean("compactPrompt", true, ctx.cwd) ? `${glyphs(ctx.cwd).prompt} compact` : "default chrome"}`,
 		`shift+enter newline: ${settingBoolean("newlineOnShiftEnter", true, ctx.cwd) ? "enabled" : "disabled"}`,
 		`Fallback newline key: ${newlineFallbackKey(ctx.cwd)}`,
 		`Pending queue preview: ${settingBoolean("pendingQueue.asciiGreen", true, ctx.cwd) ? "ANSI green" : "Pi default"}`,
@@ -28,6 +33,7 @@ export function statusMessage(ctx: ExtensionContext): string {
 		`Rename command: ${settingBoolean("enableSessionNameCommand", true, ctx.cwd) ? "enabled (/rename)" : "disabled"}`,
 		`Auto session rename: ${autoRenameEnabled(ctx.cwd) ? `enabled (${settingString("sessionAutoRename.model", DEFAULT_AUTO_RENAME_MODEL, ctx.cwd)})` : "disabled"}`,
 		`Handoff command: ${settingBoolean("enableHandoffCommand", true, ctx.cwd) ? "enabled" : "disabled"}`,
+		`Schedule command: ${settingBoolean("enableScheduleCommand", true, ctx.cwd) ? "enabled (/schedule)" : "disabled"}`,
 		`Handoff prompt review: ${settingBoolean("handoffReviewPrompt", true, ctx.cwd) ? "enabled" : "disabled"}`,
 		`Session search: ${settingBoolean("sessionSearch.enabled", true, ctx.cwd) ? `enabled (/search${searchShortcut ? `, ${searchShortcut}` : ""})` : "disabled"}`,
 		`Custom compaction: ${settingBoolean("compaction.customEnabled", false, ctx.cwd) ? `enabled (${settingString("compaction.model", DEFAULT_COMPACTION_MODEL, ctx.cwd)}, ${compactionProfile(ctx.cwd)})` : "disabled (Pi default)"}`,

package/extensions/qol/statusline.ts

@@ -5,6 +5,7 @@ import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import { subagentStatuslineMarker } from "./agent-statusline.js";
 import { stripAnsi } from "./ansi.js";
 import { readCavemanBridge } from "./bridges.js";
+import { glyphs } from "./glyphs.js";
 import { CAVEMAN_ICON_ACTIVE, CAVEMAN_ICON_INACTIVE } from "./constants.js";
 import { settingBoolean, settingNumber } from "./settings.js";
 
@@ -136,14 +137,14 @@ export function sessionNameHeader(width: number, pi: ExtensionAPI, theme: Pick<T
 	const prefixPlain = "Session ";
 	const prefix = theme.fg("muted", prefixPlain);
 	const innerWidth = Math.max(1, width - visibleWidth(prefixPlain) - 2);
-	const inner = truncateToWidth(name, innerWidth, "…");
+	const inner = truncateToWidth(name, innerWidth, glyphs().ellipsis);
 	const plain = ` ${inner} `;
 	const badge = theme.bg("selectedBg", theme.fg("text", plain));
 	return [truncateToWidth(`${prefix}${badge}`, width, "")];
 }
 
 export function formatTmuxSessionTitle(sessionName: string): string {
-	return `π ${sessionName}`;
+	return `${glyphs().prompt} ${sessionName}`;
 }
 
 export function tmuxPaneTarget(): string | undefined {
@@ -201,7 +202,7 @@ export function renderStatusLine(width: number, ctx: ExtensionContext, git: GitS
 	const cavemanSegment = caveman ? `${statusSeparator}${cavemanGlyph}` : "";
 	const contextSeparator = caveman ? ` ${statusSeparator}` : "";
 	const leftPlain = `${projectChunk}${statusSeparator}${thinkingChunk}${cavemanSegment}${contextSeparator}${contextChunk.trimStart()}`;
-	const percentPlain = percent === null ? "…%" : `${percent}%`;
+	const percentPlain = percent === null ? `${glyphs(ctx.cwd).ellipsis}%` : `${percent}%`;
 	const subagentMarker = subagentStatuslineMarker(ctx.cwd);
 	const rightPlain = subagentMarker ? `${percentPlain} ${subagentMarker.plain}` : percentPlain;
 	const percentColor = percent === null ? "muted" : percent <= 15 ? "error" : percent <= 30 ? "warning" : "success";
@@ -214,6 +215,6 @@ export function renderStatusLine(width: number, ctx: ExtensionContext, git: GitS
 	const gapWidth = Math.max(minimumGap, width - visibleWidth(leftPlain) - visibleWidth(rightPlain) - 2);
 	const filled = percent === null ? 0 : Math.round(gapWidth * (percent / 100));
 	const empty = Math.max(0, gapWidth - filled);
-	const bar = " ".repeat(empty) + theme.fg("warning", "─".repeat(filled));
+	const bar = " ".repeat(empty) + theme.fg("warning", glyphs(ctx.cwd).line.repeat(filled));
 	return truncateToWidth(`${leftColored} ${bar} ${right}`, width, "");
 }

package/extensions/qol/transcript-risk.ts

@@ -0,0 +1,28 @@
+// Transcript risk for /context: estimate serialized request payload size and
+// warn before it crosses a char budget, even when the token count alone has
+// not reached the context window. Keeps /context independent of compaction.ts
+// (no summarizer/fs/artifact dependencies on the UI path).
+
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { convertToLlm, serializeConversation } from "@earendil-works/pi-coding-agent";
+import { evaluateTranscriptRisk, type TranscriptRiskResult } from "./budget-guard.js";
+
+function stripThinking(messages: any[]): any[] {
+	return messages.map((message: any) => {
+		if (message.role !== "assistant" || !Array.isArray(message.content)) return message;
+		return { ...message, content: message.content.filter((part: any) => part?.type !== "thinking") };
+	});
+}
+
+export function transcriptRiskState(messages: AgentMessage[], threshold: number): TranscriptRiskResult {
+	if (!Array.isArray(messages) || messages.length === 0 || threshold <= 0) {
+		return { chars: 0, exceeded: false, messageCount: messages?.length ?? 0, threshold };
+	}
+	try {
+		const serialized = serializeConversation(stripThinking(convertToLlm(messages)));
+		return evaluateTranscriptRisk({ chars: serialized.length, messageCount: messages.length, threshold });
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return evaluateTranscriptRisk({ chars: 0, error: message, messageCount: messages.length, threshold });
+	}
+}