@astralyn/pi 0.99.0 → 1.0.1

package/dist/modes/interactive/tasks/manager.js

@@ -1,380 +1,380 @@
-/** Task selection and layout; execution modules own the two content regions. */
-import { stripTerminalSequences, truncateToWidth, visibleWidth, } from "@earendil-works/pi-tui";
+/** Panel lifecycle and input routing; selection, output ownership and layout have separate owners. */
+import { Input, } from "@earendil-works/pi-tui";
 import { isTaskTerminal } from "../../../core/tasks/types.js";
-import { sanitizeBinaryOutput } from "../../../utils/shell.js";
-import { DynamicBorder } from "../components/dynamic-border.js";
-import { keyLabel } from "../components/keybinding-hints.js";
-import { STATUS_SPINNER_INTERVAL_MS, statusMarker } from "../components/status-marker.js";
-import { fallbackTaskView } from "./fallback-view.js";
-import { runtimeLabel } from "./task-view.js";
+import { STATUS_SPINNER_INTERVAL_MS } from "../components/status-marker.js";
+import { TaskInspector } from "./inspector.js";
+import { renderTasksLayout } from "./layout.js";
+import { TaskList } from "./list.js";
+import { TaskSelection } from "./model.js";
+import { cleanTaskText } from "./text.js";
 import { TaskViewport } from "./viewport.js";
-const clean = (text) => sanitizeBinaryOutput(stripTerminalSequences(text));
-const pad = (text, width) => truncateToWidth(text, Math.max(1, width), "…", true);
+const actions = [
+    "app.tasks.search",
+    "app.tasks.kill",
+    "app.tasks.detachSelected",
+    "app.tasks.previousTab",
+    "app.tasks.nextTab",
+    "app.tasks.follow",
+    "app.tasks.top",
+    "app.tasks.bottom",
+    "app.tasks.nextFocus",
+    "app.tasks.previousFocus",
+    "app.tasks.help",
+];
 export class TasksMenu {
     constructor(options) {
         this.focused = false;
-        this.tasks = [];
-        this.viewGeneration = 0;
-        this.positions = new Map();
+        this.list = new TaskList();
         this.focus = "list";
-        this.listHeight = 1;
-        this.reading = false;
+        this.searching = false;
+        this.dirty = true;
+        this.tickQueued = false;
+        this.refreshQueued = false;
         this.disposed = false;
-        this.lastFrame = "";
         this.options = options;
         this.width = options.tui.terminal.columns;
+        this.selection = new TaskSelection(options.state ?? { tab: "output" });
+        this.inspector = new TaskInspector({
+            host: options.host,
+            theme: options.theme,
+            requestRender: () => options.tui.requestRender(),
+        });
+        this.search = new Input({ prompt: "Find task: ", placeholder: "title, command, kind or ID" });
         this.sync();
         this.unsubscribe = options.host.subscribe(() => {
-            this.sync();
-            if (this.selected && isTaskTerminal(this.selected.status))
-                this.queueTick();
-        });
-        this.unsubscribeViews = options.views?.subscribe(() => {
-            this.syncView();
+            this.dirty = true;
             this.queueTick();
+            options.tui.requestRender();
         });
-        this.pollTimer = setInterval(() => this.queueTick(), options.pollIntervalMs ?? 1000);
+        this.pollTimer = setInterval(() => {
+            this.queueTick(true);
+            if (this.selection.activeCount)
+                options.tui.requestRender();
+        }, options.pollIntervalMs ?? 1000);
         this.pollTimer.unref?.();
-        this.queueTick();
-    }
-    invalidate() {
-        this.lastFrame = "";
-        this.view?.info.invalidate();
-        this.view?.output.invalidate();
-    }
-    dispose() {
-        if (this.disposed)
-            return;
-        this.disposed = true;
-        clearInterval(this.pollTimer);
-        clearInterval(this.animationTimer);
-        this.clearKill();
-        this.unsubscribe();
-        this.unsubscribeViews?.();
-        this.disposeView();
-        this.releasePin?.();
-        this.positions.clear();
+        this.queueTick(true);
     }
     sync() {
-        if (this.disposed)
+        if (this.disposed || !this.dirty)
             return;
-        const all = this.options.host.list();
-        this.tasks = all
-            .filter((task) => !isTaskTerminal(task.status))
-            .sort((a, b) => b.startedAt - a.startedAt || a.id.localeCompare(b.id));
-        const watched = all.find((task) => task.id === this.selected?.id);
-        if (watched)
-            this.selected = watched;
-        else
-            this.select(this.tasks[0]);
-        // The watched terminal task is absent from the selectable list.
-        const retained = new Set([...this.tasks.map((task) => task.id), this.selected?.id]);
-        for (const id of this.positions.keys())
-            if (!retained.has(id))
-                this.positions.delete(id);
-        if (this.pendingKill && !this.tasks.some((task) => task.id === this.pendingKill))
+        this.dirty = false;
+        const previous = this.selection.selected;
+        this.selection.sync(this.options.host.list());
+        this.inspector.select(this.selection.selected);
+        this.inspector.prune(new Set(this.selection.all.map((task) => task.id)));
+        const selected = this.selection.selected;
+        if (selected && isTaskTerminal(selected.status) && previous && !isTaskTerminal(previous.status))
+            this.feedback = undefined;
+        if (this.pendingKill && (this.pendingKill !== selected?.id || (selected && isTaskTerminal(selected.status))))
             this.clearKill();
-        this.syncView();
-        if (this.tasks.some((task) => task.status === "running" || task.status === "stopping")) {
-            if (!this.animationTimer) {
-                this.animationTimer = setInterval(() => this.options.tui.requestRender(), STATUS_SPINNER_INTERVAL_MS);
-                this.animationTimer.unref?.();
-            }
+        const animates = this.selection.all.some((task) => task.status === "running");
+        if (animates && !this.animationTimer) {
+            this.animationTimer = setInterval(() => this.options.tui.requestRender(), STATUS_SPINNER_INTERVAL_MS);
+            this.animationTimer.unref?.();
         }
-        else {
+        else if (!animates) {
             clearInterval(this.animationTimer);
             this.animationTimer = undefined;
         }
     }
-    select(task) {
-        if (task?.id === this.selected?.id) {
-            this.selected = task;
+    queueTick(refresh = false) {
+        if (this.disposed)
             return;
-        }
-        const release = task ? this.options.host.retain(task.id) : undefined;
-        const previous = this.releasePin;
-        this.selected = task;
-        this.releasePin = release;
-        previous?.();
+        this.refreshQueued ||= refresh;
+        if (this.tickQueued)
+            return;
+        this.tickQueued = true;
+        void Promise.resolve()
+            .then(async () => {
+            this.tickQueued = false;
+            if (this.disposed)
+                return;
+            const refresh = this.refreshQueued;
+            this.refreshQueued = false;
+            this.sync();
+            if (refresh || (this.inspector.task && isTaskTerminal(this.inspector.task.status)))
+                await this.inspector.refresh();
+        })
+            .catch(() => {
+            /* Task observers cannot reject execution. */
+        });
+    }
+    invalidate() {
+        this.inspector.invalidate();
+    }
+    clearKill() {
+        this.pendingKill = undefined;
+    }
+    selectedChanged() {
         this.clearKill();
-        this.syncView();
+        this.list.showSelection();
+        this.inspector.select(this.selection.selected);
+        this.queueTick(true);
     }
-    disposeView() {
-        this.viewGeneration++;
-        this.viewSnapshot = undefined;
-        this.viewRead = undefined;
-        try {
-            this.view?.dispose?.();
+    stop(confirm = false) {
+        const task = this.selection.selected;
+        if (confirm) {
+            const id = this.pendingKill;
+            this.clearKill();
+            if (!id || id !== task?.id || isTaskTerminal(task.status))
+                return;
+            this.feedback = this.options.host.kill(id)
+                ? "Cancellation requested; waiting for cleanup."
+                : "No new cancellation requested.";
         }
-        catch {
-            /* Renderer cleanup cannot affect execution. */
+        else if (task && !isTaskTerminal(task.status) && task.status !== "stopping") {
+            this.pendingKill = task.id;
         }
-        this.view = undefined;
     }
-    syncView() {
-        const provider = this.selected ? (this.options.views?.get(this.selected.kind) ?? fallbackTaskView) : undefined;
-        if (provider === this.provider && this.viewTaskId === this.selected?.id)
+    finishSearch(cancel) {
+        const id = cancel ? this.beforeSearch?.id : this.selection.state.selectedId;
+        if (!cancel && !id)
             return;
-        this.disposeView();
-        this.provider = provider;
-        this.viewTaskId = this.selected?.id;
-        this.viewError = undefined;
-        if (!provider)
-            return;
-        const generation = this.viewGeneration;
-        try {
-            this.view = provider.create({
-                theme: this.options.theme,
-                requestRender: () => {
-                    if (!this.disposed && generation === this.viewGeneration)
-                        this.options.tui.requestRender();
-                },
-            });
-        }
-        catch (error) {
-            this.failView(error);
-        }
-    }
-    failView(error) {
-        this.disposeView();
-        this.viewError = `Task view unavailable: ${clean(String(error))}`;
-        this.view = fallbackTaskView.create({ theme: this.options.theme, requestRender: () => { } });
+        this.focus = cancel ? (this.beforeSearch?.focus ?? "list") : "list";
+        this.searching = false;
+        this.search.focused = false;
+        this.selection.query = "";
+        this.selection.select(id);
+        this.beforeSearch = undefined;
+        this.selectedChanged();
     }
-    position() {
-        const id = this.selected?.id ?? "";
-        let position = this.positions.get(id);
-        if (!position) {
-            position = { info: new TaskViewport(), output: new TaskViewport(this.provider?.outputMode === "tail") };
-            if (id)
-                this.positions.set(id, position);
+    action(key) {
+        switch (key) {
+            case "app.tasks.search":
+                this.beforeSearch = { id: this.selection.state.selectedId, focus: this.focus };
+                this.focus = "list";
+                this.searching = true;
+                this.search.focused = true;
+                this.search.setValue("");
+                break;
+            case "app.tasks.previousTab":
+            case "app.tasks.nextTab":
+                if (this.focus === "inspector")
+                    this.selection.state.tab = key === "app.tasks.previousTab" ? "output" : "info";
+                break;
+            case "app.tasks.nextFocus":
+            case "app.tasks.previousFocus":
+                this.focus = this.focus === "list" ? "inspector" : "list";
+                break;
+            case "app.tasks.follow":
+                if (this.focus === "inspector" && this.selection.state.tab === "output") {
+                    this.inspector.position.output.jump(true, true);
+                    this.queueTick(true);
+                }
+                break;
+            case "app.tasks.top":
+            case "app.tasks.bottom":
+                if (this.focus === "list") {
+                    this.selection.select(key === "app.tasks.top" ? this.selection.rows[0]?.id : this.selection.rows.at(-1)?.id);
+                    this.selectedChanged();
+                }
+                else
+                    this.inspector.position[this.selection.state.tab].jump(key === "app.tasks.bottom", this.selection.state.tab === "output");
+                break;
+            case "app.tasks.kill":
+                this.stop();
+                break;
+            case "app.tasks.confirmStop":
+                this.stop(true);
+                break;
+            case "app.tasks.detachSelected": {
+                const task = this.selection.selected;
+                if (task?.mode === "foreground" &&
+                    !isTaskTerminal(task.status) &&
+                    task.status !== "stopping" &&
+                    this.options.host.enabled !== false) {
+                    this.feedback = this.options.host.detach?.(task.id)
+                        ? "Selected task moved to background; execution continues."
+                        : "This task cannot move to background.";
+                }
+                break;
+            }
+            case "app.tasks.help":
+                this.help = this.help ? undefined : new TaskViewport();
+                break;
         }
-        return position;
-    }
-    queueTick() {
-        void this.tick().catch(() => {
-            /* The observer cannot reject execution. */
-        });
     }
-    async tick() {
-        if (this.disposed)
-            return;
-        this.sync();
-        await this.refresh();
-        if (this.disposed)
+    move(direction, page = false) {
+        if (this.help) {
+            this.help.move(direction, page, false);
             return;
-        const frame = this.render(this.width).join("\n");
-        if (frame !== this.lastFrame) {
-            this.lastFrame = frame;
-            this.options.tui.requestRender();
         }
-    }
-    async refresh() {
-        const task = this.selected;
-        if (!task || this.provider?.outputMode !== "tail" || this.viewError || this.reading)
-            return;
-        const position = this.position();
-        if (position.read && (!position.output.follow || isTaskTerminal(position.read.task.status)))
-            return;
-        this.reading = true;
-        try {
-            const read = await this.options.host.read(task.id, { mode: "tail", bytes: 48 * 1024 });
-            if (this.disposed || this.selected?.id !== task.id || (!position.output.follow && position.read))
+        if (this.focus === "list") {
+            const rows = this.selection.rows;
+            if (!rows.length)
                 return;
-            position.read = read;
+            const index = rows.findIndex((task) => task.id === this.selection.state.selectedId);
+            const next = page
+                ? Math.max(0, Math.min(rows.length - 1, index + direction * (this.layout?.listPageSize ?? 1)))
+                : (index + direction + rows.length) % rows.length;
+            this.selection.select(rows[next]?.id);
+            this.selectedChanged();
         }
-        catch (error) {
-            if (!this.disposed && this.selected?.id === task.id && (position.output.follow || !position.read)) {
-                position.read = {
-                    task,
-                    text: "",
-                    readError: `Cannot read output: ${clean(String(error))}`,
-                    totalBytes: 0,
-                    truncated: false,
-                };
-            }
-        }
-        finally {
-            this.reading = false;
-            if (!this.disposed && this.selected?.id !== task.id)
-                this.queueTick();
-        }
-    }
-    clearKill() {
-        clearTimeout(this.killTimer);
-        this.killTimer = undefined;
-        this.pendingKill = undefined;
+        else
+            this.inspector.position[this.selection.state.tab].move(direction, page, this.selection.state.tab === "output");
     }
     handleInput(data) {
         if (this.disposed)
             return;
+        this.sync();
+        this.render(this.width);
         const kb = this.options.keybindings;
         this.feedback = undefined;
-        if (this.pendingKill) {
-            const id = this.pendingKill;
-            this.clearKill();
-            if (data === "y" || data === "Y") {
-                try {
-                    this.feedback = this.options.host.kill(id) ? `Stopping ${id}…` : "No new cancellation requested.";
-                }
-                catch (error) {
-                    this.feedback = clean(String(error));
+        try {
+            if (this.help) {
+                if (kb.matches(data, "tui.select.cancel") || kb.matches(data, "app.tasks.help"))
+                    this.help = undefined;
+                else if (kb.matches(data, "app.tasks.top") || kb.matches(data, "app.tasks.bottom"))
+                    this.help.jump(kb.matches(data, "app.tasks.bottom"), false);
+                else if (kb.matches(data, "tui.select.up") || kb.matches(data, "tui.editor.pageUp"))
+                    this.help.move(-1, kb.matches(data, "tui.editor.pageUp"), false);
+                else if (kb.matches(data, "tui.select.down") || kb.matches(data, "tui.editor.pageDown"))
+                    this.help.move(1, kb.matches(data, "tui.editor.pageDown"), false);
+            }
+            else if (this.searching) {
+                if (kb.matches(data, "tui.select.cancel"))
+                    this.finishSearch(true);
+                else if (kb.matches(data, "tui.select.confirm"))
+                    this.finishSearch(false);
+                else if (kb.matches(data, "tui.select.up") || kb.matches(data, "tui.select.pageUp"))
+                    this.move(-1, kb.matches(data, "tui.select.pageUp"));
+                else if (kb.matches(data, "tui.select.down") || kb.matches(data, "tui.select.pageDown"))
+                    this.move(1, kb.matches(data, "tui.select.pageDown"));
+                else {
+                    this.search.handleInput(data);
+                    this.selection.query = this.search.getValue().slice(0, 512);
+                    this.selection.refresh();
+                    this.selectedChanged();
                 }
             }
-        }
-        else if (kb.matches(data, "tui.select.cancel")) {
-            if (this.focus !== "list")
-                this.focus = "list";
-            else {
+            else if (this.pendingKill) {
+                if (kb.matches(data, "app.tasks.confirmStop"))
+                    this.stop(true);
+                else if (kb.matches(data, "tui.select.cancel"))
+                    this.clearKill();
+            }
+            else if (kb.matches(data, "tui.select.cancel")) {
                 this.dispose();
                 this.options.onClose();
                 return;
             }
+            else {
+                const pageUp = kb.matches(data, this.focus === "list" ? "tui.select.pageUp" : "tui.editor.pageUp");
+                const pageDown = kb.matches(data, this.focus === "list" ? "tui.select.pageDown" : "tui.editor.pageDown");
+                if (pageUp || kb.matches(data, "tui.select.up"))
+                    this.move(-1, pageUp);
+                else if (pageDown || kb.matches(data, "tui.select.down"))
+                    this.move(1, pageDown);
+                else if (kb.matches(data, "tui.select.confirm"))
+                    return;
+                else {
+                    const key = actions.find((key) => kb.matches(data, key));
+                    if (key)
+                        this.action(key);
+                }
+            }
         }
-        else if (kb.matches(data, "app.tasks.kill")) {
-            if (this.selected && !isTaskTerminal(this.selected.status) && this.selected.status !== "stopping") {
-                this.pendingKill = this.selected.id;
-                this.killTimer = setTimeout(() => {
-                    this.clearKill();
-                    this.options.tui.requestRender();
-                }, 5000);
-                this.killTimer.unref?.();
+        catch (error) {
+            this.feedback = cleanTaskText(error instanceof Error ? error.message : String(error));
+        }
+        this.queueTick(true);
+        this.options.tui.requestRender();
+    }
+    handleMouse(event) {
+        if (this.disposed || event.ctrl || event.alt || event.shift)
+            return;
+        this.render(event.width);
+        const layout = this.layout;
+        if (event.type === "wheel" && event.wheelDelta) {
+            if (!this.pendingKill && event.y >= 2 && event.y < this.options.tui.terminal.rows - 3) {
+                const delta = Math.sign(event.wheelDelta) * Math.min(20, Math.abs(event.wheelDelta));
+                const region = this.width >= 100 ? (event.x < layout.listWidth ? "list" : "inspector") : this.focus;
+                if (this.help)
+                    this.help.move(delta, false, false);
+                else if (region === "list")
+                    this.list.scroll(delta);
+                else if (!this.searching)
+                    this.inspector.position[this.selection.state.tab].move(delta, false, this.selection.state.tab === "output");
             }
         }
-        else if (kb.matches(data, "app.tasks.focusList"))
-            this.focus = "list";
-        else if (kb.matches(data, "app.tasks.focusInfo"))
-            this.focus = "info";
-        else if (kb.matches(data, "app.tasks.focusPreview") || kb.matches(data, "tui.select.confirm"))
-            this.focus = "output";
-        else {
-            const pageUp = kb.matches(data, this.focus === "list" ? "tui.select.pageUp" : "tui.editor.pageUp");
-            const pageDown = kb.matches(data, this.focus === "list" ? "tui.select.pageDown" : "tui.editor.pageDown");
-            const direction = pageUp || kb.matches(data, "tui.select.up") ? -1 : pageDown || kb.matches(data, "tui.select.down") ? 1 : 0;
-            if (direction) {
-                this.render(this.width);
-                if (this.focus === "list" && this.tasks.length) {
-                    const index = this.tasks.findIndex((task) => task.id === this.selected?.id);
-                    const next = index < 0
-                        ? direction > 0
-                            ? 0
-                            : this.tasks.length - 1
-                        : pageUp || pageDown
-                            ? Math.max(0, Math.min(this.tasks.length - 1, index + direction * this.listHeight))
-                            : (index + direction + this.tasks.length) % this.tasks.length;
-                    this.select(this.tasks[next]);
-                    this.sync();
+        else if (event.type === "click" && event.button === "left") {
+            const hit = layout.hits.find((hit) => hit.y === event.y && event.x >= hit.x && event.x < hit.x + hit.width);
+            try {
+                if (hit?.cancel) {
+                    if (this.searching)
+                        this.finishSearch(true);
+                    else if (this.help)
+                        this.help = undefined;
+                    else if (this.pendingKill)
+                        this.clearKill();
+                    else {
+                        this.dispose();
+                        this.options.onClose();
+                    }
                 }
-                else if (this.focus !== "list")
-                    this.position()[this.focus].move(direction, pageUp || pageDown, this.focus === "output" && this.provider?.outputMode === "tail");
-            }
-            else if (this.focus !== "list") {
-                try {
-                    this.view?.[this.focus].handleInput?.(data);
+                else if (hit?.taskId) {
+                    this.selection.select(hit.taskId);
+                    this.selectedChanged();
+                    this.focus = "list";
+                    if (this.searching)
+                        this.finishSearch(false);
+                }
+                else if (hit?.tab) {
+                    this.focus = "inspector";
+                    this.selection.state.tab = hit.tab;
                 }
-                catch (error) {
-                    this.failView(error);
+                else if (hit?.key) {
+                    if (hit.key === "app.tasks.follow")
+                        this.focus = "inspector";
+                    this.action(hit.key);
                 }
+                else if (!this.pendingKill &&
+                    !this.searching &&
+                    !this.help &&
+                    event.y >= 1 &&
+                    event.y < this.options.tui.terminal.rows - 2 &&
+                    this.width >= 100)
+                    this.focus = event.x < layout.listWidth ? "list" : "inspector";
             }
-        }
-        this.queueTick();
-        this.options.tui.requestRender();
-    }
-    regionLines(width) {
-        if (!this.selected || !this.view)
-            return { info: [], output: [] };
-        try {
-            const read = this.position().read;
-            if (this.selected !== this.viewSnapshot || read !== this.viewRead) {
-                this.view.update(this.selected, read);
-                this.viewSnapshot = this.selected;
-                this.viewRead = read;
+            catch (error) {
+                this.feedback = cleanTaskText(error instanceof Error ? error.message : String(error));
             }
-            return { info: this.view.info.render(width), output: this.view.output.render(width) };
-        }
-        catch (error) {
-            this.failView(error);
-            this.view.update(this.selected);
-            return { info: this.view.info.render(width), output: this.view.output.render(width) };
         }
+        else
+            return;
+        this.queueTick(true);
+        this.options.tui.requestRender();
+        return { handled: true, focus: event.type === "click" };
     }
     render(width) {
-        if (width < 1)
-            return [];
         this.width = width;
-        const { theme, keybindings, tui } = this.options;
-        const height = tui.terminal.rows;
-        const rule = new DynamicBorder((text) => theme.fg("border", text)).render(width)[0] ?? "";
-        if (width < 60 || height < 14)
-            return [
-                rule,
-                pad("Terminal too small for /tasks — resize to 60×14.", width),
-                pad(`${keyLabel("tui.select.cancel", { keybindings })} close`, width),
-                ...Array.from({ length: Math.max(0, height - 3) }, () => pad("", width)),
-            ].slice(0, height);
-        const wide = width >= 100;
-        const bodyHeight = height - 5;
-        const listWidth = wide ? Math.min(40, Math.max(28, Math.floor(width * 0.3))) : width;
-        const rightWidth = wide ? width - listWidth - 1 : width;
-        this.listHeight = wide ? bodyHeight : Math.min(4, Math.max(1, this.tasks.length));
-        const selectedIndex = this.tasks.findIndex((task) => task.id === this.selected?.id);
-        const first = Math.max(0, selectedIndex - this.listHeight + 1);
-        const list = this.tasks.slice(first, first + this.listHeight).map((task) => {
-            const marker = statusMarker(task.status);
-            const selected = task.id === this.selected?.id;
-            const cursor = selected ? theme.fg(this.focus === "list" ? "accent" : "muted", "→ ") : "  ";
-            const suffix = theme.fg("dim", `${task.mode === "foreground" ? "fg" : "bg"} · ${runtimeLabel(task)}`);
-            const prefix = `${cursor}${theme.fg(marker.color, marker.glyph)} `;
-            const label = clean(task.command ?? task.title).replace(/\s+/g, " ");
-            return `${prefix}${pad(theme.fg(selected && this.focus === "list" ? "accent" : "text", label), listWidth - visibleWidth(prefix) - visibleWidth(suffix) - 1)} ${suffix}`;
+        this.sync();
+        this.layout = renderTasksLayout({
+            width,
+            height: this.options.tui.terminal.rows,
+            theme: this.options.theme,
+            keybindings: this.options.keybindings,
+            selection: this.selection,
+            inspector: this.inspector,
+            list: this.list,
+            focus: this.focus,
+            searchLine: this.searching ? (width) => this.search.render(width).join("") : undefined,
+            pendingKill: this.pendingKill,
+            feedback: this.feedback,
+            help: this.help,
+            canDetach: this.options.host.enabled !== false && !!this.options.host.detach,
         });
-        if (!list.length)
-            list.push(theme.fg("muted", "No ongoing tasks."));
-        const available = bodyHeight - (wide ? 0 : this.listHeight);
-        const regions = this.regionLines(rightWidth);
-        const task = this.selected;
-        const common = task
-            ? [
-                `Status    ${task.status} · ${task.mode} · ${runtimeLabel(task)}`,
-                `Task      ${task.id}`,
-                ...(task.error ? [theme.fg("error", clean(task.error))] : []),
-            ]
-            : [theme.fg("muted", "Select an ongoing task.")];
-        if (this.viewError)
-            common.push(theme.fg("error", this.viewError));
-        const infoHeight = Math.max(1, Math.min(Math.floor(available * 0.4), common.length + regions.info.length));
-        const outputHeight = Math.max(1, available - infoHeight - 2);
-        const position = this.position();
-        const info = position.info.layout([...common, ...regions.info], rightWidth, infoHeight);
-        const output = position.output.layout(regions.output, rightWidth, outputHeight);
-        const heading = (label, focus, suffix) => {
-            const text = `─ ${theme.fg(this.focus === focus ? "accent" : "muted", label)} ${theme.fg("dim", suffix)} `;
-            return pad(text + theme.fg("borderMuted", "─".repeat(Math.max(0, rightWidth - visibleWidth(text)))), rightWidth);
-        };
-        const tail = this.provider?.outputMode === "tail" && !this.viewError
-            ? ` · ${position.output.follow ? "following" : "browsing"}`
-            : "";
-        const right = [
-            heading("Information", "info", position.info.range),
-            ...info,
-            ...Array.from({ length: Math.max(0, infoHeight - info.length) }, () => ""),
-            heading("Output", "output", position.output.range + tail),
-            ...output,
-        ];
-        const body = wide
-            ? Array.from({ length: bodyHeight }, (_, i) => `${pad(list[i] ?? "", listWidth)}${theme.fg("borderMuted", "│")}${pad(right[i] ?? "", rightWidth)}`)
-            : [...list, ...Array.from({ length: Math.max(0, this.listHeight - list.length) }, () => ""), ...right];
-        while (body.length < bodyHeight)
-            body.push("");
-        const hint = (id) => keyLabel(id, { keybindings });
-        const hints = this.focus === "list"
-            ? `${hint("tui.select.up")}/${hint("tui.select.down")} select · ${hint("app.tasks.focusInfo")} info · ${hint("app.tasks.focusPreview")} output · ${hint("app.tasks.kill")} stop · ${hint("tui.select.cancel")} close`
-            : `${hint("tui.select.up")}/${hint("tui.select.down")} scroll · ${hint("tui.editor.pageUp")}/${hint("tui.editor.pageDown")} page · ${hint("app.tasks.focusList")} list · ${hint("app.tasks.focusInfo")} info · ${hint("app.tasks.focusPreview")} output · ${hint("tui.select.cancel")} back`;
-        const title = theme.fg("accent", theme.bold("Tasks")) +
-            (this.tasks.length ? theme.fg("muted", ` · ${this.tasks.length} ongoing`) : "");
-        const footer = this.pendingKill
-            ? theme.fg("warning", `Stop ${this.pendingKill} (whole task)? y/N`)
-            : theme.fg("dim", this.feedback ?? hints);
-        return [rule, title, ...body.slice(0, bodyHeight), rule, footer, rule].map((line) => pad(line, width));
+        return this.layout.lines;
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        clearInterval(this.pollTimer);
+        clearInterval(this.animationTimer);
+        this.clearKill();
+        this.unsubscribe();
+        this.inspector.dispose();
     }
 }
 //# sourceMappingURL=manager.js.map