pi-minimal 0.1.0 → 0.2.2

package/dist/cwd.js

@@ -1,7 +1,10 @@
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 import path from "node:path";
-import { CHROME_MARGIN } from "./chrome.js";
-function formatCwd(cwd) {
+import * as chrome from "./chrome.js";
+import { formatGitState } from "./git-state.js";
+/** Tolerates a stale chrome module after /reload, where only CHROME_MARGIN may exist. */
+const margin = () => (typeof chrome.chromeMargin === "function" ? chrome.chromeMargin() : (chrome.CHROME_MARGIN ?? 1));
+export function formatCwd(cwd) {
     const home = process.env.HOME || process.env.USERPROFILE || "";
     if (!home)
         return cwd;
@@ -12,7 +15,7 @@ function formatCwd(cwd) {
     }
     return cwd;
 }
-function formatTokens(n) {
+export function formatTokens(n) {
     if (n < 1000)
         return String(n);
     if (n < 10000)
@@ -23,7 +26,7 @@ function formatTokens(n) {
         return `${(n / 1e6).toFixed(1)}M`;
     return `${Math.round(n / 1e6)}M`;
 }
-function modelIcon(id) {
+export function modelIcon(id) {
     const s = id.toLowerCase();
     if (s.includes("grok"))
         return "✦";
@@ -38,7 +41,7 @@ function modelIcon(id) {
         return "◈";
     return "◆";
 }
-function shortModel(id) {
+export function shortModel(id) {
     return (id.split("/").pop() || id).replace(/^claude-/, "");
 }
 function thinkingColor(level) {
@@ -48,56 +51,95 @@ function thinkingColor(level) {
         return "accent";
     return "dim";
 }
-function meter(percent, fill, empty) {
-    const n = 8;
-    const filled = Math.max(0, Math.min(n, Math.round((percent / 100) * n)));
-    return fill.repeat(filled) + empty.repeat(n - filled);
+/** Context pressure band used for the meter and percentage colour. */
+export function contextBand(pct) {
+    if (pct >= 90)
+        return "error";
+    if (pct >= 70)
+        return "warning";
+    return "accent";
 }
-function splitRow(left, right, width) {
-    let L = left;
-    let R = right;
-    while (visibleWidth(L) + 1 + visibleWidth(R) > width && visibleWidth(R) > 0) {
-        R = truncateToWidth(R, Math.max(0, visibleWidth(R) - 1), "");
+export function meter(percent, fill, empty, cells = 8) {
+    const filled = Math.max(0, Math.min(cells, Math.round((percent / 100) * cells)));
+    return fill.repeat(filled) + empty.repeat(cells - filled);
+}
+/**
+ * Fit `left` and `right` into `width`. Right-hand segments are dropped from the end first (they are
+ * the least important), then the left is truncated.
+ */
+export function splitRow(left, rightSegments, width, sep = "  ") {
+    const segments = [...rightSegments.filter((s) => visibleWidth(s) > 0)];
+    let right = segments.join(sep);
+    while (segments.length > 0 && visibleWidth(left) + 2 + visibleWidth(right) > width) {
+        segments.pop();
+        right = segments.join(sep);
     }
-    while (visibleWidth(L) + 1 + visibleWidth(R) > width && visibleWidth(L) > 0) {
-        L = truncateToWidth(L, Math.max(0, visibleWidth(L) - 1), "");
+    let L = left;
+    if (visibleWidth(L) + (right ? 2 : 0) + visibleWidth(right) > width) {
+        L = truncateToWidth(L, Math.max(0, width - (right ? 2 : 0) - visibleWidth(right)), "");
     }
-    const gap = Math.max(1, width - visibleWidth(L) - visibleWidth(R));
-    return L + " ".repeat(gap) + R;
+    const gap = right ? Math.max(2, width - visibleWidth(L) - visibleWidth(right)) : 0;
+    return L + " ".repeat(gap) + right;
+}
+function siblingColor(status) {
+    if (status === "idle" || status === "done")
+        return "success";
+    if (status === "working")
+        return "accent";
+    if (status === "blocked")
+        return "error";
+    return "muted";
 }
-export function installCwd(ctx) {
-    ctx.ui.setWidget("tw-cwd", (_tui, theme) => ({
-        invalidate() { },
-        render(width) {
-            const inner = Math.max(8, width - CHROME_MARGIN * 2);
-            const id = ctx.model?.id || "no-model";
-            const icon = theme.fg("accent", modelIcon(id));
-            const name = theme.fg("text", shortModel(id));
-            const usage = ctx.getContextUsage?.();
-            const window = usage?.contextWindow || ctx.model?.contextWindow;
-            const used = usage?.tokens;
-            let tokenStr = theme.fg("dim", "?/?");
-            let bar = theme.fg("dim", "░░░░░░░░");
-            let pctStr = theme.fg("dim", "?%");
-            if (typeof used === "number" && window) {
-                const pct = Math.max(0, Math.min(100, Math.round((used / window) * 100)));
-                tokenStr = theme.fg("dim", `${formatTokens(used)}/${formatTokens(window)}`);
-                const hot = pct >= 85;
-                bar = meter(pct, theme.fg(hot ? "warning" : "accent", "█"), theme.fg("dim", "░"));
-                pctStr = theme.fg(hot ? "warning" : "muted", `${pct}%`);
-            }
-            else if (used === null && window) {
-                tokenStr = theme.fg("dim", `?/${formatTokens(window)}`);
-            }
-            const thinking = ctx.thinkingLevel || "";
-            const think = thinking ? theme.fg(thinkingColor(thinking), thinking) : "";
-            const midot = theme.fg("dim", " · ");
-            const left = [`${icon} ${name}`, tokenStr, `${bar} ${pctStr}`, think]
-                .filter(Boolean)
-                .join(midot);
-            const right = ctx.cwd ? theme.fg("accent", formatCwd(ctx.cwd)) : "";
-            const row = splitRow(left, right, inner);
-            return [`${" ".repeat(CHROME_MARGIN)}${row}`];
-        },
-    }), { placement: "aboveEditor" });
+export function installCwd(ctx, sources) {
+    ctx.ui.setWidget("tw-cwd", (tui, theme) => {
+        const unsub = sources.onGitChange(() => tui.requestRender());
+        return {
+            dispose: unsub,
+            invalidate() { },
+            render(width) {
+                const inner = Math.max(8, width - margin() * 2);
+                const id = ctx.model?.id || "no-model";
+                const icon = theme.fg("accent", modelIcon(id));
+                const name = theme.fg("text", shortModel(id));
+                const thinking = ctx.thinkingLevel || "";
+                const think = thinking ? theme.fg(thinkingColor(thinking), thinking) : "";
+                const usage = ctx.getContextUsage?.();
+                const window = usage?.contextWindow || ctx.model?.contextWindow;
+                const used = usage?.tokens;
+                let bar = theme.fg("dim", "░░░░░░░░");
+                let pctStr = theme.fg("dim", "?%");
+                let tokenStr = theme.fg("dim", "?/?");
+                if (typeof used === "number" && window) {
+                    const pct = Math.max(0, Math.min(100, Math.round((used / window) * 100)));
+                    const band = contextBand(pct);
+                    bar = meter(pct, theme.fg(band, "▓"), theme.fg("dim", "░"));
+                    pctStr = theme.fg(band === "accent" ? "muted" : band, `${pct}%`);
+                    tokenStr = theme.fg("dim", `${formatTokens(used)}/${formatTokens(window)}`);
+                }
+                else if (used === null && window) {
+                    tokenStr = theme.fg("dim", `?/${formatTokens(window)}`);
+                }
+                const midot = theme.fg("dim", " · ");
+                const model = [`${icon} ${name}`, think].filter(Boolean).join(midot);
+                const context = `${bar} ${pctStr} ${tokenStr}`;
+                const left = `${model}   ${context}`;
+                const right = [];
+                if (ctx.cwd)
+                    right.push(theme.fg("muted", formatCwd(ctx.cwd)));
+                const git = formatGitState(sources.gitState());
+                if (git.branch) {
+                    const dirty = git.dirty ? ` ${theme.fg("warning", git.dirty)}` : "";
+                    right.push(`${theme.fg("dim", "⎇")} ${theme.fg("muted", git.branch)}${dirty}`);
+                }
+                const siblings = sources.siblings();
+                if (siblings && siblings.length > 0) {
+                    right.push(siblings
+                        .map((s) => `${theme.fg("text", s.name)} ${theme.fg(siblingColor(s.status), s.status)}`)
+                        .join(theme.fg("dim", " · ")));
+                }
+                const row = splitRow(left, right, inner);
+                return [`${" ".repeat(margin())}${row}`];
+            },
+        };
+    }, { placement: "aboveEditor" });
 }

package/dist/footer.js

@@ -1,43 +1,44 @@
 import { keyHint } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import { CHROME_MARGIN } from "./chrome.js";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import * as chrome from "./chrome.js";
 import { formatTrackerLines } from "./tracker.js";
-function statusColor(status) {
-    if (status === "idle" || status === "done")
-        return "success";
-    if (status === "working")
-        return "accent";
-    if (status === "blocked")
-        return "error";
-    return "muted";
+/** Tolerates a stale chrome module after /reload, where only CHROME_MARGIN may exist. */
+const margin = () => (typeof chrome.chromeMargin === "function" ? chrome.chromeMargin() : (chrome.CHROME_MARGIN ?? 1));
+/**
+ * Key hints are shown only when nothing else needs the line: idle agent, empty editor. Otherwise
+ * the footer collapses to zero lines (tracker lines excepted).
+ */
+export function footerHints(sources, hints) {
+    if (sources.busy())
+        return [];
+    if (sources.editorText().trim().length > 0)
+        return [];
+    const pct = sources.contextPct();
+    const out = [...hints];
+    if (pct !== undefined && pct >= 70)
+        out.push("/compact");
+    return out;
 }
-export function installFooter(ctx, getSiblings) {
+export function installFooter(ctx, sources) {
     ctx.ui.setFooter((tui, theme, footerData) => {
         const unsub = footerData.onBranchChange(() => tui.requestRender());
         return {
             dispose: unsub,
             invalidate() { },
             render(width) {
-                const send = keyHint("tui.input.submit", "send");
-                const think = keyHint("app.thinking.cycle", "thinking");
-                const left = [send, think].filter(Boolean).join("  ·  ");
-                const siblings = getSiblings();
-                let right = "";
-                if (siblings && siblings.length > 0) {
-                    right = siblings
-                        .map((s) => {
-                        const name = theme.fg("text", s.name);
-                        const st = theme.fg(statusColor(s.status), s.status);
-                        return `${name} ${st}`;
-                    })
-                        .join(theme.fg("dim", "  ·  "));
+                const inner = Math.max(8, width - margin() * 2);
+                const out = [];
+                const hints = footerHints(sources, [
+                    keyHint("tui.input.submit", "send"),
+                    keyHint("app.thinking.cycle", "thinking"),
+                    keyHint("app.tools.expand", "expand tools"),
+                ].filter(Boolean));
+                if (hints.length > 0) {
+                    const line = theme.fg("dim", hints.join("  ·  "));
+                    out.push(`${" ".repeat(margin())}${truncateToWidth(line, inner, "")}`);
                 }
-                const inner = Math.max(8, width - CHROME_MARGIN * 2);
-                const pad = Math.max(1, inner - visibleWidth(left) - visibleWidth(right));
-                const line = truncateToWidth(left + " ".repeat(pad) + right, inner, "");
-                const out = [`${" ".repeat(CHROME_MARGIN)}${line}`];
                 for (const extra of formatTrackerLines(ctx, theme)) {
-                    out.push(`${" ".repeat(CHROME_MARGIN)}${truncateToWidth(extra, inner, "")}`);
+                    out.push(`${" ".repeat(margin())}${truncateToWidth(extra, inner, "")}`);
                 }
                 return out;
             },

package/dist/git-state.js

@@ -0,0 +1,63 @@
+export function parseBranch(stdout) {
+    const line = stdout.trim().split("\n")[0]?.trim();
+    if (!line || line === "HEAD")
+        return undefined;
+    return line;
+}
+export function parsePorcelain(stdout) {
+    return stdout.split("\n").filter((line) => line.trim().length > 0).length;
+}
+export function formatGitState(state) {
+    if (!state?.branch)
+        return { branch: "", dirty: "" };
+    const dirty = state.dirty && state.dirty > 0 ? `±${state.dirty}` : "";
+    return { branch: state.branch, dirty };
+}
+/**
+ * Polls git for the current branch and dirty count. Call `refresh()` after events that may have
+ * changed the tree (tool results, turn end); `get()` is always synchronous.
+ */
+export function createGitState(pi, cwd, minIntervalMs = 5000) {
+    let state;
+    let lastRun = 0;
+    let inFlight;
+    const listeners = new Set();
+    const refresh = (force = false) => {
+        const now = Date.now();
+        if (inFlight)
+            return inFlight;
+        if (!force && now - lastRun < minIntervalMs)
+            return Promise.resolve();
+        lastRun = now;
+        inFlight = (async () => {
+            try {
+                const branchRun = await pi.exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: cwd(), timeout: 2000 });
+                if (branchRun.code !== 0) {
+                    state = undefined;
+                    return;
+                }
+                const branch = parseBranch(branchRun.stdout);
+                const statusRun = await pi.exec("git", ["status", "--porcelain"], { cwd: cwd(), timeout: 3000 });
+                const dirty = statusRun.code === 0 ? parsePorcelain(statusRun.stdout) : undefined;
+                state = { branch, dirty };
+            }
+            catch {
+                state = undefined;
+            }
+            finally {
+                inFlight = undefined;
+                for (const listener of listeners)
+                    listener();
+            }
+        })();
+        return inFlight;
+    };
+    return {
+        get: () => state,
+        refresh,
+        onChange(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}

package/dist/index.js

@@ -5,11 +5,21 @@ import { installFooter } from "./footer.js";
 import { installCwd } from "./cwd.js";
 import { listSiblings, parseAgentList, parseTabList } from "./herdr.js";
 import { hideGauntletWidgets } from "./tracker.js";
-import { stopLiveWatch, wrapBuiltinTools } from "./tools.js";
+import { installToolRenderers, stopLiveWatch } from "./tools.js";
 import { applyReclaim, reclaimPolicy } from "./reclaim.js";
 import { installWorkingStatus } from "./working-status.js";
+import { installTurnRule } from "./turn-rule.js";
+import { installTranscript } from "./transcript.js";
+import { createGitState } from "./git-state.js";
+import { installCodeBox } from "./code-box.js";
+import { setChromeMargin } from "./chrome.js";
+import { SettingsManager } from "@earendil-works/pi-coding-agent";
 export default function piMinimalExtension(pi) {
     const stopWorkingStatus = installWorkingStatus(pi);
+    const stopTurnRule = installTurnRule(pi);
+    installToolRenderers(pi);
+    installTranscript(pi);
+    installCodeBox();
     let fastTimer;
     let slowTimer;
     let stealTimer;
@@ -17,6 +27,9 @@ export default function piMinimalExtension(pi) {
     let siblings;
     let generation = 0;
     let hideWidgets = true;
+    let busy = false;
+    let currentCwd = process.cwd();
+    const gitState = createGitState(pi, () => currentCwd);
     const stopTimers = () => {
         if (fastTimer)
             clearInterval(fastTimer);
@@ -103,16 +116,37 @@ export default function piMinimalExtension(pi) {
             },
             chrome: () => {
                 installHeader(ctx);
-                installFooter(ctx, () => siblings);
+                installChromeFooter(ctx);
             },
         });
     };
+    const contextPct = (ctx) => {
+        const usage = ctx.getContextUsage?.();
+        const window = usage?.contextWindow || ctx.model?.contextWindow;
+        if (typeof usage?.tokens !== "number" || !window)
+            return undefined;
+        return Math.max(0, Math.min(100, Math.round((usage.tokens / window) * 100)));
+    };
+    const installChromeFooter = (ctx) => {
+        installFooter(ctx, {
+            busy: () => busy,
+            editorText: () => (typeof ctx.ui.getEditorText === "function" ? ctx.ui.getEditorText() : ""),
+            contextPct: () => contextPct(ctx),
+        });
+    };
+    const installStatusLine = (ctx) => {
+        installCwd(ctx, {
+            gitState: gitState.get,
+            siblings: () => siblings,
+            onGitChange: gitState.onChange,
+        });
+    };
     const pinChrome = (ctx, reason) => {
         hideForeignChrome(ctx, reason);
         if (ctx.mode !== "tui" || !reclaimPolicy(reason).reinstallChrome)
             return;
         ctx.ui.setWidget("tw-cwd", undefined);
-        installCwd(ctx);
+        installStatusLine(ctx);
     };
     pi.on("session_start", async (_event, ctx) => {
         if (ctx.mode !== "tui")
@@ -123,10 +157,18 @@ export default function piMinimalExtension(pi) {
             projectTrusted: ctx.isProjectTrusted(),
         });
         hideWidgets = config.hideGauntletWidgets;
+        currentCwd = ctx.cwd;
+        try {
+            const settings = SettingsManager.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted() });
+            setChromeMargin(settings.getOutputPad());
+        }
+        catch {
+            // Keep the default margin when settings are unavailable.
+        }
         installHeader(ctx);
-        installFooter(ctx, () => siblings);
-        installCwd(ctx);
-        wrapBuiltinTools(pi, ctx);
+        installChromeFooter(ctx);
+        installStatusLine(ctx);
+        void gitState.refresh(true);
         pinChrome(ctx, "session_start");
         ctx.ui.setHiddenThinkingLabel("◆ Thought");
         ctx.ui.setWorkingIndicator();
@@ -139,15 +181,26 @@ export default function piMinimalExtension(pi) {
             await probe(ctx);
         }
     });
+    pi.on("agent_start", () => {
+        busy = true;
+    });
+    pi.on("agent_end", () => {
+        busy = false;
+        void gitState.refresh();
+    });
     pi.on("turn_end", (_event, ctx) => {
         pinChrome(ctx, "turn_end");
+        void gitState.refresh();
     });
     pi.on("tool_execution_end", (_event, ctx) => {
         pinChrome(ctx, "tool_execution_end");
+        void gitState.refresh();
     });
     pi.on("session_shutdown", async () => {
+        busy = false;
         stopTimers();
         stopWorkingStatus();
+        stopTurnRule();
         stopLiveWatch();
         generation += 1;
         siblings = undefined;

package/dist/tool-rows.js

@@ -1,7 +1,7 @@
-let activityGroup;
-export function resetActivityGroup() {
-    activityGroup = undefined;
-}
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+/** Width of the verb column so items align across rows. */
+export const VERB_WIDTH = 5;
+const BASH_STATUS = /^Command (?:exited with code (\d+)|terminated without an exit code)$/;
 export function shortName(path) {
     const parts = path.split("/").filter(Boolean);
     if (parts.length <= 1)
@@ -22,13 +22,144 @@ export function toolItem(kind, args) {
         "";
     return path ? shortName(path) : kind;
 }
-export function nextGroupedRow(verb, item, id) {
-    if (activityGroup && activityGroup.verb === verb) {
-        activityGroup.seen.add(id);
-        if (id === activityGroup.leadId)
-            return { header: verb, item };
-        return { header: undefined, item };
+export function resultText(result) {
+    if (!result?.content)
+        return "";
+    return result.content
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n");
+}
+export function rowGlyph(status, frame) {
+    if (status === "running")
+        return frame === 1 ? "◓" : "◐";
+    return status === "error" ? "✗" : "✓";
+}
+export function formatDuration(ms) {
+    if (ms === undefined || !Number.isFinite(ms))
+        return "";
+    if (ms < 1000)
+        return `${Math.round(ms / 100) / 10}s`;
+    if (ms < 60_000)
+        return `${Math.round(ms / 100) / 10}s`;
+    const minutes = Math.floor(ms / 60_000);
+    const seconds = Math.round((ms % 60_000) / 1000);
+    return `${minutes}m ${seconds}s`;
+}
+function plural(n, word, pluralWord = `${word}s`) {
+    return `${n} ${n === 1 ? word : pluralWord}`;
+}
+function countLines(text) {
+    if (!text)
+        return 0;
+    return text.split("\n").filter((line) => line.length > 0).length;
+}
+/** Strip pi's bash status trailer and truncation note from output text. */
+export function bashBody(text) {
+    const lines = text.split("\n");
+    let exitCode;
+    while (lines.length > 0) {
+        const last = lines[lines.length - 1].trim();
+        const match = BASH_STATUS.exec(last);
+        if (match) {
+            exitCode = match[1] !== undefined ? Number(match[1]) : undefined;
+            lines.pop();
+            continue;
+        }
+        if (last.startsWith("[Showing ") && last.endsWith("]")) {
+            lines.pop();
+            continue;
+        }
+        if (last === "") {
+            lines.pop();
+            continue;
+        }
+        break;
+    }
+    return { body: lines.join("\n"), exitCode };
+}
+export function diffStats(diff) {
+    let added = 0;
+    let removed = 0;
+    for (const line of diff.split("\n")) {
+        if (line.startsWith("+++") || line.startsWith("---"))
+            continue;
+        if (line.startsWith("+"))
+            added += 1;
+        else if (line.startsWith("-"))
+            removed += 1;
+    }
+    return { added, removed };
+}
+export function formatOutcome(kind, args, result, isError, durationMs) {
+    const text = resultText(result);
+    const dur = formatDuration(durationMs);
+    const join = (...parts) => parts.filter(Boolean).join(" · ");
+    if (kind === "bash") {
+        const { body, exitCode } = bashBody(text);
+        if (isError || (exitCode !== undefined && exitCode !== 0)) {
+            const code = exitCode !== undefined ? `exit ${exitCode}` : "failed";
+            return { text: join(code, dur), errorLine: firstLine(body) };
+        }
+        const lines = countLines(body);
+        const summary = lines === 0 || body === "(no output)" ? "ok" : plural(lines, "line");
+        return { text: join(summary, dur) };
+    }
+    if (isError)
+        return { text: join("failed", dur), errorLine: firstLine(text) };
+    if (kind === "edit") {
+        const details = result?.details;
+        const diff = typeof details?.diff === "string" ? diffStats(details.diff) : undefined;
+        return diff ? { text: dur, diff } : { text: join("edited", dur) };
+    }
+    if (kind === "write") {
+        const bytes = typeof args?.content === "string" ? Buffer.byteLength(args.content, "utf8") : undefined;
+        return { text: join(bytes === undefined ? "written" : formatBytes(bytes), dur) };
+    }
+    if (kind === "read") {
+        return { text: join(plural(countLines(text), "line"), dur) };
+    }
+    if (kind === "grep") {
+        if (/^No matches found/m.test(text))
+            return { text: join("0 matches", dur) };
+        return { text: join(plural(countLines(text), "match"), dur) };
+    }
+    // find / ls
+    return { text: join(plural(countLines(text), "entry", "entries"), dur) };
+}
+export function firstLine(text) {
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (trimmed && trimmed !== "(no output)")
+            return trimmed;
+    }
+    return undefined;
+}
+export function formatBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${Math.round(n / 102.4) / 10} KB`;
+    return `${Math.round(n / (1024 * 102.4)) / 10} MB`;
+}
+/**
+ * Lay out one row: `<glyph> <verb> <item> ... <outcome>`. The item is truncated so the outcome
+ * stays visible; the outcome is dropped only when the row is too narrow to show both.
+ */
+export function layoutRow(width, verb, item, outcome) {
+    const verbCol = verb.padEnd(VERB_WIDTH);
+    // glyph + space + verb column + space
+    const prefixWidth = 2 + VERB_WIDTH + 1;
+    const outcomeWidth = visibleWidth(outcome);
+    const minGap = 2;
+    let shownOutcome = outcome;
+    let itemRoom = width - prefixWidth - (outcomeWidth ? outcomeWidth + minGap : 0);
+    if (itemRoom < 12 && outcomeWidth) {
+        shownOutcome = "";
+        itemRoom = width - prefixWidth;
     }
-    activityGroup = { verb, leadId: id, seen: new Set([id]) };
-    return { header: verb, item };
+    const shownItem = truncateToWidth(item, Math.max(0, itemRoom), "…");
+    const used = prefixWidth + visibleWidth(shownItem) + visibleWidth(shownOutcome);
+    const gap = shownOutcome ? Math.max(minGap, width - used) : 0;
+    return { verb: verbCol, item: shownItem, gap, outcome: shownOutcome };
 }