@giovannijecha/jecode 0.8.4 → 0.8.6

package/dist/tui/app-workflows.js

@@ -1,336 +1,11 @@
-// Foreground command and model-turn workflows for the TUI shell.
-import { handleCommand } from "../commands.js";
-import { runTurn } from "../controller.js";
-import { resolveContextPolicy } from "../context/capacity.js";
-import { compactContext } from "../context/compactor.js";
-import { compactSession } from "../context/manual.js";
-import { isContextOverflow } from "../context/policy.js";
-import { updateSettings } from "../settings.js";
-import { steeringInbox } from "../steering.js";
-import { saveTranscript } from "../transcript-export.js";
-import { recordAuxiliaryUsage, recordRequestInput, recordUsage } from "../usage.js";
-import { selectTimeline } from "../timeline.js";
-import { transition } from "./activity.js";
-import { answerAt } from "./approve.js";
-import * as edit from "./editor.js";
-import { cancel as cancelOpen } from "./overlay.js";
-import { controllerOptions, turnFailure } from "./session-view.js";
-import { transcribe } from "./turn.js";
-const WAITING = "Waiting";
+// Wire foreground workflows to the shell and their shared compaction lifetime.
+import { automaticCompactionGate } from "../context/automatic.js";
+import { commandWorkflow } from "./command-workflow.js";
+import { turnWorkflow } from "./turn-workflow.js";
 export function appWorkflows(options) {
-    const { session, state, permissions, feedback } = options;
-    let activeSteering;
-    const choose = (picker) => new Promise((resolve) => {
-        state.open = { picker, settle: resolve };
-        options.render();
-    });
-    async function command(text) {
-        const activity = options.startActivity("command", `Running ${text.split(/\s+/)[0]}`);
-        if (activity === undefined)
-            return;
-        const status = (label) => transition(activity, label);
-        try {
-            const outcome = await handleCommand(text, session, {
-                emit: options.commandNotice,
-                signal: activity.control.signal,
-                showHelp: () => new Promise((resolve) => {
-                    state.open = { help: true, settle: resolve };
-                    options.render();
-                }),
-                choose,
-                dismiss: () => {
-                    state.open = state.open === undefined ? undefined : cancelOpen(state.open);
-                    options.render();
-                },
-                type: (field) => new Promise((resolve) => {
-                    state.open = { field, settle: resolve };
-                    options.render();
-                }),
-                status: (said) => {
-                    status(said ?? activity.label);
-                    options.render();
-                },
-                reset: async () => {
-                    await session.persistence?.reset();
-                    state.blocks.splice(0);
-                    state.past.length = 0;
-                    permissions.reset();
-                    state.scroll = 0;
-                    state.follow = true;
-                    state.unseen = 0;
-                    state.lastMaxScroll = 0;
-                    state.committedNodeId = 0;
-                },
-                permissions,
-                exportTranscript: () => saveTranscript(options.transcriptRoot, state.blocks),
-                saveSettings: async (patch) => {
-                    await updateSettings(patch);
-                },
-                refreshSettings: options.refreshSettings,
-                timeline: async () => {
-                    const selected = await selectTimeline(session, choose);
-                    if (!selected)
-                        return "unchanged";
-                    options.replaceTranscript();
-                    return session.conversation.activeNodeId === state.committedNodeId
-                        ? "unchanged"
-                        : "selected";
-                },
-                compact: async () => {
-                    if (session.conversation.activeNodeId !== state.committedNodeId) {
-                        return "branch-pending";
-                    }
-                    return compactSession(session, {
-                        signal: activity.control.signal,
-                        onStatus: (said) => {
-                            status(said ?? activity.label);
-                            options.render();
-                        },
-                    });
-                },
-            });
-            if (outcome === "exit")
-                state.closeWhenIdle = true;
-        }
-        catch (error) {
-            // Command cancellation is already visible through the dock closing and
-            // the activity ending. Keep it silent instead of replacing the footer
-            // with a redundant warning.
-            if (!activity.control.signal.aborted) {
-                feedback.show({
-                    text: error.message,
-                    tone: "error",
-                    timeoutMs: 6_000,
-                });
-            }
-        }
-        finally {
-            options.finishActivity(activity);
-        }
-    }
-    async function turn(text) {
-        const activity = options.startActivity("turn", WAITING);
-        if (activity === undefined)
-            return;
-        const inbox = steeringInbox((pending, accepting) => {
-            if (activeSteering !== inbox)
-                return;
-            state.steering = accepting ? pending : undefined;
-            options.render();
-        });
-        activeSteering = inbox;
-        state.steering = 0;
-        const status = (label) => transition(activity, label);
-        const parentId = session.conversation.activeNodeId;
-        const history = session.conversation.history;
-        const modelHistory = session.conversation.contextHistory;
-        const historyStart = history.length;
-        const blockStart = state.blocks.length;
-        const createdAt = new Date().toISOString();
-        const prospectiveNodeId = session.conversation.nodes.length + 1;
-        let nodeId;
-        let context;
-        const unpersistedSteering = [];
-        let firstPolicy = true;
-        const policy = () => {
-            let visible = firstPolicy;
-            firstPolicy = false;
-            if (visible) {
-                status("Checking context");
-                options.render();
-            }
-            return resolveContextPolicy({
-                provider: session.provider,
-                model: session.model,
-                compactionPercent: session.config.compactionPercent,
-                signal: activity.control.signal,
-                onStatus: (said) => {
-                    visible = true;
-                    status(said);
-                    options.render();
-                },
-            }).finally(() => {
-                if (visible) {
-                    status(WAITING);
-                    options.render();
-                }
-            });
-        };
-        options.emit({ kind: "user", text });
-        const user = { role: "user", content: [{ kind: "text", text }] };
-        history.push(user);
-        modelHistory.push(structuredClone(user));
-        const events = transcribe({
-            emit: options.emit,
-            render: options.render,
-            palette: session.palette,
-            approved: (call) => permissions.approved(call),
-            remember: (call) => permissions.remember(call),
-            ask: (prompt, settle) => {
-                state.open = { picker: prompt, settle: (index) => settle(answerAt(index)) };
-                options.render();
-            },
-            status: (text) => {
-                status(text);
-            },
-            usage: (usage) => recordUsage(session.usage, usage),
-            requestInput: (inputTokens) => recordRequestInput(session.usage, inputTokens),
-        });
-        const persist = async (checkpoint, settlement, failure) => {
-            const next = session.conversation.commit({
-                ...(nodeId === undefined ? {} : { nodeId }),
-                parentId,
-                createdAt,
-                identity: {
-                    providerId: session.provider.id,
-                    model: session.model,
-                    effort: session.config.effort,
-                },
-                messages: checkpoint.slice(historyStart),
-                blocks: state.blocks.slice(blockStart),
-                ...(context === undefined ? {} : { context }),
-                ...(failure === undefined ? {} : { failure }),
-            }, settlement);
-            await session.persistence?.checkpoint(next);
-            session.conversation = next;
-            nodeId = next.activeNodeId;
-            state.committedNodeId = next.activeNodeId;
-            unpersistedSteering.length = 0;
-        };
-        const compact = async (checkpoint, projected, request) => {
-            if (request.reason === "overflow" &&
-                (request.error === undefined || !isContextOverflow(request.error))) {
-                return undefined;
-            }
-            const force = request.reason === "overflow";
-            const result = await compactContext({
-                provider: session.provider,
-                model: session.model,
-                effort: session.config.effort,
-                context: projected,
-                turn: checkpoint.slice(historyStart),
-                nodeId: nodeId ?? prospectiveNodeId,
-                coveredMessages: context?.messageCount ?? 0,
-                lastInputTokens: Math.max(session.usage.lastInputTokens, request.inputTokens),
-                estimatedInputTokens: request.inputTokens,
-                signal: activity.control.signal,
-                force,
-                policy: request.policy,
-                onBegin: () => {
-                    status("Compacting");
-                    options.render();
-                },
-                onEnd: () => {
-                    status(WAITING);
-                    options.render();
-                },
-            });
-            if (result === undefined)
-                return undefined;
-            context = result.anchor;
-            if (result.usage !== undefined)
-                recordAuxiliaryUsage(session.usage, result.usage);
-            return result.messages;
-        };
-        events.onContext = compact;
-        events.onSteering = (guidance) => {
-            unpersistedSteering.push(guidance);
-            options.emit({ kind: "user", text: guidance });
-            options.render();
-        };
-        events.onCheckpoint = async (checkpoint, settlement, projected) => {
-            await persist(checkpoint, settlement);
-            const compacted = await compact(checkpoint, projected, {
-                reason: "budget",
-                policy: await policy(),
-                inputTokens: session.usage.lastInputTokens,
-            });
-            if (compacted !== undefined)
-                await persist(checkpoint, settlement);
-            return compacted;
-        };
-        let finishReason;
-        let failed;
-        try {
-            await runTurn(history, controllerOptions(session, policy, permissions.availableTools(), inbox), events, activity.control.signal, modelHistory);
-        }
-        catch (error) {
-            const interrupted = activity.control.signal.aborted;
-            const completed = nodeId !== undefined && session.conversation.activeNodeId === nodeId &&
-                session.conversation.activeNode?.settlement === "completed";
-            if (completed) {
-                const notice = turnFailure(session, error, interrupted);
-                feedback.show({ text: notice.text, tone: notice.tone, timeoutMs: 6_000 });
-            }
-            else {
-                finishReason = interrupted ? "interrupted" : "failed";
-                failed = { error: error, interrupted };
-            }
-        }
-        finally {
-            let pendingSteering = inbox.close();
-            if (activeSteering === inbox)
-                activeSteering = undefined;
-            state.steering = undefined;
-            try {
-                events.finish(finishReason);
-                if (failed !== undefined) {
-                    const notice = turnFailure(session, failed.error, failed.interrupted);
-                    const settlement = failed.interrupted ? "interrupted" : "failed";
-                    const failure = {
-                        text: notice.text,
-                        tone: failed.interrupted ? "warn" : "error",
-                    };
-                    options.emit(notice);
-                    try {
-                        await persist(closeFailedTurn(history, settlement), settlement, failure);
-                    }
-                    catch (error) {
-                        // A failed persistence boundary cannot remain visible as if it had
-                        // been saved. Revert to the last durable path and return the input
-                        // to the composer so the user can retry without losing it.
-                        options.replaceTranscript();
-                        state.editor = edit.of([
-                            ...(nodeId === undefined ? [text] : []),
-                            ...unpersistedSteering,
-                            ...pendingSteering,
-                            state.editor.text,
-                        ].filter((part) => part !== "").join("\n\n"));
-                        state.completing = undefined;
-                        pendingSteering = [];
-                        feedback.show({
-                            text: error.message,
-                            tone: "error",
-                            timeoutMs: 6_000,
-                        });
-                    }
-                }
-            }
-            finally {
-                restorePendingSteering(state, pendingSteering);
-                options.finishActivity(activity);
-            }
-        }
-    }
-    function steer(text) {
-        return activeSteering?.offer(text) ?? "unavailable";
-    }
-    return { command, turn, steer };
-}
-function restorePendingSteering(state, messages) {
-    if (messages.length === 0)
-        return;
-    const pending = messages.join("\n\n");
-    state.editor = edit.of(state.editor.text === "" ? pending : `${pending}\n\n${state.editor.text}`);
-    state.completing = undefined;
-}
-function closeFailedTurn(history, settlement) {
-    const closed = [...history];
-    if (closed.at(-1)?.role === "assistant")
-        return closed;
-    const text = settlement === "interrupted"
-        ? "The previous attempt was interrupted by the user before completion."
-        : "The previous attempt failed before completion.";
-    closed.push({ role: "assistant", content: [{ kind: "text", text }] });
-    return closed;
+    const automaticCompaction = automaticCompactionGate();
+    return {
+        command: commandWorkflow(options, () => automaticCompaction.reset()),
+        ...turnWorkflow(options, automaticCompaction),
+    };
 }

package/dist/tui/approve.js

@@ -16,13 +16,15 @@ export { scopeFor };
 export function promptFor(call, target, pal) {
     const scope = scopeFor(call);
     const options = [
-        { label: "Yes, once", hint: "enter", key: "y" },
-        { label: `Yes, ${scopeNoun(scope)} for the session`, hint: "a", key: "a" },
-        { label: "No, and say why", hint: "esc", key: "n" },
+        { label: "Yes, once", hint: "y", key: "y", description: "Approve only this call. Ask again next time." },
+        { label: `Yes, ${scopeNoun(scope)} for the session`, hint: "a", key: "a",
+            description: `Reuse approval for ${scopeNoun(scope)} in this session.` },
+        { label: "No, and say why", hint: "n", key: "n", description: "Do not run this call. Return feedback to the model." },
     ];
     return {
         title: [{ text: question(call.name), fg: pal.ink.attention, bold: true }],
         right: `${call.name}${target === "" ? "" : ` · ${target}`}`,
+        controls: "↑↓ choose · enter confirm · esc deny",
         options,
         index: 0,
     };

package/dist/tui/blocks.js

@@ -2,23 +2,24 @@
 import { renderAnswer, renderReasoning, renderUser } from "./components/messages.js";
 import { renderNotice } from "./components/misc.js";
 import { renderTool } from "./components/tool.js";
+import { insetTranscript, modelTranscriptWidth } from "./transcript-grammar.js";
 export function render(block, width, pal, context = {}) {
+    const inner = modelTranscriptWidth(width);
     switch (block.kind) {
         case "user":
             return renderUser(block, width, pal);
         case "answer":
-            return renderAnswer(block, width, pal);
+            return insetTranscript(renderAnswer(block, inner, pal));
         case "reasoning":
-            return renderReasoning(block, width, pal, {
+            return insetTranscript(renderReasoning(block, inner, pal, {
                 continues: context.previous?.kind === "reasoning",
-            });
+            }));
         case "tool":
-            return renderTool(block, width, pal, {
-                continues: context.previous?.kind === "tool",
+            return insetTranscript(renderTool(block, inner, pal, {
+                continues: context.previous?.kind === "reasoning",
                 now: context.now,
-                motion: context.motion,
                 reducedMotion: context.reducedMotion,
-            });
+            }));
         case "notice":
             return renderNotice(block, width, pal);
     }

package/dist/tui/command-workflow.js

@@ -0,0 +1,106 @@
+// Foreground slash-command interactions and their session updates.
+import { handleCommand } from "../commands.js";
+import { compactSession } from "../context/manual.js";
+import { resetRequestIdentity } from "../request-identity.js";
+import { updateSettings } from "../settings.js";
+import { selectTimeline } from "../timeline.js";
+import { saveTranscript } from "../transcript-export.js";
+import { transition } from "./activity.js";
+import { cancel as cancelOpen } from "./overlay.js";
+export function commandWorkflow(options, resetCompaction) {
+    const { session, state, permissions, feedback } = options;
+    const choose = (picker) => new Promise((resolve) => {
+        state.open = { picker, settle: resolve };
+        options.render();
+    });
+    async function command(text) {
+        const activity = options.startActivity("command", `Running ${text.split(/\s+/)[0]}`);
+        if (activity === undefined)
+            return;
+        const status = (label) => transition(activity, label);
+        try {
+            const outcome = await handleCommand(text, session, {
+                emit: options.commandNotice,
+                signal: activity.control.signal,
+                showHelp: () => new Promise((resolve) => {
+                    state.open = { help: true, settle: resolve };
+                    options.render();
+                }),
+                choose,
+                dismiss: () => {
+                    state.open = state.open === undefined ? undefined : cancelOpen(state.open);
+                    options.render();
+                },
+                type: (field) => new Promise((resolve) => {
+                    state.open = { field, settle: resolve };
+                    options.render();
+                }),
+                status: (said) => {
+                    status(said ?? activity.label);
+                    options.render();
+                },
+                reset: async () => {
+                    await session.persistence?.reset();
+                    resetRequestIdentity(session);
+                    resetCompaction();
+                    state.blocks.splice(0);
+                    state.past.length = 0;
+                    permissions.reset();
+                    state.scroll = 0;
+                    state.follow = true;
+                    state.unseen = 0;
+                    state.lastMaxScroll = 0;
+                    state.committedNodeId = 0;
+                },
+                permissions,
+                exportTranscript: () => saveTranscript(options.transcriptRoot, state.blocks),
+                saveSettings: async (patch) => {
+                    await updateSettings(patch);
+                },
+                refreshSettings: options.refreshSettings,
+                timeline: async () => {
+                    const selected = await selectTimeline(session, choose);
+                    if (!selected)
+                        return "unchanged";
+                    options.replaceTranscript();
+                    return session.conversation.activeNodeId === state.committedNodeId
+                        ? "unchanged"
+                        : "selected";
+                },
+                compact: async () => {
+                    if (session.conversation.activeNodeId !== state.committedNodeId) {
+                        return "branch-pending";
+                    }
+                    const result = await compactSession(session, {
+                        signal: activity.control.signal,
+                        onStatus: (said) => {
+                            status(said ?? activity.label);
+                            options.render();
+                        },
+                    });
+                    if (result === "compacted")
+                        resetCompaction();
+                    return result;
+                },
+            });
+            if (outcome === "exit")
+                state.closeWhenIdle = true;
+        }
+        catch (error) {
+            // Command cancellation is already visible through the dock closing and
+            // the activity ending. Keep it silent instead of replacing the footer
+            // with a redundant warning.
+            if (!activity.control.signal.aborted) {
+                feedback.show({
+                    text: error.message,
+                    tone: "error",
+                    timeoutMs: 6_000,
+                });
+            }
+        }
+        finally {
+            options.finishActivity(activity);
+        }
+    }
+    return command;
+}

package/dist/tui/components/command-menu.js

@@ -1,18 +1,15 @@
-import { menuWindow, renderMenuRows } from "./menu.js";
+import { renderMenu } from "./menu.js";
 const MAX_ROWS = 4;
 export function renderCommandMenu(commands, selected, width, pal) {
     const selectedIndex = selected === undefined ? 0 : Math.max(0, Math.min(commands.length - 1, selected));
-    const { first, last } = menuWindow(commands.length, selectedIndex, MAX_ROWS);
-    const shown = commands.slice(first, last);
-    if (shown.length === 0)
+    if (commands.length === 0)
         return { rows: [], right: "" };
+    const menu = renderMenu(commands.map((command, index) => ({
+        label: `/${command.name}`, description: command.blurb, selected: selectedIndex === index,
+    })), width, pal, { maxRows: MAX_ROWS + 2, visible: MAX_ROWS });
     return {
-        rows: renderMenuRows(shown.map((command, index) => ({
-            label: `/${command.name}`,
-            description: command.blurb,
-            selected: selectedIndex === first + index,
-        })), width, pal),
-        right: commands.length > shown.length ? `${first + 1}–${last} / ${commands.length}` : "",
+        rows: menu.rows,
+        right: commands.length > menu.last - menu.first ? `${menu.first + 1}–${menu.last} / ${commands.length}` : "",
     };
 }
 export function commandMenuLimit() {

package/dist/tui/components/footer.js

@@ -10,7 +10,7 @@ export function renderFooter(info, status, width, pal) {
 function identity(info, cols) {
     if (cols <= 0)
         return "";
-    const core = `${info.model || "no model"} · ${info.effort}`;
+    const core = `${info.provider || "Provider"} · ${info.model || "no model"} · ${info.effort}`;
     if (textWidth(core) >= cols || info.workspace === "")
         return elide(core, cols);
     const divider = " · ";

package/dist/tui/components/menu.js

@@ -1,12 +1,57 @@
-// One visual row grammar for autocomplete and every interactive selector.
-import { hasColor, plainLen, row } from "../../ui/render.js";
-import { elide } from "../../ui/width.js";
+// Ribbon rows and a stable detail area shared by completion and selectors.
+import { row } from "../../ui/render.js";
+import { terminalText } from "../../ui/terminal-text.js";
+import { elide, textWidth, wrapText } from "../../ui/width.js";
 export function renderMenuRows(entries, width, pal) {
+    return entries.map((entry) => {
+        const right = summary(entry, width);
+        return row(width, [
+            { text: entry.selected ? "● " : "  ", fg: pal.focus },
+            { text: entry.label, fg: entry.selected ? pal.ink.bright : pal.ink.muted, bold: entry.selected },
+        ], right === "" ? [] : [{ text: right, fg: entry.selected ? pal.focus : pal.ink.dim }], entry.selected ? pal.surface.subtle : undefined);
+    });
+}
+/** A missing palette measures the window without producing styled rows. */
+export function renderMenu(entries, width, pal, options) {
+    const room = Math.max(0, options.maxRows);
+    if (room === 0)
+        return { rows: [], first: 0, last: 0 };
+    const detailLimit = Math.min(2, room - 1);
+    let detailRows = 0;
+    // Measure every possible selection to keep the dock stable without reserving
+    // a second row when all details fit on one line at this width.
+    for (const entry of entries) {
+        detailRows = Math.max(detailRows, detailLines(entry, width, detailLimit).length);
+        if (detailRows === detailLimit)
+            break;
+    }
+    const visible = Math.min(options.visible ?? 6, room - detailRows);
+    const at = Math.max(0, entries.findIndex((entry) => entry.selected));
+    const { first, last } = menuWindow(entries.length, at, visible);
+    if (pal === undefined)
+        return { rows: [], first, last };
     if (entries.length === 0)
+        return {
+            rows: [row(width, [{ text: "No matches. Change the filter.", fg: pal.ink.muted }])], first, last,
+        };
+    const active = entries.find((entry) => entry.selected);
+    const lines = detailLines(active, width, detailRows);
+    return {
+        rows: [
+            ...renderMenuRows(entries.slice(first, last), width, pal),
+            ...Array.from({ length: detailRows }, (_, index) => lines[index] === undefined ? ""
+                : row(width, [{ text: "  " + lines[index], fg: pal.ink.muted }])),
+        ], first, last,
+    };
+}
+function detailLines(entry, width, maxRows) {
+    if (entry === undefined || maxRows <= 0)
         return [];
-    const widest = Math.max(...entries.map(primaryWidth));
-    const labelWidth = Math.min(42, Math.max(12, widest + 2));
-    return entries.map((entry) => renderEntry(entry, labelWidth, width, pal));
+    // Complete identity and values take priority over explanatory copy.
+    const room = Math.max(1, width - 2);
+    const lines = menuText(clippedParts(entry, width).join(" · "), room, maxRows);
+    lines.push(...menuText(entry.description ?? "", room, maxRows - lines.length));
+    return lines;
 }
 export function menuWindow(length, selected, visible) {
     const count = Math.max(0, length);
@@ -15,42 +60,28 @@ export function menuWindow(length, selected, visible) {
     const first = Math.max(0, Math.min(at - Math.floor(room / 2), count - room));
     return { first, last: Math.min(count, first + room) };
 }
-function renderEntry(entry, labelWidth, width, pal) {
-    // Colour terminals spend focus on the active label instead of painting a
-    // full-width band. Monochrome has no colour, so it alone reserves a fixed
-    // arrow column to keep selection visible without shifting peer rows.
-    const monochrome = !hasColor();
-    const selectedMark = monochrome ? (entry.selected ? "→ " : "  ") : "";
-    const fg = entry.selected ? pal.focus : pal.ink.fg;
-    const primary = [
-        { text: selectedMark, fg },
-        { text: entry.label, fg, bold: entry.selected || undefined },
+/** Wrap untrusted menu copy, marking a bounded final row when it omits text. */
+export function menuText(text, width, maxRows) {
+    if (text === "" || maxRows <= 0)
+        return [];
+    const lines = wrapText(terminalText(text), Math.max(1, width));
+    return lines.slice(0, maxRows).map((line, index) => index === maxRows - 1 && lines.length > maxRows ? elide(line + " …", width) : line);
+}
+function fullSummary(entry) {
+    const value = entry.value === undefined ? "" : entry.selected && entry.adjustable ? "‹ " + entry.value + " ›" : entry.value;
+    return [entry.hint, value].filter(Boolean).join(" · ");
+}
+function summary(entry, width) {
+    return elide(terminalText(fullSummary(entry)), Math.max(1, Math.floor(width * 0.42)));
+}
+function clippedParts(entry, width) {
+    // Reserve the stepper's width for every peer, so moving selection cannot
+    // make the shared detail area appear or disappear.
+    const stable = entry.adjustable ? { ...entry, selected: true } : entry;
+    const right = summary(stable, width);
+    const leftRoom = Math.max(0, width - 2 - (right === "" ? 0 : textWidth(right) + 1));
+    return [
+        ...(textWidth(terminalText(entry.label)) > leftRoom ? [entry.label] : []),
+        ...(right !== terminalText(fullSummary(stable)) ? [fullSummary(stable)] : []),
     ];
-    if (width > 40 && entry.description !== undefined) {
-        const gap = Math.max(2, labelWidth - primaryWidth(entry));
-        primary.push({
-            text: `${" ".repeat(gap)}${entry.description}`,
-            fg: entry.selected ? pal.ink.bright : pal.ink.muted,
-        });
-    }
-    const value = entry.value === undefined
-        ? undefined
-        : entry.selected && entry.adjustable === true
-            ? `‹ ${entry.value} ›`
-            : entry.value;
-    const summary = [entry.hint, value]
-        .filter((part) => part !== undefined)
-        .join(" · ");
-    const rightColor = entry.selected ? pal.focus : pal.ink.muted;
-    const right = summary === "" || (width <= 40 && entry.value === undefined)
-        ? []
-        : [{
-                text: elide(summary, Math.max(1, Math.floor(entry.value === undefined ? width / 4 : width * 0.45))),
-                fg: rightColor,
-                bold: entry.selected || undefined,
-            }];
-    return row(width, primary, right);
-}
-function primaryWidth(entry) {
-    return plainLen([{ text: entry.label }]);
 }