@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/dist/tui/view-persistence.js

@@ -1,51 +0,0 @@
-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

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

package/dist/tui/view-session.js

@@ -1,37 +0,0 @@
-/** 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

@@ -1,144 +0,0 @@
-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

@@ -1,245 +0,0 @@
-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

@@ -1,145 +0,0 @@
-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()));
-}