kritya 0.8.45-beta → 0.8.47-beta

package/dist/ui/App.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Fragment, useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { Box, Static, Text, useApp, useBoxMetrics, useInput, useStderr, useWindowSize, } from "ink";
 import fs from "node:fs";
 import { glob } from "tinyglobby";
@@ -28,6 +28,7 @@ import { StreamViewport } from "./StreamViewport.js";
 import { TextInput } from "./TextInput.js";
 import { TranscriptItem } from "./TranscriptItem.js";
 import { terminalColumns, terminalRows } from "./viewport.js";
+import { fitRow, listRows, ROW_GUTTER, ROW_SEPARATOR, windowList } from "./windowList.js";
 import { BUILTIN_COMMANDS, runCommand } from "../commands/registry.js";
 import { mcpPrompts, mcpResources } from "../mcp/client.js";
 import { useAgent } from "./useAgent.js";
@@ -147,7 +148,7 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
             .catch(() => { });
     }, [workspace]);
     useEffect(refreshFileList, [refreshFileList]);
-    const { items, addItem, clearItems, phase, setPhase, stream, thinking, activity, setActivity, runningPhase, setRunningPhase, workflow, refreshWorkflow, permission, elicitation, inFlight, model, provider, servedModel, totalUsage, totalCost, tasks, setTasks, ctxPct, setCtxPct, tokenBudget, budgetPct, budgetUsed, budgetStopped, resetBudget, setBudgetLimit, branch, planMode, setPlanMode, dryRunMode, killed, killReason, engageKill, releaseKill, acceptEdits, setAcceptEdits, bypassMode, setBypassMode, autoApprovedCount, cycleMode, onAcceptEditsConfirm, onBypassModeConfirm, abortRef, setModelEverywhere, setProviderEverywhere, costReport, runAgent, runWebSearch, onPermissionDecision, onElicitationDecision, onResumeSelect, requestPermission, requestElicitation, persistenceWarningCount, } = useAgent({
+    const { items, addItem, clearItems, phase, setPhase, stream, thinking, activity, setActivity, runningPhase, setRunningPhase, setChained, workflow, refreshWorkflow, prefill, setPrefill, permission, elicitation, inFlight, model, provider, servedModel, totalUsage, totalCost, tasks, setTasks, ctxPct, setCtxPct, tokenBudget, budgetPct, budgetUsed, budgetStopped, resetBudget, setBudgetLimit, branch, planMode, setPlanMode, dryRunMode, killed, killReason, engageKill, releaseKill, acceptEdits, setAcceptEdits, bypassMode, setBypassMode, autoApprovedCount, cycleMode, onAcceptEditsConfirm, onBypassModeConfirm, abortRef, setModelEverywhere, setProviderEverywhere, costReport, runAgent, runWebSearch, onPermissionDecision, onElicitationDecision, onResumeSelect, requestPermission, requestElicitation, persistenceWarningCount, } = useAgent({
         agent,
         workspace,
         modelRef,
@@ -167,6 +168,18 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
     useEffect(() => {
         onRequestElicitationReady?.(requestElicitation);
     }, [onRequestElicitationReady, requestElicitation]);
+    // Drop a prefilled command into the input line when a phase ends at a gate,
+    // so Enter continues the workflow instead of the user retyping `/flow`. The
+    // gate still holds: nothing runs until it is submitted, and any edit — or
+    // Esc — discards the suggestion. Applied only from the idle prompt, since a
+    // prefill arriving while a picker was open would clobber what was typed there.
+    useEffect(() => {
+        if (prefill === null || phase !== "input")
+            return;
+        setInput(prefill);
+        setInputKey((k) => k + 1);
+        setPrefill(null);
+    }, [prefill, phase, setPrefill]);
     // Tick an elapsed-seconds counter while the agent is working.
     useEffect(() => {
         if (phase !== "working") {
@@ -226,6 +239,37 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
         ? allCommands.filter((c) => c.name.startsWith(input.trim()))
         : [];
     const selectedCmd = suggestions.length ? Math.min(cmdIndex, suggestions.length - 1) : 0;
+    /**
+     * The suggestion list flattened to rendered lines, so a group heading costs
+     * a row like any other — windowing the commands alone would still let the
+     * headings push real rows off the bottom of the screen.
+     *
+     * `lineOfCmd[i]` is the line `suggestions[i]` landed on. The cursor indexes
+     * commands, because that is what the arrow keys move through; this is what
+     * maps it onto a line.
+     */
+    const suggestionLines = [];
+    const lineOfCmd = [];
+    {
+        // Group headers only earn their keep once more than one category is
+        // actually on screen — once typing has filtered down to a single family,
+        // a lone header is just noise.
+        const showHeaders = new Set(suggestions.map((c) => c.category)).size > 1;
+        let lastCategory;
+        for (const c of suggestions) {
+            if (showHeaders && c.category !== lastCategory) {
+                suggestionLines.push({ kind: "header", label: c.category ?? "Other" });
+                lastCategory = c.category;
+            }
+            lineOfCmd.push(suggestionLines.length);
+            suggestionLines.push({ kind: "cmd", cmd: c });
+        }
+    }
+    // The transcript above is static; this reserves the prompt box, the hint
+    // line and the status line, which is what has to stay visible.
+    const suggestionWindow = windowList(suggestionLines, lineOfCmd[selectedCmd] ?? 0, listRows(rows, 8));
+    // The list is indented by its own paddingLeft, then by the row's marker.
+    const suggestionRowWidth = contentWidth - 2 - ROW_GUTTER;
     // File suggestions while typing an @mention.
     const mentionMatch = phase === "input" && !input.startsWith("/") ? MENTION_RE.exec(input) : null;
     const mentionFragment = mentionMatch ? mentionMatch[2].toLowerCase() : null;
@@ -342,6 +386,14 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
             setActivity("cancelling…");
             abortRef.current?.abort();
         }
+        // Esc clears the idle input line. This is the documented way to decline a
+        // command prefilled at a workflow gate; it also just empties a half-typed
+        // prompt, which is what a bare Esc on an idle prompt is expected to do.
+        if (key.escape && phase === "input" && input) {
+            setInput("");
+            setInputKey((k) => k + 1);
+            return;
+        }
         // Ctrl+O toggles showing full tool output.
         if (key.ctrl && _input === "o") {
             setVerbose((v) => !v);
@@ -503,7 +555,9 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
             setPhase,
             setActivity,
             setRunningPhase,
+            setChained,
             refreshWorkflow,
+            setPrefill,
             setCtxPct,
             setTasks,
             setPlanMode,
@@ -685,18 +739,18 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
                                     setInput(v.replace(/\t/g, ""));
                                     setCmdIndex(0);
                                     setFileIndex(0);
-                                }, onSubmit: handleSubmit }, inputKey)] }), suggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [(() => {
-                                // Group headers only earn their keep once more than one
-                                // category is actually on screen — once typing has filtered
-                                // down to a single family, a lone header is just noise.
-                                const showHeaders = new Set(suggestions.map((c) => c.category)).size > 1;
-                                let lastCategory;
-                                return suggestions.map((c, i) => {
-                                    const showHeader = showHeaders && c.category !== lastCategory;
-                                    lastCategory = c.category;
-                                    return (_jsxs(Fragment, { children: [showHeader && _jsx(Text, { dimColor: true, children: c.category ?? "Other" }), _jsxs(Text, { color: i === selectedCmd ? "cyan" : undefined, children: [i === selectedCmd ? "❯ " : "  ", _jsx(Text, { bold: i === selectedCmd, children: c.name }), _jsxs(Text, { dimColor: true, children: [" \u2014 ", c.description] })] })] }, c.name));
-                                });
-                            })(), _jsx(Text, { dimColor: true, children: "\u2191\u2193 select \u00B7 Tab/Enter select \u00B7 Enter again to run" })] })), fileSuggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [fileSuggestions.map((f, i) => (_jsxs(Text, { color: i === selectedFile ? "cyan" : undefined, children: [i === selectedFile ? "❯ " : "  ", f] }, f))), _jsx(Text, { dimColor: true, children: "\u2191\u2193 select \u00B7 Tab/Enter attach file" })] }))] })), _jsx(Box, { children: _jsx(StatusLine, { killed: killed, killReason: killReason, dryRunMode: dryRunMode, planMode: planMode, acceptEdits: acceptEdits, bypassMode: bypassMode, autoApprovedCount: autoApprovedCount, provider: provider, model: servedModel && servedModel !== model
+                                }, onSubmit: handleSubmit }, inputKey)] }), suggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [suggestionWindow.visible.map((line, i) => {
+                                if (line.kind === "header") {
+                                    return (_jsx(Text, { dimColor: true, wrap: "truncate", children: line.label }, `header:${line.label}`));
+                                }
+                                const c = line.cmd;
+                                const selected = i === suggestionWindow.cursor;
+                                const row = fitRow(c.name, c.description, suggestionRowWidth);
+                                return (_jsxs(Text, { color: selected ? "cyan" : undefined, wrap: "truncate", children: [selected ? "❯ " : "  ", _jsx(Text, { bold: selected, children: row.label }), row.hint ? (_jsxs(Text, { dimColor: true, children: [ROW_SEPARATOR, row.hint] })) : null] }, c.name));
+                            }), suggestionWindow.clipped ? (_jsxs(Text, { dimColor: true, children: ["  ", suggestionWindow.from, "\u2013", suggestionWindow.to, " of ", suggestionWindow.total, " \u00B7 \u2191\u2193 to scroll"] })) : null, _jsx(Text, { dimColor: true, children: "\u2191\u2193 select \u00B7 Tab/Enter insert \u00B7 Esc cancel" })] })), phase === "input" &&
+                        input.startsWith("/") &&
+                        !input.includes(" ") &&
+                        suggestions.length === 0 && (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { dimColor: true, children: ["no command matches ", input.trim(), " \u00B7 Esc to clear"] }) })), fileSuggestions.length > 0 && (_jsxs(Box, { flexDirection: "column", paddingLeft: 2, children: [fileSuggestions.map((f, i) => (_jsxs(Text, { color: i === selectedFile ? "cyan" : undefined, wrap: "truncate", children: [i === selectedFile ? "❯ " : "  ", f] }, f))), _jsx(Text, { dimColor: true, children: "\u2191\u2193 select \u00B7 Tab/Enter attach file" })] }))] })), _jsx(Box, { children: _jsx(StatusLine, { killed: killed, killReason: killReason, dryRunMode: dryRunMode, planMode: planMode, acceptEdits: acceptEdits, bypassMode: bypassMode, autoApprovedCount: autoApprovedCount, provider: provider, model: servedModel && servedModel !== model
                         ? `${model}-${modelDisplaySlug(servedModel)}`
                         : model, workflow: workflow, branch: branch, budgetPct: budgetPct, budgetStopped: budgetStopped, totalCost: totalCost, sandboxActive: (config.sandboxExec ?? defaultSandboxMode()) !== "off" && sandboxAvailable(), persistenceWarningCount: persistenceWarningCount, privacyMode: privacyMode }) })] }));
 }

package/dist/ui/SelectList.js

@@ -1,10 +1,33 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from "react";
-import { Box, Text, useInput } from "ink";
-export function SelectList({ items, onSelect, onCancel, }) {
+import { Box, Text, useInput, useWindowSize } from "ink";
+import { terminalColumns, terminalRows } from "./viewport.js";
+import { fitRow, listRows, ROW_GUTTER, ROW_SEPARATOR, windowList } from "./windowList.js";
+/**
+ * The list every picker in the app renders through — the Ctrl+P palette, the
+ * model picker, the permission and trust prompts, the elicitation prompt, and
+ * session resume.
+ *
+ * It measures the terminal itself and windows to fit, so all of those inherit
+ * scrolling and row truncation without passing anything: a list longer than
+ * the screen scrolls with the cursor kept in view, and a long row is cut
+ * instead of wrapping onto a second line. `width`/`maxRows` are there for a
+ * caller that knows its own layout better than the terminal size suggests.
+ */
+export function SelectList({ items, onSelect, onCancel, width, maxRows, reservedRows, }) {
     const [rawIndex, setIndex] = useState(0);
+    const windowSize = useWindowSize();
+    const rows = maxRows ??
+        (reservedRows === undefined
+            ? listRows(terminalRows(windowSize))
+            : listRows(terminalRows(windowSize), reservedRows));
+    // A row also spends ROW_GUTTER columns on its selection marker, and the
+    // border/padding the caller wrapped us in is not ours to know — so leave a
+    // couple of columns of slack rather than assume the terminal's full width.
+    const rowWidth = (width ?? terminalColumns(windowSize) - 4) - ROW_GUTTER;
     // Items can shrink under us (e.g. a live filter above the list).
     const index = items.length ? Math.min(rawIndex, items.length - 1) : 0;
+    const list = windowList(items, index, rows);
     useInput((_input, key) => {
         if (!items.length) {
             if (key.escape && onCancel)
@@ -20,5 +43,8 @@ export function SelectList({ items, onSelect, onCancel, }) {
         else if (key.escape && onCancel)
             onCancel();
     });
-    return (_jsx(Box, { flexDirection: "column", children: items.map((item, i) => (_jsxs(Text, { color: i === index ? "green" : undefined, children: [i === index ? "❯ " : "  ", item.label, item.hint ? _jsxs(Text, { dimColor: true, children: [" \u2014 ", item.hint] }) : null] }, item.value))) }));
+    return (_jsxs(Box, { flexDirection: "column", children: [list.visible.map((item, i) => {
+                const row = fitRow(item.label, item.hint, rowWidth);
+                return (_jsxs(Text, { color: i === list.cursor ? "green" : undefined, wrap: "truncate", children: [i === list.cursor ? "❯ " : "  ", row.label, row.hint ? (_jsxs(Text, { dimColor: true, children: [ROW_SEPARATOR, row.hint] })) : null] }, item.value));
+            }), list.clipped ? (_jsxs(Text, { dimColor: true, children: ["  ", list.from, "\u2013", list.to, " of ", list.total, " \u00B7 \u2191\u2193 to scroll"] })) : null] }));
 }

package/dist/ui/StatusLine.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Text } from "ink";
+import { PHASE_ORDER, phaseIndex } from "../agent/workflow.js";
 import { displayModelId } from "../config/models.js";
 /**
  * The single dim status bar pinned to the bottom of the screen. Keeps only
@@ -17,5 +18,5 @@ export function StatusLine({ killed, killReason, dryRunMode, planMode, acceptEdi
                                 ? "plan"
                                 : acceptEdits
                                     ? `accept-edits (${autoApprovedCount} auto)`
-                                    : "default", " · "] }), displayModelId(provider, model), _jsxs(Text, { color: sandboxActive ? "green" : "red", children: [" ", "\u00B7 ", sandboxActive ? "🔒 sandbox:active" : "🔓 sandbox:inactive"] }), workflow ? (_jsxs(Text, { color: "magenta", children: [" ", "\u00B7 \u2691 ", workflow.name, ":", workflow.phase] })) : (""), branch ? ` · ⎇ ${branch}` : "", budgetStopped || budgetPct >= 80 ? (_jsxs(Text, { color: budgetStopped ? "red" : "yellow", children: [" \u00B7 budget ", budgetPct, "%"] })) : (""), totalCost > 0 ? ` · $${totalCost.toFixed(4)}` : "", persistenceWarningCount > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 \u26A0 persistence warnings: ", persistenceWarningCount] })) : (""), privacyMode ? _jsx(Text, { color: "cyan", children: " \u00B7 privacy:on" }) : "", " · /diff review · /undo revert · Ctrl+K stop · /status for details"] }));
+                                    : "default", " · "] }), displayModelId(provider, model), _jsxs(Text, { color: sandboxActive ? "green" : "red", children: [" ", "\u00B7 ", sandboxActive ? "🔒 sandbox:active" : "🔓 sandbox:inactive"] }), workflow ? (_jsxs(Text, { color: "magenta", children: [" ", "\u00B7 \u2691 ", workflow.name, " ", phaseIndex(workflow.phase), "/", PHASE_ORDER.length, " ", workflow.phase] })) : (""), branch ? ` · ⎇ ${branch}` : "", budgetStopped || budgetPct >= 80 ? (_jsxs(Text, { color: budgetStopped ? "red" : "yellow", children: [" \u00B7 budget ", budgetPct, "%"] })) : (""), totalCost > 0 ? ` · $${totalCost.toFixed(4)}` : "", persistenceWarningCount > 0 ? (_jsxs(Text, { color: "yellow", children: [" \u00B7 \u26A0 persistence warnings: ", persistenceWarningCount] })) : (""), privacyMode ? _jsx(Text, { color: "cyan", children: " \u00B7 privacy:on" }) : "", " · /diff review · /undo revert · Ctrl+K stop · /status for details"] }));
 }

package/dist/ui/useAgent.js

@@ -9,7 +9,7 @@ import { SWITCHYARD_ROUTE_ID, resolveEffectiveModel } from "../provider/switchya
 import { KillSwitchError } from "../agent/killSwitch.js";
 import { TAGLINE } from "./Banner.js";
 import { defaultSandboxMode, sandboxAvailable } from "../shell/sandbox.js";
-import { loadProjectState, nextPhase, PHASE_COMMAND, } from "../agent/workflow.js";
+import { loadProjectState, nextPhase, PHASE_ORDER, phaseDoneMessage, phaseIndex, prefillAfter, } from "../agent/workflow.js";
 import { tavilySearch } from "../tools/webSearch.js";
 import { killActiveNotice, useKillSwitch } from "./useKillSwitch.js";
 import { useUsageBudget } from "./useUsageBudget.js";
@@ -69,6 +69,21 @@ export function useAgent({ agent, workspace, modelRef, providerRef, config, uiBr
                     : `Resumed previous session (${resumedCount} messages)${taskNote}.`,
             });
         }
+        // A project parked mid-flow is the single most useful thing to say at
+        // launch: without it the user has to remember which phase they were in,
+        // and `/flow` on its own does not say where it will resume from.
+        const active = loadProjectState(workspace);
+        if (active) {
+            const next = nextPhase(active.phase);
+            initial.push({
+                id: nextId.current++,
+                kind: "info",
+                text: `Project "${active.name}" is at the ${active.phase} phase ` +
+                    `(${phaseIndex(active.phase)}/${PHASE_ORDER.length}). ` +
+                    (next ? `/flow continues with ${next} · ` : `every phase has run · `) +
+                    `/project for status.`,
+            });
+        }
         return initial;
     });
     const [phase, setPhase] = useState(resumeSessions?.length ? "resume" : "input");
@@ -103,8 +118,27 @@ export function useAgent({ agent, workspace, modelRef, providerRef, config, uiBr
         runningPhaseRef.current = p;
         setRunningPhaseState(p);
     }, []);
+    /**
+     * True while one command is running several phases back to back. A ref, not
+     * state: the teardown reads it in the same tick the command is still inside,
+     * and nothing renders from it.
+     */
+    const chainedRef = useRef(false);
+    const setChained = useCallback((chained) => {
+        chainedRef.current = chained;
+    }, []);
     /** The active project workflow, for the statusline. Persists between turns. */
     const [workflow, setWorkflow] = useState(() => loadProjectState(workspace));
+    /**
+     * Text to drop into the input line once the turn ends.
+     *
+     * Stopping at a gate costs two steps — read the result, then type the next
+     * command — and the second one is pure retyping of something the app already
+     * knows. Prefilling it means Enter continues and Esc (or any edit) discards
+     * it, without taking the decision away: nothing runs until the user submits.
+     * One-shot; the UI clears it as soon as it is applied.
+     */
+    const [prefill, setPrefill] = useState(null);
     const [permission, setPermission] = useState(null);
     const [elicitation, setElicitation] = useState(null);
     const [model, setModel] = useState(modelRef.current);
@@ -394,22 +428,29 @@ export function useAgent({ agent, workspace, modelRef, providerRef, config, uiBr
      * paraphrasing its instructions drops it often enough that the handoff can't
      * depend on that — the user is left at a prompt with no idea what comes next.
      * Printing it here makes it deterministic.
+     *
+     * This covers a single-phase command only. The last phase of a *chain* is
+     * announced by `runFlow` instead: this runs at the end of every turn, which
+     * for a chain is while the chain is still going, so it has no way to tell
+     * "middle of a chain" from "chain just ended at a gate" — and staying quiet
+     * for both is the safe half of that. `runFlow` knows which it is.
      */
     const announceNextPhase = useCallback(() => {
         const ran = runningPhaseRef.current;
         setRunningPhase(null);
         if (!ran)
             return;
+        // A chain runs the next phase itself, so naming the command to type would
+        // point at work that is already starting. The chain prints its own plan.
+        if (chainedRef.current)
+            return;
         // Prefer the phase on disk: an autonomous turn may have advanced it past
         // whatever the command started.
         const current = loadProjectState(workspace)?.phase ?? ran;
-        const next = nextPhase(current);
-        addItem({
-            kind: "info",
-            text: next
-                ? `✓ ${current} phase done — next: ${PHASE_COMMAND[next]} (or /project to review where you are)`
-                : `✓ ${current} phase done — the workflow is complete. /project clear ends it.`,
-        });
+        addItem({ kind: "info", text: phaseDoneMessage(current) });
+        const prefill = prefillAfter(current);
+        if (prefill)
+            setPrefill(prefill);
     }, [workspace, addItem, setRunningPhase]);
     const runWebSearch = async (query) => {
         if (agent.kill.active) {
@@ -606,8 +647,11 @@ export function useAgent({ agent, workspace, modelRef, providerRef, config, uiBr
         setActivity,
         runningPhase,
         setRunningPhase,
+        setChained,
         workflow,
         refreshWorkflow,
+        prefill,
+        setPrefill,
         permission,
         elicitation,
         inFlight,

package/dist/ui/windowList.js

@@ -0,0 +1,100 @@
+import stringWidth from "string-width";
+import { truncateToWidth } from "./inline.js";
+/**
+ * Windowing and width-fitting for every list in the UI: the Ctrl+P palette,
+ * the inline `/` suggestions, the history search, the model picker, and the
+ * permission/trust prompts. They were each written separately and each one
+ * grew its own way of not fitting on screen — some wrapped a long row onto a
+ * second line, and the long ones (a bare `/` is 33 commands plus group
+ * headings) simply ran off the bottom of the terminal with no way to scroll.
+ *
+ * Kept pure and React-free so the arithmetic is testable on its own, and so
+ * the renderers only have to decide what a row looks like, never how much of
+ * it fits.
+ */
+/** Columns the selection marker (`"❯ "` / `"  "`) occupies at the start of a row. */
+export const ROW_GUTTER = 2;
+/** What sits between a row's label and its hint. */
+export const ROW_SEPARATOR = " — ";
+/**
+ * The label keeps at least this many columns before a hint is allowed any
+ * space — below it the label alone is more use than a two-letter stub plus a
+ * truncated hint.
+ */
+const MIN_LABEL = 8;
+/** Under this a hint is dropped outright rather than squeezed to a stub. */
+const MIN_HINT = 8;
+/** Chrome a list should leave alone by default: prompt box, hints, status line. */
+const DEFAULT_RESERVED_ROWS = 10;
+/**
+ * Rows a list may occupy: the terminal, less the chrome around it.
+ *
+ * The floor is deliberately low rather than generous — a very short terminal
+ * should still show a usable list instead of collapsing to nothing, and the
+ * caller can always pass an explicit `maxRows` when it knows its own layout.
+ */
+export function listRows(terminalRows, reserved = DEFAULT_RESERVED_ROWS) {
+    return Math.max(3, Math.floor(terminalRows) - Math.max(0, Math.floor(reserved)));
+}
+/**
+ * The slice of `items` to render, plus where the cursor sits inside it.
+ *
+ * The window is centred on the cursor and then clamped to the ends, which
+ * makes it a pure function of the cursor — there is no scroll offset to carry
+ * between renders, so a list can never get stuck scrolled away from the row
+ * it is highlighting. Centring also means moving within the first page does
+ * not shift the list at all, and the last row is reachable without the window
+ * running off the bottom.
+ */
+export function windowList(items, cursor, maxRows) {
+    const total = items.length;
+    const rows = Math.max(1, Math.floor(maxRows));
+    if (total === 0) {
+        return { visible: [], cursor: 0, from: 0, to: 0, total: 0, clipped: false };
+    }
+    // `cursor` can be stale — items shrink under a live filter — so clamp it
+    // rather than trust it, exactly like the renderers used to do by hand.
+    const at = Math.min(Math.max(Math.floor(cursor), 0), total - 1);
+    const offset = Math.min(Math.max(at - Math.floor(rows / 2), 0), Math.max(0, total - rows));
+    const visible = items.slice(offset, offset + rows);
+    return {
+        visible,
+        cursor: at - offset,
+        from: offset + 1,
+        to: offset + visible.length,
+        total,
+        clipped: visible.length < total,
+    };
+}
+/**
+ * Fit one row into `width` display columns, cutting the *hint* before the
+ * label: the label is what identifies the row, so a long description must
+ * never be the reason a command's name is unreadable. When there is no room
+ * for both, the hint goes entirely.
+ *
+ * `width` is what is left after the gutter, and may be unknown (-1, or 0 from
+ * a terminal that has not reported a size yet) — in which case the row is
+ * returned untouched and the renderer's `wrap="truncate"` backstop takes over.
+ */
+export function fitRow(label, hint, width) {
+    if (width <= 0)
+        return { label, hint };
+    if (!hint)
+        return { label: truncateToWidth(label, width), hint: undefined };
+    const sepWidth = stringWidth(ROW_SEPARATOR);
+    const labelWidth = stringWidth(label);
+    if (width < MIN_LABEL + sepWidth + MIN_HINT) {
+        return { label: truncateToWidth(label, width), hint: undefined };
+    }
+    if (labelWidth + sepWidth + MIN_HINT <= width) {
+        return { label, hint: truncateToWidth(hint, width - labelWidth - sepWidth) };
+    }
+    // The label itself has to give ground, but never below MIN_LABEL's worth of
+    // room for the hint to be worth showing at all.
+    const fittedLabel = truncateToWidth(label, width - sepWidth - MIN_HINT);
+    const rest = width - stringWidth(fittedLabel) - sepWidth;
+    return {
+        label: fittedLabel,
+        hint: rest >= MIN_HINT ? truncateToWidth(hint, rest) : undefined,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kritya",
-  "version": "0.8.45-beta",
+  "version": "0.8.47-beta",
   "description": "Kritya — Superintelligence at your command line",
   "type": "module",
   "publishConfig": {