@dungle-scrubs/tallow 0.8.21 → 0.8.23

package/extensions/plan-mode-tool/__tests__/agent-end-execution.test.ts

@@ -0,0 +1,373 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { ExtensionHarness } from "../../../test-utils/extension-harness.js";
+import planModeExtension from "../index.js";
+import type { TodoItem } from "../utils.js";
+
+const BASELINE_TOOLS = [
+	"read",
+	"bash",
+	"grep",
+	"find",
+	"ls",
+	"edit",
+	"write",
+	"subagent",
+	"bg_bash",
+	"questionnaire",
+	"plan_mode",
+] as const;
+
+/**
+ * Register mock tools for the test session.
+ *
+ * @param pi - Extension API
+ */
+function registerMockTools(pi: ExtensionAPI): void {
+	for (const name of [
+		"read",
+		"bash",
+		"grep",
+		"find",
+		"ls",
+		"edit",
+		"write",
+		"subagent",
+		"bg_bash",
+		"questionnaire",
+	] as const) {
+		pi.registerTool({
+			name,
+			label: name,
+			description: `Mock ${name}`,
+			parameters: Type.Object({}),
+			async execute() {
+				return { content: [{ type: "text", text: `${name}-ok` }], details: {} };
+			},
+		});
+	}
+}
+
+/**
+ * Build persisted session entries that place the extension in execution mode.
+ *
+ * @param todos - Todo items for the plan
+ * @returns Array of session entries
+ */
+function executionModeEntries(todos: TodoItem[]): unknown[] {
+	return [
+		{
+			type: "custom",
+			customType: "plan-mode",
+			data: {
+				enabled: false,
+				executing: true,
+				normalTools: [...BASELINE_TOOLS],
+				todos,
+				currentStepIndex: 0,
+			},
+		},
+		{ type: "custom", customType: "plan-mode-execute" },
+	];
+}
+
+/**
+ * Create an extension context with a configurable `select` stub.
+ *
+ * @param entries - Session entries for state restoration
+ * @param selectReturn - Value that ctx.ui.select() resolves to
+ * @returns Context and a record of select calls
+ */
+function createUIContext(
+	entries: unknown[] = [],
+	selectReturn?: string
+): { ctx: ExtensionContext; selectCalls: Array<{ title: string; options: string[] }> } {
+	const selectCalls: Array<{ title: string; options: string[] }> = [];
+	const ctx = {
+		cwd: process.cwd(),
+		hasUI: true,
+		ui: {
+			notify() {},
+			setStatus() {},
+			setEditorComponent() {},
+			setWidget() {},
+			setWorkingMessage() {},
+			async select(title: string, options: string[]) {
+				selectCalls.push({ title, options });
+				return selectReturn;
+			},
+			async editor() {
+				return undefined;
+			},
+			theme: {
+				fg(_token: string, value: string) {
+					return value;
+				},
+				bg(_token: string, value: string) {
+					return value;
+				},
+				strikethrough(value: string) {
+					return value;
+				},
+			},
+		} as never,
+		sessionManager: {
+			getEntries() {
+				return entries;
+			},
+		} as never,
+	} as unknown as ExtensionContext;
+	return { ctx, selectCalls };
+}
+
+/**
+ * Create a headless context (no UI).
+ *
+ * @param entries - Session entries for state restoration
+ * @returns Extension context with hasUI=false
+ */
+function createHeadlessContext(entries: unknown[] = []): ExtensionContext {
+	return {
+		cwd: process.cwd(),
+		hasUI: false,
+		ui: {
+			notify() {},
+			setStatus() {},
+			setEditorComponent() {},
+			setWidget() {},
+			setWorkingMessage() {},
+			theme: {
+				fg(_token: string, value: string) {
+					return value;
+				},
+				strikethrough(value: string) {
+					return value;
+				},
+			},
+		} as never,
+		sessionManager: {
+			getEntries() {
+				return entries;
+			},
+		} as never,
+	} as unknown as ExtensionContext;
+}
+
+const SAMPLE_TODOS: TodoItem[] = [
+	{ step: 1, text: "Add error handling", completed: false },
+	{ step: 2, text: "Write tests", completed: false },
+	{ step: 3, text: "Update docs", completed: false },
+];
+
+describe("agent_end execution mode — partial completion", () => {
+	let harness: ExtensionHarness;
+
+	beforeEach(async () => {
+		harness = ExtensionHarness.create();
+		await harness.loadExtension(registerMockTools);
+		await harness.loadExtension(planModeExtension);
+		harness.api.setActiveTools([...BASELINE_TOOLS]);
+	});
+
+	test("shows select menu when agent finishes with incomplete steps", async () => {
+		const todos = SAMPLE_TODOS.map((t) => ({ ...t }));
+		const entries = executionModeEntries(todos);
+		const { ctx, selectCalls } = createUIContext(entries, "Abort plan");
+
+		// Restore execution mode state
+		await harness.fireEvent("session_start", { type: "session_start" }, ctx);
+
+		// Agent finishes a turn — no [DONE:n] markers
+		await harness.fireEvent(
+			"agent_end",
+			{ messages: [{ role: "assistant", content: [{ type: "text", text: "Did some work." }] }] },
+			ctx
+		);
+
+		expect(selectCalls).toHaveLength(1);
+		expect(selectCalls[0].title).toContain("0/3");
+		expect(selectCalls[0].options).toEqual([
+			"Continue execution",
+			"Provide guidance",
+			"Mark plan as done",
+			"Abort plan",
+		]);
+	});
+
+	test("shows correct count when some steps are completed", async () => {
+		const todos = SAMPLE_TODOS.map((t) => ({ ...t }));
+		todos[0].completed = true; // step 1 done
+		const entries = executionModeEntries(todos);
+		const { ctx, selectCalls } = createUIContext(entries, "Abort plan");
+
+		await harness.fireEvent("session_start", { type: "session_start" }, ctx);
+		await harness.fireEvent(
+			"agent_end",
+			{ messages: [{ role: "assistant", content: [{ type: "text", text: "Finished step 1." }] }] },
+			ctx
+		);
+
+		expect(selectCalls).toHaveLength(1);
+		expect(selectCalls[0].title).toContain("1/3");
+	});
+
+	test("'Continue execution' sends message with triggerTurn", async () => {
+		const todos = SAMPLE_TODOS.map((t) => ({ ...t }));
+		const entries = executionModeEntries(todos);
+		const { ctx } = createUIContext(entries, "Continue execution");
+
+		await harness.fireEvent("session_start", { type: "session_start" }, ctx);
+		await harness.fireEvent(
+			"agent_end",
+			{ messages: [{ role: "assistant", content: [{ type: "text", text: "Partial." }] }] },
+			ctx
+		);
+
+		const execMsg = harness.sentMessages.find((m) => m.customType === "plan-mode-execute");
+		expect(execMsg).toBeDefined();
+		expect(execMsg?.options?.triggerTurn).toBe(true);
+		expect(execMsg?.content).toContain("step 1");
+	});
+
+	test("'Mark plan as done' clears execution mode and restores tools", async () => {
+		const todos = SAMPLE_TODOS.map((t) => ({ ...t }));
+		const entries = executionModeEntries(todos);
+		const { ctx } = createUIContext(entries, "Mark plan as done");
+
+		await harness.fireEvent("session_start", { type: "session_start" }, ctx);
+		await harness.fireEvent(
+			"agent_end",
+			{ messages: [{ role: "assistant", content: [{ type: "text", text: "Done enough." }] }] },
+			ctx
+		);
+
+		// Should send plan-complete message
+		const completeMsg = harness.sentMessages.find((m) => m.customType === "plan-complete");
+		expect(completeMsg).toBeDefined();
+		expect(completeMsg?.options?.triggerTurn).toBe(false);
+
+		// Should restore full tool set
+		expect(harness.api.getActiveTools()).toEqual([...BASELINE_TOOLS]);
+
+		// Persisted state should reflect cleared execution mode
+		const lastEntry = harness.appendedEntries.findLast((e) => e.customType === "plan-mode");
+		expect(lastEntry?.data).toMatchObject({ executing: false, todos: [] });
+	});
+
+	test("'Abort plan' clears execution mode without completion message", async () => {
+		const todos = SAMPLE_TODOS.map((t) => ({ ...t }));
+		const entries = executionModeEntries(todos);
+		const { ctx } = createUIContext(entries, "Abort plan");
+
+		await harness.fireEvent("session_start", { type: "session_start" }, ctx);
+		await harness.fireEvent(
+			"agent_end",
+			{ messages: [{ role: "assistant", content: [{ type: "text", text: "Stopping." }] }] },
+			ctx
+		);
+
+		// Should NOT send plan-complete message
+		const completeMsg = harness.sentMessages.find((m) => m.customType === "plan-complete");
+		expect(completeMsg).toBeUndefined();
+
+		// Should restore full tool set
+		expect(harness.api.getActiveTools()).toEqual([...BASELINE_TOOLS]);
+
+		// Persisted state should reflect cleared execution mode
+		const lastEntry = harness.appendedEntries.findLast((e) => e.customType === "plan-mode");
+		expect(lastEntry?.data).toMatchObject({ executing: false, todos: [] });
+	});
+
+	test("headless mode (no UI) returns silently", async () => {
+		const todos = SAMPLE_TODOS.map((t) => ({ ...t }));
+		const entries = executionModeEntries(todos);
+		const ctx = createHeadlessContext(entries);
+
+		await harness.fireEvent("session_start", { type: "session_start" }, ctx);
+		await harness.fireEvent(
+			"agent_end",
+			{ messages: [{ role: "assistant", content: [{ type: "text", text: "Done." }] }] },
+			ctx
+		);
+
+		// No select calls, no crash, no sent messages
+		expect(harness.sentMessages).toHaveLength(0);
+	});
+
+	test("all steps completed via [DONE:n] triggers clean completion", async () => {
+		const todos = SAMPLE_TODOS.map((t) => ({ ...t }));
+		const entries = executionModeEntries(todos);
+		const { ctx, selectCalls } = createUIContext(entries);
+
+		await harness.fireEvent("session_start", { type: "session_start" }, ctx);
+
+		// Simulate turn_end with all DONE markers
+		await harness.fireEvent(
+			"turn_end",
+			{
+				message: {
+					role: "assistant",
+					content: [{ type: "text", text: "[DONE:1] [DONE:2] [DONE:3]" }],
+				},
+			},
+			ctx
+		);
+
+		// Now agent_end fires — all steps are complete
+		await harness.fireEvent(
+			"agent_end",
+			{
+				messages: [
+					{
+						role: "assistant",
+						content: [{ type: "text", text: "[DONE:1] [DONE:2] [DONE:3]" }],
+					},
+				],
+			},
+			ctx
+		);
+
+		// Should get "Plan Complete!" not the select menu
+		const completeMsg = harness.sentMessages.find((m) => m.customType === "plan-complete");
+		expect(completeMsg).toBeDefined();
+		expect(selectCalls).toHaveLength(0);
+	});
+});
+
+describe("execution mode widgets removed", () => {
+	let harness: ExtensionHarness;
+	let widgetCalls: Array<{ name: string; value: unknown }>;
+
+	beforeEach(async () => {
+		harness = ExtensionHarness.create();
+		await harness.loadExtension(registerMockTools);
+		await harness.loadExtension(planModeExtension);
+		harness.api.setActiveTools([...BASELINE_TOOLS]);
+		widgetCalls = [];
+	});
+
+	test("execution mode does not render banner or todo widgets", async () => {
+		const todos = SAMPLE_TODOS.map((t) => ({ ...t }));
+		const entries = executionModeEntries(todos);
+		const { ctx } = createUIContext(entries, "Abort plan");
+
+		// Intercept setWidget calls
+		ctx.ui.setWidget = ((name: string, value: unknown) => {
+			widgetCalls.push({ name, value });
+		}) as never;
+
+		await harness.fireEvent("session_start", { type: "session_start" }, ctx);
+
+		// All plan-banner and plan-todos calls should be clearing (undefined)
+		const bannerCalls = widgetCalls.filter((c) => c.name === "plan-banner");
+		const todoCalls = widgetCalls.filter((c) => c.name === "plan-todos");
+
+		for (const call of bannerCalls) {
+			expect(call.value).toBeUndefined();
+		}
+		for (const call of todoCalls) {
+			expect(call.value).toBeUndefined();
+		}
+	});
+});

package/extensions/plan-mode-tool/index.ts

@@ -24,12 +24,14 @@ import {
 import {
 	type EditorTheme,
 	Key,
+	Loader,
 	type TUI,
 	truncateToWidth,
 	visibleWidth,
 } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { getIcon } from "../_icons/index.js";
+import { renderBorderedBox } from "../_shared/bordered-box.js";
 import {
 	detectPlanIntent,
 	extractTodoItems,
@@ -204,14 +206,8 @@ export default function planModeExtension(pi: ExtensionAPI): void {
 	 * @param ctx - The extension context
 	 */
 	function updateStatus(ctx: ExtensionContext): void {
-		// Footer status
-		if (executionMode && todoItems.length > 0) {
-			const completed = todoItems.filter((t) => t.completed).length;
-			ctx.ui.setStatus(
-				"plan-mode",
-				ctx.ui.theme.fg("accent", `${getIcon("task_list")} ${completed}/${todoItems.length}`)
-			);
-		} else if (planModeEnabled) {
+		// Footer status — plan mode only; execution mode defers to tasks extension
+		if (planModeEnabled) {
 			ctx.ui.setStatus(
 				"plan-mode",
 				ctx.ui.theme.fg("warning", `${getIcon("plan_mode")} PLAN MODE — read-only`)
@@ -229,14 +225,15 @@ export default function planModeExtension(pi: ExtensionAPI): void {
 			ctx.ui.setEditorComponent(undefined);
 		}
 
-		// Full-width banner above editor using existing theme background tokens
-		if (planModeEnabled || executionMode) {
+		// Full-width banner above editor — plan mode only.
+		// Execution mode does not show a banner; the tasks extension owns progress tracking.
+		if (planModeEnabled) {
 			ctx.ui.setWidget("plan-banner", (_tui, theme) => {
-				const label = planModeEnabled ? " PLAN MODE — READ ONLY " : " EXECUTING PLAN ";
-				const bg = planModeEnabled ? "customMessageBg" : "toolSuccessBg";
-				const fg = planModeEnabled ? "customMessageLabel" : "success";
+				const label = " PLAN MODE — READ ONLY ";
 				return {
-					render: (width: number) => [theme.bg(bg, theme.fg(fg, label.padEnd(width)))],
+					render: (width: number) => [
+						theme.bg("customMessageBg", theme.fg("customMessageLabel", label.padEnd(width))),
+					],
 					invalidate() {},
 				};
 			});
@@ -244,21 +241,8 @@ export default function planModeExtension(pi: ExtensionAPI): void {
 			ctx.ui.setWidget("plan-banner", undefined);
 		}
 
-		// Widget showing todo list
-		if (executionMode && todoItems.length > 0) {
-			const lines = todoItems.map((item) => {
-				if (item.completed) {
-					return (
-						ctx.ui.theme.fg("success", "☑ ") +
-						ctx.ui.theme.fg("muted", ctx.ui.theme.strikethrough(item.text))
-					);
-				}
-				return `${ctx.ui.theme.fg("muted", `${getIcon("pending")} `)}${item.text}`;
-			});
-			ctx.ui.setWidget("plan-todos", lines);
-		} else {
-			ctx.ui.setWidget("plan-todos", undefined);
-		}
+		// Todo list widget — plan mode only (execution delegates to tasks extension)
+		ctx.ui.setWidget("plan-todos", undefined);
 	}
 
 	/**
@@ -636,7 +620,77 @@ If you receive [PLAN GUIDANCE — Step n: ...], treat it as user steering for th
 				currentStepIndex = null;
 				restoreNormalModeTools();
 				updateStatus(ctx);
-				persistState(); // Save cleared state so resume doesn't restore old execution mode
+				persistState();
+			} else if (ctx.hasUI) {
+				// Agent finished its turn but not all steps are marked complete.
+				// Show progress summary and prompt for next action.
+				const completed = todoItems.filter((t) => t.completed);
+
+				updateStatus(ctx);
+				ctx.ui.setWorkingMessage(Loader.HIDE);
+
+				const choice = await ctx.ui.select(
+					`Plan execution paused (${completed.length}/${todoItems.length} done)`,
+					["Continue execution", "Provide guidance", "Mark plan as done", "Abort plan"]
+				);
+
+				if (choice === "Continue execution") {
+					const nextStep = getCurrentStep();
+					const continueMessage =
+						nextStep !== null
+							? `Continue executing the plan. Next: step ${nextStep.step}: ${nextStep.text}`
+							: "Continue executing the remaining plan steps.";
+					pi.sendMessage(
+						{ customType: "plan-mode-execute", content: continueMessage, display: true },
+						{ triggerTurn: true }
+					);
+				} else if (choice === "Provide guidance") {
+					const nextStep = getCurrentStep();
+					const stepLabel = nextStep ? `step ${nextStep.step} (${nextStep.text})` : "next step";
+					const guidance = await ctx.ui.editor(`Guidance for ${stepLabel}:`, "");
+					const trimmedGuidance = guidance?.trim();
+					if (trimmedGuidance && nextStep) {
+						pi.sendUserMessage(
+							[
+								`[PLAN GUIDANCE — Step ${nextStep.step}: ${nextStep.text}]`,
+								"",
+								"User guidance:",
+								trimmedGuidance,
+							].join("\n")
+						);
+					} else if (trimmedGuidance) {
+						pi.sendUserMessage(trimmedGuidance);
+					} else {
+						ctx.ui.notify("No guidance provided. Plan unchanged.", "info");
+					}
+				} else if (choice === "Mark plan as done") {
+					const completedList = todoItems
+						.map((t) => (t.completed ? `~~${t.text}~~` : t.text))
+						.join("\n");
+					pi.sendMessage(
+						{
+							customType: "plan-complete",
+							content: `**Plan Complete!** ${getIcon("success")}\n\n${completedList}`,
+							display: true,
+						},
+						{ triggerTurn: false }
+					);
+					executionMode = false;
+					todoItems = [];
+					currentStepIndex = null;
+					restoreNormalModeTools();
+					updateStatus(ctx);
+					persistState();
+				} else {
+					// Abort plan (or dismissed/escaped the select)
+					executionMode = false;
+					todoItems = [];
+					currentStepIndex = null;
+					restoreNormalModeTools();
+					updateStatus(ctx);
+					persistState();
+					ctx.ui.notify("Plan aborted.", "info");
+				}
 			}
 			return;
 		}
@@ -652,27 +706,35 @@ If you receive [PLAN GUIDANCE — Step n: ...], treat it as user steering for th
 			}
 		}
 
-		// Show plan steps and prompt for next action
+		// Show plan steps in a bordered widget above the editor
 		if (todoItems.length > 0) {
-			const todoListText = todoItems
-				.map((t, i) => `${i + 1}. ${getIcon("pending")} ${t.text}`)
-				.join("\n");
-			pi.sendMessage(
-				{
-					customType: "plan-todo-list",
-					content: `**Plan Steps (${todoItems.length}):**\n\n${todoListText}`,
-					display: true,
+			ctx.ui.setWidget("plan-steps", (_tui, theme) => ({
+				render(width: number): string[] {
+					const stepLines = todoItems.map(
+						(t) => `${theme.fg("muted", `${getIcon("pending")} `)}${t.text}`
+					);
+					return renderBorderedBox(stepLines, width, {
+						title: `PLAN (${todoItems.length} steps)`,
+						style: "rounded",
+						borderColorFn: (s: string) => theme.fg("warning", s),
+						titleColorFn: (s: string) => theme.fg("warning", s),
+					});
 				},
-				{ triggerTurn: false }
-			);
+				invalidate() {},
+			}));
 		}
 
+		ctx.ui.setWorkingMessage(Loader.HIDE);
+
 		const choice = await ctx.ui.select("Plan mode - what next?", [
 			todoItems.length > 0 ? "Execute the plan (track progress)" : "Execute the plan",
 			"Stay in plan mode",
 			"Refine the plan",
 		]);
 
+		// Clear the plan steps widget after user makes a choice
+		ctx.ui.setWidget("plan-steps", undefined);
+
 		if (choice?.startsWith("Execute")) {
 			planModeEnabled = false;
 			executionMode = todoItems.length > 0;

package/extensions/prompt-suggestions/__tests__/editor-compatibility.test.ts

@@ -0,0 +1,42 @@
+/**
+ * Tests for prompt-suggestions editor capability detection.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { resolvePromptSuggestionEditor } from "../index.js";
+
+describe("resolvePromptSuggestionEditor", () => {
+	test("returns editor when ghost-text APIs are available", () => {
+		const editor = {
+			addChangeListener() {},
+			getText() {
+				return "hello";
+			},
+			setGhostText() {},
+		};
+
+		expect(resolvePromptSuggestionEditor(editor)).toBe(editor);
+	});
+
+	test("returns null when setGhostText is missing", () => {
+		const editor = {
+			addChangeListener() {},
+			getText() {
+				return "hello";
+			},
+		};
+
+		expect(resolvePromptSuggestionEditor(editor)).toBeNull();
+	});
+
+	test("returns null when addChangeListener is missing", () => {
+		const editor = {
+			getText() {
+				return "hello";
+			},
+			setGhostText() {},
+		};
+
+		expect(resolvePromptSuggestionEditor(editor)).toBeNull();
+	});
+});

package/extensions/prompt-suggestions/index.ts

@@ -46,6 +46,31 @@ const DEFAULT_DEBOUNCE_MS = 600;
 /** Max autocomplete calls per session (cost guardrail). */
 const MAX_CALLS_PER_SESSION = 200;
 
+interface PromptSuggestionEditor {
+	addChangeListener(fn: (text: string) => void): void;
+	getText(): string;
+	setGhostText(text: string | null): void;
+}
+
+/**
+ * Resolve the subset of editor APIs required by prompt suggestions.
+ *
+ * Published installs may resolve upstream `@mariozechner/pi-tui`, whose
+ * editor does not implement ghost-text helpers. In that case, the
+ * extension should degrade safely instead of crashing.
+ *
+ * @param editor - Candidate editor instance
+ * @returns Prompt-suggestion editor surface, or null when unavailable
+ */
+export function resolvePromptSuggestionEditor(editor: unknown): PromptSuggestionEditor | null {
+	if (!editor || typeof editor !== "object") return null;
+	const candidate = editor as Partial<PromptSuggestionEditor>;
+	if (typeof candidate.getText !== "function") return null;
+	if (typeof candidate.setGhostText !== "function") return null;
+	if (typeof candidate.addChangeListener !== "function") return null;
+	return candidate as PromptSuggestionEditor;
+}
+
 // ─── Idle suggestions ────────────────────────────────────────────────────────
 
 /**
@@ -214,7 +239,7 @@ export default function promptSuggestions(pi: ExtensionAPI): void {
 	const modelSetting = readSetting("prompt-suggestions.model", DEFAULT_AUTOCOMPLETE_MODEL);
 
 	/** Reference to the editor instance for ghost text control. */
-	let editorRef: CustomEditor | null = null;
+	let editorRef: PromptSuggestionEditor | null = null;
 
 	/** Autocomplete engine instance, created after editor is available. */
 	let engine: AutocompleteEngine | null = null;
@@ -275,8 +300,18 @@ export default function promptSuggestions(pi: ExtensionAPI): void {
 
 		ctx.ui.setEditorComponent((tui, editorTheme: EditorTheme, keybindings) => {
 			const editor = new CustomEditor(tui, editorTheme, keybindings);
-			editorRef = editor;
-
+			const promptEditor = resolvePromptSuggestionEditor(editor);
+			if (!promptEditor) {
+				engine = null;
+				editorRef = null;
+				ctx.ui.notify(
+					"Prompt suggestions disabled: current editor runtime lacks ghost-text support.",
+					"warning"
+				);
+				return editor;
+			}
+
+			editorRef = promptEditor;
 			engine = new AutocompleteEngine(
 				{
 					enabled: autocompleteEnabled,
@@ -286,12 +321,12 @@ export default function promptSuggestions(pi: ExtensionAPI): void {
 				},
 				ctx.modelRegistry,
 				getCompletion,
-				(text) => editor.setGhostText(text),
-				() => editor.getText(),
+				(text) => promptEditor.setGhostText(text),
+				() => promptEditor.getText(),
 				() => (sessionManagerRef ? buildConversationContext(sessionManagerRef) : null)
 			);
 
-			editor.addChangeListener((newText: string) => {
+			promptEditor.addChangeListener((newText: string) => {
 				clearIdleTimer();
 
 				if (newText.length === 0 && !engine?.busy) {