@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/tui/components/tasks-pane.d.ts

@@ -0,0 +1,126 @@
+import { type Component, type TuiMouseEvent } from "@bubblebrain-ai/pi-tui";
+import type { WorkflowRunSnapshot } from "../../agent/workflow/control.js";
+import type { BackgroundTaskInfo } from "../../tasks/manager.js";
+import { type Theme } from "../model/theme.js";
+import { type SubagentDisplay, type SubagentGroup } from "../model/subagent-view.js";
+export interface TasksPaneSnapshot {
+    groups: SubagentGroup[];
+    workflows: WorkflowRunSnapshot[];
+    tasks: BackgroundTaskInfo[];
+    /** Start of the current agent run; undefined keeps finished work hidden. */
+    turnStartedAt?: number;
+}
+export interface WorkflowPaneItem {
+    kind: "workflow";
+    id: string;
+    title: string;
+    status: string;
+    members: SubagentDisplay[];
+    createdAt?: number;
+    updatedAt?: number;
+}
+export interface SubagentPaneItem {
+    kind: "subagent";
+    id: string;
+    title: string;
+    status: string;
+    member: SubagentDisplay;
+}
+export interface TaskPaneItem {
+    kind: "task";
+    id: string;
+    title: string;
+    status: string;
+    task: BackgroundTaskInfo;
+}
+export type PaneItem = WorkflowPaneItem | SubagentPaneItem | TaskPaneItem;
+export interface TasksPaneCallbacks {
+    onRender(): void;
+    onOpenWorkflow(item: WorkflowPaneItem): void;
+    onOpenSubagent(item: SubagentPaneItem): void;
+    onOpenTask(item: TaskPaneItem): void;
+    onStopWorkflow(id: string): void;
+    onStopSubagent(id: string): void;
+    onStopTask(id: string): void;
+    onCopyTaskOutput?(id: string): void;
+    onEscape(): void;
+}
+export declare class TasksPaneComponent implements Component {
+    private readonly getSnapshot;
+    private readonly getTerminalRows;
+    private readonly callbacks;
+    private readonly getTheme;
+    focused: boolean;
+    private open;
+    private manuallyClosed;
+    /**
+     * History is a view the user opts into for one look, never a mode: it is
+     * dropped whenever the pane closes and when a new round of activity starts.
+     * Otherwise one Ctrl+G after a finished turn left every earlier subagent
+     * listed above the composer for the rest of the session, next to a header
+     * that counts only the running ones.
+     */
+    private showHistory;
+    private selectedId?;
+    /**
+     * Whether the user picked the selection (keys or click). The pane always
+     * needs one, so it defaults to the first row — but a default nobody chose
+     * must not steer the window: a task that was once the only row stayed
+     * "selected" and scrolled later subagents out of an untouched pane.
+     */
+    private selectionIsUsers;
+    private hoveredId?;
+    private lastActiveCount;
+    private lastTurnStartedAt;
+    private lastRows;
+    private allRows;
+    private frame;
+    private readonly collapsed;
+    constructor(getSnapshot: () => TasksPaneSnapshot, getTerminalRows: () => number, callbacks: TasksPaneCallbacks, getTheme?: () => Theme);
+    isAnimationActive(): boolean;
+    advanceAnimationFrame(): boolean;
+    dispose(): void;
+    invalidate(): void;
+    isOpen(): boolean;
+    isAvailable(): boolean;
+    activeCount(): number;
+    /** Rows the default view lists: running work plus what this turn launched. */
+    defaultViewCount(): number;
+    visibleCount(): number;
+    /**
+     * Finished rows the pane lists next to the running ones, by outcome. Counted
+     * in the pane's current view, history included when it is showing, so the
+     * header never reports fewer rows than the list holds.
+     */
+    settledCounts(): {
+        done: number;
+        failed: number;
+        stopped: number;
+    };
+    totalCount(): number;
+    activityGlyph(): string;
+    theme(): Theme;
+    toggle(forceFocus?: boolean): void;
+    close(): void;
+    /**
+     * Advance open/history state from the latest snapshot. Both the status bar
+     * and the pane call this before rendering: the bar is laid out first, so a
+     * transition made only inside the pane's render would leave the bar one
+     * frame behind — forever, when nothing is animating to trigger a redraw.
+     * Idempotent per snapshot (it compares against the last values it saw).
+     */
+    syncState(): void;
+    render(width: number): string[];
+    private renderItem;
+    handleInput(data: string): void;
+    handleMouse(event: TuiMouseEvent): boolean;
+    private openItem;
+    private stopItem;
+}
+export declare class TaskStatusBarComponent implements Component {
+    private readonly pane;
+    constructor(pane: TasksPaneComponent);
+    render(width: number): string[];
+    handleMouse(event: TuiMouseEvent): boolean;
+    invalidate(): void;
+}

package/dist/tui/components/tasks-pane.js

@@ -0,0 +1,566 @@
+import { matchesKey, truncateToWidth, visibleWidth, } from "@bubblebrain-ai/pi-tui";
+import { darkTheme } from "../model/theme.js";
+import { themeBackground, themeDim, themeForeground } from "../model/theme-style.js";
+import { safeSheetText } from "./bottom-sheet.js";
+import { latestSubagentNote, } from "../model/subagent-view.js";
+const FINAL = new Set(["completed", "failed", "blocked", "cancelled", "closed", "killed"]);
+const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+function isActive(status) {
+    return !FINAL.has(status);
+}
+function safe(value) {
+    return safeSheetText(value).replace(/[\r\n\t]+/g, " ").trim();
+}
+function pad(line, width) {
+    const clipped = truncateToWidth(line, width, "");
+    return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
+}
+function paint(line, width, state, theme = darkTheme) {
+    const filled = pad(line, width);
+    if (state === "selected")
+        return themeBackground(theme.traceSelectedBg, filled);
+    if (state === "hover")
+        return themeBackground(theme.traceHoverBg, filled);
+    return filled;
+}
+function statusGlyph(status, frame, theme = darkTheme) {
+    if (status === "completed" || status === "closed")
+        return themeForeground(theme.success, "✓");
+    if (status === "failed" || status === "blocked")
+        return themeForeground(theme.error, "×");
+    if (status === "cancelled" || status === "killed")
+        return themeForeground(theme.muted, "■");
+    if (status === "queued")
+        return themeForeground(theme.muted, "○");
+    return themeForeground(theme.accent, SPINNER[frame % SPINNER.length]);
+}
+function elapsed(createdAt, updatedAt, active = true) {
+    if (!createdAt)
+        return "";
+    const ms = Math.max(0, (active ? Date.now() : updatedAt ?? Date.now()) - createdAt);
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    return minutes < 60 ? `${minutes}m` : `${Math.floor(minutes / 60)}h${minutes % 60}m`;
+}
+function usageLabel(member) {
+    const usage = member.usage;
+    if (!usage)
+        return "";
+    const total = usage.promptTokens + usage.completionTokens;
+    return total >= 1000 ? `${(total / 1000).toFixed(total < 10_000 ? 1 : 0)}k` : String(total);
+}
+function workflowMembers(workflow, groups) {
+    if (workflow.snapshots.length > 0) {
+        return workflow.snapshots.map((snapshot) => ({
+            subAgentId: snapshot.agentId,
+            agentName: snapshot.agentName,
+            nickname: snapshot.nickname,
+            status: snapshot.status,
+            category: snapshot.category,
+            phase: snapshot.phase,
+            route: snapshot.route,
+            task: snapshot.task,
+            summary: snapshot.summary,
+            toolNotes: snapshot.toolNotes,
+            error: snapshot.error,
+            usage: snapshot.usage,
+            createdAt: snapshot.createdAt,
+            updatedAt: snapshot.updatedAt,
+        }));
+    }
+    return groups.find((group) => group.kind === "workflow" && group.runId === workflow.runId)?.members ?? [];
+}
+function normalize(snapshot, showHistory) {
+    const workflowItems = snapshot.workflows.map((workflow) => ({
+        kind: "workflow",
+        id: workflow.runId,
+        title: workflow.title,
+        status: workflow.status,
+        members: workflowMembers(workflow, snapshot.groups),
+        createdAt: workflow.createdAt,
+        updatedAt: workflow.updatedAt,
+    }));
+    const knownWorkflowRuns = new Set(snapshot.workflows.map((workflow) => workflow.runId));
+    for (const group of snapshot.groups) {
+        if (group.kind !== "workflow" || (group.runId && knownWorkflowRuns.has(group.runId)))
+            continue;
+        const statuses = group.members.map((member) => member.status ?? "running");
+        const status = statuses.some(isActive)
+            ? "running"
+            : statuses.some((value) => value === "failed" || value === "blocked") ? "failed" : "completed";
+        workflowItems.push({
+            kind: "workflow",
+            id: group.runId ?? group.id,
+            title: group.label,
+            status,
+            members: group.members,
+            createdAt: group.members.map((member) => member.createdAt).filter((value) => value !== undefined).sort()[0],
+            updatedAt: Math.max(0, ...group.members.map((member) => member.updatedAt ?? 0)),
+        });
+    }
+    const subagentItems = snapshot.groups
+        .filter((group) => group.kind !== "workflow")
+        .flatMap((group) => group.members.map((member) => ({
+        kind: "subagent",
+        id: member.subAgentId ?? group.id,
+        title: member.nickname ?? member.agentName ?? group.label,
+        status: member.status ?? "running",
+        member,
+    })));
+    const taskItems = snapshot.tasks.map((task) => ({
+        kind: "task",
+        id: task.id,
+        title: task.description || task.command,
+        status: task.status,
+        task,
+    }));
+    // Which rows belong above the composer is derived, not remembered: whatever
+    // is still running, plus whatever this turn launched — so a sibling that
+    // finishes (or fails) first stays in view with its outcome until the next
+    // turn, whether its siblings ran in parallel or one after another. Work from
+    // earlier turns is history and shows only on request.
+    const launchedThisTurn = (item) => {
+        const launchedAt = itemLaunchedAt(item);
+        return snapshot.turnStartedAt !== undefined && launchedAt !== undefined && launchedAt >= snapshot.turnStartedAt;
+    };
+    const filter = (items) => (showHistory
+        ? items
+        : items.filter((item) => isActive(item.status) || launchedThisTurn(item)))
+        .sort((left, right) => {
+        const activityOrder = Number(isActive(right.status)) - Number(isActive(left.status));
+        if (activityOrder !== 0)
+            return activityOrder;
+        return itemUpdatedAt(right) - itemUpdatedAt(left);
+    });
+    return {
+        workflows: filter(workflowItems),
+        subagents: filter(subagentItems),
+        tasks: filter(taskItems),
+    };
+}
+function itemLaunchedAt(item) {
+    if (item.kind === "workflow")
+        return item.createdAt;
+    if (item.kind === "subagent")
+        return item.member.createdAt;
+    return item.task.startedAt;
+}
+function itemUpdatedAt(item) {
+    if (item.kind === "workflow")
+        return item.updatedAt ?? item.createdAt ?? 0;
+    if (item.kind === "subagent")
+        return item.member.updatedAt ?? item.member.createdAt ?? 0;
+    return item.task.endedAt ?? item.task.startedAt;
+}
+export class TasksPaneComponent {
+    getSnapshot;
+    getTerminalRows;
+    callbacks;
+    getTheme;
+    focused = false;
+    open = false;
+    manuallyClosed = false;
+    /**
+     * History is a view the user opts into for one look, never a mode: it is
+     * dropped whenever the pane closes and when a new round of activity starts.
+     * Otherwise one Ctrl+G after a finished turn left every earlier subagent
+     * listed above the composer for the rest of the session, next to a header
+     * that counts only the running ones.
+     */
+    showHistory = false;
+    selectedId;
+    /**
+     * Whether the user picked the selection (keys or click). The pane always
+     * needs one, so it defaults to the first row — but a default nobody chose
+     * must not steer the window: a task that was once the only row stayed
+     * "selected" and scrolled later subagents out of an untouched pane.
+     */
+    selectionIsUsers = false;
+    hoveredId;
+    lastActiveCount = 0;
+    lastTurnStartedAt;
+    lastRows = [];
+    allRows = [];
+    frame = 0;
+    collapsed = new Set();
+    constructor(getSnapshot, getTerminalRows, callbacks, getTheme = () => darkTheme) {
+        this.getSnapshot = getSnapshot;
+        this.getTerminalRows = getTerminalRows;
+        this.callbacks = callbacks;
+        this.getTheme = getTheme;
+    }
+    isAnimationActive() {
+        return this.isAvailable() && this.activeCount() > 0;
+    }
+    advanceAnimationFrame() {
+        if (!this.isAnimationActive())
+            return false;
+        this.frame = (this.frame + 1) % SPINNER.length;
+        return true;
+    }
+    dispose() { }
+    invalidate() { }
+    isOpen() {
+        return this.open && this.getTerminalRows() >= 12;
+    }
+    isAvailable() {
+        return this.getTerminalRows() >= 12;
+    }
+    activeCount() {
+        const items = normalize(this.getSnapshot(), true);
+        return Object.values(items).flat().filter((item) => isActive(item.status)).length;
+    }
+    /** Rows the default view lists: running work plus what this turn launched. */
+    defaultViewCount() {
+        return Object.values(normalize(this.getSnapshot(), false)).flat().length;
+    }
+    visibleCount() {
+        return Object.values(normalize(this.getSnapshot(), this.showHistory)).flat().length;
+    }
+    /**
+     * Finished rows the pane lists next to the running ones, by outcome. Counted
+     * in the pane's current view, history included when it is showing, so the
+     * header never reports fewer rows than the list holds.
+     */
+    settledCounts() {
+        const counts = { done: 0, failed: 0, stopped: 0 };
+        for (const item of Object.values(normalize(this.getSnapshot(), this.showHistory)).flat()) {
+            if (isActive(item.status))
+                continue;
+            if (item.status === "failed" || item.status === "blocked")
+                counts.failed += 1;
+            else if (item.status === "cancelled" || item.status === "killed")
+                counts.stopped += 1;
+            else
+                counts.done += 1;
+        }
+        return counts;
+    }
+    totalCount() {
+        const items = normalize(this.getSnapshot(), true);
+        return Object.values(items).flat().length;
+    }
+    activityGlyph() {
+        return SPINNER[this.frame % SPINNER.length];
+    }
+    theme() {
+        return this.getTheme();
+    }
+    toggle(forceFocus = false) {
+        if (this.open && !forceFocus) {
+            this.open = false;
+            this.manuallyClosed = true;
+            this.showHistory = false;
+            // Closing through the status bar (a click) bypasses the app's Ctrl+G
+            // handler. A pane that still owned the keyboard would swallow input while
+            // invisible — and the bar itself can now be hidden — so hand focus back.
+            if (this.focused) {
+                this.focused = false;
+                this.callbacks.onEscape();
+            }
+        }
+        else {
+            this.open = true;
+            this.manuallyClosed = false;
+            // Once all activity has settled, Ctrl+G must remain a usable route back
+            // to the completed child transcript. Opening an empty active-only pane
+            // makes the work look lost even though the child session still exists.
+            // This turn's rows (what the bar counts) open first; older history only
+            // when there is nothing else to show, and behind `h` otherwise.
+            if (this.activeCount() === 0 && this.defaultViewCount() === 0 && this.totalCount() > 0)
+                this.showHistory = true;
+        }
+        this.callbacks.onRender();
+    }
+    close() {
+        this.open = false;
+        this.manuallyClosed = true;
+        this.showHistory = false;
+        this.callbacks.onRender();
+    }
+    /**
+     * Advance open/history state from the latest snapshot. Both the status bar
+     * and the pane call this before rendering: the bar is laid out first, so a
+     * transition made only inside the pane's render would leave the bar one
+     * frame behind — forever, when nothing is animating to trigger a redraw.
+     * Idempotent per snapshot (it compares against the last values it saw).
+     */
+    syncState() {
+        if (this.getTerminalRows() < 12)
+            return;
+        const activeCount = this.activeCount();
+        // A new run, or activity starting from idle, ends the history view. The
+        // run boundary matters on its own: with a task still running the count
+        // never crosses zero, and new work would otherwise keep listing history.
+        // A user who is browsing history inside the pane keeps their rows; the
+        // view resets when they close it.
+        const turnStartedAt = this.getSnapshot().turnStartedAt;
+        const newTurn = turnStartedAt !== this.lastTurnStartedAt;
+        this.lastTurnStartedAt = turnStartedAt;
+        const activityFromIdle = activeCount > 0 && this.lastActiveCount === 0;
+        if ((newTurn || activityFromIdle) && !this.focused) {
+            this.showHistory = false;
+            // If that leaves nothing to list (the pane was opened while idle, then a
+            // turn launches nothing), close it rather than keep an empty pane under
+            // a "0 completed" header. Not a manual close: the next activity reopens it.
+            if (this.open && this.visibleCount() === 0) {
+                this.open = false;
+                this.manuallyClosed = false;
+            }
+        }
+        if (activityFromIdle && !this.manuallyClosed)
+            this.open = true;
+        if (activeCount === 0 && this.lastActiveCount > 0) {
+            if (this.focused) {
+                // A user who is already inspecting the pane should see the final
+                // status land in place instead of watching the selected row vanish.
+                // This turn's rows stay on their own; only work launched in an earlier
+                // turn needs the history view to remain visible.
+                if (this.visibleCount() === 0)
+                    this.showHistory = true;
+            }
+            else {
+                this.open = false;
+                this.manuallyClosed = false;
+                this.showHistory = false;
+            }
+        }
+        this.lastActiveCount = activeCount;
+    }
+    render(width) {
+        const terminalRows = this.getTerminalRows();
+        if (terminalRows < 12) {
+            this.lastRows = [];
+            this.allRows = [];
+            return [];
+        }
+        this.syncState();
+        if (!this.open) {
+            this.lastRows = [];
+            this.allRows = [];
+            return [];
+        }
+        const items = normalize(this.getSnapshot(), this.showHistory);
+        const sections = [
+            ["workflows", "Workflows"],
+            ["subagents", "Subagents"],
+            ["tasks", "Tasks"],
+        ];
+        const rows = [];
+        for (const [section] of sections) {
+            if (items[section].length === 0)
+                continue;
+            rows.push({ kind: "header", section });
+            if (!this.collapsed.has(section))
+                rows.push(...items[section].map((item) => ({ kind: "item", item })));
+        }
+        const itemRows = rows.filter((row) => row.kind === "item");
+        this.allRows = rows;
+        const selectionGone = !this.selectedId
+            || !itemRows.some((row) => `${row.item.kind}:${row.item.id}` === this.selectedId);
+        if (selectionGone)
+            this.selectionIsUsers = false;
+        if (!this.selectionIsUsers) {
+            this.selectedId = itemRows[0] ? `${itemRows[0].item.kind}:${itemRows[0].item.id}` : undefined;
+        }
+        // When the rows do not fit, the last line says how many are out of view
+        // rather than clipping them silently. Only a focused pane scrolls to its
+        // selection; untouched, it shows the top, where running work sorts first.
+        const maxRows = Math.max(3, Math.min(8, Math.floor(terminalRows * 0.15)));
+        const selectedIndex = this.focused
+            ? rows.findIndex((row) => row.kind === "item" && `${row.item.kind}:${row.item.id}` === this.selectedId)
+            : -1;
+        const layout = (windowRows) => {
+            const start = selectedIndex >= windowRows ? selectedIndex - windowRows + 1 : 0;
+            const items = (slice) => slice.filter((row) => row.kind === "item").length;
+            return { start, windowRows, above: items(rows.slice(0, start)), below: items(rows.slice(start + windowRows)) };
+        };
+        // Reserve the last line only when it has something to say: hidden rows can
+        // be nothing but collapsed section headers, and a blank reserved slot would
+        // cost one of as few as three lines.
+        let view = layout(maxRows);
+        if (rows.length > maxRows) {
+            const reserved = layout(maxRows - 1);
+            if (reserved.above + reserved.below > 0)
+                view = reserved;
+        }
+        const visibleRows = rows.slice(view.start, view.start + view.windowRows);
+        this.lastRows = visibleRows;
+        const theme = this.getTheme();
+        const more = [
+            view.above > 0 ? `${view.above} more above` : "",
+            view.below > 0 ? `${view.below} more below` : "",
+        ].filter(Boolean).join(" · ");
+        const moreLine = view.windowRows < maxRows && more
+            ? [themeDim(theme.dim, pad(`   … ${more}${this.focused ? "" : " · Ctrl+G"}`, width))]
+            : [];
+        return [...visibleRows.map((row) => {
+                if (row.kind === "header") {
+                    const count = items[row.section].length;
+                    const marker = this.collapsed.has(row.section) ? "▸" : "▾";
+                    const label = sections.find(([section]) => section === row.section)?.[1] ?? row.section;
+                    return themeDim(theme.dim, pad(` ${marker} ${label} ${count}`, width));
+                }
+                const key = `${row.item.kind}:${row.item.id}`;
+                const state = key === this.selectedId && this.focused ? "selected" : key === this.hoveredId ? "hover" : "idle";
+                return paint(this.renderItem(row.item, width), width, state, theme);
+            }), ...moreLine];
+    }
+    renderItem(item, width) {
+        const theme = this.getTheme();
+        const glyph = statusGlyph(item.status, this.frame, theme);
+        if (item.kind === "workflow") {
+            const done = item.members.filter((member) => !isActive(member.status ?? "running")).length;
+            const progress = item.members.length > 0 ? `${done}/${item.members.length}` : item.status;
+            const duration = elapsed(item.createdAt, item.updatedAt, isActive(item.status));
+            return truncateToWidth(`   ${glyph} ${safe(item.title)}  ${themeDim(theme.dim, `${progress}${duration ? ` · ${duration}` : ""}`)}${isActive(item.status) ? themeDim(theme.dim, "  view  ×") : themeDim(theme.dim, "  view")}`, width, "");
+        }
+        if (item.kind === "task") {
+            const duration = elapsed(item.task.startedAt, item.task.endedAt, isActive(item.status));
+            const lineCount = `${item.task.outputLines} line${item.task.outputLines === 1 ? "" : "s"}`;
+            return truncateToWidth(`   ${glyph} ${safe(item.title)}  ${themeDim(theme.dim, `${item.status}${duration ? ` · ${duration}` : ""} · ${lineCount}`)}${isActive(item.status) ? themeDim(theme.dim, "  view  ×") : themeDim(theme.dim, "  view")}`, width, "");
+        }
+        const member = item.member;
+        const activity = latestSubagentNote(member);
+        const model = member.route?.model ?? member.agentName ?? "";
+        const tokens = usageLabel(member);
+        const duration = elapsed(member.createdAt, member.updatedAt, isActive(item.status));
+        const meta = [model, tokens ? `${tokens} tok` : "", duration].filter(Boolean).join(" · ");
+        const detail = activity ? ` — ${safe(activity)}` : "";
+        return truncateToWidth(`   ${glyph} ${safe(item.title)}${detail}  ${themeDim(theme.dim, meta)}${isActive(item.status) ? themeDim(theme.dim, "  view  ×") : themeDim(theme.dim, "  view")}`, width, "");
+    }
+    handleInput(data) {
+        if (matchesKey(data, "escape")) {
+            this.focused = false;
+            this.callbacks.onEscape();
+            return;
+        }
+        if (data === "h") {
+            this.showHistory = !this.showHistory;
+            this.callbacks.onRender();
+            return;
+        }
+        const itemRows = this.allRows.filter((row) => row.kind === "item");
+        const index = Math.max(0, itemRows.findIndex((row) => `${row.item.kind}:${row.item.id}` === this.selectedId));
+        if (matchesKey(data, "up") || data === "k") {
+            const row = itemRows[Math.max(0, index - 1)];
+            if (row) {
+                this.selectedId = `${row.item.kind}:${row.item.id}`;
+                this.selectionIsUsers = true;
+            }
+            this.callbacks.onRender();
+            return;
+        }
+        if (matchesKey(data, "down") || data === "j") {
+            const row = itemRows[Math.min(itemRows.length - 1, index + 1)];
+            if (row) {
+                this.selectedId = `${row.item.kind}:${row.item.id}`;
+                this.selectionIsUsers = true;
+            }
+            this.callbacks.onRender();
+            return;
+        }
+        const selected = itemRows.find((row) => `${row.item.kind}:${row.item.id}` === this.selectedId)?.item;
+        if ((matchesKey(data, "left") || matchesKey(data, "right")) && selected) {
+            const section = selected.kind === "workflow" ? "workflows" : selected.kind === "subagent" ? "subagents" : "tasks";
+            if (matchesKey(data, "left"))
+                this.collapsed.add(section);
+            else
+                this.collapsed.delete(section);
+            this.callbacks.onRender();
+            return;
+        }
+        if ((matchesKey(data, "enter") || matchesKey(data, "ctrl+f")) && selected)
+            this.openItem(selected);
+        if (data === "x" && selected && isActive(selected.status))
+            this.stopItem(selected);
+        if (data === "y" && selected?.kind === "task")
+            this.callbacks.onCopyTaskOutput?.(selected.id);
+    }
+    handleMouse(event) {
+        if (event.kind === "leave") {
+            const changed = this.hoveredId !== undefined;
+            this.hoveredId = undefined;
+            return changed;
+        }
+        const row = this.lastRows[event.y];
+        if (event.kind === "move") {
+            const next = row?.kind === "item" ? `${row.item.kind}:${row.item.id}` : undefined;
+            const changed = next !== this.hoveredId;
+            this.hoveredId = next;
+            return changed;
+        }
+        if (event.release || (event.button & 3) !== 0 || !row)
+            return false;
+        if (row.kind === "header") {
+            if (this.collapsed.has(row.section))
+                this.collapsed.delete(row.section);
+            else
+                this.collapsed.add(row.section);
+            return true;
+        }
+        this.selectedId = `${row.item.kind}:${row.item.id}`;
+        this.selectionIsUsers = true;
+        if (event.clickCount >= 2)
+            this.openItem(row.item);
+        return true;
+    }
+    openItem(item) {
+        if (item.kind === "workflow")
+            this.callbacks.onOpenWorkflow(item);
+        else if (item.kind === "subagent")
+            this.callbacks.onOpenSubagent(item);
+        else
+            this.callbacks.onOpenTask(item);
+    }
+    stopItem(item) {
+        if (item.kind === "workflow")
+            this.callbacks.onStopWorkflow(item.id);
+        else if (item.kind === "subagent")
+            this.callbacks.onStopSubagent(item.id);
+        else
+            this.callbacks.onStopTask(item.id);
+    }
+}
+export class TaskStatusBarComponent {
+    pane;
+    constructor(pane) {
+        this.pane = pane;
+    }
+    render(width) {
+        if (!this.pane.isAvailable())
+            return [];
+        this.pane.syncState();
+        const count = this.pane.activeCount();
+        // The bar describes what the pane lists: open, the rows on screen; closed,
+        // the default view Ctrl+G opens (running work plus this turn's). It used to
+        // count the whole session, a number that only ever grew. With nothing from
+        // this turn the bar is hidden; Ctrl+G still reaches the history.
+        const total = this.pane.isOpen() ? this.pane.visibleCount() : this.pane.defaultViewCount();
+        if (total === 0 && !this.pane.isOpen())
+            return [];
+        const marker = this.pane.isOpen() ? "▾" : "▸";
+        const theme = this.pane.theme();
+        // The list below also holds this turn's finished rows; say so, or the
+        // header counts fewer activities than the pane shows.
+        const settled = this.pane.settledCounts();
+        const outcome = [
+            settled.failed > 0 ? themeForeground(theme.error, `${settled.failed} failed`) : "",
+            settled.done > 0 ? `${settled.done} done` : "",
+            settled.stopped > 0 ? `${settled.stopped} stopped` : "",
+        ].filter(Boolean).map((part) => ` · ${part}`).join("");
+        const text = count > 0
+            ? `${marker} ${themeForeground(theme.accent, this.pane.activityGlyph())} ${count} background activit${count === 1 ? "y" : "ies"}${outcome} · Ctrl+G`
+            : `${marker} ${themeForeground(theme.success, "✓")} ${total} completed activit${total === 1 ? "y" : "ies"} · Ctrl+G`;
+        return [themeDim(theme.dim, truncateToWidth(` ${text}`, Math.max(1, width), ""))];
+    }
+    handleMouse(event) {
+        if (event.kind !== "press" || event.release || (event.button & 3) !== 0)
+            return false;
+        this.pane.toggle();
+        return true;
+    }
+    invalidate() { }
+}