@bastani/atomic 0.8.31-alpha.4 → 0.9.0-alpha.1

package/dist/builtin/subagents/src/runs/foreground/chain-clarify-behavior.ts

@@ -0,0 +1,75 @@
+import { findModelInfo, getSupportedThinkingLevels, splitKnownThinkingSuffix, type ThinkingLevel } from "../../shared/model-info.ts";
+import type { ResolvedStepBehavior } from "../../shared/settings.ts";
+import { resolveModelCandidate } from "../shared/model-fallback.ts";
+import type { ChainClarifyState } from "./chain-clarify-state.ts";
+import type { BehaviorOverride } from "./chain-clarify-types.ts";
+
+export function getEffectiveBehavior(state: ChainClarifyState, stepIndex: number): ResolvedStepBehavior {
+	const base = state.resolvedBehaviors[stepIndex]!;
+	const override = state.behaviorOverrides.get(stepIndex);
+	if (!override) return base;
+
+	return {
+		output: override.output !== undefined ? override.output : base.output,
+		outputMode: base.outputMode,
+		reads: override.reads !== undefined ? override.reads : base.reads,
+		progress: override.progress !== undefined ? override.progress : base.progress,
+		skills: override.skills !== undefined ? override.skills : base.skills,
+		model: override.model !== undefined ? override.model : base.model,
+	};
+}
+
+export function resolveModelFullId(state: ChainClarifyState, modelName: string): string {
+	return resolveModelCandidate(modelName, state.availableModels, state.preferredProvider) ?? modelName;
+}
+
+export function getEffectiveModel(state: ChainClarifyState, stepIndex: number): string {
+	const override = state.behaviorOverrides.get(stepIndex);
+	if (override?.model) return resolveModelFullId(state, override.model);
+
+	const baseModel = state.resolvedBehaviors[stepIndex]?.model;
+	if (baseModel) return resolveModelFullId(state, baseModel);
+	return "default";
+}
+
+export function updateBehavior<K extends keyof BehaviorOverride>(
+	state: ChainClarifyState,
+	stepIndex: number,
+	field: K,
+	value: Exclude<BehaviorOverride[K], undefined>,
+): void {
+	const existing = state.behaviorOverrides.get(stepIndex) ?? {};
+	state.behaviorOverrides.set(stepIndex, { ...existing, [field]: value });
+}
+
+export function getAvailableThinkingLevels(state: ChainClarifyState, stepIndex: number): ThinkingLevel[] {
+	const model = findModelInfo(getEffectiveModel(state, stepIndex), state.availableModels, state.preferredProvider);
+	return getSupportedThinkingLevels(model);
+}
+
+export function applyThinkingLevel(state: ChainClarifyState, stepIndex: number, level: ThinkingLevel): void {
+	const currentModel = getEffectiveBehavior(state, stepIndex).model;
+	if (!currentModel) return;
+
+	const { baseModel } = splitKnownThinkingSuffix(currentModel);
+	const newModel = level === "off" ? baseModel : `${baseModel}:${level}`;
+	updateBehavior(state, stepIndex, "model", newModel);
+}
+
+export function propagateOutputChange(state: ChainClarifyState, changedStepIndex: number, oldOutput: string, newOutput: string): void {
+	for (let i = changedStepIndex + 1; i < state.agentConfigs.length; i++) {
+		const behavior = getEffectiveBehavior(state, i);
+
+		if (behavior.reads === false || !behavior.reads || behavior.reads.length === 0) {
+			continue;
+		}
+
+		const readsArray = behavior.reads;
+		const oldIndex = readsArray.indexOf(oldOutput);
+		if (oldIndex !== -1) {
+			const newReads = [...readsArray];
+			newReads[oldIndex] = newOutput;
+			updateBehavior(state, i, "reads", newReads);
+		}
+	}
+}

package/dist/builtin/subagents/src/runs/foreground/chain-clarify-component.ts

@@ -0,0 +1,202 @@
+import type { Theme } from "@bastani/atomic";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import { matchesKey } from "@earendil-works/pi-tui";
+import type { AgentConfig } from "../../agents/agents.ts";
+import type { ModelInfo } from "../../shared/model-info.ts";
+import type { ResolvedStepBehavior } from "../../shared/settings.ts";
+import { updateBehavior } from "./chain-clarify-behavior.ts";
+import { enterEditMode, handleEditInput } from "./chain-clarify-edit.ts";
+import { renderChainMode, renderParallelMode, renderSingleMode } from "./chain-clarify-render-modes.ts";
+import { renderFullEditMode, renderModelSelector, renderSkillSelector, renderThinkingSelector } from "./chain-clarify-render-selectors.ts";
+import { enterModelSelector, enterSkillSelector, enterThinkingSelector, handleModelSelectorInput, handleSkillSelectorInput, handleThinkingSelectorInput } from "./chain-clarify-selectors.ts";
+import { CHAIN_CLARIFY_WIDTH, createChainClarifyState, disposeNoticeTimer, type ChainClarifyState } from "./chain-clarify-state.ts";
+import type { BehaviorOverride, ChainClarifyResult, ClarifyMode, SkillOption } from "./chain-clarify-types.ts";
+
+/**
+ * TUI component for chain clarification.
+ * Factory signature matches ctx.ui.custom: (tui, theme, kb, done) => Component
+ */
+export class ChainClarifyComponent implements Component {
+	readonly width = CHAIN_CLARIFY_WIDTH;
+	private readonly state: ChainClarifyState;
+
+	constructor(
+		tui: TUI,
+		theme: Theme,
+		agentConfigs: AgentConfig[],
+		templates: string[],
+		originalTask: string,
+		chainDir: string | undefined,
+		resolvedBehaviors: ResolvedStepBehavior[],
+		availableModels: ModelInfo[],
+		preferredProvider: string | undefined,
+		availableSkills: SkillOption[],
+		done: (result: ChainClarifyResult) => void,
+		mode: ClarifyMode = "chain",
+	) {
+		this.state = createChainClarifyState({
+			tui,
+			theme,
+			agentConfigs,
+			templates,
+			originalTask,
+			chainDir,
+			resolvedBehaviors,
+			availableModels,
+			preferredProvider,
+			availableSkills,
+			done,
+			mode,
+		});
+	}
+
+	handleInput(data: string): void {
+		const state = this.state;
+		if (state.editingStep !== null) {
+			this.handleModalInput(data);
+			return;
+		}
+
+		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
+			state.done({ confirmed: false, templates: [], behaviorOverrides: [] });
+			return;
+		}
+
+		if (matchesKey(data, "return")) {
+			const overrides: (BehaviorOverride | undefined)[] = [];
+			for (let i = 0; i < state.agentConfigs.length; i++) {
+				overrides.push(state.behaviorOverrides.get(i));
+			}
+			state.done({
+				confirmed: true,
+				templates: state.templates,
+				behaviorOverrides: overrides,
+				runInBackground: state.runInBackground,
+			});
+			return;
+		}
+
+		if (matchesKey(data, "up")) {
+			state.selectedStep = Math.max(0, state.selectedStep - 1);
+			state.tui.requestRender();
+			return;
+		}
+
+		if (matchesKey(data, "down")) {
+			const maxStep = Math.max(0, state.agentConfigs.length - 1);
+			state.selectedStep = Math.min(maxStep, state.selectedStep + 1);
+			state.tui.requestRender();
+			return;
+		}
+
+		this.handleMainShortcut(data);
+	}
+
+	private handleModalInput(data: string): void {
+		const state = this.state;
+		if (state.editMode === "model") {
+			handleModelSelectorInput(state, data);
+		} else if (state.editMode === "thinking") {
+			handleThinkingSelectorInput(state, data);
+		} else if (state.editMode === "skills") {
+			handleSkillSelectorInput(state, data);
+		} else {
+			handleEditInput(state, data);
+		}
+	}
+
+	private handleMainShortcut(data: string): void {
+		const state = this.state;
+		if (data === "e") {
+			enterEditMode(state, "template");
+			return;
+		}
+
+		if (data === "m") {
+			enterModelSelector(state);
+			return;
+		}
+
+		if (data === "t") {
+			enterThinkingSelector(state);
+			return;
+		}
+
+		if (data === "s") {
+			enterSkillSelector(state);
+			return;
+		}
+
+		if (data === "w" && state.mode !== "parallel") {
+			enterEditMode(state, "output");
+			return;
+		}
+
+		if (data === "r" && state.mode === "chain") {
+			enterEditMode(state, "reads");
+			return;
+		}
+
+		if (data === "p" && state.mode === "chain") {
+			this.toggleProgressForAllSteps();
+			return;
+		}
+
+		if (data === "b") {
+			state.runInBackground = !state.runInBackground;
+			state.tui.requestRender();
+		}
+	}
+
+	private toggleProgressForAllSteps(): void {
+		const state = this.state;
+		const anyEnabled = state.agentConfigs.some((_, i) => {
+			const override = state.behaviorOverrides.get(i);
+			const base = state.resolvedBehaviors[i]!;
+			return override?.progress !== undefined ? override.progress : base.progress;
+		});
+		const newState = !anyEnabled;
+		for (let i = 0; i < state.agentConfigs.length; i++) {
+			updateBehavior(state, i, "progress", newState);
+		}
+		state.tui.requestRender();
+	}
+
+	render(_width: number): string[] {
+		const state = this.state;
+		if (state.editingStep !== null) {
+			return this.renderModal();
+		}
+
+		switch (state.mode) {
+			case "single":
+				return renderSingleMode(state);
+			case "parallel":
+				return renderParallelMode(state);
+			case "chain":
+				return renderChainMode(state);
+		}
+	}
+
+	private renderModal(): string[] {
+		const state = this.state;
+		switch (state.editMode) {
+			case "model":
+				return renderModelSelector(state);
+			case "thinking":
+				return renderThinkingSelector(state);
+			case "skills":
+				return renderSkillSelector(state);
+			case "template":
+			case "output":
+			case "reads":
+				return renderFullEditMode(state);
+		}
+	}
+
+	invalidate(): void {}
+
+	dispose(): void {
+		disposeNoticeTimer(this.state);
+	}
+}

package/dist/builtin/subagents/src/runs/foreground/chain-clarify-edit.ts

@@ -0,0 +1,97 @@
+import { matchesKey } from "@earendil-works/pi-tui";
+import { getCursorDisplayPos, handleEditorInput, wrapText } from "./chain-clarify-editor.ts";
+import { getEffectiveBehavior, propagateOutputChange, updateBehavior } from "./chain-clarify-behavior.ts";
+import { EDIT_VIEWPORT_HEIGHT, exitEditMode, type ChainClarifyState } from "./chain-clarify-state.ts";
+import type { EditMode } from "./chain-clarify-types.ts";
+
+export function enterEditMode(state: ChainClarifyState, mode: EditMode): void {
+	state.editingStep = state.selectedStep;
+	state.editMode = mode;
+	let buffer = "";
+
+	if (mode === "template") {
+		const template = state.templates[state.selectedStep] ?? "";
+		buffer = template.split("\n")[0] ?? "";
+	} else if (mode === "output") {
+		const behavior = getEffectiveBehavior(state, state.selectedStep);
+		buffer = behavior.output === false ? "" : (behavior.output || "");
+	} else if (mode === "reads") {
+		const behavior = getEffectiveBehavior(state, state.selectedStep);
+		buffer = behavior.reads === false ? "" : (behavior.reads?.join(", ") || "");
+	}
+
+	state.editState = { buffer, cursor: 0, viewportOffset: 0 };
+	state.tui.requestRender();
+}
+
+export function handleEditInput(state: ChainClarifyState, data: string): void {
+	const textWidth = state.width - 4;
+	if (matchesKey(data, "shift+up") || matchesKey(data, "pageUp")) {
+		const { lines: wrapped, starts } = wrapText(state.editState.buffer, textWidth);
+		const cursorPos = getCursorDisplayPos(state.editState.cursor, starts);
+		const targetLine = Math.max(0, cursorPos.line - EDIT_VIEWPORT_HEIGHT);
+		const targetCol = Math.min(cursorPos.col, wrapped[targetLine]?.length ?? 0);
+		state.editState = { ...state.editState, cursor: starts[targetLine]! + targetCol };
+		state.tui.requestRender();
+		return;
+	}
+
+	if (matchesKey(data, "shift+down") || matchesKey(data, "pageDown")) {
+		const { lines: wrapped, starts } = wrapText(state.editState.buffer, textWidth);
+		const cursorPos = getCursorDisplayPos(state.editState.cursor, starts);
+		const targetLine = Math.min(wrapped.length - 1, cursorPos.line + EDIT_VIEWPORT_HEIGHT);
+		const targetCol = Math.min(cursorPos.col, wrapped[targetLine]?.length ?? 0);
+		state.editState = { ...state.editState, cursor: starts[targetLine]! + targetCol };
+		state.tui.requestRender();
+		return;
+	}
+
+	if (matchesKey(data, "tab")) return;
+
+	const nextState = handleEditorInput(state.editState, data, textWidth);
+	if (nextState) {
+		state.editState = nextState;
+		state.tui.requestRender();
+		return;
+	}
+
+	if (matchesKey(data, "escape")) {
+		saveEdit(state);
+		exitEditMode(state);
+		return;
+	}
+
+	if (matchesKey(data, "ctrl+c")) {
+		exitEditMode(state);
+		return;
+	}
+}
+
+function saveEdit(state: ChainClarifyState): void {
+	const stepIndex = state.editingStep!;
+
+	if (state.editMode === "template") {
+		const original = state.templates[stepIndex] ?? "";
+		const originalLines = original.split("\n");
+		originalLines[0] = state.editState.buffer;
+		state.templates[stepIndex] = originalLines.join("\n");
+	} else if (state.editMode === "output") {
+		const oldBehavior = getEffectiveBehavior(state, stepIndex);
+		const oldOutput = typeof oldBehavior.output === "string" ? oldBehavior.output : null;
+		const trimmed = state.editState.buffer.trim();
+		const newOutput = trimmed === "" ? false : trimmed;
+		updateBehavior(state, stepIndex, "output", newOutput);
+
+		if (oldOutput && typeof newOutput === "string" && oldOutput !== newOutput) {
+			propagateOutputChange(state, stepIndex, oldOutput, newOutput);
+		}
+	} else if (state.editMode === "reads") {
+		const trimmed = state.editState.buffer.trim();
+		if (trimmed === "") {
+			updateBehavior(state, stepIndex, "reads", false);
+		} else {
+			const files = trimmed.split(",").map((f) => f.trim()).filter((f) => f !== "");
+			updateBehavior(state, stepIndex, "reads", files.length > 0 ? files : false);
+		}
+	}
+}

package/dist/builtin/subagents/src/runs/foreground/chain-clarify-editor.ts

@@ -0,0 +1,160 @@
+import { matchesKey, visibleWidth } from "@earendil-works/pi-tui";
+
+export interface TextEditorState {
+	buffer: string;
+	cursor: number;
+	viewportOffset: number;
+}
+
+export function createEditorState(initial = ""): TextEditorState {
+	return { buffer: initial, cursor: 0, viewportOffset: 0 };
+}
+
+export function wrapText(text: string, width: number): { lines: string[]; starts: number[] } {
+	if (width <= 0) return { lines: [text], starts: [0] };
+	if (text.length === 0) return { lines: [""], starts: [0] };
+
+	const lines: string[] = [];
+	const starts: number[] = [];
+	let offset = 0;
+	const segments = text.split("\n");
+	for (const [index, segment] of segments.entries()) {
+		if (segment.length === 0) {
+			starts.push(offset);
+			lines.push("");
+		} else {
+			let lineStart = 0;
+			let pos = 0;
+			let lineWidth = 0;
+			while (pos < segment.length) {
+				const char = String.fromCodePoint(segment.codePointAt(pos)!);
+				const charWidth = visibleWidth(char);
+				if (lineWidth > 0 && lineWidth + charWidth > width) {
+					starts.push(offset + lineStart);
+					lines.push(segment.slice(lineStart, pos));
+					lineStart = pos;
+					lineWidth = 0;
+					continue;
+				}
+				pos += char.length;
+				lineWidth += charWidth;
+			}
+			starts.push(offset + lineStart);
+			lines.push(segment.slice(lineStart));
+		}
+		offset += segment.length + (index < segments.length - 1 ? 1 : 0);
+	}
+	if (!text.endsWith("\n") && text.length > 0 && visibleWidth(lines[lines.length - 1] ?? "") === width) {
+		starts.push(text.length);
+		lines.push("");
+	}
+	return { lines, starts };
+}
+
+export function getCursorDisplayPos(cursor: number, starts: number[]): { line: number; col: number } {
+	for (let i = starts.length - 1; i >= 0; i--) {
+		if (cursor >= starts[i]!) return { line: i, col: cursor - starts[i]! };
+	}
+	return { line: 0, col: 0 };
+}
+
+export function ensureCursorVisible(cursorLine: number, viewportHeight: number, currentOffset: number): number {
+	if (cursorLine < currentOffset) return Math.max(0, cursorLine);
+	if (cursorLine >= currentOffset + viewportHeight) return Math.max(0, cursorLine - viewportHeight + 1);
+	return Math.max(0, currentOffset);
+}
+
+function isWordChar(ch: string): boolean {
+	const code = ch.charCodeAt(0);
+	return (code >= 48 && code <= 57) || (code >= 65 && code <= 90) || (code >= 97 && code <= 122) || code === 95;
+}
+
+function wordBackward(buffer: string, cursor: number): number {
+	let pos = cursor;
+	while (pos > 0 && !isWordChar(buffer[pos - 1]!)) pos--;
+	while (pos > 0 && isWordChar(buffer[pos - 1]!)) pos--;
+	return pos;
+}
+
+function wordForward(buffer: string, cursor: number): number {
+	let pos = cursor;
+	while (pos < buffer.length && isWordChar(buffer[pos]!)) pos++;
+	while (pos < buffer.length && !isWordChar(buffer[pos]!)) pos++;
+	return pos;
+}
+
+function normalizeInsertText(data: string): string | null {
+	let text = data.split("\x1b[200~").join("").split("\x1b[201~").join("");
+	text = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+	const newline = text.indexOf("\n");
+	if (newline !== -1) text = text.slice(0, newline);
+	text = text.replace(/\t/g, "    ");
+	if (text.length === 0) return null;
+	for (let i = 0; i < text.length; i++) {
+		if (text.charCodeAt(i) < 32) return null;
+	}
+	return text;
+}
+
+export function handleEditorInput(state: TextEditorState, data: string, textWidth: number): TextEditorState | null {
+	if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c") || matchesKey(data, "return")) return null;
+
+	const { lines: wrapped, starts } = wrapText(state.buffer, textWidth);
+	const cursorPos = getCursorDisplayPos(state.cursor, starts);
+
+	if (matchesKey(data, "alt+left") || matchesKey(data, "ctrl+left")) return { ...state, cursor: wordBackward(state.buffer, state.cursor) };
+	if (matchesKey(data, "alt+right") || matchesKey(data, "ctrl+right")) return { ...state, cursor: wordForward(state.buffer, state.cursor) };
+	if (matchesKey(data, "left")) return state.cursor > 0 ? { ...state, cursor: state.cursor - 1 } : state;
+	if (matchesKey(data, "right")) return state.cursor < state.buffer.length ? { ...state, cursor: state.cursor + 1 } : state;
+	if (matchesKey(data, "up") && cursorPos.line > 0) {
+		const targetLine = cursorPos.line - 1;
+		return { ...state, cursor: starts[targetLine]! + Math.min(cursorPos.col, wrapped[targetLine]?.length ?? 0) };
+	}
+	if (matchesKey(data, "down") && cursorPos.line < wrapped.length - 1) {
+		const targetLine = cursorPos.line + 1;
+		return { ...state, cursor: starts[targetLine]! + Math.min(cursorPos.col, wrapped[targetLine]?.length ?? 0) };
+	}
+	if (matchesKey(data, "home")) return { ...state, cursor: starts[cursorPos.line]! };
+	if (matchesKey(data, "end")) return { ...state, cursor: starts[cursorPos.line]! + (wrapped[cursorPos.line]?.length ?? 0) };
+	if (matchesKey(data, "ctrl+home")) return { ...state, cursor: 0 };
+	if (matchesKey(data, "ctrl+end")) return { ...state, cursor: state.buffer.length };
+	if (matchesKey(data, "alt+backspace")) {
+		const target = wordBackward(state.buffer, state.cursor);
+		return target === state.cursor ? state : { ...state, buffer: state.buffer.slice(0, target) + state.buffer.slice(state.cursor), cursor: target };
+	}
+	if (matchesKey(data, "backspace")) {
+		return state.cursor > 0
+			? { ...state, buffer: state.buffer.slice(0, state.cursor - 1) + state.buffer.slice(state.cursor), cursor: state.cursor - 1 }
+			: state;
+	}
+	if (matchesKey(data, "delete")) {
+		return state.cursor < state.buffer.length
+			? { ...state, buffer: state.buffer.slice(0, state.cursor) + state.buffer.slice(state.cursor + 1) }
+			: state;
+	}
+
+	const insert = normalizeInsertText(data);
+	return insert
+		? { ...state, buffer: state.buffer.slice(0, state.cursor) + insert + state.buffer.slice(state.cursor), cursor: state.cursor + insert.length }
+		: null;
+}
+
+function renderWithCursor(text: string, cursorPos: number): string {
+	const before = text.slice(0, cursorPos);
+	const cursorChar = text[cursorPos] ?? " ";
+	const after = text.slice(cursorPos + 1);
+	return `${before}\x1b[7m${cursorChar}\x1b[27m${after}`;
+}
+
+export function renderEditor(state: TextEditorState, width: number, viewportHeight: number): string[] {
+	const { lines: wrapped, starts } = wrapText(state.buffer, width);
+	const cursorPos = getCursorDisplayPos(state.cursor, starts);
+	const lines: string[] = [];
+	for (let i = 0; i < viewportHeight; i++) {
+		const lineIdx = state.viewportOffset + i;
+		let content = lineIdx < wrapped.length ? wrapped[lineIdx] ?? "" : "";
+		if (lineIdx === cursorPos.line) content = renderWithCursor(content, cursorPos.col);
+		lines.push(content);
+	}
+	return lines;
+}

package/dist/builtin/subagents/src/runs/foreground/chain-clarify-frame.ts

@@ -0,0 +1,72 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { disposeNoticeTimer, type ChainClarifyState } from "./chain-clarify-state.ts";
+
+export function padVisible(s: string, len: number): string {
+	const vis = visibleWidth(s);
+	return s + " ".repeat(Math.max(0, len - vis));
+}
+
+export function row(state: ChainClarifyState, content: string): string {
+	const innerW = state.width - 2;
+	return state.theme.fg("border", "│") + padVisible(content, innerW) + state.theme.fg("border", "│");
+}
+
+export function renderHeader(state: ChainClarifyState, text: string): string {
+	const innerW = state.width - 2;
+	const padLen = Math.max(0, innerW - visibleWidth(text));
+	const padLeft = Math.floor(padLen / 2);
+	const padRight = padLen - padLeft;
+	return (
+		state.theme.fg("border", "╭" + "─".repeat(padLeft)) +
+		state.theme.fg("accent", text) +
+		state.theme.fg("border", "─".repeat(padRight) + "╮")
+	);
+}
+
+export function renderFooter(state: ChainClarifyState, text: string): string {
+	const innerW = state.width - 2;
+	const padLen = Math.max(0, innerW - visibleWidth(text));
+	const padLeft = Math.floor(padLen / 2);
+	const padRight = padLen - padLeft;
+	return (
+		state.theme.fg("border", "╰" + "─".repeat(padLeft)) +
+		state.theme.fg("dim", text) +
+		state.theme.fg("border", "─".repeat(padRight) + "╯")
+	);
+}
+
+export function getStepLabel(state: ChainClarifyState, stepIndex: number): string {
+	const agentName = state.agentConfigs[stepIndex]?.name ?? "unknown";
+	if (state.mode === "single") return agentName;
+	if (state.mode === "parallel") return `Task ${stepIndex + 1}: ${agentName}`;
+	return `Step ${stepIndex + 1}: ${agentName}`;
+}
+
+export function getFooterText(state: ChainClarifyState): string {
+	const bgLabel = state.runInBackground ? "[b]g:ON" : "[b]g";
+	switch (state.mode) {
+		case "single":
+			return ` [Enter] Run • [Esc] Cancel • e m t w s ${bgLabel} `;
+		case "parallel":
+			return ` [Enter] Run • [Esc] Cancel • e m t s ${bgLabel} • ↑↓ Nav `;
+		case "chain":
+			return ` [Enter] Run • [Esc] Cancel • e m t w r p s ${bgLabel} • ↑↓ Nav `;
+	}
+}
+
+export function appendNotice(state: ChainClarifyState, lines: string[]): void {
+	if (!state.noticeMessage) return;
+	const color = state.noticeMessage.type === "error" ? "error" : "success";
+	lines.push(row(state, ` ${state.theme.fg(color, state.noticeMessage.text)}`));
+}
+
+export function showNotice(state: ChainClarifyState, text: string, type: "info" | "error"): void {
+	state.noticeMessage = { text, type };
+	disposeNoticeTimer(state);
+	state.noticeMessageTimer = setTimeout(() => {
+		state.noticeMessage = null;
+		state.noticeMessageTimer = null;
+		state.tui.requestRender();
+	}, 2000);
+	state.tui.requestRender();
+}