@litfamily/litopencode 1.0.31 → 1.0.33

package/dist/tui/mission-source.js

@@ -4,7 +4,11 @@
 import fs from "node:fs";
 import path from "node:path";
 import { planChecklist, readLitMark, readWorkState } from "./mission-model.js";
+import { isLaneResult, isReviewLane } from "./mission-looks.js";
 import { readSkillUse, skillChips } from "./mission-skills.js";
+import { isRealCount } from "./mission-threads.js";
+import { readSiblingStacksSync, readStackSync } from "../workflow-stack.js";
+import { readLivenessSync } from "../session-liveness.js";
 const ledgerByteLimit = 1024 * 1024;
 /** The same root the server plugin uses: the worktree unless it is the filesystem root, else the directory. */
 export function missionProjectRoot(paths) {
@@ -67,7 +71,7 @@ export function createWorkReader() {
             return undefined;
         const inside = work.planPath !== "" && path.isAbsolute(work.planPath) && !path.relative(path.resolve(root), work.planPath).startsWith("..");
         const plan = inside ? readPlan(work.planPath) : undefined;
-        return { status: work.status, iterations: work.iterations, ...(plan === undefined ? {} : { plan }) };
+        return { status: work.status, iterations: work.iterations, ...(plan === undefined ? {} : { plan }), ...(work.boundary === true ? { boundary: true } : {}) };
     };
 }
 function lstatOrUndefined(file) {
@@ -235,6 +239,35 @@ export function readMissionInput(state, sessionID, ledger, now, records = {}) {
         now
     };
 }
+/** A completed `review-work` call with action `lane`: one lane's reported result. */
+export function readLaneReport(part) {
+    if (!isRecord(part) || part.type !== "tool" || part.tool !== "review-work" || !isRecord(part.state) || part.state.status !== "completed")
+        return undefined;
+    const input = isRecord(part.state.input) ? part.state.input : {};
+    if (input.action !== "lane" || !isReviewLane(input.lane) || !isLaneResult(input.result))
+        return undefined;
+    return { lane: input.lane, result: input.result };
+}
+/**
+ * True when the reply's first line of prose opens with `BLOCKED:`. The ignition mark comes first on the
+ * host (a fenced LIT block from experimental.text.complete, and the model's `LIT IGNITED` line), so those
+ * lines and blank ones are passed over; anything else ends the search.
+ */
+export function opensBlocked(parts) {
+    const text = parts.map((part) => (isRecord(part) && part.type === "text" && typeof part.text === "string" ? part.text : "")).join("\n");
+    let fenced = false;
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("```")) {
+            fenced = !fenced;
+            continue;
+        }
+        if (fenced || trimmed === "" || trimmed.includes("LIT IGNITED"))
+            continue;
+        return /^BLOCKED:/u.test(trimmed);
+    }
+    return false;
+}
 /**
  * What the band card shows beside the mission: the session's skill chips, whether a turn is running,
  * context use and git branch. OpenCode keeps each session's last `session.status` ({ type: "busy" },
@@ -244,23 +277,205 @@ export function readCardInput(state, sessionID) {
     const messages = state.session.messages(sessionID);
     const uses = [];
     let since;
+    // A new review start clears the lanes, so the border shows only this review's reports.
+    let lanes;
     for (const message of messages) {
         const at = num(message.time?.created);
         if (message.role === "user")
             since = at;
         for (const part of state.part(message.id)) {
+            const report = readLaneReport(part);
+            if (report !== undefined) {
+                lanes = { ...lanes, [report.lane]: report.result };
+                continue;
+            }
             const use = readSkillUse(part, at);
             if (use !== undefined)
                 uses.push(use);
+            const action = isRecord(part) && isRecord(part.state) && isRecord(part.state.input) ? part.state.input.action : undefined;
+            if (use?.name === "review-work" && action !== "status" && action !== "lane")
+                lanes = {};
         }
     }
     const status = state.session.status(sessionID)?.type;
     const busy = status === "busy" || status === "retry";
     const branch = state.vcs?.branch?.trim();
+    const last = messages.at(-1);
+    const asked = state.session.permission(sessionID).length > 0 || state.session.question(sessionID).length > 0;
     return {
         chips: skillChips(uses, { since, busy }),
         busy,
         contextPercent: contextPercent(state, messages),
-        ...(branch === undefined || branch === "" ? {} : { branch })
+        ...(branch === undefined || branch === "" ? {} : { branch }),
+        ...(lanes === undefined ? {} : { lanes }),
+        ...(asked ? { asked } : {}),
+        ...(last?.role === "user" ? { userSpokeLast: true } : {}),
+        ...(last?.role === "assistant" && opensBlocked(state.part(last.id)) ? { blockedReply: true } : {})
+    };
+}
+export const earlierWorkWindowMs = 7 * 24 * 60 * 60_000;
+const siblingFreshMs = 15 * 60_000;
+const siblingMax = 6;
+const taskLingerMs = 30_000;
+const recentAssistantMessages = 3;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function countsOf(done, total) {
+    return isRealCount(done, total) ? { done, total } : {};
+}
+function taskSources(state, sessionID, now) {
+    const sources = [];
+    const children = new Set();
+    const assistants = state.session.messages(sessionID).filter((message) => message.role === "assistant").slice(-recentAssistantMessages);
+    for (const message of assistants) {
+        for (const part of state.part(message.id)) {
+            if (part.type !== "tool" || part.tool !== "task" || !isRecord(part.state))
+                continue;
+            const toolState = part.state;
+            const status = toolState.status;
+            const time = isRecord(toolState.time) ? toolState.time : {};
+            const start = typeof time.start === "number" ? time.start : undefined;
+            const end = typeof time.end === "number" ? time.end : undefined;
+            if (status !== "running" && status !== "completed" && status !== "error")
+                continue;
+            if (status !== "running" && (end === undefined || now - end > taskLingerMs))
+                continue;
+            const input = isRecord(toolState.input) ? toolState.input : {};
+            const metadata = isRecord(toolState.metadata) ? toolState.metadata : {};
+            const child = typeof metadata.sessionId === "string" ? metadata.sessionId : undefined;
+            if (child !== undefined)
+                children.add(child);
+            const todos = child === undefined ? [] : state.session.todo(child).filter((todo) => todo.status !== "cancelled");
+            const done = todos.filter((todo) => todo.status === "completed").length;
+            const name = typeof input.description === "string" && input.description.trim() !== "" ? input.description.trim() : typeof input.subagent_type === "string" ? input.subagent_type : "subagent";
+            // A running task last moved when its own session did; its start time alone would read a long, busy run as idle.
+            const moved = child === undefined ? undefined : lastActivity(state, child);
+            sources.push({
+                kind: "task",
+                name,
+                status: status === "running" ? "working" : status === "completed" ? "done" : "failed",
+                ...countsOf(done, todos.length),
+                ...(start === undefined ? {} : { startedAt: start }),
+                touchedAt: end ?? (start === undefined && moved === undefined ? now : Math.max(start ?? 0, moved ?? 0))
+            });
+        }
+    }
+    return { sources, children };
+}
+/** The latest time any message of a session was created or completed, if it has one. */
+function lastActivity(state, sessionID) {
+    let latest;
+    for (const message of state.session.messages(sessionID)) {
+        for (const at of [message.time?.created, message.time?.completed]) {
+            if (typeof at === "number" && Number.isFinite(at) && (latest === undefined || at > latest))
+                latest = at;
+        }
+    }
+    return latest;
+}
+function stackSources(stack) {
+    return (stack?.frames ?? []).map((frame) => ({
+        kind: "stack",
+        name: frame.skill,
+        status: frame.status === "active" ? "working" : "paused",
+        ...countsOf(frame.done, frame.total),
+        ...(frame.phase === undefined ? {} : { phase: frame.phase }),
+        touchedAt: frame.at
+    }));
+}
+/** `<skill> · <herdr pane>` when the session runs in a herdr pane, else the last four characters of its id. */
+function siblingName(skill, sessionID, liveness) {
+    return `${skill} · ${liveness?.herdrPane ?? sessionID.slice(-4)}`;
+}
+/** A sibling's own liveness record settles its status: ended reads done, idle reads idle (a held frame stays paused). */
+function siblingSource(stack, liveness, finishedAt) {
+    const top = stack.frames.find((frame) => frame.status === "active") ?? stack.frames[stack.frames.length - 1];
+    const endedAt = liveness?.state === "ended" ? Date.parse(liveness.at) : finishedAt;
+    const status = endedAt !== undefined ? "done" : top.status !== "active" ? "paused" : liveness?.state === "idle" ? "idle" : "working";
+    return {
+        kind: "session",
+        name: siblingName(top.skill, stack.sessionID, liveness),
+        status,
+        ...countsOf(top.done, top.total),
+        ...(top.phase === undefined ? {} : { phase: top.phase }),
+        touchedAt: Math.max(stack.updatedAt, liveness === undefined ? 0 : Date.parse(liveness.at)),
+        ...(endedAt === undefined ? {} : { doneAt: endedAt }),
+        ...(liveness === undefined && finishedAt === undefined ? {} : { settled: true })
     };
 }
+/** Another session's start-work run that completed, with when, read from the bounded work record. */
+function finishedWork(root, sessionID, now) {
+    const file = path.join(litLoopDir(root), "work-schema-3.json");
+    const stat = lstatOrUndefined(file);
+    if (stat === undefined || !stat.isFile() || stat.size > ledgerByteLimit)
+        return undefined;
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!isRecord(raw) || raw.schemaVersion !== 3 || raw.status !== "completed" || typeof raw.sessionID !== "string" || raw.sessionID === sessionID)
+            return undefined;
+        const at = typeof raw.updatedAt === "string" ? Date.parse(raw.updatedAt) : Number.NaN;
+        return Number.isFinite(at) && at <= now && now - at <= siblingFreshMs ? { sessionID: raw.sessionID, at } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The lanes beside this session's own mission: its workflow stack frames, its running `task` calls and
+ * the stacks of other sessions in the workspace that moved in the last fifteen minutes, read with their
+ * liveness records. Another session's completed start-work run shows as done. Only counts that are real
+ * totals are carried; the input of a tool call is read for its description alone.
+ */
+export function readThreadSources(state, sessionID, root, now) {
+    const tasks = taskSources(state, sessionID, now);
+    if (root === undefined)
+        return tasks.sources;
+    const siblings = readSiblingStacksSync(root, sessionID, { now, freshMs: siblingFreshMs, max: siblingMax }).filter((stack) => !tasks.children.has(stack.sessionID));
+    const finished = finishedWork(root, sessionID, now);
+    const others = siblings.map((stack) => siblingSource(stack, readLivenessSync(root, stack.sessionID), stack.sessionID === finished?.sessionID ? finished.at : undefined));
+    if (finished !== undefined && !siblings.some((stack) => stack.sessionID === finished.sessionID) && !tasks.children.has(finished.sessionID)) {
+        others.push({ kind: "session", name: siblingName("start-work", finished.sessionID, readLivenessSync(root, finished.sessionID)), status: "done", touchedAt: finished.at, doneAt: finished.at, settled: true });
+    }
+    return [...stackSources(readStackSync(root, sessionID)), ...tasks.sources, ...others];
+}
+/**
+ * Whether earlier work exists for the band's idle hint and the one suggestion: another session here
+ * touched its workflow stack within `withinMs`.
+ */
+/** When the session's last message and its last user prompt were created, from the reactive store. */
+export function messageTimes(state, sessionID) {
+    let lastAt;
+    let lastPromptAt;
+    for (const message of state.session.messages(sessionID)) {
+        const created = message.time?.created;
+        if (typeof created !== "number")
+            continue;
+        if (lastAt === undefined || created > lastAt)
+            lastAt = created;
+        if (message.role === "user" && (lastPromptAt === undefined || created > lastPromptAt))
+            lastPromptAt = created;
+    }
+    return { ...(lastAt === undefined ? {} : { lastAt }), ...(lastPromptAt === undefined ? {} : { lastPromptAt }) };
+}
+/** The way back in is offered after this long without a message in the session. */
+export const adhdBreakMs = 30 * 60_000;
+/** The idle card names lit adhd in a fresh session or after a break, only when earlier work exists. */
+export function wayBackDue(lastActivityAt, now, earlier) {
+    return earlier && (lastActivityAt === undefined || now - lastActivityAt >= adhdBreakMs);
+}
+function localDay(at) {
+    const date = new Date(at);
+    return `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
+}
+/** At most one start suggestion per workspace per local day; records the day when it answers true. */
+export function adhdSuggestDue(days, root, now) {
+    const day = localDay(now);
+    if (days.get(root) === day)
+        return false;
+    days.set(root, day);
+    return true;
+}
+export function hasEarlierWork(root, sessionID, now, withinMs) {
+    return root !== undefined && readSiblingStacksSync(root, sessionID, { now, freshMs: withinMs, max: 1 }).length > 0;
+}

package/dist/tui/mission-text.d.ts

@@ -53,6 +53,8 @@ export declare function chipBudget(input: {
     readonly child: boolean;
 }): number;
 export declare function cellWidth(value: string): number;
+/** Record text without terminal escape sequences or control characters; tabs and newlines become spaces later. */
+export declare function stripControls(value: string): string;
 /** Cuts `value` to at most `max` cells, ending in an ellipsis when anything was dropped. */
 export declare function truncateCells(value: string, max: number): string;
 export declare function padCells(value: string, width: number): string;

package/dist/tui/mission-text.js

@@ -120,9 +120,17 @@ export function cellWidth(value) {
         width += charWidth(char);
     return width;
 }
+// Escape and control sequences (CSI, OSC, C1) from plan rows, todos, branches or commit text would act on
+// the terminal instead of being drawn, so they are removed before any record text reaches a cell.
+const terminalSequence = /\u001b\[[0-?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)?|\u001b[@-Z\\-_]|\u009b[0-?]*[ -/]*[@-~]|\u009d[^\u0007\u009c]*[\u0007\u009c]?/gu;
+const controlCharacter = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f]/gu;
+/** Record text without terminal escape sequences or control characters; tabs and newlines become spaces later. */
+export function stripControls(value) {
+    return value.replace(terminalSequence, "").replace(controlCharacter, "");
+}
 /** Cuts `value` to at most `max` cells, ending in an ellipsis when anything was dropped. */
 export function truncateCells(value, max) {
-    const clean = value.replace(/\s+/gu, " ").trim();
+    const clean = stripControls(value).replace(/\s+/gu, " ").trim();
     if (cellWidth(clean) <= max)
         return clean;
     if (max <= 0)

package/dist/tui/mission-threads.d.ts

@@ -0,0 +1,58 @@
+import { type Line, type MissionPalette } from "./mission-text.ts";
+export type ThreadStatus = "working" | "paused" | "done" | "failed" | "idle";
+export type ThreadSource = {
+    readonly kind: "stack" | "task" | "session";
+    readonly name: string;
+    readonly status: ThreadStatus;
+    /** Both counts or neither. */
+    readonly done?: number;
+    readonly total?: number;
+    /** A word for what is known, such as the stage a frame is on. */
+    readonly phase?: string;
+    /** When the lane started, for the elapsed time of a task. */
+    readonly startedAt?: number;
+    /** When the lane last moved; an old one reads as idle. */
+    readonly touchedAt?: number;
+    /** When a done lane finished; it leaves the card a minute later. */
+    readonly doneAt?: number;
+    /** The status came from the session's liveness record, so the five-minute idle guess does not apply. */
+    readonly settled?: boolean;
+};
+export type ThreadRow = {
+    readonly key: string;
+    readonly name: string;
+    readonly status: ThreadStatus;
+    readonly done?: number;
+    readonly total?: number;
+    readonly facts: string;
+};
+export declare const threadRowCap = 4;
+/** A lane untouched for this long is shown as idle rather than working. */
+export declare const idleAfterMs: number;
+/** A finished lane stays this long, so a glance still catches it, then leaves. */
+export declare const doneLingerMs = 60000;
+export declare function isRealCount(done: unknown, total: unknown): done is number;
+/**
+ * The rows for the sources, or undefined when only one lane of the session's own work exists, which the
+ * four-row card already shows; one other session is still a row. A source untouched for five minutes reads
+ * as idle unless a liveness record settled it, a done lane leaves a minute after it finished, and other
+ * sessions follow the session's own lanes, working first, then paused, finished and idle.
+ */
+export declare function threadsOf(sources: readonly ThreadSource[], now: number): ThreadRow[] | undefined;
+/** How many card rows the threads take: the fork line, the shown lanes and the `+N more` line. */
+export declare function threadLineCount(rows: readonly ThreadRow[] | undefined): number;
+/** `[▉▉▉░░░░░] 3/10` for a real total, an empty string otherwise. */
+export declare function threadGauge(done: number | undefined, total: number | undefined, cells: number): string;
+/** An indeterminate pulse: five cells that scan while motion is on, one steady frame otherwise. */
+export declare function pulseText(now: number, motion: boolean): string;
+export type ThreadDrawOptions = {
+    readonly now: number;
+    readonly motion: boolean;
+    /** A colour per gauge index while the rainbow plays; the gauge keeps the palette colour otherwise. */
+    readonly gaugeColor?: (index: number) => string;
+};
+/**
+ * The lines under the skill row: `┬ 3 lanes in parallel`, then one `├─`/`└─` line per lane (four at most;
+ * `+N more` names the rest). Each line is fitted to `width` by the caller.
+ */
+export declare function threadLines(rows: readonly ThreadRow[], palette: MissionPalette, width: number, options: ThreadDrawOptions): Line[];

package/dist/tui/mission-threads.js

@@ -0,0 +1,128 @@
+// Thread rows for the band: the lanes of work that run beside the session's own mission. A lane is a
+// frame on this session's workflow stack (a paused spine under an interjected command), a `task` tool
+// call that runs a subagent, or another session in the same workspace whose stack moved lately. The
+// module is pure: sources go in, rows and drawn lines come out.
+//
+// A gauge needs a real total. Without one a row says what is known in words (how long it has run, which
+// step it is on) and, while it is working, plays a small pulse; it never shows a question mark.
+import { cellWidth, lineWidth, truncateCells } from "./mission-text.js";
+export const threadRowCap = 4;
+/** A lane untouched for this long is shown as idle rather than working. */
+export const idleAfterMs = 5 * 60_000;
+/** A finished lane stays this long, so a glance still catches it, then leaves. */
+export const doneLingerMs = 60_000;
+const sessionRank = { working: 0, paused: 1, done: 2, failed: 2, idle: 3 };
+const pulseFrames = ["▓▒░░░", "░▓▒░░", "░░▓▒░", "░░░▓▒", "░░▒▓░", "░▒▓░░"];
+const steadyPulse = "░▒▓▒░";
+const pulseMs = 250;
+const statusWordCells = 7;
+export function isRealCount(done, total) {
+    return Number.isInteger(done) && Number.isInteger(total) && total > 0 && done >= 0 && done <= total;
+}
+function minutes(from, now) {
+    if (from === undefined || !Number.isFinite(from) || from > now)
+        return undefined;
+    const total = Math.floor((now - from) / 60_000);
+    return total < 1 ? "<1m" : total < 60 ? `${total}m` : `${Math.floor(total / 60)}h${String(total % 60).padStart(2, "0")}`;
+}
+function factsFor(source, status, now) {
+    const parts = [];
+    if (source.phase !== undefined && source.phase !== "")
+        parts.push(source.phase);
+    const elapsed = minutes(source.startedAt ?? (status === "working" ? source.touchedAt : undefined), now);
+    if (elapsed !== undefined && status === "working")
+        parts.push(elapsed);
+    if (parts.length === 0)
+        parts.push(status === "done" ? "finished" : status === "failed" ? "stopped" : status === "paused" ? "held" : status === "idle" ? "quiet" : "started");
+    return parts.join(" · ");
+}
+/**
+ * The rows for the sources, or undefined when only one lane of the session's own work exists, which the
+ * four-row card already shows; one other session is still a row. A source untouched for five minutes reads
+ * as idle unless a liveness record settled it, a done lane leaves a minute after it finished, and other
+ * sessions follow the session's own lanes, working first, then paused, finished and idle.
+ */
+export function threadsOf(sources, now) {
+    const live = sources.filter((source) => !(source.status === "done" && source.doneAt !== undefined && now - source.doneAt > doneLingerMs));
+    const statusOf = (source) => source.status === "working" && source.settled !== true && source.touchedAt !== undefined && now - source.touchedAt > idleAfterMs ? "idle" : source.status;
+    const own = live.filter((source) => source.kind !== "session");
+    const others = live.filter((source) => source.kind === "session").sort((left, right) => sessionRank[statusOf(left)] - sessionRank[statusOf(right)]);
+    if (others.length === 0 && own.length < 2)
+        return undefined;
+    return [...own, ...others].map((source, index) => {
+        const status = statusOf(source);
+        return {
+            key: `${source.kind}:${index}:${source.name}`,
+            name: source.name,
+            status,
+            ...(isRealCount(source.done, source.total) ? { done: source.done, total: source.total } : {}),
+            facts: factsFor(source, status, now)
+        };
+    });
+}
+/** How many card rows the threads take: the fork line, the shown lanes and the `+N more` line. */
+export function threadLineCount(rows) {
+    if (rows === undefined || rows.length === 0)
+        return 0;
+    return 1 + Math.min(rows.length, threadRowCap) + (rows.length > threadRowCap ? 1 : 0);
+}
+/** `[▉▉▉░░░░░] 3/10` for a real total, an empty string otherwise. */
+export function threadGauge(done, total, cells) {
+    if (!isRealCount(done, total) || cells < 1)
+        return "";
+    const full = Math.round((done / total) * cells);
+    return `[${"▉".repeat(full)}${"░".repeat(cells - full)}] ${done}/${total}`;
+}
+/** An indeterminate pulse: five cells that scan while motion is on, one steady frame otherwise. */
+export function pulseText(now, motion) {
+    return motion ? pulseFrames[Math.floor(now / pulseMs) % pulseFrames.length] : steadyPulse;
+}
+const statusWords = { working: "working", paused: "paused", done: "done", failed: "failed", idle: "idle" };
+function statusColor(status, palette) {
+    if (status === "working")
+        return palette.info;
+    if (status === "done")
+        return palette.success;
+    if (status === "failed")
+        return palette.error;
+    if (status === "paused")
+        return palette.warning;
+    return palette.muted;
+}
+function rowLine(row, index, last, palette, width, options) {
+    const branch = { text: last ? "└─ " : "├─ ", fg: palette.borderSubtle };
+    const word = { text: statusWords[row.status].padEnd(statusWordCells), fg: statusColor(row.status, palette), bold: row.status === "working" };
+    const gap = { text: "  ", fg: palette.muted };
+    const gaugeColor = options.gaugeColor?.(index) ?? palette.accent;
+    const real = threadGauge(row.done, row.total, 8);
+    const trailing = (room) => {
+        if (real !== "" && cellWidth(real) <= room)
+            return [{ text: real, fg: gaugeColor }];
+        const facts = truncateCells(row.facts, Math.max(0, room - (row.status === "working" ? 6 : 0)));
+        const pulse = row.status === "working" ? [{ text: ` ${pulseText(options.now, options.motion)}`, fg: gaugeColor }] : [];
+        return [{ text: facts, fg: palette.muted }, ...pulse];
+    };
+    const fixed = lineWidth([branch, gap, word, gap]);
+    const room = Math.max(0, width - fixed);
+    const nameRoom = Math.max(6, Math.min(24, Math.floor(room / 2)));
+    const name = { text: truncateCells(row.name, nameRoom), fg: row.status === "idle" || row.status === "done" ? palette.muted : palette.text };
+    const pad = { text: " ".repeat(Math.max(0, Math.min(24, nameRoom) - cellWidth(name.text))), fg: palette.muted };
+    const left = [branch, name, pad, gap, word, gap];
+    return [...left, ...trailing(Math.max(0, width - lineWidth(left)))];
+}
+/**
+ * The lines under the skill row: `┬ 3 lanes in parallel`, then one `├─`/`└─` line per lane (four at most;
+ * `+N more` names the rest). Each line is fitted to `width` by the caller.
+ */
+export function threadLines(rows, palette, width, options) {
+    if (rows.length === 0)
+        return [];
+    const shown = rows.slice(0, threadRowCap);
+    const more = rows.length - shown.length;
+    const fork = [{ text: "┬ ", fg: palette.borderSubtle }, { text: `${rows.length} ${rows.length === 1 ? "lane" : "lanes"} in parallel`, fg: palette.muted }];
+    const lines = [fork];
+    shown.forEach((row, index) => lines.push(rowLine(row, index, index === shown.length - 1 && more === 0, palette, width, options)));
+    if (more > 0)
+        lines.push([{ text: "└─ ", fg: palette.borderSubtle }, { text: `+${more} more`, fg: palette.muted }]);
+    return lines;
+}