@giovannijecha/jecode 0.7.4 → 0.8.0

package/dist/settings-command.js

@@ -41,9 +41,6 @@ export async function settingsCommand(session, host) {
             case "maxTokens":
                 await numberSetting(session, host, "maxTokens", "max output tokens");
                 break;
-            case "maxSteps":
-                await numberSetting(session, host, "maxSteps", "max tool steps");
-                break;
             case "compactionPercent":
                 await compactionSetting(session, host);
                 break;
@@ -81,7 +78,6 @@ function settingsItems(values) {
                     action: "maxTokens",
                     option: { label: "max output tokens", value: String(values.maxTokens) },
                 }]),
-        { action: "maxSteps", option: { label: "max tool steps", value: String(values.maxSteps) } },
         {
             action: "compactionPercent",
             option: { label: "context compaction", value: `${values.compactionPercent}%` },
@@ -102,7 +98,6 @@ function settingsValues(session) {
         model: session.model,
         effort: session.config.effort,
         ...(session.provider.id === "openai-codex" ? {} : { maxTokens: session.config.maxTokens }),
-        maxSteps: session.config.maxSteps,
         compactionPercent: session.config.compactionPercent,
         reducedMotion: session.config.reducedMotion,
     };

package/dist/settings.js

@@ -59,7 +59,6 @@ function normalize(value) {
     const effort = member(value["effort"], EFFORTS);
     const reducedMotion = typeof value["reducedMotion"] === "boolean" ? value["reducedMotion"] : undefined;
     const maxTokens = positiveInteger(value["maxTokens"]);
-    const maxSteps = positiveInteger(value["maxSteps"]);
     const compactionPercent = percentage(value["compactionPercent"]);
     return {
         ...(provider === undefined ? {} : { provider }),
@@ -68,7 +67,6 @@ function normalize(value) {
         ...(effort === undefined ? {} : { effort }),
         ...(reducedMotion === undefined ? {} : { reducedMotion }),
         ...(maxTokens === undefined ? {} : { maxTokens }),
-        ...(maxSteps === undefined ? {} : { maxSteps }),
         ...(compactionPercent === undefined ? {} : { compactionPercent }),
     };
 }

package/dist/steering.js

@@ -0,0 +1,58 @@
+// A bounded cooperative inbox for guidance submitted during an active turn.
+export const MAX_STEERING_MESSAGES = 8;
+export const MAX_STEERING_CODE_UNITS = 32_768;
+/**
+ * Build one inbox for one model turn. `drainOrClose` is the atomic completion
+ * handshake: pending guidance keeps the turn open; an empty queue closes it
+ * before the final checkpoint so late input cannot disappear.
+ */
+export function steeringInbox(changed = () => { }) {
+    let accepting = true;
+    let codeUnits = 0;
+    const messages = [];
+    const take = () => {
+        if (messages.length === 0)
+            return [];
+        const drained = messages.splice(0);
+        codeUnits = 0;
+        changed(0, accepting);
+        return drained;
+    };
+    return {
+        offer(text) {
+            if (!accepting)
+                return "closed";
+            if (messages.length >= MAX_STEERING_MESSAGES ||
+                codeUnits + text.length > MAX_STEERING_CODE_UNITS)
+                return "full";
+            messages.push(text);
+            codeUnits += text.length;
+            changed(messages.length, true);
+            return "queued";
+        },
+        drain: take,
+        drainOrClose() {
+            if (messages.length > 0)
+                return { messages: take(), closed: false };
+            accepting = false;
+            changed(0, false);
+            return { messages: [], closed: true };
+        },
+        close() {
+            if (!accepting && messages.length === 0)
+                return [];
+            accepting = false;
+            if (messages.length === 0) {
+                changed(0, false);
+                return [];
+            }
+            return take();
+        },
+        get pending() {
+            return messages.length;
+        },
+        get accepting() {
+            return accepting;
+        },
+    };
+}

package/dist/tools/args.js

@@ -2,7 +2,7 @@
 // tool takes three arguments and this is the whole job.
 //
 // Every throw here becomes an is_error tool result the model can read and
-// correct on the next step, so the messages are written for that reader.
+// correct on the next request, so the messages are written for that reader.
 export function requireString(args, name, allowEmpty = false) {
     const value = args[name];
     if (typeof value !== "string" || (!allowEmpty && value === "")) {

package/dist/transcript.js

@@ -1,5 +1,6 @@
 // A portable transcript: screen blocks in, Markdown out.
 import { terminalText } from "./ui/terminal-text.js";
+import { toolDuration } from "./duration.js";
 export function defaultTranscriptName(now = new Date()) {
     return `jecode-transcript-${now.toISOString().replace(/[-:.]/g, "")}.md`;
 }
@@ -17,7 +18,11 @@ export function transcriptMarkdown(blocks) {
                 out.push("<details>", "<summary>Reasoning</summary>", "", safeMultiline(block.text), "", "</details>", "");
                 break;
             case "tool":
-                out.push(`- **${safeInline(block.name)}**${block.target === "" ? "" : ` \`${inlineCode(block.target)}\``}${block.right === "" ? "" : ` — ${safeInline(block.right)}`}`);
+                const outcome = [
+                    block.right === "" ? undefined : safeInline(block.right),
+                    block.durationMs === undefined ? undefined : toolDuration(block.durationMs),
+                ].filter((part) => part !== undefined).join(" · ");
+                out.push(`- **${safeInline(block.name)}**${block.target === "" ? "" : ` \`${inlineCode(block.target)}\``}${outcome === "" ? "" : ` — ${outcome}`}`);
                 if ((block.body?.length ?? 0) > 0) {
                     out.push("", "````text", ...(block.body ?? []).map(detail), "````", "");
                 }

package/dist/tui/activity.js

@@ -1,14 +1,29 @@
 // One foreground operation owns cancellation and elapsed time.
 export function begin(kind, label, now = Date.now()) {
-    return { kind, label, control: new AbortController(), startedAt: now };
+    return {
+        kind,
+        label,
+        control: new AbortController(),
+        startedAt: now,
+        phase: { label, startedAt: now },
+    };
+}
+/** Change the visible phase without restarting its timer on repeated stream chunks. */
+export function transition(activity, label, now = Date.now()) {
+    if (activity.phase.label === label)
+        return;
+    activity.phase = { label, startedAt: now };
 }
 export function elapsed(activity, now = Date.now()) {
-    const seconds = Math.max(0, Math.floor((now - activity.startedAt) / 1_000));
+    return since(activity.startedAt, now);
+}
+export function activityStatus(activity, now = Date.now()) {
+    return `${activity.phase.label} · ${since(activity.phase.startedAt, now)}`;
+}
+function since(startedAt, now) {
+    const seconds = Math.max(0, Math.floor((now - startedAt) / 1_000));
     if (seconds < 60)
         return `${seconds}s`;
     const minutes = Math.floor(seconds / 60);
     return `${minutes}m ${String(seconds % 60).padStart(2, "0")}s`;
 }
-export function activityStatus(activity, label = activity.label, now = Date.now()) {
-    return `${label} · ${elapsed(activity, now)}`;
-}

package/dist/tui/app-input.js

@@ -69,6 +69,8 @@ export function appInput(options) {
                 return;
             }
             case "tab": {
+                if (state.activity !== undefined)
+                    return;
                 const completion = state.completing ?? activateCompletion(state.editor.text);
                 const completed = completion === undefined ? undefined : selectedCompletion(completion);
                 if (completed !== undefined) {
@@ -107,7 +109,7 @@ export function appInput(options) {
         const edited = applyKey(state.editor, key);
         if (edited !== undefined) {
             state.editor = edited;
-            state.completing = activateCompletion(edited.text);
+            state.completing = state.activity === undefined ? activateCompletion(edited.text) : undefined;
         }
     }
     function recall(step) {
@@ -131,9 +133,26 @@ export function appInput(options) {
     }
     function submit() {
         const text = state.editor.text.trim();
-        if (text === "" || state.activity !== undefined)
+        if (text === "")
             return;
         const isCommand = text.startsWith("/");
+        if (state.activity !== undefined) {
+            if (isCommand) {
+                keep("Slash commands run after the active work finishes");
+                return;
+            }
+            const result = actions.steer(text);
+            if (result !== "queued") {
+                keep(result === "full"
+                    ? "Steering queue is full"
+                    : result === "closed"
+                        ? "The turn is finishing"
+                        : "Wait for the active command to finish");
+                return;
+            }
+            accept(text);
+            return;
+        }
         if (!isCommand) {
             const blocker = turnBlocker(session);
             if (blocker !== undefined) {
@@ -141,6 +160,13 @@ export function appInput(options) {
                 return;
             }
         }
+        accept(text);
+        if (isCommand)
+            void actions.command(text);
+        else
+            void actions.turn(text);
+    }
+    function accept(text) {
         state.editor = edit.EMPTY;
         state.recall = -1;
         state.draft = "";
@@ -149,10 +175,9 @@ export function appInput(options) {
         state.scroll = 0;
         state.follow = true;
         state.unseen = 0;
-        if (isCommand)
-            void actions.command(text);
-        else
-            void actions.turn(text);
+    }
+    function keep(text) {
+        feedback.show({ text: `${text} · prompt kept`, tone: "warn", timeoutMs: 4_000 });
     }
     return { handle };
 }

package/dist/tui/app-workflows.js

@@ -6,9 +6,11 @@ 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";
@@ -17,6 +19,7 @@ import { transcribe } from "./turn.js";
 const WAITING = "Waiting";
 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();
@@ -25,6 +28,7 @@ export function appWorkflows(options) {
         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,
@@ -43,7 +47,7 @@ export function appWorkflows(options) {
                     options.render();
                 }),
                 status: (said) => {
-                    state.status = said ?? activity.label;
+                    status(said ?? activity.label);
                     options.render();
                 },
                 reset: async () => {
@@ -78,8 +82,8 @@ export function appWorkflows(options) {
                     }
                     return compactSession(session, {
                         signal: activity.control.signal,
-                        onStatus: (status) => {
-                            state.status = status ?? activity.label;
+                        onStatus: (said) => {
+                            status(said ?? activity.label);
                             options.render();
                         },
                     });
@@ -108,6 +112,15 @@ export function appWorkflows(options) {
         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;
@@ -117,12 +130,13 @@ export function appWorkflows(options) {
         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) {
-                state.status = "Checking context";
+                status("Checking context");
                 options.render();
             }
             return resolveContextPolicy({
@@ -130,14 +144,14 @@ export function appWorkflows(options) {
                 model: session.model,
                 compactionPercent: session.config.compactionPercent,
                 signal: activity.control.signal,
-                onStatus: (status) => {
+                onStatus: (said) => {
                     visible = true;
-                    state.status = status;
+                    status(said);
                     options.render();
                 },
             }).finally(() => {
                 if (visible) {
-                    state.status = WAITING;
+                    status(WAITING);
                     options.render();
                 }
             });
@@ -157,7 +171,7 @@ export function appWorkflows(options) {
                 options.render();
             },
             status: (text) => {
-                state.status = text;
+                status(text);
             },
             usage: (usage) => recordUsage(session.usage, usage),
             requestInput: (inputTokens) => recordRequestInput(session.usage, inputTokens),
@@ -181,6 +195,7 @@ export function appWorkflows(options) {
             session.conversation = next;
             nodeId = next.activeNodeId;
             state.committedNodeId = next.activeNodeId;
+            unpersistedSteering.length = 0;
         };
         const compact = async (checkpoint, projected, request) => {
             if (request.reason === "overflow" &&
@@ -201,11 +216,11 @@ export function appWorkflows(options) {
                 force,
                 policy: request.policy,
                 onBegin: () => {
-                    state.status = "Compacting";
+                    status("Compacting");
                     options.render();
                 },
                 onEnd: () => {
-                    state.status = WAITING;
+                    status(WAITING);
                     options.render();
                 },
             });
@@ -217,6 +232,11 @@ export function appWorkflows(options) {
             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, {
@@ -231,7 +251,7 @@ export function appWorkflows(options) {
         let finishReason;
         let failed;
         try {
-            await runTurn(history, controllerOptions(session, policy, permissions.availableTools()), events, activity.control.signal, modelHistory);
+            await runTurn(history, controllerOptions(session, policy, permissions.availableTools(), inbox), events, activity.control.signal, modelHistory);
         }
         catch (error) {
             const interrupted = activity.control.signal.aborted;
@@ -247,6 +267,10 @@ export function appWorkflows(options) {
             }
         }
         finally {
+            let pendingSteering = inbox.close();
+            if (activeSteering === inbox)
+                activeSteering = undefined;
+            state.steering = undefined;
             try {
                 events.finish(finishReason);
                 if (failed !== undefined) {
@@ -265,7 +289,14 @@ export function appWorkflows(options) {
                         // 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(text);
+                        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",
@@ -275,11 +306,22 @@ export function appWorkflows(options) {
                 }
             }
             finally {
+                restorePendingSteering(state, pendingSteering);
                 options.finishActivity(activity);
             }
         }
     }
-    return { command, turn };
+    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];

package/dist/tui/app.js

@@ -21,6 +21,7 @@ import { appWorkflows } from "./app-workflows.js";
 import { sessionPermissions } from "../permissions.js";
 import { resumePicker } from "./resume.js";
 const FRAME_MS = 16;
+const MOTION_FRAME_MS = 40;
 const ACTIVITY_REFRESH_MS = 1_000;
 /** How long a lone escape waits to prove it is not the start of a sequence. */
 const ESCAPE_MS = 25;
@@ -36,6 +37,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     const permissions = sessionPermissions(session.tools, session.config.autoApprove);
     let closed;
     let frameTimer;
+    let motionTimer;
     let activityTimer;
     let escapeTimer;
     let stopResize = () => { };
@@ -67,10 +69,12 @@ export async function runApp(session, transcriptRoot, environment = {}) {
             footer: footerInfo(session, workspace),
             status: state.activity === undefined
                 ? undefined
-                : activityStatus(state.activity, state.status ?? state.activity.label, now),
+                : activityStatus(state.activity, now),
+            steering: state.steering,
             feedback: state.feedback,
             readiness: turnBlocker(session),
             now,
+            reducedMotion: session.config.reducedMotion,
             modal: overlay.shown(state.open),
             menu: completionOptions(state.completing),
             menuIndex: state.completing?.index,
@@ -98,6 +102,16 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         paint.paint(frame.rows, frame.cursor);
         if (frame.transcriptPending)
             render();
+        if (frame.transcriptAnimating && motionTimer === undefined) {
+            motionTimer = setTimeout(() => guard(() => {
+                motionTimer = undefined;
+                render();
+            }), Math.max(0, MOTION_FRAME_MS - FRAME_MS));
+        }
+        else if (!frame.transcriptAnimating && motionTimer !== undefined) {
+            clearTimeout(motionTimer);
+            motionTimer = undefined;
+        }
     };
     // Streaming produces a token at a time; painting at that rate is wasted
     // work, so repaints coalesce onto one frame.
@@ -148,6 +162,8 @@ export async function runApp(session, transcriptRoot, environment = {}) {
             clearInterval(activityTimer);
         if (frameTimer !== undefined)
             clearTimeout(frameTimer);
+        if (motionTimer !== undefined)
+            clearTimeout(motionTimer);
         if (escapeTimer !== undefined)
             clearTimeout(escapeTimer);
         safely(() => feedback.close());
@@ -193,7 +209,6 @@ export async function runApp(session, transcriptRoot, environment = {}) {
             return undefined;
         const activity = begin(kind, label);
         state.activity = activity;
-        state.status = label;
         activityTimer = setInterval(() => guard(() => {
             let activeTool;
             for (let index = state.blocks.length - 1; index >= 0; index--) {
@@ -215,7 +230,6 @@ export async function runApp(session, transcriptRoot, environment = {}) {
             clearInterval(activityTimer);
         activityTimer = undefined;
         state.activity = undefined;
-        state.status = undefined;
         state.open = overlay.cancel(state.open);
         if (state.closeWhenIdle)
             quit();
@@ -248,6 +262,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         actions: {
             command: (text) => track(actions.command(text)),
             turn: (text) => track(actions.turn(text)),
+            steer: (text) => actions.steer(text),
         },
         live: () => live,
         quit,

package/dist/tui/blocks.js

@@ -9,11 +9,16 @@ export function render(block, width, pal, context = {}) {
         case "answer":
             return renderAnswer(block, width, pal);
         case "reasoning":
-            return renderReasoning(block, width, pal);
+            return renderReasoning(block, width, pal, {
+                continues: context.previous?.kind === "tool" || context.previous?.kind === "reasoning",
+            });
         case "tool":
             return renderTool(block, width, pal, {
-                continues: context.previous?.kind === "tool",
+                continues: context.previous?.kind === "tool" || context.previous?.kind === "reasoning",
+                followsReasoning: context.previous?.kind === "reasoning",
                 now: context.now,
+                motion: context.motion,
+                reducedMotion: context.reducedMotion,
             });
         case "notice":
             return renderNotice(block, width, pal);

package/dist/tui/components/messages.js

@@ -1,29 +1,32 @@
 import { trailingText } from "../../text-boundary.js";
-import { blank, row } from "../../ui/render.js";
+import { row } from "../../ui/render.js";
 import { markdown } from "../../ui/markdown.js";
-const PAD = 1;
+import { transcriptLead, transcriptWidth } from "../transcript-grammar.js";
 export const REASONING_PREVIEW_ROWS = 3;
 const MIN_REASONING_PREVIEW_CHARS = 4_096;
 const REASONING_PREVIEW_OVERSCAN = 12;
 export function renderUser(block, width, pal) {
-    const inner = Math.max(8, width - PAD * 2);
+    const inner = transcriptWidth(width);
     const content = markdown(block.text, inner, pal, inner);
     return [
         "",
-        blank(width, pal.surface.subtle),
-        ...content.map((line) => row(width, line.segs, [], pal.surface.subtle, PAD)),
-        blank(width, pal.surface.subtle),
+        ...content.map((line, index) => row(width, [
+            ...transcriptLead(width, index === 0
+                ? { text: "❯", fg: pal.accent, bold: true }
+                : undefined),
+            ...line.segs,
+        ])),
     ];
 }
 export function renderAnswer(block, width, pal) {
-    const inner = Math.max(8, width - PAD * 2);
+    const inner = transcriptWidth(width);
     return [
         "",
-        ...markdown(block.text, inner, pal, inner).map((line) => row(width, line.segs, [], undefined, PAD)),
+        ...markdown(block.text, inner, pal, inner).map((line) => row(width, [...transcriptLead(width), ...line.segs])),
     ];
 }
-export function renderReasoning(block, width, pal) {
-    const inner = Math.max(8, width - PAD * 2);
+export function renderReasoning(block, width, pal, context = {}) {
+    const inner = transcriptWidth(width);
     // Expanding a live stream is deferred until it is sealed. Re-parsing an
     // ever-growing full thought on every token makes the whole TUI stall.
     const expanded = block.expanded === true && block.live !== true;
@@ -33,8 +36,11 @@ export function renderReasoning(block, width, pal) {
     const content = markdown(source.text, inner, pal, inner);
     const visible = expanded ? content : content.slice(-REASONING_PREVIEW_ROWS);
     return [
-        "",
-        ...visible.map((line) => row(width, line.segs.map((seg) => ({ ...seg, fg: pal.ink.dim, italic: true })), [], undefined, PAD)),
+        ...(context.continues === true ? [] : [""]),
+        ...visible.map((line) => row(width, [
+            ...transcriptLead(width, { text: "│", fg: pal.rule }),
+            ...line.segs.map((seg) => ({ ...seg, fg: pal.ink.dim, italic: true })),
+        ])),
     ];
 }
 export function reasoningPreviewSource(text, width) {

package/dist/tui/components/misc.js

@@ -1,18 +1,19 @@
 import { row, wrap } from "../../ui/render.js";
+import { transcriptLead, transcriptWidth } from "../transcript-grammar.js";
 export function renderNotice(block, width, pal) {
     const fg = {
         info: pal.ink.muted,
         warn: pal.ink.attention,
         error: pal.ink.removed,
     };
-    const mark = block.tone === "error" ? "× " : block.tone === "warn" ? "! " : undefined;
+    const mark = block.tone === "error" ? "×" : block.tone === "warn" ? "!" : "·";
     return [
         "",
-        ...wrap(block.text, Math.max(1, width - 3)).map((line, index) => row(width, [
-            ...(mark === undefined
-                ? []
-                : [{ text: index === 0 ? mark : "  ", fg: fg[block.tone], bold: index === 0 }]),
+        ...wrap(block.text, transcriptWidth(width)).map((line, index) => row(width, [
+            ...transcriptLead(width, index === 0
+                ? { text: mark, fg: fg[block.tone], bold: block.tone !== "info" }
+                : undefined),
             { text: line, fg: fg[block.tone] },
-        ], [], undefined, 1)),
+        ])),
     ];
 }

package/dist/tui/components/status.js

@@ -6,8 +6,19 @@ export function renderStatus(info, pal) {
     if (urgent !== undefined)
         return withUnseen(feedbackSegments(urgent, pal), info.unseen, pal);
     if (info.status !== undefined) {
+        const active = info.steering !== undefined && info.steering > 0
+            ? [
+                { text: `${info.steering} queued`, fg: pal.accent, bold: true },
+                { text: ` · ${info.status}`, fg: pal.ink.muted, optional: true },
+            ]
+            : [
+                { text: info.status, fg: pal.ink.muted },
+                ...(info.steering === 0
+                    ? [{ text: " · enter to steer", fg: pal.ink.dim, optional: true }]
+                    : []),
+            ];
         return withUnseen([
-            { text: info.status, fg: pal.ink.muted },
+            ...active,
             { text: " · esc to interrupt", fg: pal.ink.dim, optional: true },
         ], info.unseen, pal);
     }