@fitchmultz/pi-subagents 0.44.6 → 0.45.0

package/dist/tui/view-persistence.js

@@ -0,0 +1,51 @@
+import { Type, Check } from "../shared/native-typebox.js";
+const quote = Type.Object({ title: Type.String(), text: Type.String() });
+const anchor = Type.Object({ id: Type.String(), line: Type.Number() });
+const outgoing = Type.Object({
+    id: Type.String(),
+    runId: Type.String(),
+    index: Type.Number(),
+    text: Type.String(),
+    draft: Type.String(),
+    quote: Type.Optional(quote),
+    at: Type.Number(),
+    status: Type.Union([
+        Type.Literal("sending"),
+        Type.Literal("waiting"),
+        Type.Literal("unconfirmed"),
+    ]),
+    reason: Type.Optional(Type.String()),
+});
+const visit = Type.Object({
+    draft: Type.String(),
+    quote: Type.Optional(quote),
+    anchor: Type.Optional(anchor),
+    readThrough: Type.Optional(Type.Union([Type.String(), Type.Null()])),
+    seenActivityAt: Type.Optional(Type.Number()),
+    outbox: Type.Array(outgoing),
+    lastSentId: Type.Optional(Type.String()),
+    notice: Type.Optional(Type.Union([
+        Type.String(),
+        Type.Object({ continue: Type.Union([Type.Literal("finished"), Type.Literal("blocked")]) }),
+    ])),
+});
+const saved = Type.Object({
+    ownerSessionId: Type.String(),
+    visits: Type.Array(Type.Tuple([Type.String(), visit])),
+    pinned: Type.Optional(Type.String()),
+});
+export function restoredView(value, ownerSessionId) {
+    if (!Check(saved, value) || value.ownerSessionId !== ownerSessionId) {
+        return;
+    }
+    // The restored visit store owns its copies, never mutable session-entry data.
+    const visits = new Map(structuredClone(value.visits));
+    for (const current of visits.values()) {
+        for (const sent of current.outbox) {
+            if (sent.status === "sending") {
+                sent.status = "unconfirmed";
+            }
+        }
+    }
+    return { visits, pinned: value.pinned };
+}

package/dist/tui/view-ports.js

@@ -0,0 +1 @@
+export {};

package/dist/tui/view-session.js

@@ -0,0 +1,37 @@
+/** One owner identity and cancellation generation shared by asynchronous UI observations/actions. */
+export class ViewSession {
+    ctx;
+    ownerSessionId;
+    generation = 0;
+    pending = new AbortController();
+    state;
+    constructor(state) {
+        this.state = state;
+    }
+    context() {
+        if (!this.ctx) {
+            throw new Error("The owning session is no longer available.");
+        }
+        return this.ctx;
+    }
+    get signal() {
+        return this.pending.signal;
+    }
+    start(ctx) {
+        this.ctx = ctx;
+        this.ownerSessionId = ctx.sessionManager.getSessionId();
+        this.pending = new AbortController();
+    }
+    live(generation = this.generation) {
+        return (generation === this.generation &&
+            this.ctx !== undefined &&
+            this.ctx.sessionManager.getSessionId() === this.ownerSessionId &&
+            this.state.lastUiContext?.sessionManager.getSessionId() === this.ownerSessionId);
+    }
+    dispose() {
+        this.generation++;
+        this.pending.abort();
+        this.ctx = undefined;
+        this.ownerSessionId = undefined;
+    }
+}

package/dist/tui/widget-details.js

@@ -0,0 +1,144 @@
+import { shortenPath } from "../shared/formatters.js";
+import { aggregateStepStatus, formatParallelOutcome } from "../shared/status-format.js";
+import { getTermWidth, themeBold, modelThinkingBadge, buildLiveStatusLine, truncLine, } from "./display.js";
+import { buildAsyncChainStepSpans } from "./workflow-labels.js";
+import { widgetStepGlyph, widgetStepsRunningSeed, widgetStepActivity, widgetStepRunningSeed, widgetStepStatus, widgetStepStats, widgetStepActivityLine, widgetOutputPath, widgetActivity, widgetStats, widgetJobName, widgetStatusGlyph, } from "./widget-status.js";
+import { formatNestedWidgetLines } from "./nested-widget.js";
+import { hasText } from "./text-values.js";
+function widgetChainDetails(job, theme, width) {
+    const steps = job.steps ?? [], total = job.chainStepCount ?? steps.length, lines = [];
+    for (const span of buildAsyncChainStepSpans(total, steps.length, job.parallelGroups)) {
+        const group = steps.slice(span.start, span.start + span.count);
+        if (span.isParallel) {
+            const status = aggregateStepStatus(group);
+            lines.push(`  ${widgetStepGlyph(status, theme, widgetStepsRunningSeed(group))} Step ${span.stepIndex + 1}/${total}: ${themeBold(theme, "parallel group")} ${theme.fg("dim", "·")} ${theme.fg("dim", formatParallelOutcome(group, span.count))}`);
+            continue;
+        }
+        const step = group.at(0);
+        if (!step) {
+            lines.push(`  ${theme.fg("dim", `◦ Step ${span.stepIndex + 1}/${total}: pending`)}`);
+            continue;
+        }
+        lines.push(...foregroundStyleWidgetStepLines(job, theme, step, {
+            title: "Step",
+            index: span.stepIndex + 1,
+            total,
+            width,
+        }));
+    }
+    return lines;
+}
+function parallelStepLines(job, theme, step, layout) {
+    const marker = layout.index === (job.steps?.length ?? 0) ? "└" : "├";
+    const activity = widgetStepActivity(step, job.updatedAt), model = modelThinkingBadge(theme, step.model, step.thinking);
+    const lines = [
+        `  ${theme.fg("dim", `${marker} ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, layout.index - 1))} ${layout.title} ${layout.index}/${layout.total}: ${step.agent} · ${widgetStepStatus(step.status, theme)}${model}${hasText(activity) ? ` · ${activity}` : ""}`)}`,
+    ];
+    for (const nested of formatNestedWidgetLines(step.children, theme, layout.width, {
+        snapshotNow: job.updatedAt,
+        lineBudget: 8,
+    })) {
+        lines.push(`    ${nested}`);
+    }
+    return lines;
+}
+export function widgetParallelAgentDetails(job, theme, width = getTermWidth()) {
+    const steps = job.steps ?? [];
+    if (steps.length === 0 || (job.mode !== "parallel" && job.mode !== "chain")) {
+        return [];
+    }
+    if (hasLogicalChainGroups(job)) {
+        return widgetChainDetails(job, theme, width);
+    }
+    const total = job.stepsTotal ?? steps.length, title = job.mode === "parallel" || job.activeParallelGroup === true ? "Agent" : "Step";
+    return steps.flatMap((step, index) => parallelStepLines(job, theme, step, { title, index: index + 1, total, width }));
+}
+function hasLogicalChainGroups(job) {
+    return (job.mode === "chain" &&
+        job.activeParallelGroup !== true &&
+        (job.parallelGroups?.length ?? 0) > 0);
+}
+function recentToolLines(step, theme, width) {
+    const max = Math.max(40, width - 30);
+    return (step.recentTools ?? []).slice(-3).map((tool) => {
+        const args = tool.args.length <= max ? tool.args : `${tool.args.slice(0, max)}...`;
+        return `      ${theme.fg("dim", `${tool.tool}${hasText(args) ? `: ${args}` : ""}`)}`;
+    });
+}
+function runningStepLines(job, theme, step, layout) {
+    const lines = [], output = widgetOutputPath(job, step), live = buildLiveStatusLine(step, job.updatedAt);
+    if (hasText(output)) {
+        lines.push(`    ${theme.fg("dim", `output: ${shortenPath(output)}`)}`);
+    }
+    if (hasText(live) && live !== layout.activity) {
+        lines.push(`    ${theme.fg("accent", live)}`);
+    }
+    lines.push(...recentToolLines(step, theme, layout.width));
+    for (const line of (step.recentOutput ?? []).slice(-5)) {
+        lines.push(`      ${theme.fg("dim", line)}`);
+    }
+    return lines;
+}
+function foregroundStyleWidgetStepLines(job, theme, step, layout) {
+    const status = widgetStepStatus(step.status, theme), stats = widgetStepStats(theme, step), model = modelThinkingBadge(theme, step.model, step.thinking);
+    const lines = [
+        `  ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, layout.index - 1))} ${layout.title} ${layout.index}/${layout.total}: ${themeBold(theme, step.agent)} ${theme.fg("dim", "·")} ${status}${model}${hasText(stats) ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
+    ];
+    const activity = widgetStepActivityLine(step, layout.width, true, job.updatedAt);
+    if (hasText(activity)) {
+        lines.push(`    ${theme.fg("dim", `⎿  ${activity}`)}`);
+    }
+    for (const nested of formatNestedWidgetLines(step.children, theme, layout.width, {
+        snapshotNow: job.updatedAt,
+    })) {
+        lines.push(`    ${nested}`);
+    }
+    if (step.status === "running") {
+        lines.push(...runningStepLines(job, theme, step, { width: layout.width, activity }));
+    }
+    return lines;
+}
+function unattachedChildren(job, theme, width) {
+    const attached = new Set((job.steps ?? []).flatMap((step) => step.children?.map((child) => child.id) ?? []));
+    return formatNestedWidgetLines(job.nestedChildren?.filter((child) => !attached.has(child.id)), theme, width, { snapshotNow: job.updatedAt }).map((line) => `  ${line}`);
+}
+function foregroundStyleWidgetDetails(job, theme, width) {
+    const steps = job.steps ?? [];
+    if (steps.length === 0) {
+        return [
+            `  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`,
+            ...formatNestedWidgetLines(job.nestedChildren, theme, width, {
+                snapshotNow: job.updatedAt,
+            }).map((line) => `  ${line}`),
+        ];
+    }
+    if (hasLogicalChainGroups(job)) {
+        return widgetChainDetails(job, theme, width);
+    }
+    const total = job.stepsTotal ?? steps.length, title = job.mode === "parallel" || job.activeParallelGroup === true ? "Agent" : "Step";
+    return [
+        ...steps.flatMap((step, index) => foregroundStyleWidgetStepLines(job, theme, step, { title, index: index + 1, total, width })),
+        ...unattachedChildren(job, theme, width),
+    ];
+}
+export function buildSingleWidgetLines(job, theme, width) {
+    const stats = widgetStats(job, theme), mode = widgetJobName(job);
+    const count = job.mode === "chain"
+        ? job.chainStepCount
+        : (job.stepsTotal ?? job.agents?.length ?? job.steps?.length);
+    const title = `async subagent ${mode}${(count ?? 0) > 1 ? ` (${count ?? 0})` : ""}`;
+    return [
+        `${theme.fg("toolTitle", themeBold(theme, title))} ${theme.fg("dim", "· background")}`,
+        `${widgetStatusGlyph(job, theme)} ${themeBold(theme, mode)}${hasText(stats) ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
+        ...foregroundStyleWidgetDetails(job, theme, width),
+    ].map((line) => truncLine(line, width));
+}
+export function collapsedJobRow(job, theme, width) {
+    const stats = widgetStats(job, theme), running = job.steps?.filter((step) => step.status === "running") ?? [];
+    const solo = running.length === 1 ? running[0] : undefined;
+    let activity = widgetActivity(job, false);
+    if (job.status === "running" && solo) {
+        activity = widgetStepActivityLine(solo, width, false, job.updatedAt);
+    }
+    return `${widgetStatusGlyph(job, theme)} ${themeBold(theme, widgetJobName(job))}${hasText(stats) ? ` ${theme.fg("dim", "·")} ${stats}` : ""}${hasText(activity) ? ` ${theme.fg("dim", "·")} ${theme.fg("dim", activity)}` : ""}`;
+}

package/dist/tui/widget-status.js

@@ -0,0 +1,245 @@
+import { hasText } from "./text-values.js";
+import * as path from "node:path";
+import { activityFacts, joinActivity } from "./activity-lines.js";
+import { formatDuration } from "../shared/formatters.js";
+import { flatToLogicalStepIndex } from "../runs/background/parallel-groups.js";
+import { formatAgentRunningLabel } from "../shared/status-format.js";
+import { firstOutputLine, buildLiveStatusLine, runningSeed, runningGlyph, formatTokenStat, formatToolUseStat, statJoin, formatCurrentToolLine, } from "./display.js";
+export function widgetRenderKey(job) {
+    return JSON.stringify({
+        asyncDir: job.asyncDir,
+        status: job.status,
+        activityState: job.activityState,
+        lastActivityAt: job.lastActivityAt,
+        currentTool: job.currentTool,
+        currentToolStartedAt: job.currentToolStartedAt,
+        currentPath: job.currentPath,
+        turnCount: job.turnCount,
+        toolCount: job.toolCount,
+        mode: job.mode,
+        agents: job.agents,
+        currentStep: job.currentStep,
+        chainStepCount: job.chainStepCount,
+        parallelGroups: job.parallelGroups,
+        steps: job.steps,
+        nestedChildren: job.nestedChildren,
+        stepsTotal: job.stepsTotal,
+        runningSteps: job.runningSteps,
+        completedSteps: job.completedSteps,
+        activeParallelGroup: job.activeParallelGroup,
+        startedAt: job.startedAt,
+        updatedAt: job.updatedAt,
+        totalTokens: job.totalTokens,
+    });
+}
+export function formatWidgetAgents(agents) {
+    const distinct = [...new Set(agents)];
+    if (distinct.length === 1 && agents.length > 1) {
+        return `${distinct[0]} ×${agents.length}`;
+    }
+    if (agents.length > 3) {
+        return `${agents.slice(0, 2).join(", ")} +${agents.length - 2} more`;
+    }
+    return agents.join(", ");
+}
+export function widgetJobName(job) {
+    const agents = job.agents ?? [];
+    if (job.mode === "parallel") {
+        return "parallel";
+    }
+    if (job.mode === "chain") {
+        return "chain";
+    }
+    if (job.mode === "single" && agents.length === 1) {
+        return agents[0] ?? "subagent";
+    }
+    if (agents.length > 0) {
+        return formatWidgetAgents(agents);
+    }
+    return job.mode ?? "subagent";
+}
+export function widgetActivity(job, includeCounts = true) {
+    const facts = activityFacts(job, job.updatedAt, includeCounts);
+    if (job.status === "running") {
+        return joinActivity(facts, buildLiveStatusLine(job, job.updatedAt), "thinking…");
+    }
+    const labels = {
+        queued: "queued…",
+        paused: "Paused",
+        failed: "Failed",
+        blocked: "Needs your action",
+        complete: "Done",
+    };
+    const error = job.status === "failed" ? job.steps?.find((step) => hasText(step.error))?.error : undefined;
+    return [labels[job.status], hasText(error) ? firstOutputLine(error) : "", ...facts]
+        .filter(Boolean)
+        .join(" · ");
+}
+export function widgetStepRunningSeed(step, fallbackIndex) {
+    return runningSeed(fallbackIndex, step.index, step.toolCount, step.turnCount, step.tokens?.total, step.lastActivityAt, step.currentToolStartedAt, step.durationMs);
+}
+export function widgetStepsRunningSeed(steps) {
+    let seed;
+    for (const [index, step] of (steps ?? []).entries()) {
+        seed = runningSeed(seed, widgetStepRunningSeed(step, index));
+    }
+    return seed;
+}
+function widgetJobRunningSeed(job) {
+    return runningSeed(job.updatedAt, job.lastActivityAt, job.toolCount, job.turnCount, job.totalTokens?.total, job.currentStep, job.runningSteps, job.completedSteps, widgetStepsRunningSeed(job.steps));
+}
+export function widgetJobsRunningSeed(jobs) {
+    let seed;
+    for (const job of jobs) {
+        seed = runningSeed(seed, widgetJobRunningSeed(job));
+    }
+    return seed;
+}
+export function widgetStatusGlyph(job, theme) {
+    if (job.status === "running") {
+        return theme.fg("accent", runningGlyph(widgetJobRunningSeed(job)));
+    }
+    if (job.status === "queued") {
+        return theme.fg("muted", "◦");
+    }
+    if (job.status === "complete") {
+        return theme.fg("success", "✓");
+    }
+    if (job.status === "blocked") {
+        return theme.fg("warning", "■");
+    }
+    if (job.status === "paused") {
+        return theme.fg("warning", "■");
+    }
+    return theme.fg("error", "✗");
+}
+export function widgetStepGlyph(status, theme, seed) {
+    if (status === "running") {
+        return theme.fg("accent", runningGlyph(seed));
+    }
+    if (status === "complete" || status === "completed") {
+        return theme.fg("success", "✓");
+    }
+    if (status === "failed" || status === "timed-out") {
+        return theme.fg("error", "✗");
+    }
+    if (status === "blocked") {
+        return theme.fg("warning", "■");
+    }
+    if (status === "paused") {
+        return theme.fg("warning", "■");
+    }
+    return theme.fg("muted", "◦");
+}
+export function widgetStepStatus(status, theme) {
+    if (status === "running") {
+        return theme.fg("accent", "running");
+    }
+    if (status === "complete" || status === "completed") {
+        return theme.fg("success", "complete");
+    }
+    if (status === "failed") {
+        return theme.fg("error", "failed");
+    }
+    if (status === "timed-out") {
+        return theme.fg("error", "timed out");
+    }
+    if (status === "blocked") {
+        return theme.fg("warning", "needs your action");
+    }
+    if (status === "paused") {
+        return theme.fg("warning", "paused");
+    }
+    return theme.fg("dim", status);
+}
+export function widgetStepActivity(step, snapshotNow) {
+    if ((step.status === "failed" || step.status === "timed-out") && hasText(step.error)) {
+        return firstOutputLine(step.error);
+    }
+    const facts = activityFacts(step, snapshotNow);
+    if ((step.tokens?.total ?? 0) > 0) {
+        facts.push(formatTokenStat(step.tokens?.total ?? 0));
+    }
+    return joinActivity(facts, buildLiveStatusLine(step, snapshotNow));
+}
+function activeGroupStep(job) {
+    const groups = job.parallelGroups ?? [], current = job.currentStep;
+    const group = current === undefined
+        ? groups.find((candidate) => candidate.start === 0)
+        : groups.find((candidate) => current >= candidate.start && current < candidate.start + candidate.count);
+    return group?.stepIndex ?? current ?? 0;
+}
+function parallelJobStat(job, total) {
+    const running = job.runningSteps ?? Number(job.status === "running");
+    const succeeded = job.completedSteps ?? (job.status === "complete" ? total : 0);
+    const parts = [`${succeeded}/${total} succeeded`];
+    if (job.status === "running" && running > 0) {
+        parts.unshift(formatAgentRunningLabel(running));
+    }
+    if (job.mode === "parallel") {
+        return total > 0 ? parts.join(" · ") : parts.slice(0, -1).join(" · ");
+    }
+    return `step ${activeGroupStep(job) + 1}/${job.chainStepCount ?? total} · parallel group: ${parts.join(" · ")}`;
+}
+function jobStepStat(job) {
+    const total = job.stepsTotal ?? job.agents?.length ?? 1;
+    if (job.activeParallelGroup === true) {
+        return parallelJobStat(job, total);
+    }
+    if (job.currentStep === undefined) {
+        return total > 1 ? `steps ${total}` : "";
+    }
+    return currentStepStat(job, job.currentStep, total);
+}
+function currentStepStat(job, current, total) {
+    const parallelGroups = job.parallelGroups ?? [];
+    if (job.mode !== "chain" || parallelGroups.length === 0) {
+        return `step ${current + 1}/${total}`;
+    }
+    const chainTotal = job.chainStepCount ?? total;
+    return `step ${flatToLogicalStepIndex(current, chainTotal, parallelGroups) + 1}/${chainTotal}`;
+}
+export function widgetStats(job, theme) {
+    const parts = [jobStepStat(job)];
+    if (job.toolCount !== undefined) {
+        parts.push(formatToolUseStat(job.toolCount));
+    }
+    if ((job.totalTokens?.total ?? 0) > 0) {
+        parts.push(formatTokenStat(job.totalTokens?.total ?? 0));
+    }
+    if (job.status !== "queued" && job.startedAt !== undefined && job.updatedAt !== undefined) {
+        parts.push(formatDuration(Math.max(0, job.updatedAt - job.startedAt)));
+    }
+    return statJoin(theme, parts);
+}
+export function widgetStepStats(theme, step) {
+    return statJoin(theme, [
+        step.turnCount !== undefined ? `${step.turnCount} turns` : "",
+        step.toolCount !== undefined ? formatToolUseStat(step.toolCount) : "",
+        (step.tokens?.total ?? 0) !== 0 ? formatTokenStat(step.tokens?.total ?? 0) : "",
+        step.durationMs !== undefined ? formatDuration(step.durationMs) : "",
+    ]);
+}
+export function widgetStepActivityLine(step, width, expanded, snapshotNow) {
+    if ((step.status === "failed" || step.status === "timed-out") && hasText(step.error)) {
+        return firstOutputLine(step.error);
+    }
+    const toolLine = formatCurrentToolLine(step, width, expanded, snapshotNow);
+    if (hasText(toolLine)) {
+        return toolLine;
+    }
+    const activity = buildLiveStatusLine(step, snapshotNow);
+    if (hasText(activity)) {
+        return activity;
+    }
+    if (step.status === "running") {
+        return "thinking…";
+    }
+    return "";
+}
+export function widgetOutputPath(job, step) {
+    if (typeof step.index !== "number") {
+        return undefined;
+    }
+    return path.join(job.asyncDir, `output-${step.index}.log`);
+}

package/dist/tui/widget.js

@@ -0,0 +1,145 @@
+import { Container, Text } from "@earendil-works/pi-tui";
+import { MAX_WIDGET_JOBS, WIDGET_KEY, } from "../shared/types.js";
+import { isTuiContext } from "../shared/ui-mode.js";
+import { truncLine, getTermWidth, themeBold, runningGlyph } from "./display.js";
+import { buildSingleWidgetLines, collapsedJobRow, widgetParallelAgentDetails, } from "./widget-details.js";
+import { widgetStats, widgetStatusGlyph, widgetJobName, widgetActivity, widgetJobsRunningSeed, } from "./widget-status.js";
+import { hasText } from "./text-values.js";
+function groups(jobs) {
+    return {
+        running: jobs.filter((job) => job.status === "running"),
+        queued: jobs.filter((job) => job.status === "queued"),
+        finished: jobs.filter((job) => job.status !== "running" && job.status !== "queued"),
+    };
+}
+function queuedItem(jobs, expanded) {
+    const first = jobs.at(0);
+    return jobs.length === 1 && !expanded && first
+        ? { kind: "job", job: first }
+        : { kind: "queued", count: jobs.length };
+}
+function selectItems(input, expanded) {
+    const shownRunning = input.running.slice(0, MAX_WIDGET_JOBS), items = shownRunning.map((job) => ({ kind: "job", job }));
+    let slots = MAX_WIDGET_JOBS - items.length, queuedShown = false;
+    if (input.queued.length > 0 && slots > 0) {
+        items.push(queuedItem(input.queued, expanded));
+        slots--;
+        queuedShown = true;
+    }
+    const shownFinished = input.finished.slice(0, slots);
+    items.push(...shownFinished.map((job) => ({ kind: "job", job })));
+    const running = input.running.length - shownRunning.length, finished = input.finished.length - shownFinished.length, queued = queuedShown ? 0 : input.queued.length;
+    if (running + finished + queued > 0) {
+        items.push({ kind: "hidden", running, finished, queued });
+    }
+    return items;
+}
+function hiddenLabel(item) {
+    const parts = [];
+    if (item.running > 0) {
+        parts.push(`${item.running} running`);
+    }
+    if (item.queued > 0) {
+        parts.push(`${item.queued} queued`);
+    }
+    if (item.finished > 0) {
+        parts.push(`${item.finished} finished`);
+    }
+    return `+${item.running + item.finished + item.queued} more (${parts.join(", ")})`;
+}
+function jobLines(job, theme, width, expanded) {
+    if (!expanded) {
+        return [collapsedJobRow(job, theme, width)];
+    }
+    const stats = widgetStats(job, theme);
+    return [
+        `${widgetStatusGlyph(job, theme)} ${themeBold(theme, widgetJobName(job))}${hasText(stats) ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
+        `  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`,
+        ...widgetParallelAgentDetails(job, theme, width),
+    ];
+}
+function itemLines(item, theme, width, expanded) {
+    switch (item.kind) {
+        case "job":
+            return jobLines(item.job, theme, width, expanded);
+        case "queued":
+            return [`${theme.fg("muted", "◦")} ${theme.fg("dim", `${item.count} queued`)}`];
+        case "hidden":
+            return [theme.fg("dim", hiddenLabel(item))];
+    }
+}
+function treeLines(items, theme, width) {
+    const lines = [];
+    for (const [index, item] of items.entries()) {
+        const last = index === items.length - 1, branch = last ? "└─" : "├─", continuation = last ? "   " : "│  ";
+        lines.push(truncLine(`${theme.fg("dim", branch)} ${item[0] ?? ""}`, width));
+        for (const detail of item.slice(1)) {
+            lines.push(truncLine(`${theme.fg("dim", continuation)} ${detail}`, width));
+        }
+    }
+    return lines;
+}
+function header(input, theme, hint) {
+    const active = input.running.length > 0 || input.queued.length > 0;
+    let glyph = active ? "●" : "○";
+    if (input.running.length > 0) {
+        glyph = runningGlyph(widgetJobsRunningSeed(input.running));
+    }
+    const color = active ? "accent" : "dim";
+    return `${theme.fg(color, glyph)} ${theme.fg(color, "Async agents")} ${theme.fg("dim", "· background")}${hint}`;
+}
+function expansionHint(running, theme, expanded) {
+    return running > 0 && !expanded ? ` ${theme.fg("dim", "·")} ${theme.fg("accent", "Ctrl+O")}` : "";
+}
+export function buildWidgetLines(jobs, theme, width = getTermWidth(), expanded = false) {
+    const first = jobs.at(0);
+    if (first === undefined) {
+        return [];
+    }
+    if (jobs.length === 1 && expanded) {
+        return buildSingleWidgetLines(first, theme, width);
+    }
+    const input = groups(jobs), items = selectItems(input, expanded).map((item) => itemLines(item, theme, width, expanded));
+    const hint = expansionHint(input.running.length, theme, expanded);
+    if (items.length === 1 && !expanded) {
+        return [truncLine(`${items.at(0)?.at(0) ?? ""}${hint}`, width)];
+    }
+    return [truncLine(header(input, theme, hint), width), ...treeLines(items, theme, width)];
+}
+function fitWidgetLineBudget(lines, theme, width, expanded) {
+    const rows = process.stdout.rows > 0 ? process.stdout.rows : 30;
+    const budget = expanded ? Math.max(4, Math.min(24, Math.floor(rows * 0.4))) : MAX_WIDGET_JOBS + 2;
+    if (lines.length <= budget) {
+        return [...lines];
+    }
+    const visible = Math.max(1, budget - 1), hidden = lines.length - visible;
+    const hint = expanded
+        ? `… ${hidden} live-detail lines hidden`
+        : `… ${hidden} lines hidden · Ctrl+O expands`;
+    return [...lines.slice(0, visible), truncLine(theme.fg("dim", hint), width)];
+}
+function buildWidgetComponent(jobs, isExpanded) {
+    return (_tui, theme) => ({
+        render(availableWidth) {
+            const width = Math.max(1, availableWidth - 2), expanded = isExpanded(), container = new Container();
+            const lines = fitWidgetLineBudget(buildWidgetLines(jobs, theme, width, expanded), theme, width, expanded);
+            for (const line of lines) {
+                container.addChild(new Text(line, 1, 0));
+            }
+            return container.render(availableWidth);
+        },
+        invalidate() {
+            /* This widget rebuilds its small live layout from current facts on each render. */
+        },
+    });
+}
+export function renderWidget(ctx, jobs) {
+    if (!isTuiContext(ctx)) {
+        return;
+    }
+    if (jobs.length === 0) {
+        ctx.ui.setWidget(WIDGET_KEY, undefined);
+        return;
+    }
+    ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(jobs, () => ctx.ui.getToolsExpanded()));
+}