@xopcai/xopc 0.0.103 → 0.0.104

package/dist/src/tui/extension-host/runtime.js

@@ -1,89 +1,33 @@
 import { theme } from "../theme.js";
+import { getGitBranchCached } from "../tui-git-branch.js";
+import { ExtensionEditorDialog, ExtensionInputDialog, ExtensionSelectDialog } from "../components/extension-dialog.js";
 import { createSkillsAutocompleteProvider } from "../tui-skills-autocomplete.js";
 import { clearTuiToolRenderers } from "./tool-renderers.js";
 import { createTuiExtensionHost, invokeTuiExtensionRegistrars } from "./host.js";
+import { ChainedAutocompleteProvider, WrappedAutocompleteProvider } from "./autocomplete.js";
+import { STALE_EXTENSION_CONTEXT_MESSAGE, boundedWidgetLines, createDefaultModelRegistry, createEmptySessionManager, disposeComponent, getTuiContextUsage, getTuiModelInfo, getTuiReasoningLevel, getTuiThinkingLevel, getTuiVerboseLevel, hasPendingTuiMessages, invokeCustomFactory, isTuiIdle, notifyInChatLog, resolveCustomOverlayOptions } from "./runtime-context.js";
 import { TuiExtensionSurface } from "./surface.js";
-import { CombinedAutocompleteProvider } from "@earendil-works/pi-tui";
+import { CombinedAutocompleteProvider, matchesKey } from "@earendil-works/pi-tui";
 //#region src/tui/extension-host/runtime.ts
-var ChainedAutocompleteProvider = class {
-	constructor(primary, extraProviders, extensionSlashCommands, getSessionKey, cwd) {
-		this.primary = primary;
-		this.extraProviders = extraProviders;
-		this.extensionSlashCommands = extensionSlashCommands;
-		this.getSessionKey = getSessionKey;
-		this.cwd = cwd;
-	}
-	async getSuggestions(lines, cursorLine, cursorCol, options) {
-		const primary = await this.primary.getSuggestions(lines, cursorLine, cursorCol, options);
-		const beforeCursor = (lines[cursorLine] ?? "").slice(0, cursorCol);
-		const slashMatch = beforeCursor.match(/^\/([\w-]*)$/);
-		if (slashMatch && this.extensionSlashCommands.length > 0) {
-			const query = (slashMatch[1] ?? "").toLowerCase();
-			const prefix = `/${slashMatch[1] ?? ""}`;
-			const items = this.extensionSlashCommands.filter((c) => !query || c.name.startsWith(query)).map((c) => ({
-				value: `/${c.name}`,
-				label: c.name,
-				description: c.description
-			}));
-			if (items.length > 0) {
-				const merged = primary?.items ? [...primary.items, ...items] : items;
-				const seen = /* @__PURE__ */ new Set();
-				return {
-					prefix,
-					items: merged.filter((item) => {
-						if (seen.has(item.value)) return false;
-						seen.add(item.value);
-						return true;
-					}).slice(0, 30)
-				};
-			}
-		}
-		const atMatch = beforeCursor.match(/@([\w.-]*)$/);
-		if (!atMatch) return primary;
-		const query = atMatch[1] ?? "";
-		const prefix = `@${query}`;
-		const sessionKey = this.getSessionKey();
-		const items = [];
-		for (const provider of this.extraProviders) {
-			const suggestions = await provider(query, {
-				cwd: this.cwd,
-				sessionKey
-			});
-			for (const s of suggestions) items.push({
-				value: `@${s.name}`,
-				label: s.name,
-				description: s.description
-			});
-		}
-		if (items.length === 0) return primary;
-		return {
-			prefix,
-			items: (query ? items.filter((item) => item.label.toLowerCase().includes(query.toLowerCase())) : items).slice(0, 20)
-		};
-	}
-	applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
-		if (prefix.startsWith("@")) {
-			const line = lines[cursorLine] ?? "";
-			const start = line.slice(0, cursorCol).length - prefix.length;
-			const nextLine = line.slice(0, start) + item.value + line.slice(cursorCol);
-			const nextLines = [...lines];
-			nextLines[cursorLine] = nextLine;
-			return {
-				lines: nextLines,
-				cursorLine,
-				cursorCol: start + item.value.length
-			};
+function recomputeSlashCommandInvocationNames(commands) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const command of commands) counts.set(command.originalName, (counts.get(command.originalName) ?? 0) + 1);
+	const seen = /* @__PURE__ */ new Map();
+	const taken = /* @__PURE__ */ new Set();
+	for (const command of commands) {
+		const occurrence = (seen.get(command.originalName) ?? 0) + 1;
+		seen.set(command.originalName, occurrence);
+		let name = (counts.get(command.originalName) ?? 0) > 1 ? `${command.originalName}:${occurrence}` : command.originalName;
+		if (taken.has(name)) {
+			let suffix = occurrence;
+			do {
+				suffix += 1;
+				name = `${command.originalName}:${suffix}`;
+			} while (taken.has(name));
 		}
-		return this.primary.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
-	}
-	shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
-		return this.primary.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ?? false;
+		command.name = name;
+		taken.add(name);
 	}
-};
-function notifyInChatLog(chatLog, tui, message, level) {
-	const prefix = level === "error" ? theme.error("✖ ") : level === "warn" ? "⚠ " : "";
-	chatLog.addSystem(`${prefix}${message}`);
-	tui.requestRender();
 }
 function suggestionsToAutocompleteItems(suggestions) {
 	return suggestions.map((s) => ({
@@ -95,50 +39,553 @@ function suggestionsToAutocompleteItems(suggestions) {
 function createTuiExtensionRuntime(opts) {
 	const surface = new TuiExtensionSurface();
 	const slashCommands = [];
+	const shortcuts = [];
 	const autocompleteProviders = [createSkillsAutocompleteProvider()];
+	const autocompleteProviderFactories = [];
 	const disposers = [];
-	const chainedProvider = new ChainedAutocompleteProvider(new CombinedAutocompleteProvider(opts.baseSlashCommands.map((c) => ({
+	const autocompleteProvider = new WrappedAutocompleteProvider(new ChainedAutocompleteProvider(new CombinedAutocompleteProvider(opts.baseSlashCommands.map((c) => ({
 		name: c.name,
 		description: c.description
-	})), opts.cwd, opts.fdPath), autocompleteProviders, slashCommands, () => opts.getState().currentSessionKey, opts.cwd);
+	})), opts.cwd, opts.fdPath), autocompleteProviders, slashCommands, new Set(opts.baseSlashCommands.map((command) => command.name)), () => opts.getState().currentSessionKey, opts.cwd), autocompleteProviderFactories);
 	const invalidate = () => {
+		opts.header.setCustomComponent?.(surface.customHeader);
 		opts.header.setExtensionLines(surface.getHeaderLines());
+		opts.header.setExtensionComponents?.(surface.getHeaderComponents());
+		opts.bottomBar.setCustomComponent?.(surface.customFooter);
 		opts.bottomBar.setExtensionLines(surface.getFooterLines());
+		opts.bottomBar.setExtensionComponents?.(surface.getFooterComponents());
 		opts.bottomBar.setExtensionStatusParts(surface.getStatusParts());
 		opts.onInvalidate();
 	};
+	const createWidgetComponent = (factory) => factory(opts.tui, theme);
+	const footerDataProvider = {
+		getGitBranch: () => getGitBranchCached(opts.cwd),
+		getExtensionStatuses: () => surface.statusSlots,
+		getAvailableProviderCount: () => opts.getAvailableProviderCount?.() ?? 0,
+		onBranchChange: () => () => {}
+	};
+	const modelRegistry = opts.getModelRegistry?.() ?? createDefaultModelRegistry();
+	const setCustomHeader = (factory) => {
+		disposeComponent(surface.customHeader);
+		surface.customHeader = factory ? factory(opts.tui, theme) : void 0;
+		invalidate();
+	};
+	const setCustomFooter = (factory) => {
+		disposeComponent(surface.customFooter);
+		surface.customFooter = factory ? factory(opts.tui, theme, footerDataProvider) : void 0;
+		invalidate();
+	};
+	const clearWidgetKey = (fullKey) => {
+		surface.headerWidgets.delete(fullKey);
+		surface.footerWidgets.delete(fullKey);
+		const headerComponent = surface.headerWidgetComponents.get(fullKey);
+		const footerComponent = surface.footerWidgetComponents.get(fullKey);
+		surface.headerWidgetComponents.delete(fullKey);
+		surface.footerWidgetComponents.delete(fullKey);
+		disposeComponent(headerComponent);
+		disposeComponent(footerComponent);
+	};
+	const createActionUiContext = (extensionId) => {
+		const widgetKey = (key) => `${extensionId}:${key}`;
+		return {
+			select: selectDialog,
+			confirm: confirmDialog,
+			input: inputDialog,
+			notify: (message, level) => notifyInChatLog(opts.chatLog, opts.tui, message, level),
+			onTerminalInput: (handler) => {
+				const unregister = opts.addInputListener?.(handler);
+				if (!unregister) return () => {};
+				disposers.push(unregister);
+				return () => {
+					unregister();
+					const idx = disposers.indexOf(unregister);
+					if (idx >= 0) disposers.splice(idx, 1);
+				};
+			},
+			setStatus: (key, text) => {
+				const fullKey = widgetKey(key);
+				if (!text) surface.statusSlots.delete(fullKey);
+				else surface.statusSlots.set(fullKey, text);
+				invalidate();
+			},
+			setWorkingMessage: (message) => {
+				opts.setWorkingMessage?.(message ?? void 0);
+				invalidate();
+			},
+			setWorkingVisible: (visible) => {
+				opts.setWorkingVisible?.(visible);
+				invalidate();
+			},
+			setWorkingIndicator: (indicator) => {
+				opts.setWorkingIndicator?.(indicator ?? void 0);
+				invalidate();
+			},
+			setHiddenThinkingLabel: (label) => {
+				opts.chatLog.setHiddenThinkingLabel(label ?? void 0);
+				invalidate();
+			},
+			setWidget: (key, content, options) => {
+				const fullKey = widgetKey(key);
+				clearWidgetKey(fullKey);
+				if (!content) {
+					invalidate();
+					return;
+				}
+				if (typeof content === "function") (options?.placement === "belowEditor" ? surface.footerWidgetComponents : surface.headerWidgetComponents).set(fullKey, createWidgetComponent(content));
+				else (options?.placement === "belowEditor" ? surface.footerWidgets : surface.headerWidgets).set(fullKey, boundedWidgetLines(content));
+				invalidate();
+			},
+			setFooter: setCustomFooter,
+			setHeader: setCustomHeader,
+			custom: customOverlay,
+			setTitle: (title) => opts.setTitle?.(title),
+			pasteToEditor: (text) => opts.pasteToEditor?.(text),
+			setEditorText: (text) => opts.setEditorText?.(text),
+			getEditorText: () => opts.getEditorText?.() ?? "",
+			editor: editorDialog,
+			addAutocompleteProvider: (factory) => {
+				autocompleteProviderFactories.push(factory);
+				const dispose = () => {
+					const idx = autocompleteProviderFactories.indexOf(factory);
+					if (idx >= 0) autocompleteProviderFactories.splice(idx, 1);
+				};
+				disposers.push(dispose);
+				return dispose;
+			},
+			setEditorComponent: (factory) => opts.setEditorComponent?.(factory),
+			getEditorComponent: () => opts.getEditorComponent?.(),
+			get theme() {
+				return opts.getThemeObject?.() ?? {};
+			},
+			getAllThemes: () => opts.getAllThemes?.() ?? [],
+			getTheme: (name) => opts.getTheme?.(name),
+			setTheme: (nextTheme) => opts.setTheme?.(nextTheme) ?? {
+				success: false,
+				error: "Theme switching is not available in this TUI host."
+			},
+			getToolsExpanded: () => opts.getToolsExpanded?.() ?? false,
+			setToolsExpanded: (expanded) => opts.setToolsExpanded?.(expanded)
+		};
+	};
+	const createActionContext = (extensionId) => {
+		let staleMessage;
+		const assertActive = () => {
+			if (staleMessage) throw new Error(staleMessage);
+		};
+		const markStale = () => {
+			staleMessage ??= STALE_EXTENSION_CONTEXT_MESSAGE;
+		};
+		const guardedReplacement = async (work) => {
+			assertActive();
+			const result = await work();
+			if (!result.cancelled) markStale();
+			return result;
+		};
+		return Object.defineProperties({
+			isProjectTrusted: () => {
+				assertActive();
+				return opts.isProjectTrusted?.() ?? false;
+			},
+			isIdle: () => {
+				assertActive();
+				return isTuiIdle(opts.getState());
+			},
+			hasPendingMessages: () => {
+				assertActive();
+				return hasPendingTuiMessages(opts.getState());
+			},
+			abort: () => {
+				assertActive();
+				return opts.abortActive?.();
+			},
+			shutdown: () => {
+				assertActive();
+				return opts.requestExit?.();
+			},
+			compact: (options) => {
+				assertActive();
+				return opts.compactSession?.(options);
+			},
+			getSystemPrompt: () => {
+				assertActive();
+				return opts.getSystemPrompt?.() ?? "";
+			},
+			getSystemPromptOptions: () => {
+				assertActive();
+				return opts.getSystemPromptOptions?.() ?? {
+					cwd: opts.cwd,
+					sessionKey: opts.getState().currentSessionKey,
+					model: getTuiModelInfo(opts.getState())
+				};
+			},
+			waitForIdle: () => {
+				assertActive();
+				return opts.waitForIdle?.() ?? Promise.resolve();
+			},
+			newSession: (options) => guardedReplacement(() => opts.newSession?.(options) ?? Promise.resolve({ cancelled: true })),
+			fork: (entryId, options) => guardedReplacement(() => opts.forkSession?.(entryId, options) ?? Promise.resolve({ cancelled: true })),
+			navigateTree: (targetId, options) => {
+				assertActive();
+				return opts.navigateTree?.(targetId, options) ?? Promise.resolve({ cancelled: true });
+			},
+			switchSession: (sessionPath, options) => guardedReplacement(() => opts.switchSession?.(sessionPath, options) ?? Promise.resolve({ cancelled: true })),
+			reload: async () => {
+				assertActive();
+				await (opts.reload?.() ?? Promise.resolve());
+				markStale();
+			},
+			getModel: () => {
+				assertActive();
+				return getTuiModelInfo(opts.getState());
+			},
+			setModel: (modelRef) => {
+				assertActive();
+				return opts.setModel?.(modelRef);
+			},
+			getThinkingLevel: () => {
+				assertActive();
+				return getTuiThinkingLevel(opts.getState());
+			},
+			setThinkingLevel: (level) => {
+				assertActive();
+				return opts.setThinkingLevel?.(level);
+			},
+			getReasoningLevel: () => {
+				assertActive();
+				return getTuiReasoningLevel(opts.getState());
+			},
+			setReasoningLevel: (level) => {
+				assertActive();
+				return opts.setReasoningLevel?.(level);
+			},
+			getVerboseLevel: () => {
+				assertActive();
+				return getTuiVerboseLevel(opts.getState());
+			},
+			setVerboseLevel: (level) => {
+				assertActive();
+				return opts.setVerboseLevel?.(level);
+			},
+			getCommands: () => {
+				assertActive();
+				return [...opts.baseSlashCommands.map((command) => ({
+					name: command.name,
+					description: command.description,
+					source: "builtin"
+				})), ...slashCommands.map((command) => ({
+					name: command.name,
+					description: command.description,
+					source: "extension"
+				}))];
+			},
+			getContextUsage: () => {
+				assertActive();
+				return getTuiContextUsage(opts.getState());
+			},
+			notify: (message, level) => {
+				assertActive();
+				return notifyInChatLog(opts.chatLog, opts.tui, message, level);
+			}
+		}, {
+			mode: {
+				enumerable: true,
+				get: () => {
+					assertActive();
+					return "tui";
+				}
+			},
+			hasUI: {
+				enumerable: true,
+				get: () => {
+					assertActive();
+					return true;
+				}
+			},
+			signal: {
+				enumerable: true,
+				get: () => {
+					assertActive();
+					return opts.getActiveSignal?.();
+				}
+			},
+			ui: {
+				enumerable: true,
+				get: () => {
+					assertActive();
+					return createActionUiContext(extensionId);
+				}
+			},
+			sessionManager: {
+				enumerable: true,
+				get: () => {
+					assertActive();
+					return opts.getSessionManager?.() ?? createEmptySessionManager(opts.cwd, opts.getState().currentSessionKey);
+				}
+			},
+			modelRegistry: {
+				enumerable: true,
+				get: () => {
+					assertActive();
+					return modelRegistry;
+				}
+			},
+			model: {
+				enumerable: true,
+				get: () => {
+					assertActive();
+					return getTuiModelInfo(opts.getState());
+				}
+			},
+			cwd: {
+				enumerable: true,
+				get: () => {
+					assertActive();
+					return opts.cwd;
+				}
+			},
+			sessionKey: {
+				enumerable: true,
+				get: () => {
+					assertActive();
+					return opts.getState().currentSessionKey;
+				}
+			}
+		});
+	};
+	const runDialog = (createDialog, dialogOpts, cancelValue) => new Promise((resolve) => {
+		if (dialogOpts?.signal?.aborted) {
+			resolve(cancelValue);
+			return;
+		}
+		let settled = false;
+		let timeout;
+		let interval;
+		const finish = (value) => {
+			if (settled) return;
+			settled = true;
+			if (timeout) clearTimeout(timeout);
+			if (interval) clearInterval(interval);
+			dialogOpts?.signal?.removeEventListener("abort", onAbort);
+			opts.closeOverlay();
+			opts.onInvalidate();
+			resolve(value);
+		};
+		const onAbort = () => finish(cancelValue);
+		dialogOpts?.signal?.addEventListener("abort", onAbort, { once: true });
+		const dialog = createDialog(finish, () => finish(cancelValue));
+		if (dialogOpts?.timeout != null && dialogOpts.timeout > 0) {
+			const deadline = Date.now() + dialogOpts.timeout;
+			const updateCountdown = () => {
+				const remainingMs = Math.max(0, deadline - Date.now());
+				dialog.setCountdownSeconds?.(Math.ceil(remainingMs / 1e3));
+				opts.onInvalidate();
+			};
+			updateCountdown();
+			interval = setInterval(updateCountdown, 250);
+			timeout = setTimeout(() => finish(cancelValue), dialogOpts.timeout);
+		}
+		opts.openOverlay(dialog);
+		opts.onInvalidate();
+	});
+	const selectDialog = (title, options, dialogOpts) => {
+		if (options.length === 0) return Promise.resolve(void 0);
+		return runDialog((resolve, cancel) => new ExtensionSelectDialog(title, options, {
+			onSelect: resolve,
+			onCancel: cancel
+		}, opts.keybindings), dialogOpts, void 0);
+	};
+	const confirmDialog = async (title, message, dialogOpts) => {
+		return await selectDialog(`${title}\n${message}`, ["Yes", "No"], dialogOpts) === "Yes";
+	};
+	const inputDialog = (title, placeholder, dialogOpts) => runDialog((resolve, cancel) => new ExtensionInputDialog(title, placeholder, {
+		onSubmit: resolve,
+		onCancel: cancel
+	}, opts.keybindings), dialogOpts, void 0);
+	const editorDialog = (title, prefill) => runDialog((resolve, cancel) => new ExtensionEditorDialog(opts.tui, title, prefill, {
+		onSubmit: resolve,
+		onCancel: cancel
+	}, opts.keybindings), void 0, void 0);
+	const customOverlay = (factory, customOpts) => new Promise((resolve, reject) => {
+		let closed = false;
+		let component;
+		let cleanup;
+		const removeCleanup = () => {
+			if (!cleanup) return;
+			const idx = disposers.indexOf(cleanup);
+			if (idx >= 0) disposers.splice(idx, 1);
+		};
+		const close = (result) => {
+			if (closed) return;
+			closed = true;
+			removeCleanup();
+			opts.closeOverlay();
+			opts.onInvalidate();
+			try {
+				component?.dispose?.();
+			} catch {}
+			resolve(result);
+		};
+		Promise.resolve().then(() => invokeCustomFactory(factory, opts.tui, opts.keybindings, close)).then((nextComponent) => {
+			if (closed) return;
+			component = nextComponent;
+			cleanup = () => {
+				if (closed) return;
+				closed = true;
+				opts.closeOverlay();
+				opts.onInvalidate();
+				try {
+					component?.dispose?.();
+				} catch {}
+			};
+			disposers.push(cleanup);
+			const overlayOptions = resolveCustomOverlayOptions(nextComponent, customOpts);
+			const handle = opts.openOverlay(nextComponent, overlayOptions);
+			if (handle) customOpts?.onHandle?.(handle);
+			opts.onInvalidate();
+		}).catch((err) => {
+			if (closed) return;
+			closed = true;
+			removeCleanup();
+			try {
+				component?.dispose?.();
+			} catch {}
+			reject(err);
+		});
+	});
 	const createHost = (extensionId) => createTuiExtensionHost({
 		extensionId,
 		surface,
 		getSessionKey: () => opts.getState().currentSessionKey,
 		notify: (message, level) => notifyInChatLog(opts.chatLog, opts.tui, message, level),
+		onTerminalInputAdded: (handler) => {
+			const unregister = opts.addInputListener?.(handler);
+			if (!unregister) return () => {};
+			disposers.push(unregister);
+			return () => {
+				unregister();
+				const idx = disposers.indexOf(unregister);
+				if (idx >= 0) disposers.splice(idx, 1);
+			};
+		},
 		showOverlay: opts.openOverlay,
 		hideOverlay: opts.closeOverlay,
+		custom: customOverlay,
+		createWidgetComponent,
+		setFooter: setCustomFooter,
+		setHeader: setCustomHeader,
+		setTitle: (title) => opts.setTitle?.(title),
+		pasteToEditor: (text) => opts.pasteToEditor?.(text),
+		setEditorText: (text) => opts.setEditorText?.(text),
+		getEditorText: () => opts.getEditorText?.() ?? "",
+		editor: editorDialog,
+		setEditorComponent: (factory) => opts.setEditorComponent?.(factory),
+		getEditorComponent: () => opts.getEditorComponent?.(),
+		getThemeObject: () => opts.getThemeObject?.() ?? {},
+		getAllThemes: () => opts.getAllThemes?.() ?? [],
+		getTheme: (name) => opts.getTheme?.(name),
+		setTheme: (nextTheme) => opts.setTheme?.(nextTheme) ?? {
+			success: false,
+			error: "Theme switching is not available in this TUI host."
+		},
+		getToolsExpanded: () => opts.getToolsExpanded?.() ?? false,
+		setToolsExpanded: (expanded) => opts.setToolsExpanded?.(expanded),
+		select: selectDialog,
+		confirm: confirmDialog,
+		input: inputDialog,
 		onAutocompleteProviderAdded: (provider) => {
 			autocompleteProviders.push(provider);
-			return () => {
+			const dispose = () => {
 				const idx = autocompleteProviders.indexOf(provider);
 				if (idx >= 0) autocompleteProviders.splice(idx, 1);
 			};
+			disposers.push(dispose);
+			return dispose;
+		},
+		onAutocompleteProviderFactoryAdded: (factory) => {
+			autocompleteProviderFactories.push(factory);
+			const dispose = () => {
+				const idx = autocompleteProviderFactories.indexOf(factory);
+				if (idx >= 0) autocompleteProviderFactories.splice(idx, 1);
+			};
+			disposers.push(dispose);
+			return dispose;
+		},
+		onMessageRendererAdded: (customType, renderer) => {
+			const normalized = customType.trim();
+			if (!normalized) return () => {};
+			opts.chatLog.setCustomMessageRenderer(normalized, renderer);
+			opts.onInvalidate();
+			const dispose = () => {
+				opts.chatLog.setCustomMessageRenderer(normalized, void 0);
+				opts.onInvalidate();
+			};
+			disposers.push(dispose);
+			return dispose;
 		},
 		onSlashCommandAdded: (name, description, handler) => {
+			const normalized = name.replace(/^\//, "").toLowerCase();
 			const entry = {
-				name: name.replace(/^\//, "").toLowerCase(),
+				originalName: normalized,
+				name: normalized,
 				description,
-				handler
+				handler,
+				getContext: () => createActionContext(extensionId)
 			};
 			slashCommands.push(entry);
-			return () => {
+			recomputeSlashCommandInvocationNames(slashCommands);
+			const dispose = () => {
 				const idx = slashCommands.indexOf(entry);
 				if (idx >= 0) slashCommands.splice(idx, 1);
+				recomputeSlashCommandInvocationNames(slashCommands);
+			};
+			disposers.push(dispose);
+			return dispose;
+		},
+		onShortcutAdded: (key, description, handler) => {
+			const entry = {
+				key,
+				description,
+				handler,
+				getContext: () => createActionContext(extensionId)
+			};
+			shortcuts.push(entry);
+			const dispose = () => {
+				const idx = shortcuts.indexOf(entry);
+				if (idx >= 0) shortcuts.splice(idx, 1);
 			};
+			disposers.push(dispose);
+			return dispose;
+		},
+		setHiddenThinkingLabel: (label) => {
+			opts.chatLog.setHiddenThinkingLabel(label);
+		},
+		setWorkingMessage: (message) => {
+			opts.setWorkingMessage?.(message);
+		},
+		setWorkingVisible: (visible) => {
+			opts.setWorkingVisible?.(visible);
+		},
+		setWorkingIndicator: (options) => {
+			opts.setWorkingIndicator?.(options);
 		},
 		onInvalidate: invalidate
 	});
 	return {
 		surface,
 		slashCommands,
-		autocompleteProvider: chainedProvider,
+		shortcuts,
+		autocompleteProvider,
+		handleShortcut(data) {
+			for (const shortcut of shortcuts) {
+				if (data !== shortcut.key && !matchesKey(data, shortcut.key)) continue;
+				Promise.resolve(shortcut.handler(shortcut.getContext())).catch((err) => {
+					const errorMessage = err instanceof Error ? err.message : String(err);
+					notifyInChatLog(opts.chatLog, opts.tui, `Shortcut handler error: ${errorMessage}`, "error");
+				});
+				return true;
+			}
+			return false;
+		},
 		async activate() {
 			await invokeTuiExtensionRegistrars(opts.registry?.getTuiRegistrations() ?? [], createHost, (extensionId, errorMessage) => {
 				notifyInChatLog(opts.chatLog, opts.tui, `[${extensionId}] TUI init failed: ${errorMessage}`, "error");
@@ -149,9 +596,24 @@ function createTuiExtensionRuntime(opts) {
 			for (const dispose of disposers) dispose();
 			disposers.length = 0;
 			clearTuiToolRenderers();
+			disposeComponent(surface.customHeader);
+			disposeComponent(surface.customFooter);
+			surface.disposeWidgetComponents();
+			surface.customHeader = void 0;
+			surface.customFooter = void 0;
 			surface.headerWidgets.clear();
 			surface.footerWidgets.clear();
 			surface.statusSlots.clear();
+			opts.chatLog.setHiddenThinkingLabel();
+			opts.setWorkingMessage?.();
+			opts.setWorkingVisible?.(true);
+			opts.setWorkingIndicator?.();
+			opts.setEditorComponent?.(void 0);
+			slashCommands.length = 0;
+			shortcuts.length = 0;
+			autocompleteProviders.length = 1;
+			autocompleteProviderFactories.length = 0;
+			invalidate();
 		}
 	};
 }