infinity-harness 2.8.9 → 2.8.11

package/dist/src/ui/widget.js

@@ -0,0 +1,721 @@
+/**
+ * infinity-harness — the plan widget.
+ *
+ * This is what the human watches while the loop runs unattended for hours. It
+ * has to answer three questions in one glance, without scrolling:
+ *
+ *   Where are we?      the phase rail
+ *   How far along?     the progress meter
+ *   What is happening? the task window, centred on the active task
+ *
+ * Everything is derived from state on disk, so the widget is always truthful
+ * even if the agent's own narration has drifted.
+ */
+import { computeProgress, flattenTasks, nextActionableTask } from "../core/featureList.js";
+import { getPhaseOrder } from "../core/phases.js";
+import { focusRowIndex } from "./planTree.js";
+import { defaultDisplay, normalizeDisplay } from "./display.js";
+import { createStyler, detectGlyphs, padEnd, truncate, width, wrap, } from "./theme.js";
+export const DEFAULT_WIDTH = 76;
+/** Plan rows shown at once. Enough for context, short enough to stay glanceable. */
+export const TASK_WINDOW = 9;
+/** Completed rows kept above the active task so progress stays visible. */
+export const COMPLETED_CONTEXT = 3;
+/** How many rows one scroll step moves. */
+export const SCROLL_STEP = 3;
+/** Rows shown when the human expands the widget. */
+export const EXPANDED_WINDOW = 28;
+export function defaultView() {
+    return { scroll: null, expanded: false };
+}
+/**
+ * Move the view. Returns a new view; the caller stores it.
+ *
+ * Scrolling to the very top is how the human gets back to "following the run":
+ * a widget that has to be reset from a menu is a widget that stays stuck.
+ */
+export function scrollView(view, delta, rowCount, windowRows) {
+    const max = Math.max(0, rowCount - windowRows);
+    const current = view.scroll ?? 0;
+    const next = Math.max(0, Math.min(max, current + delta));
+    return { ...view, scroll: next };
+}
+const STATUS_ROLE = {
+    pending: "pending",
+    in_progress: "active",
+    complete: "success",
+    blocked: "blocked",
+    rework: "rework",
+};
+export function statusGlyph(status, g = detectGlyphs()) {
+    switch (status) {
+        case "complete":
+        case "done":
+        case "closed":
+        case "passed":
+            return g.complete;
+        case "in_progress":
+        case "in-progress":
+        case "active":
+            return g.inProgress;
+        case "blocked":
+            return g.blocked;
+        case "rework":
+        case "waiting":
+            return g.rework;
+        default:
+            return g.pending;
+    }
+}
+function statusRole(status) {
+    return STATUS_ROLE[status] ?? "pending";
+}
+/**
+ * Pick the slice of tasks to display: centred on the active task, biased so a
+ * few completed rows stay visible above it. Clamps at both ends so the window
+ * is always exactly `limit` rows when there are enough tasks.
+ */
+export function taskWindowBounds(tasks, limit = TASK_WINDOW, context = COMPLETED_CONTEXT) {
+    const total = tasks.length;
+    if (total <= limit)
+        return { start: 0, end: total };
+    let active = tasks.findIndex((t) => t.status === "in_progress");
+    if (active === -1)
+        active = tasks.findIndex((t) => t.status === "rework");
+    if (active === -1)
+        active = tasks.findIndex((t) => t.status === "blocked");
+    if (active === -1)
+        active = tasks.findIndex((t) => t.status === "pending");
+    if (active === -1)
+        active = total - 1; // everything done: show the tail
+    if (active < limit - context)
+        return { start: 0, end: limit };
+    if (active >= total - (limit - context))
+        return { start: total - limit, end: total };
+    const start = Math.max(0, Math.min(active - context, total - limit));
+    return { start, end: start + limit };
+}
+/** `▰▰▰▰▱▱▱▱ 62%` — a fixed-width meter that never reflows the line. */
+export function progressBar(percent, cells, g, s) {
+    const clamped = Math.max(0, Math.min(100, percent));
+    const filled = Math.round((clamped / 100) * cells);
+    const bar = s.fg("success", g.barFull.repeat(filled)) + s.fg("rule", g.barEmpty.repeat(Math.max(0, cells - filled)));
+    return bar + " " + s.bold(String(clamped).padStart(3) + "%");
+}
+/**
+ * `define ─ plan ─ ◉ BUILD ─ verify ─ review ─ ship`
+ *
+ * Collapses to just the current phase plus its neighbours when the terminal is
+ * too narrow to hold the whole pipeline.
+ */
+export function phaseRail(current, enabled, max, g, s, gateHistory) {
+    const order = getPhaseOrder(enabled);
+    const idx = current ? order.indexOf(current) : -1;
+    // Last verdict per phase — failed phases show as blocked (red).
+    const lastByPhase = new Map();
+    if (gateHistory) {
+        for (let i = gateHistory.length - 1; i >= 0; i--) {
+            const e = gateHistory[i];
+            if (!e?.phase || !e?.result)
+                continue;
+            if (!lastByPhase.has(e.phase))
+                lastByPhase.set(e.phase, e.result);
+        }
+    }
+    const render = (phases, elideLeft, elideRight) => {
+        const parts = phases.map((p) => {
+            const i = order.indexOf(p);
+            const last = lastByPhase.get(p);
+            if (p === current)
+                return s.bold(s.fg("accent", g.phaseCurrent + " " + p.toUpperCase()));
+            if (last === "fail")
+                return s.bold(s.fg("blocked", g.blocked + " " + p));
+            if (idx >= 0 && i < idx)
+                return s.fg("success", g.phaseDone + " " + p);
+            return s.fg("muted", g.phaseTodo + " " + p);
+        });
+        const joiner = s.fg("rule", " " + g.rail + " ");
+        const body = parts.join(joiner);
+        const lead = elideLeft ? s.fg("rule", g.more + " ") : "";
+        const tail = elideRight ? s.fg("rule", " " + g.more) : "";
+        return lead + body + tail;
+    };
+    const full = render(order, false, false);
+    if (width(full) <= max || idx === -1)
+        return truncate(full, max);
+    // Narrow: keep the current phase and one neighbour each side.
+    const lo = Math.max(0, idx - 1);
+    const hi = Math.min(order.length, idx + 2);
+    const windowed = render(order.slice(lo, hi), lo > 0, hi < order.length);
+    return truncate(windowed, max);
+}
+function depLabel(deps, indexByKey, g, s) {
+    if (!deps || deps.length === 0)
+        return "";
+    const nums = deps.map((d) => {
+        const i = indexByKey.get(d);
+        return i === undefined ? d : "#" + i;
+    });
+    return s.fg("muted", g.arrow + " " + nums.join(", "));
+}
+/** `2/5` — how much of a grouping row's branch is finished. */
+function countTag(row, s) {
+    if (row.total === 0)
+        return s.fg("rule", "empty");
+    const role = row.done === row.total ? "success" : row.done > 0 ? "active" : "muted";
+    return s.fg(role, row.done + "/" + row.total);
+}
+const LEVEL_ROLE = {
+    goal: "brand",
+    sprint: "accent",
+    feature: "muted",
+    task: "text",
+    subtask: "muted",
+};
+/**
+ * One plan row, drawn.
+ *
+ * Indentation is by level, so the five levels of the plan are five columns on
+ * screen and the shape of the plan is readable without counting ids. The
+ * grouping rows carry a `done/total` tag on the right, which is what turns a
+ * long plan into something you can judge at a glance instead of reading.
+ */
+function renderRow(row, inner, indexByKey, g, s, display) {
+    const indent = "  ".repeat(row.depth);
+    const tagFor = (r) => (display.counts ? countTag(r, s) : "");
+    if (row.level === "goal" || row.level === "sprint") {
+        const icon = s.fg(LEVEL_ROLE[row.level], row.level === "goal" ? g.goal : g.sprint);
+        const tag = tagFor(row);
+        const prefix = indent + icon + " ";
+        const head = s.bold(s.fg(LEVEL_ROLE[row.level], row.title)) +
+            (row.label && row.label !== row.title ? s.fg("rule", "  " + row.label) : "");
+        const body = truncate(prefix + head, tag ? Math.max(8, inner - width(tag) - 1) : inner);
+        if (!tag)
+            return [body];
+        const gap = Math.max(1, inner - width(body) - width(tag));
+        return [body + " ".repeat(gap) + tag];
+    }
+    if (row.level === "feature") {
+        const tag = tagFor(row);
+        const prefix = indent + s.fg("muted", g.branch + " ");
+        const head = s.fg("muted", row.label) + s.fg("rule", " · ") + s.fg("text", row.title);
+        const body = truncate(prefix + head, tag ? Math.max(8, inner - width(tag) - 1) : inner);
+        if (!tag)
+            return [body];
+        const gap = Math.max(1, inner - width(body) - width(tag));
+        return [body + " ".repeat(gap) + tag];
+    }
+    if (row.level === "subtask") {
+        const icon = row.status === "complete"
+            ? s.fg("success", g.subDone)
+            : row.status === "in_progress"
+                ? s.fg("active", g.subActive)
+                : s.fg("rule", g.subPending);
+        const prefix = indent + icon + " ";
+        return [truncate(prefix + s.fg("muted", row.title), inner)];
+    }
+    // -- a task ---------------------------------------------------------------
+    const role = statusRole(row.status ?? "pending");
+    const icon = s.fg(role, statusGlyph(row.status ?? "pending", g));
+    const num = s.fg("rule", row.label);
+    const dep = display.dependencies ? depLabel(row.dependsOn, indexByKey, g, s) : "";
+    const prefix = indent + icon + " " + num + " ";
+    const prefixW = width(prefix);
+    const depW = dep ? width(dep) + 1 : 0;
+    const titleMax = Math.max(8, inner - prefixW - depW);
+    const titleLines = wrap(row.title || row.id, titleMax);
+    const first = titleLines[0] ?? row.id;
+    const head = row.active
+        ? s.bold(s.fg("text", first))
+        : s.fg(role === "success" ? "muted" : "text", first);
+    let line = prefix + head;
+    if (dep) {
+        const spacer = Math.max(1, inner - width(line) - width(dep));
+        line += " ".repeat(spacer) + dep;
+    }
+    const out = [line];
+    for (const extra of titleLines.slice(1))
+        out.push(" ".repeat(prefixW) + s.fg("muted", extra));
+    return out;
+}
+/**
+ * Which slice of rows to show.
+ *
+ * With no explicit scroll the window follows the run: centred on the active
+ * task, biased so a few finished rows stay above it, because "what just got
+ * done" is most of what makes progress legible.
+ */
+export function rowWindow(rows, limit, scroll, context = COMPLETED_CONTEXT) {
+    const total = rows.length;
+    if (total <= limit)
+        return { start: 0, end: total };
+    if (scroll !== null) {
+        const start = Math.max(0, Math.min(scroll, total - limit));
+        return { start, end: start + limit };
+    }
+    const focus = focusRowIndex(rows);
+    if (focus < limit - context)
+        return { start: 0, end: limit };
+    if (focus >= total - (limit - context))
+        return { start: total - limit, end: total };
+    const start = Math.max(0, Math.min(focus - context, total - limit));
+    return { start, end: start + limit };
+}
+/**
+ * Render the widget as terminal lines.
+ *
+ * Returns plain strings so the host can hand them straight to
+ * `ctx.ui.setWidget`. Colour is embedded as ANSI when the styler is colouring.
+ */
+/** Rows of background log drawn by default. Enough to see the shape of a minute. */
+export const ACTIVITY_ROWS = 5;
+const ACTIVITY_ROLE = {
+    info: "muted",
+    work: "text",
+    warn: "rework",
+    error: "blocked",
+    good: "success",
+};
+const WORKER_ROLE = {
+    starting: "active",
+    working: "active",
+    idle: "muted",
+    closed: "muted",
+    failed: "blocked",
+};
+/** `HH:MM` in local time — a full ISO stamp is six columns of nothing. */
+function clock(iso) {
+    const d = new Date(iso);
+    if (Number.isNaN(d.getTime()))
+        return "--:--";
+    return String(d.getHours()).padStart(2, "0") + ":" + String(d.getMinutes()).padStart(2, "0");
+}
+/**
+ * The background sessions, one line each.
+ *
+ * The model is on the line on purpose. The whole point of routing work out of
+ * the human's session is that a different model does it, and a claim you
+ * cannot see is a claim nobody believes — least of all after the version
+ * where it silently did not happen.
+ */
+export function renderWorkers(workers, inner, g, s) {
+    const out = [];
+    for (const w of workers) {
+        const role = WORKER_ROLE[w.state] ?? "muted";
+        const dot = s.fg(role, w.state === "working" || w.state === "starting" ? g.inProgress : g.pending);
+        const head = dot +
+            " " +
+            s.bold(s.fg(role, w.name)) +
+            s.fg("rule", " · ") +
+            s.fg("text", w.unit) +
+            (w.difficulty ? s.fg("muted", " (" + w.difficulty + ")") : "");
+        const model = s.fg("accent", w.model || "pi default");
+        const ctx = typeof w.contextRatio === "number" ? s.fg(w.contextRatio > 0.75 ? "rework" : "muted", " " + Math.round(w.contextRatio * 100) + "%") : "";
+        const right = model + ctx;
+        const gap = Math.max(1, inner - width(head) - width(right));
+        out.push(truncate(head + " ".repeat(gap) + right, inner));
+        if (w.doing)
+            out.push(truncate("   " + s.fg("muted", g.arrow + " " + w.doing), inner));
+    }
+    return out;
+}
+/** The background log: the only place a human sees what the workers did. */
+export function renderActivity(lines, rows, inner, s) {
+    const tail = lines.slice(-Math.max(0, rows));
+    return tail.map((l) => truncate(s.fg("rule", clock(l.at)) +
+        " " +
+        (l.worker ? s.fg("accent", l.worker) + " " : "") +
+        s.fg(ACTIVITY_ROLE[l.level] ?? "muted", l.text), inner));
+}
+export function renderWidget(state, options = {}) {
+    const total = options.width ?? DEFAULT_WIDTH;
+    const s = options.styler ?? createStyler();
+    const g = options.glyphs ?? detectGlyphs();
+    const boxed = options.boxed ?? false;
+    const pad = boxed ? 2 : 0;
+    const inner = Math.max(24, total - pad * 2);
+    const view = state.view ?? defaultView();
+    const display = normalizeDisplay(state.display ?? defaultDisplay());
+    const limit = options.taskWindow ?? (view.expanded ? Math.max(EXPANDED_WINDOW, display.taskWindow * 2) : display.taskWindow);
+    const out = [];
+    const push = (line = "") => {
+        out.push(line);
+    };
+    const progress = computeProgress(state.list);
+    const tasks = flattenTasks(state.list);
+    const viewSnap = state.viewState ?? null;
+    // -- viewState banner -----------------------------------------------------
+    // Reads daemon.json first. Widget never renders dead run as live.
+    if (viewSnap && viewSnap.state !== "running" && viewSnap.state !== "awaiting-approval") {
+        const hb = viewSnap.daemon?.heartbeatAt ?? null;
+        const ts = hb ? s.fg("muted", ` (as of ${String(hb).slice(11, 16)})`) : "";
+        const msg = viewSnap.state === "stale"
+            ? s.fg("rework", `\u26A0 Daemon unresponsive since ${hb ? String(hb).slice(11, 16) : "?"}`) + ts
+            : viewSnap.state === "not-running"
+                ? s.fg("blocked", "Daemon not running \u2014 /infinity:run to start.") + ts
+                : viewSnap.state === "never-armed"
+                    ? s.fg("muted", viewSnap.reason ?? "Never armed \u2014 run the wizard.")
+                    : viewSnap.state === "stopped"
+                        ? s.fg("blocked", `STOPPED: ${viewSnap.reason ?? viewSnap.run?.stopReason ?? "stopped"}`) + ts
+                        : s.fg("muted", viewSnap.reason ?? "");
+        push(truncate(msg, inner));
+    }
+    if (viewSnap && viewSnap.state === "awaiting-approval") {
+        const phase2 = (viewSnap.supervisor?.phase ?? state.phase ?? "?");
+        push(truncate(s.fg("active", `\u23F8 Awaiting approval: ${String(phase2).toUpperCase()} \u2192 /infinity:approve`) + s.fg("muted", " (run is healthy, not stuck)"), inner));
+    }
+    // -- pilot badge + per-tier spend + rework queue ---------------------------
+    if (state.pilot) {
+        const pilot = state.pilot;
+        const tag = s.bold(s.fg(pilot === "full" ? "rework" : pilot === "autopilot" ? "success" : "accent", pilot.toUpperCase()));
+        const pModes = state.phaseModes ?? null;
+        const modesStr = pModes ? Object.entries(pModes).map(([ph, m]) => s.fg(m === "autopilot" ? "success" : "active", `${ph}:${m}`)).join(s.fg("rule", " \u00b7 ")) : "";
+        push(truncate(s.fg("muted", "Pilot ") + tag + (modesStr ? s.fg("rule", "  ") + modesStr : ""), inner));
+    }
+    {
+        const ts2 = state.tierSpend ?? null;
+        if (ts2) {
+            const parts = [];
+            for (const tier of ["A", "B", "C", "D", "X"]) {
+                const t = ts2[tier];
+                if (!t)
+                    continue;
+                const label = `${tier}:${t.input + t.output}`;
+                parts.push(tier === "X" && (t.cost > 0 || t.input + t.output > 0) ? s.bold(s.fg("blocked", label)) : s.fg("muted", label));
+            }
+            if (parts.length)
+                push(truncate(s.fg("muted", "Spend ") + parts.join(s.fg("rule", " \u00b7 ")), inner));
+        }
+    }
+    if (typeof state.reworkDepth === "number" && state.reworkDepth > 0) {
+        push(truncate(s.fg("rework", `\u21BB Rework queue: ${state.reworkDepth} item(s) holding gate open`), inner));
+    }
+    if (state.replanDiff)
+        push(truncate(s.fg("muted", "Replan: ") + s.fg("text", String(state.replanDiff).slice(0, 80)), inner));
+    // -- header + dashboard --------------------------------------------
+    // Every band has its own colour so the top scans as sections, not one grey block.
+    // Muted separators make it legible even with NO_COLOR.
+    const sep = () => { push(s.fg("rule", g.rail.repeat(Math.max(1, inner)))); };
+    const brand = s.bold(s.fg("brand", "\u221e INFINITY"));
+    const phaseTag = state.paused
+        ? s.fg("blocked", "PAUSED")
+        : state.phase
+            ? s.fg("accent", state.phase.toUpperCase())
+            : s.fg("muted", "NOT STARTED");
+    const revTag = state.revision === undefined ? "" : s.fg("muted", " rev " + state.revision);
+    const headLeft = brand;
+    const headRight = phaseTag + revTag;
+    const gapW = inner - width(headLeft) - width(headRight);
+    push(headLeft + (gapW > 1 ? s.fg("rule", " " + g.rail.repeat(gapW - 2) + " ") : " ") + headRight);
+    // Dashboard URL with a real port — :PORT is never correct for an ephemeral port.
+    {
+        const url = state.dashboardUrl ?? null;
+        if (url) {
+            const label = s.fg("accent", url);
+            const link = "\u001b]8;;" + url + "\u0007" + label + "\u001b]8;;\u0007";
+            push(truncate(s.fg("accent", "Dashboard \u2192 ") + link, inner));
+        }
+        else {
+            push(truncate(s.fg("muted", "Dashboard \u2192 ") + s.fg("muted", "/infinity:dashboard"), inner));
+        }
+    }
+    if (state.handoffModelNote) {
+        push(truncate(s.fg("muted", state.handoffModelNote), inner));
+    }
+    // Goal count sits right under the header; the old widget hid goals entirely.
+    {
+        const goals = state.list.goals ?? [];
+        if (goals.length === 0 && state.intake) {
+            push(truncate(s.fg("rule", "Goal \u00b7 ") + s.fg("text", state.intake.slice(0, 90)), inner));
+        }
+        else if (goals.length > 0) {
+            const n = goals.length;
+            const countLine = s.fg("brand", "\u25C8 Goals: " + String(n) + " " + (n === 1 ? "goal" : "goals"));
+            push(truncate(countLine, inner));
+        }
+    }
+    sep();
+    // -- goal + phase rail ------------------------------------------------
+    // One goal section per your spec, each with its own colour:
+    //   [brand]  Goals: N
+    //   [text]   Active goal headline
+    //   [accent/muted/success/blocked] phase rail with active/passed/failed
+    //   [muted]  Active-phase breakdown: features/tasks
+    //   [rule]   dotted separator
+    //   [accent/text] progress bar (whole project)
+    //   [rule]   dotted separator
+    {
+        const goals = state.list.goals ?? [];
+        // Single-goal headline (the old headline logic) — now sits directly under
+        // the Goals count, inside the same band, before the rail. Multi-goal plans
+        // show the active goal instead (not buried in the lane tree).
+        let headline = null;
+        if (display.levels.goal) {
+            if (goals.length === 1)
+                headline = goals[0]?.title ?? null;
+            else if (goals.length === 0)
+                headline = state.intake ?? null;
+            else {
+                // Multi-goal: pick the goal owning the next actionable task, else the first.
+                const next = nextActionableTask(state.list);
+                if (next) {
+                    const feat = state.list.features.find((f) => f.id === next.featureId) ?? null;
+                    const spr = feat?.sprintId ? (state.list.sprints ?? []).find((s) => s.id === feat.sprintId) ?? null : null;
+                    const gid = feat?.goalId ?? spr?.goalId ?? null;
+                    const g2 = gid ? goals.find((gg) => gg.id === gid) ?? goals[0] ?? null : goals[0] ?? null;
+                    headline = g2?.title ?? null;
+                }
+                else {
+                    headline = goals[0]?.title ?? null;
+                }
+            }
+        }
+        if (headline) {
+            const wrapped = wrap(headline, inner - 2);
+            wrapped.forEach((line, i) => {
+                push((i === 0 ? s.fg("muted", g.goal + " ") : "  ") + s.fg("text", line));
+            });
+        }
+        if (display.rail) {
+            push(phaseRail(state.phase, state.enabledPhases, inner, g, s, state.gateHistory ?? null));
+        }
+        // Active-phase breakdown: features + tasks in the current phase (or whole project when no phase yet).
+        // Respects display.counts; when counts off we skip the line entirely.
+        if (display.counts) {
+            const phaseName = state.phase;
+            const allFeats = state.list.features ?? [];
+            const inPhase = (phaseName
+                ? allFeats.filter((f) => f.phase === phaseName)
+                : allFeats);
+            const phaseTasks = phaseName
+                ? flattenTasks(state.list).filter((tt) => tt.effectivePhase === phaseName)
+                : flattenTasks(state.list);
+            const done = phaseTasks.filter((tt) => tt.status === "complete").length;
+            const total = phaseTasks.length;
+            const featCount = inPhase.length;
+            const label = phaseName ? phaseName.toUpperCase() : "PROJECT";
+            const featPart = s.fg("accent", String(featCount) + " " + (featCount === 1 ? "feature" : "features"));
+            const taskPart = s.fg("text", String(done) + "/" + String(total) + " tasks");
+            push(truncate(s.fg("muted", label + " \u00b7 ") + featPart + s.fg("rule", " \u00b7 ") + taskPart, inner));
+        }
+        sep();
+        if (display.progress) {
+            const full = s.fg("brand", String(progress.tasksDone) + "/" + String(progress.tasksTotal) + " tasks") +
+                s.fg("rule", " \u00b7 ") +
+                s.fg("muted", String(progress.featuresDone) + "/" + String(progress.featuresTotal) + " features") +
+                s.fg("rule", " \u00b7 ") +
+                s.fg("accent", String((state.list.goals ?? []).length) + " " + ((state.list.goals ?? []).length === 1 ? "goal" : "goals"));
+            const compact = s.fg("brand", String(progress.tasksDone) + "/" + String(progress.tasksTotal));
+            const METER_MIN = 8 + 6;
+            let stats = full;
+            if (inner - width(full) < METER_MIN)
+                stats = compact;
+            if (inner - width(stats) < METER_MIN)
+                stats = "";
+            const statsW = width(stats);
+            const barCells = Math.max(8, Math.min(24, inner - statsW - 8));
+            const bar = progressBar(progress.percent, barCells, g, s);
+            const gap2 = inner - width(bar) - statsW;
+            push(truncate(bar + (gap2 > 0 ? " ".repeat(gap2) : " ") + stats, inner));
+            sep();
+        }
+    }
+    // -- task lanes -------------------------------------------------------
+    // Aggregate task-window size respected; lane count capped; elision markers show hidden work.
+    const taskWindow = view.expanded ? Math.max(28, display.taskWindow * 2) : display.taskWindow;
+    if (!display.levels.task) {
+        const f = state.list.features[0];
+        if (f) {
+            const sname = f.sprintId ? (state.list.sprints ?? []).find((s) => s.id === f.sprintId)?.name : null;
+            const gname = f.goalId ? (state.list.goals ?? []).find((g) => g.id === f.goalId)?.title : null;
+            const shape = [];
+            if (display.levels.goal && gname)
+                shape.push(s.fg("muted", "goal " + gname.slice(0, 28)));
+            if (display.levels.sprint && sname)
+                shape.push(s.fg("muted", "sprint " + sname.slice(0, 22)));
+            if (display.levels.feature)
+                shape.push(s.fg("success", f.name.slice(0, 28)));
+            if (shape.length) {
+                push();
+                push(truncate(shape.join(s.fg("rule", " \u00b7 ")), inner));
+            }
+        }
+    }
+    if (display.levels.task) {
+        const allTasks = flattenTasks(state.list);
+        let lanes = [];
+        if (view.scroll !== null) {
+            const start = Math.max(0, Math.min(view.scroll, Math.max(0, allTasks.length - taskWindow)));
+            lanes = allTasks.slice(start, start + taskWindow).map((t) => t);
+        }
+        else {
+            const activeTasks = allTasks.filter((t) => t.status === "in_progress" || t.status === "rework");
+            const focus = nextActionableTask(state.list) ?? activeTasks[0] ?? null;
+            if (focus)
+                lanes.push(focus);
+            for (const t of activeTasks)
+                if (focus && t.compositeKey !== focus.compositeKey && lanes.length < taskWindow)
+                    lanes.push(t);
+            if (!lanes.length) {
+                const pending = nextActionableTask(state.list);
+                if (pending)
+                    lanes.push(pending);
+            }
+            if (lanes.length < taskWindow) {
+                const pendingQ = allTasks.filter((t) => t.status === "pending" && !lanes.some((l) => l.compositeKey === t.compositeKey));
+                for (const t of pendingQ) {
+                    if (lanes.length >= taskWindow)
+                        break;
+                    lanes.push(t);
+                }
+            }
+        }
+        const formatChain = (t) => {
+            const curFeature = state.list.features.find((f) => f.id === t.featureId) ?? null;
+            const curSprint = curFeature?.sprintId ? (state.list.sprints ?? []).find((s) => s.id === curFeature.sprintId) ?? null : null;
+            const parts = [];
+            if (state.phase)
+                parts.push(s.bold(s.fg("accent", state.phase.toUpperCase())));
+            if (curSprint && display.levels.sprint)
+                parts.push(s.fg("muted", "sprint " + (curSprint.name ?? curSprint.id).slice(0, 18)));
+            if (curFeature && display.levels.feature)
+                parts.push(s.fg("success", curFeature.name.slice(0, 24)));
+            const descEarly = t.description ? t.description.slice(0, 44) : "";
+            parts.push(s.fg("text", t.compositeKey + (descEarly ? " " + descEarly.slice(0, 36) : "")));
+            return parts.join(s.fg("rule", " \u00b7 "));
+        };
+        if (lanes.length) {
+            const totalPendable = allTasks.length;
+            const above = allTasks.findIndex((t) => t.compositeKey === lanes[0].compositeKey);
+            const lastIdx = allTasks.findIndex((t) => t.compositeKey === lanes[lanes.length - 1].compositeKey);
+            const below = Math.max(0, totalPendable - lastIdx - 1);
+            const shownAbove = above > 0 ? above : 0;
+            const shownBelow = below > 0 ? below : 0;
+            if (shownAbove > 0)
+                push(s.fg("rule", "  " + g.more + " " + shownAbove + " above"));
+            for (const task of lanes.slice(0, taskWindow)) {
+                push(truncate(formatChain(task), inner));
+                if (display.levels.subtask !== "none") {
+                    const cur = (task.subtasks ?? []).find((ss) => ss.status !== "complete") ?? null;
+                    if (cur)
+                        push(truncate("  " + s.fg("active", "> " + cur.title.slice(0, 56)), inner));
+                }
+            }
+            if (shownBelow > 0)
+                push(s.fg("rule", "  " + g.more + " " + shownBelow + " below"));
+        }
+        else if (state.list.features.length === 0) {
+            push(s.fg("muted", "  no plan yet"));
+        }
+    }
+    // -- background sessions --------------------------------------------------
+    //
+    // Placed above the rail because, on a run driven by workers, this is the
+    // part of the widget that changes second by second. A human glancing at the
+    // terminal is checking that something is alive.
+    const workers = state.workers ?? [];
+    if (workers.length) {
+        push();
+        push(s.fg("rule", "background") + s.fg("rule", " " + g.rail.repeat(Math.max(1, inner - 12))));
+        for (const line of renderWorkers(workers, inner, g, s))
+            push(line);
+    }
+    else if (state.engine === "background" && state.list.features.length > 0) {
+        push();
+        push(truncate(s.fg("muted", "background · no worker running — /infinity:run starts one"), inner));
+    }
+    const activityRows = state.activityRows ?? (state.activity?.length ? ACTIVITY_ROWS : 0);
+    if (activityRows > 0 && state.activity?.length) {
+        push();
+        for (const line of renderActivity(state.activity, view.expanded ? activityRows * 3 : activityRows, inner, s))
+            push(line);
+    }
+    // phase rail + whole-project progress already rendered in the header band above.
+    // -- alerts ---------------------------------------------------------------
+    const alerts = [];
+    if (progress.blocked > 0)
+        alerts.push(s.fg("blocked", g.blocked + " " + progress.blocked + " blocked"));
+    if (progress.rework > 0)
+        alerts.push(s.fg("rework", g.rework + " " + progress.rework + " rework"));
+    if (state.retries && state.retries.task > 0) {
+        const role = state.retries.task >= state.retries.max ? "blocked" : "active";
+        alerts.push(s.fg(role, "retry " + state.retries.task + "/" + state.retries.max));
+    }
+    if (state.goalPass && state.goalPass.max > 1) {
+        const role = state.goalPass.current >= state.goalPass.max ? "blocked" : "active";
+        alerts.push(s.fg(role, "pass " + state.goalPass.current + "/" + state.goalPass.max));
+    }
+    if (state.escalation?.strategy) {
+        alerts.push(s.fg("rework", g.rework + " " + state.escalation.strategy));
+    }
+    if (state.awaitingApproval) {
+        alerts.unshift(s.bold(s.fg("active", g.rework + " " + state.awaitingApproval.toUpperCase() + " needs your OK")));
+    }
+    if (typeof state.sessions === "number" && state.sessions > 1) {
+        // Proof the handoff is working. Without it a run that quietly stopped
+        // starting fresh sessions looks exactly like one that never did.
+        alerts.push(s.fg("muted", "session " + state.sessions));
+    }
+    if (state.gate && !state.gate.overall) {
+        alerts.push(s.fg("blocked", "gate: " + state.gate.failures.slice(0, 3).join(", ")));
+    }
+    if (display.alerts && alerts.length)
+        push(truncate(alerts.join(s.fg("rule", " · ")), inner));
+    // keyboard hint — always visible so scroll is discoverable without reading the README
+    {
+        const scrollable = flattenTasks(state.list).length > taskWindow;
+        const baseHint = hintKeys(g);
+        const followPart = view.scroll !== null ? s.fg("accent", " · following: /infinity:scroll follow") : "";
+        const hasWorker = (state.workers?.length ?? 0) > 0 || state.engine === "background";
+        // Keep hint one line in narrow terminals; otherwise add a second affordance line.
+        const hintLine = baseHint + followPart;
+        push(truncate(scrollable || view.scroll !== null ? s.fg("muted", hintLine) : s.fg("rule", hintLine), inner));
+        if (hasWorker) {
+            push(truncate(s.fg("muted", `  ${g.more} tip: ${s.fg("text", "/infinity:workers")} and ${s.fg("text", "/infinity:dashboard")} show live detail`), inner));
+        }
+    }
+    // footer only — scroll tree removed to keep TUI readable on narrow term
+    push(s.fg("rule", " " + g.rail.repeat(Math.max(1, inner - 2))));
+    return frame(out, total, boxed, s, g);
+}
+/**
+ * The keys that move the window, said once, where the window runs out.
+ *
+ * `alt+` rather than `ctrl+`: pi binds ctrl+j, ctrl+k and ctrl+o in the editor
+ * already, and a widget is not worth shadowing an editor key for.
+ */
+export function hintKeys(_g) {
+    return "↕ alt+j/k scroll · alt+o expand · /infinity:scroll";
+}
+function frame(lines, total, boxed, s, g) {
+    // Unboxed still has to honour the requested width: the caller sized the
+    // widget to a terminal, and a row that overruns wraps and breaks the layout.
+    if (!boxed)
+        return lines.map((l) => truncate(l, total));
+    const inner = total - 4;
+    const top = s.fg("rule", "╭" + "─".repeat(total - 2) + "╮");
+    const bottom = s.fg("rule", "╰" + "─".repeat(total - 2) + "╯");
+    const side = s.fg("rule", "│");
+    const body = lines.map((l) => side + " " + padEnd(truncate(l, inner), inner) + " " + side);
+    return [top, ...body, bottom];
+}
+/** Compact one-liner for the status bar: `BUILD 13/21 ◐`. */
+export function renderStatusLine(state, g = detectGlyphs()) {
+    const p = computeProgress(state.list);
+    if (state.paused)
+        return "paused";
+    if (state.awaitingApproval)
+        return `${state.awaitingApproval} · needs your OK`;
+    if (p.tasksTotal === 0)
+        return state.phase ?? "idle";
+    const mark = p.blocked > 0
+        ? g.blocked
+        : p.inProgress > 0
+            ? g.inProgress
+            : p.tasksDone === p.tasksTotal
+                ? g.complete
+                : g.pending;
+    const phase = state.phase ? state.phase + " " : "";
+    return phase + p.tasksDone + "/" + p.tasksTotal + " " + mark;
+}
+//# sourceMappingURL=widget.js.map