@fitchmultz/pi-subagents 0.44.7 → 0.45.0

package/dist/tui/agent-history.js

@@ -1,197 +1,64 @@
-import { stripTerminalSequences } from "@earendil-works/pi-tui";
 import { stripAcceptanceReport } from "../runs/shared/acceptance-reports.js";
-import { extractToolArgsPreview } from "../shared/utils.js";
-export function readableText(value) {
-    return stripTerminalSequences(typeof value === "string" ? value : JSON.stringify(value, null, 2) ?? "");
-}
-function contentText(content) {
-    if (typeof content === "string")
-        return readableText(content);
-    if (!Array.isArray(content))
-        return readableText(content);
-    return content.map((part) => part.type === "text" ? readableText(part.text)
-        : part.type === "thinking" ? readableText(part.thinking)
-            : part.type === "image" ? `[Image: ${part.mimeType ?? "image"}]` : "").filter(Boolean).join("\n");
-}
-function resultDisplay(result, call) {
-    const details = result.details;
-    return { text: contentText(result.content), diff: typeof details?.diff === "string" ? readableText(details.diff) : undefined,
-        details: readableText({ ...(call ? { call } : {}), result }) };
-}
-/** Keep reading/delivery facts eager; format bodies and raw tool details only when displayed. */
-function historyItem(facts, format) {
-    let display;
-    return {
-        ...facts,
-        get title() { return (display ??= format()).title; },
-        get text() { return (display ??= format()).text; },
-        get details() { return (display ??= format()).details; },
-        get diff() { return (display ??= format()).diff; },
-    };
-}
-/** Read the native entries, not a compacted model context: earlier messages remain inspectable. */
+import { displayHistory } from "./history-display.js";
+import { readableText } from "./history-text.js";
+export { readableText } from "./history-text.js";
+export { indexedHistory } from "./indexed-history.js";
+/** Read native entries, not a compacted model context: earlier messages remain inspectable. */
 export function historyItems(entries) {
-    const items = [], entryIds = [];
-    const calls = new Map();
-    const append = (item) => { items.push(item); entryIds.push(item.id); };
+    const visible = [];
     for (const entry of entries) {
-        const base = { id: entry.id, timestamp: Date.parse(entry.timestamp) };
-        if (entry.type === "custom_message") {
-            const details = entry.details;
-            const human = entry.customType === "subagent-human-message";
-            append(historyItem({ ...base, kind: human ? "user" : "notice", ...(human ? { messageId: details?.message?.id } : {}) }, () => ({ title: human ? "User · delivered to conversation" : details?.from?.name ? `From ${details.from.name}` : entry.customType, text: contentText(details?.bodyText ?? entry.content) })));
-        }
-        else if (entry.type === "compaction") {
-            append(historyItem({ ...base, kind: "notice" }, () => ({ title: "Context summary · earlier history retained above", text: readableText(entry.summary) })));
-        }
-        else if (entry.type === "branch_summary") {
-            append(historyItem({ ...base, kind: "notice" }, () => ({ title: "Branch summary", text: readableText(entry.summary) })));
-        }
-        else if (entry.type === "message") {
-            const message = entry.message;
-            if (message.role === "assistant") {
-                const model = message.model ? (message.provider ? `${message.provider}/${message.model}` : message.model) : undefined;
-                const messageIds = message.content.flatMap((part, index) => part.type === "text" && part.text || part.type === "thinking" && part.thinking ? [`${entry.id}:${index}`] : []);
-                if (messageIds.length)
-                    items.push(historyItem({ ...base, id: messageIds[0], entryIds: messageIds,
-                        kind: message.content.some((part) => part.type === "text" && part.text) ? "assistant" : "thinking",
-                        assistant: message, model }, () => ({ title: "Agent", text: contentText(message.content) })));
-                for (const [index, part] of message.content.entries()) {
-                    const id = `${entry.id}:${index}`;
-                    if (part.type === "toolCall") {
-                        const item = historyItem({ ...base, id, entryIds: [id], kind: "tool", call: part, model }, () => ({
-                            title: `${part.name} ${extractToolArgsPreview(part.arguments ?? {})}`.trim() + (item.result ? ` · ${item.result.isError ? "failed" : "result recorded"}` : " · result not recorded"),
-                            ...(item.result ? resultDisplay(item.result, part) : {
-                                text: readableText(part.arguments),
-                                details: `${readableText(part)}\n\nCommand result not recorded; exit is unconfirmed. An agent pause or exit does not prove that a command or its descendants exited.`,
-                            }),
-                        }));
-                        append(item);
-                        calls.set(part.id, item);
-                    }
-                    else if (messageIds.includes(id))
-                        entryIds.push(id);
-                }
-                if (message.errorMessage) {
-                    const id = `${entry.id}:error`;
-                    if (messageIds.length && !message.content.some((part) => part.type === "toolCall") && ["error", "aborted"].includes(message.stopReason)) {
-                        messageIds.push(id);
-                        entryIds.push(id);
-                    }
-                    else
-                        append(historyItem({ ...base, id, kind: "notice", model }, () => ({ title: "Agent error", text: readableText(message.errorMessage) })));
-                }
-            }
-            else if (message.role === "user") {
-                append(historyItem({ ...base, kind: "user" }, () => ({ title: "User / assignment", text: contentText(message.content) })));
-            }
-            else if (message.role === "toolResult") {
-                const call = calls.get(message.toolCallId);
-                if (call) {
-                    call.result = message;
-                    call.entryIds.push(entry.id);
-                    entryIds.push(entry.id);
-                }
-                else
-                    append(historyItem({ ...base, result: message, kind: "result" }, () => ({
-                        title: `${message.toolName} · call not recorded`, ...resultDisplay(message),
-                    })));
-            }
-            else if (message.role === "bashExecution") {
-                append(historyItem({ ...base, kind: "tool" }, () => ({ title: `Shell: ${readableText(message.command)}`, text: `${readableText(message.output)}\n${typeof message.exitCode === "number" ? `Shell exit code: ${message.exitCode}` : "Shell exit code not recorded"}${message.cancelled ? " · cancelled" : ""}`, details: readableText({ command: message.command, exitCode: message.exitCode, cancelled: message.cancelled }) })));
-            }
+        if (entry.type === "message" ||
+            entry.type === "custom_message" ||
+            entry.type === "compaction" ||
+            entry.type === "branch_summary") {
+            visible.push(entry.type === "message" ? { ...entry, native: entry.message } : entry);
         }
     }
-    let finalResults;
-    return { items, entryIds, findFinalResult(text) {
-            // Continuations can share a large journal. Index exact, sanitized matches once,
-            // retaining the latest assistant ID just as findLast does.
-            if (!finalResults) {
-                finalResults = new Map();
-                for (const item of items)
-                    if (item.kind === "assistant") {
-                        finalResults.set(stripAcceptanceReport(item.text).trim(), item.id);
-                        for (const part of item.assistant?.content ?? [])
-                            if (part.type === "text")
-                                finalResults.set(stripAcceptanceReport(readableText(part.text)).trim(), item.id);
-                    }
-            }
-            return finalResults.get(text);
-        } };
+    return displayHistory(visible);
+}
+function finalMatch(history, text) {
+    if (history.finalId !== undefined) {
+        return history.finalId;
+    }
+    if (history.findFinalResult) {
+        return history.findFinalResult(text);
+    }
+    return history.items.findLast((item) => item.kind === "assistant" &&
+        (stripAcceptanceReport(item.text).trim() === text ||
+            item.assistant?.content.some((part) => part.type === "text" && stripAcceptanceReport(readableText(part.text)).trim() === text) === true))?.id;
 }
 /** Canonical run output is already validated; never decode arbitrary tool JSON to find an answer. */
 export function withFinalResult(history, output, runId, timestamp) {
     const text = readableText(output).trim();
-    if (!text)
+    if (text.length === 0) {
         return history;
-    const matched = history.finalId ?? (history.findFinalResult ? history.findFinalResult(text) : history.items.findLast((item) => item.kind === "assistant" && (stripAcceptanceReport(item.text).trim() === text
-        || item.assistant?.content.some((part) => part.type === "text" && stripAcceptanceReport(readableText(part.text)).trim() === text)))?.id);
+    }
+    const matched = finalMatch(history, text);
     const existing = history.items.some((item) => item.id === matched) ? matched : undefined;
     const id = `result:${runId}`;
     let items;
-    return { get items() { return items ??= existing ? history.items.map((item) => item.id === existing ? { ...item, assistant: undefined, text } : item) : [...history.items, { id, kind: "assistant", title: "Saved result", text, timestamp }]; },
-        entryIds: existing ? history.entryIds : [...history.entryIds, id], finalId: existing ?? id,
-        findFinalResult: existing ? history.findFinalResult : (value) => value === text ? id : history.findFinalResult?.(value),
-        deliveredMessages: existing ? history.deliveredMessages : history.deliveredMessages && new Map([...history.deliveredMessages.keys()].map((id) => [id, true])),
-        configuration: history.configuration, get unavailable() { return history.unavailable; } };
-}
-/** A page retains only bounded previews; full selected records are validated by the process. */
-export async function indexedHistory(index, input) {
-    const page = await index.historyPage(input);
-    const entries = new Map(page.entries.map((entry) => [entry.id, entry]));
-    const boundary = { terminalEntryId: input.terminalEntryId, endedAt: input.endedAt };
-    if (input.terminalEntryId && page.terminalSequence === undefined)
-        throw new Error("Saved terminal entry is unavailable; retry history.");
-    const inBoundary = (entry) => (page.terminalSequence === undefined || entry.sequence <= page.terminalSequence) && (input.endedAt === undefined || (entry.timestamp ?? Infinity) <= input.endedAt);
-    const tools = new Map();
-    for (const entry of page.entries) {
-        const message = entry.entry.message;
-        if (message?.role === "assistant")
-            for (const part of message.content ?? []) {
-                if (part.type === "toolCall")
-                    tools.set(part.id, { ...tools.get(part.id), call: entry });
-            }
-        else if (message?.role === "toolResult")
-            tools.set(message.toolCallId, { ...tools.get(message.toolCallId), result: entry });
-    }
-    // Resolve only tools on this page, not the rest of the conversation. Adjacent-page
-    // pairing preserves physical reading order and never becomes completion evidence.
-    for (const entry of page.entries) {
-        const message = entry.entry.message;
-        const pairs = message?.role === "assistant" ? (message.content ?? []).filter((part) => part.type === "toolCall").map((part) => ({ toolCallId: part.id, kind: "result" }))
-            : message?.role === "toolResult" ? [{ toolCallId: message.toolCallId, kind: "call" }] : [];
-        for (const pair of pairs) {
-            const paired = tools.get(pair.toolCallId)?.[pair.kind] ?? await index.entry({ runId: input.runId, index: input.index, ...pair, ...boundary, signal: input.signal });
-            if (paired && inBoundary(paired))
-                entries.set(paired.id, paired);
-        }
-    }
-    const history = historyItems([...entries.values()].sort((a, b) => a.sequence - b.sequence).map((entry) => entry.entry));
-    const visible = new Set(page.entries.map((entry) => entry.id));
-    history.items = history.items.filter((item) => (item.entryIds ?? [item.id]).some((id) => visible.has(id.split(":")[0])));
-    // Only page-local IDs advance the read marker; paired records can live elsewhere.
-    history.entryIds = history.entryIds.filter((id) => visible.has(id.split(":")[0]));
-    history.unavailable = page.unavailable;
-    history.configuration = page.configuration;
-    history.deliveredMessages = new Map(page.deliveredMessages);
-    history.finalId = page.finalResultId;
-    for (const item of history.items)
-        item.load = async () => {
-            const ids = new Set((item.entryIds ?? [item.id]).map((id) => id.split(":")[0]));
-            const full = [];
-            for (const id of ids) {
-                const entry = entries.get(id);
-                if (!entry)
-                    throw new Error("Selected native entry is unavailable; retry history.");
-                const record = await index.record({ runId: input.runId, index: input.index, ref: entry.ref, ...boundary, signal: input.signal });
-                if (!record)
-                    throw new Error("Selected native entry is unavailable; retry history.");
-                full.push({ ...record, id });
-            }
-            const detail = historyItems(full).items.find((candidate) => candidate.id === item.id);
-            if (!detail)
-                throw new Error("Selected native entry is unavailable; retry history.");
-            return detail;
-        };
-    return { history, page };
+    return {
+        get items() {
+            items ??=
+                existing !== undefined
+                    ? history.items.map((item) => item.id === existing
+                        ? { ...item, assistant: undefined, previewAssistant: undefined, text }
+                        : item)
+                    : [...history.items, { id, kind: "assistant", title: "Saved result", text, timestamp }];
+            return items;
+        },
+        entryIds: existing !== undefined ? history.entryIds : [...history.entryIds, id],
+        finalId: existing ?? id,
+        findFinalResult: existing !== undefined
+            ? history.findFinalResult
+            : (value) => (value === text ? id : history.findFinalResult?.(value)),
+        deliveredMessages: existing !== undefined
+            ? history.deliveredMessages
+            : history.deliveredMessages &&
+                new Map([...history.deliveredMessages.keys()].map((messageId) => [messageId, true])),
+        configuration: history.configuration,
+        get unavailable() {
+            return history.unavailable;
+        },
+    };
 }

package/dist/tui/agent-model.js

@@ -0,0 +1,62 @@
+import { formatModelThinking } from "../shared/formatters.js";
+import { readableText } from "./agent-history.js";
+import { hasText } from "./text-values.js";
+export const unavailableModel = {
+    summary: "model unavailable",
+    details: "Model unavailable. No provider/model was recorded for this assignment.",
+};
+function recordedModel(child, native) {
+    if (child.state === "live") {
+        return native;
+    }
+    const saved = child.savedConfiguration ?? child.launch;
+    return hasText(native?.model) ? { ...saved, ...native } : saved;
+}
+function fallbackModel(child, native) {
+    if (child.state === "live" && hasText(native?.model)) {
+        return native;
+    }
+    return hasText(child.launch?.model) ? child.launch : child.result;
+}
+function savedModelIsCurrent(child, recorded) {
+    const selected = child.modelSelection;
+    if (selected?.modelStartedAt === undefined) {
+        return child.state !== "live";
+    }
+    return (recorded.modelRecordedAt ?? 0) > selected.modelStartedAt;
+}
+function modelSelection(child, native) {
+    const recorded = recordedModel(child, native), selected = child.modelSelection;
+    if (hasText(recorded?.model) && savedModelIsCurrent(child, recorded)) {
+        return { value: recorded, source: child.state === "live" ? "session" : "saved" };
+    }
+    return hasText(selected?.model)
+        ? { value: selected, source: "selected" }
+        : { value: fallbackModel(child, native), source: "saved" };
+}
+function formattedModel(value) {
+    return hasText(value?.model)
+        ? readableText(formatModelThinking(value.model, value.thinking))
+        : undefined;
+}
+export function agentModel(child, native) {
+    if (child.identityUnavailable === true) {
+        return unavailableModel;
+    }
+    const selection = modelSelection(child, native), formatted = formattedModel(selection.value);
+    if (formatted === undefined) {
+        return unavailableModel;
+    }
+    const selected = formattedModel(child.modelSelection), saved = formattedModel(native);
+    const details = [`Model (${selection.source}): ${formatted}`];
+    if (selected !== undefined && selected !== formatted) {
+        details.push(`Selected model: ${selected}`);
+    }
+    if (child.state === "live" && saved !== undefined && saved !== formatted) {
+        details.push(`Last saved session model (may precede this attempt): ${saved}`);
+    }
+    return {
+        summary: selection.source === "session" ? formatted : `${selection.source}: ${formatted}`,
+        details: details.join("\n"),
+    };
+}

package/dist/tui/agent-picker.js

@@ -0,0 +1,262 @@
+import { hasText, errorText } from "./text-values.js";
+import { DynamicBorder, getSelectListTheme } from "@earendil-works/pi-coding-agent";
+import { Box, Container, Input, SelectList, Spacer, Text, getKeybindings, matchesKey, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
+import { readableText } from "./agent-history.js";
+import { actionHints } from "./action-hints.js";
+import { short, activity, primaryKey } from "./view-model.js";
+import { pickerPage } from "./picker-page.js";
+export class AgentPicker extends Container {
+    list;
+    itemKeys = [];
+    closed = false;
+    search;
+    signature = "";
+    wasPending = false;
+    retryError;
+    hasFocus = false;
+    tui;
+    theme;
+    controller;
+    done;
+    constructor(tui, theme, controller, done) {
+        super();
+        this.tui = tui;
+        this.theme = theme;
+        this.controller = controller;
+        this.done = done;
+        this.search = new Input({
+            placeholder: "Filter agents or assignments…",
+            placeholderStyle: (text) => theme.fg("dim", text),
+        });
+        this.search.setValue(controller.listFilter);
+        this.render(tui.terminal.columns);
+    }
+    get focused() {
+        return this.hasFocus;
+    }
+    set focused(value) {
+        this.hasFocus = value;
+        this.search.focused = value;
+    }
+    refresh() {
+        this.tui.requestRender();
+    }
+    retry() {
+        this.retryError = undefined;
+        this.controller.retry().catch((error) => {
+            if (!this.closed) {
+                this.retryError = errorText(error);
+                this.tui.requestRender();
+            }
+        });
+    }
+    header(page, width, compact) {
+        const header = new Container(), list = this.controller.listPage;
+        header.addChild(new Text(this.theme.fg("accent", this.theme.bold(truncateToWidth(`Agents · ${list?.total ?? "…"} owned runs · page ${Math.floor((list?.offset ?? 0) / 50) + 1}`, width))), 0, 0));
+        header.addChild(this.search);
+        const status = this.retryError ?? page.status;
+        if (hasText(status)) {
+            header.addChild(new Text(this.theme.fg(hasText(this.controller.listError) || this.retryError !== undefined ? "warning" : "dim", truncateToWidth(status, width)), 0, 0));
+        }
+        if (!compact) {
+            header.addChild(new Spacer(1));
+        }
+        return header;
+    }
+    controls(width, compact) {
+        const up = primaryKey("tui.select.up"), down = primaryKey("tui.select.down");
+        const choose = [
+            { text: up, run: () => this.act("up") },
+            hasText(up) && hasText(down) ? "/" : "",
+            { text: `${down}${compact ? "" : " Choose"}`, run: () => this.act("down") },
+        ];
+        const open = {
+            text: `${primaryKey("tui.select.confirm")}${compact ? "" : " Open"}`.trim(),
+            run: () => this.act("open"),
+        };
+        const back = {
+            text: `${primaryKey("tui.select.cancel")}${compact ? "" : " Back"}`.trim(),
+            run: () => this.act("back"),
+        };
+        const filter = { text: "Type to filter", run: () => this.act("filter") };
+        if (compact) {
+            return actionHints([...choose, " · ", open, " · ", back], (text) => this.theme.fg("dim", text));
+        }
+        const controls = width < 60
+            ? [...choose, " · ", open, "\n", back, " · ", filter]
+            : [filter, " · ", ...choose, " · ", open, " · ", back];
+        return actionHints(controls, (text) => this.theme.fg("dim", text));
+    }
+    footer(page, width, compact) {
+        const footer = new Container();
+        if (!compact) {
+            footer.addChild(new Spacer(1));
+        }
+        const task = page.task;
+        if (task && !compact) {
+            footer.addChild(new Text(this.theme.fg("muted", short(`${task.child.agent} · ${activity(task)} · ${task.run.runId.slice(0, 8)}`, width)), 0, 0));
+            footer.addChild(new Text(this.theme.fg("dim", short(task.model.summary, width)), 0, 0));
+            const assignment = new Text(readableText(task.child.task ?? "Original assignment unavailable."), 0, 0).render(width);
+            footer.addChild(new Text(assignment.slice(0, 3).join("\n"), 0, 0));
+        }
+        footer.addChild(this.controls(width + 2, compact));
+        return footer;
+    }
+    select(value) {
+        if (this.controller.listPending && !["retry", "peers"].includes(value)) {
+            return;
+        }
+        if (value === "next-page" || value === "previous-page") {
+            this.controller.pageTasks(value === "next-page" ? "later" : "earlier");
+        }
+        else if (value === "retry") {
+            this.retry();
+        }
+        else {
+            this.done(value);
+        }
+    }
+    selectList(page, width, visible) {
+        // Native SelectList needs more than ten cells to show its description column.
+        const descriptionWidth = width > 40
+            ? Math.max(11, ...page.items.map((item) => visibleWidth(item.description ?? "")))
+            : 0;
+        const primaryWidth = Math.max(1, width - descriptionWidth - (descriptionWidth > 0 ? 4 : 2));
+        const list = new SelectList([...page.items], visible, getSelectListTheme(), {
+            minPrimaryColumnWidth: Math.min(24, primaryWidth),
+            maxPrimaryColumnWidth: primaryWidth,
+            truncatePrimary: ({ text, maxWidth }) => truncateToWidth(text, maxWidth),
+        });
+        list.setSelectedIndex(page.selectedIndex);
+        list.onSelect = (item) => this.select(item.value);
+        list.onCancel = () => this.act("back");
+        return list;
+    }
+    layout(page, width, height) {
+        const innerWidth = Math.max(1, width - 2), compact = height < 16;
+        const header = this.header(page, innerWidth, compact), footer = this.footer(page, innerWidth, compact);
+        const visible = Math.max(1, height - 3 - header.render(innerWidth).length - footer.render(innerWidth).length);
+        this.list = this.selectList(page, innerWidth, visible);
+        const body = new Box(1, 0, (text) => this.theme.bg("customMessageBg", text));
+        body.addChild(header);
+        body.addChild(this.list);
+        body.addChild(footer);
+        this.clear();
+        this.addChild(new DynamicBorder((text) => this.theme.fg("borderAccent", text)));
+        this.addChild(body);
+        this.addChild(new DynamicBorder((text) => this.theme.fg("borderAccent", text)));
+    }
+    pageSignature(page, query, width, height) {
+        const task = page.task;
+        return JSON.stringify([
+            page.items,
+            query,
+            width,
+            height,
+            page.status,
+            this.retryError,
+            this.controller.listPage?.total,
+            page.items.at(page.selectedIndex)?.value,
+            task && activity(task),
+            task?.model,
+            task?.child.task,
+            task?.run.runId,
+        ]);
+    }
+    render(width) {
+        const height = this.controller.availableHeight(this.tui), query = this.search.getValue();
+        const selected = this.controller.listPending || this.wasPending
+            ? undefined
+            : this.list?.getSelectedItem()?.value;
+        this.wasPending = this.controller.listPending;
+        const page = pickerPage(this.controller, query, Math.max(1, width - 2), selected);
+        this.itemKeys = page.items.map((item) => item.value);
+        const signature = this.pageSignature(page, query, width, height);
+        if (signature !== this.signature) {
+            this.layout(page, width, height);
+            this.signature = signature;
+        }
+        return super.render(width);
+    }
+    invalidate() {
+        this.signature = "";
+        super.invalidate();
+    }
+    syncDraft() {
+        /* The picker has no conversation draft editor. */
+    }
+    move(delta) {
+        if (this.itemKeys.length === 0) {
+            return;
+        }
+        const index = this.itemKeys.indexOf(this.list?.getSelectedItem()?.value ?? "");
+        this.list?.setSelectedIndex((index + delta + this.itemKeys.length) % this.itemKeys.length);
+    }
+    act(action) {
+        if (this.closed) {
+            return;
+        }
+        switch (action) {
+            case "back":
+                this.done();
+                break;
+            case "filter":
+                this.tui.setFocus(this);
+                break;
+            case "open": {
+                const item = this.list?.getSelectedItem();
+                if (item) {
+                    this.select(item.value);
+                }
+                break;
+            }
+            case "up":
+                this.move(-1);
+                break;
+            case "down":
+                this.move(1);
+                break;
+        }
+        this.tui.requestRender();
+    }
+    listInput(data) {
+        const keys = getKeybindings();
+        if (keys.matches(data, "tui.select.cancel")) {
+            this.act("back");
+            return;
+        }
+        if (["tui.select.up", "tui.select.down", "tui.select.confirm"].some((key) => keys.matches(data, key))) {
+            this.list?.handleInput(data);
+        }
+        else {
+            const previous = this.search.getValue();
+            this.search.handleInput(data);
+            if (this.search.getValue() !== previous) {
+                this.list = undefined;
+            }
+            this.controller.filterTasks(this.search.getValue());
+        }
+    }
+    handleInput(data) {
+        if (this.closed) {
+            return;
+        }
+        if (matchesKey(data, this.controller.shortcut)) {
+            this.done();
+            return;
+        }
+        if (matchesKey(data, "pageDown") || matchesKey(data, "pageUp")) {
+            this.controller.pageTasks(matchesKey(data, "pageDown") ? "later" : "earlier");
+            return;
+        }
+        if (matchesKey(data, "f5")) {
+            this.retry();
+            return;
+        }
+        this.listInput(data);
+        this.tui.requestRender();
+    }
+    dispose() {
+        this.closed = true;
+    }
+}