howtofixcli 0.7.13 → 0.7.15

package/dist/device-id.test.js

@@ -1,23 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "node:test";
-import { deviceId, hardwareIds } from "./device-id.js";
-test("the device id is 32 lowercase hex characters", () => {
-    const { id } = deviceId();
-    assert.match(id, /^[0-9a-f]{32}$/);
-});
-test("the device id is stable across calls", () => {
-    assert.equal(deviceId().id, deviceId().id);
-});
-test("the id comes from a hardware identifier when the platform has one", () => {
-    const ids = hardwareIds();
-    if (process.platform !== "linux")
-        return; // other platforms are exercised on their own machines
-    assert.ok(ids.length > 0, "a Linux host should expose a DMI or machine id");
-    assert.equal(deviceId().weak, false);
-});
-test("the raw hardware identifier is not part of the id", () => {
-    const raw = hardwareIds()[0];
-    if (!raw)
-        return;
-    assert.ok(!deviceId().id.includes(raw.replace(/-/g, "")));
-});

package/dist/errors.js

@@ -1,63 +0,0 @@
-/**
- * One way to tell a user that something failed.
- *
- * Every command used to phrase its own failure, which meant a missing file, a
- * refused connection and a typo in a flag could all arrive in the same shape:
- * a sentence that says what broke but not what to do. This module answers both
- * questions from the error itself, so the answer does not depend on which code
- * path happened to throw.
- */
-/** The action a user can take, inferred from the code Node attached. */
-function hintFor(code, message) {
-    const evidence = `${code ?? ""} ${message}`;
-    if (/EACCES|EPERM/.test(evidence))
-        return "the file or directory is not writable; check permissions and try again";
-    if (/ENOENT/.test(evidence))
-        return "a file or directory this command needs is missing";
-    if (/ENOSPC/.test(evidence))
-        return "the disk is full";
-    if (/ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ETIMEDOUT|UND_ERR|fetch failed/i.test(evidence)) {
-        return "the network request failed; check the connection and the gateway address";
-    }
-    if (/EADDRINUSE/.test(evidence))
-        return "another process is already using that port";
-    if (/MODULE_NOT_FOUND|ERR_MODULE_NOT_FOUND/.test(evidence)) {
-        return "a required file or package is missing; reinstall HowToFix";
-    }
-    if (/JSON/i.test(evidence) && /parse|unexpected token|end of input/i.test(evidence)) {
-        return "a configuration file is not valid JSON";
-    }
-    if (/not a git repository/i.test(evidence))
-        return "run the command inside a project, or pass --cwd";
-    return undefined;
-}
-/** The message, and the action that follows from it. */
-export function describeError(error) {
-    const raw = error instanceof Error ? error.message : String(error);
-    const message = raw.trim() || "unknown error";
-    const code = error?.code;
-    return { message, hint: hintFor(code, message) };
-}
-/**
- * The line(s) a failure prints.
- *
- * `context` names the thing that failed ("doctor", "update"), because "not
- * permitted" alone does not say what was not permitted. The stack is evidence,
- * and evidence only appears when `HOWTOFIX_DEBUG` asks for it.
- */
-export function formatError(appTitle, context, error, debug = false) {
-    const { message, hint } = describeError(error);
-    const head = context ? `${appTitle}: ${context}: ${message}` : `${appTitle}: ${message}`;
-    const lines = [head];
-    if (hint)
-        lines.push(`  ${hint}`);
-    if (debug && error instanceof Error && error.stack)
-        lines.push(error.stack);
-    return lines.join("\n");
-}
-/** Print a failure the same way everywhere. */
-export function reportError(appTitle, context, error, options) {
-    const debug = options?.debug ?? process.env.HOWTOFIX_DEBUG === "1";
-    const write = options?.write ?? ((text) => console.error(text));
-    write(formatError(appTitle, context, error, debug));
-}

package/dist/extensions.js

@@ -1,48 +0,0 @@
-/**
- * UI context for built-in extensions (MCP sign-in, codemode, prompts) that
- * routes select/confirm/input/notify into the workbench instead of the SDK's own TUI.
- */
-export function workbenchUI(dialogs) {
-    const noop = () => { };
-    return {
-        select: (title, choices) => dialogs.select(title, choices),
-        confirm: (title, message) => dialogs.confirm(title, message),
-        input: (title) => dialogs.input(title),
-        notify: (message, type) => dialogs.notify(message, type),
-        onTerminalInput: () => noop,
-        setStatus: (key, text) => dialogs.setStatus(key, text),
-        setWorkingMessage: noop,
-        setWorkingVisible: noop,
-        setWorkingIndicator: noop,
-        setHiddenThinkingLabel: noop,
-        // The SDK also accepts a component factory here, which needs a TUI to
-        // instantiate. The workbench hosts plain text lines, so a factory is
-        // ignored rather than clearing a widget that is already pinned.
-        setWidget: (key, content, placement) => {
-            if (content !== undefined && !Array.isArray(content))
-                return;
-            dialogs.setWidget?.(key, content, placement?.placement);
-        },
-        setFooter: noop,
-        setHeader: noop,
-        setTitle: noop,
-        // The workbench has no overlay component host; extensions fall back to
-        // text listings (for example /mcp prints its server status).
-        custom: async () => {
-            throw new Error("this screen has no custom component host; use the text commands instead");
-        },
-        pasteToEditor: noop,
-        setEditorText: noop,
-        getEditorText: () => "",
-        editor: async () => undefined,
-        addAutocompleteProvider: noop,
-        setEditorComponent: noop,
-        getEditorComponent: () => undefined,
-        theme: undefined,
-        getAllThemes: () => [],
-        getTheme: () => undefined,
-        setTheme: () => ({ success: false, error: "themes are not available in the workbench" }),
-        getToolsExpanded: () => false,
-        setToolsExpanded: noop,
-    };
-}

package/dist/fatal.js

@@ -1,35 +0,0 @@
-/**
- * What a crash says to the user.
- *
- * A CLI that prints a stack trace for a failed network call, a missing file or a
- * closed pipe looks broken, and the one line that explains it is buried under
- * frames the user cannot act on. The message is what matters; the stack is
- * evidence, and evidence belongs behind a flag.
- */
-import { describeError } from "./errors.js";
-/** The single line a failure deserves, with the stack only when asked for. */
-export function describeFatal(error, debug = false) {
-    const { message } = describeError(error);
-    if (!debug)
-        return message;
-    const stack = error instanceof Error ? error.stack : undefined;
-    return stack && stack.includes("\n") ? `${message}\n${stack}` : message;
-}
-/**
- * Catch what escapes `main()`.
- *
- * `main().catch()` only covers the awaited path. Timers, event listeners and
- * fire-and-forget promises live outside it, and Node answers them with a raw
- * stack trace and a non-zero exit that says nothing about what happened. Both
- * handlers keep the exit code honest and the message readable.
- */
-export function installCrashHandlers(appTitle, options) {
-    const debug = options?.debug ?? process.env.HOWTOFIX_DEBUG === "1";
-    const exit = options?.exit ?? ((code) => process.exit(code));
-    const report = (error) => {
-        console.error(`${appTitle}: ${describeFatal(error, debug)}`);
-        exit(1);
-    };
-    process.on("uncaughtException", report);
-    process.on("unhandledRejection", report);
-}

package/dist/feed.js

@@ -1,498 +0,0 @@
-import { Markdown, wrapTextWithAnsi } from "@netrodev/hxf-tui";
-import { ENTRANCE_MS, entrance, entering, fade, revealedLines } from "./anim.js";
-import { fg, ink, mdTheme } from "./theme.js";
-import { EXPAND_MARKER, RESULT_MARKER, formatToolCall, formatToolResult, spinnerFrame } from "./tool-render.js";
-import { collapseGroups } from "./collapse.js";
-import { stripDcpMarkers } from "./dcp/ids.js";
-/**
- * Add a note, replacing its own predecessor when that predecessor is still the
- * last thing in the transcript.
- *
- * A slash command that reports state — `/dcp status`, `/usage` — pushes a feed
- * item every time it runs, so asking twice drew the identical line twice and a
- * third time drew it three times. The screen filled with copies of one answer.
- *
- * A repeated report supersedes itself: the newest reading of `/dcp status` is
- * the answer, and the previous one is not history worth scrolling back to.
- * Anything that landed in between — the user's message, a tool call — makes the
- * old note part of the conversation, and it stays. The rule is deliberately
- * narrow (same title, still last) because only the immediately-previous,
- * same-titled note is a stale copy of this one; a note further back was
- * superseded by real work and deleting it would erase the record of that work.
- */
-export function upsertNote(items, item) {
-    const last = items[items.length - 1];
-    if (last && last.kind === "note" && last.title === item.title) {
-        return [...items.slice(0, -1), item];
-    }
-    return [...items, item];
-}
-function textOf(content) {
-    // A ref marker the model wrote into its own answer is machinery, not prose:
-    // it is stripped here so nothing painted or stored can show it. See
-    // `stripDcpMarkers`.
-    if (typeof content === "string")
-        return stripDcpMarkers(content);
-    return stripDcpMarkers(content
-        .map((part) => {
-        if (part.type === "text")
-            return part.text;
-        if (part.type === "thinking")
-            return "";
-        if (part.type === "image")
-            return "[image]";
-        if (part.type === "toolCall")
-            return "";
-        return "";
-    })
-        .filter(Boolean)
-        .join(""));
-}
-/**
- * The body of a user message, trimmed — exactly what `itemsFromMessages` draws
- * for it.
- *
- * Exported so the workbench can recognise its own optimistic copy of a message
- * when the real turn arrives: the two are generated by different code and share
- * no id, so the text is the only thing they agree on.
- */
-export function userTextOf(message) {
-    return message.role === "user" ? textOf(message.content).trim() : "";
-}
-/**
- * Bring the feed's copy of a user message in line with the session's.
- *
- * The feed draws its own copy the instant Enter is pressed — it has to, or the
- * message would not appear until the model had already answered. The session
- * later reports the same message with its own id, and pushing that report as a
- * new item drew the message twice: once as the optimistic row and once as the
- * replayed turn, with the queue state attached to the row that was about to be
- * scrolled away.
- *
- * So the report *replaces* the copy it matches. The match is on the trimmed body
- * because the two ids are generated by different code and share nothing; the
- * first match wins, which keeps a repeated message (the same text sent twice) as
- * two rows — the second send matches the row the first one left behind only if
- * that row is still unclaimed, and `replace` consumes it.
- */
-export function upsertUserTurn(items, text, id) {
-    const body = text.trim();
-    if (!body)
-        return items;
-    const at = items.findIndex((item) => item.kind === "user" && item.body.trim() === body);
-    if (at === -1)
-        return [...items, { id, kind: "user", title: "you", body }];
-    const next = [...items];
-    // `pending` is deliberately dropped: the session reporting this message is the
-    // proof that the run has it, and a marker left on would claim otherwise.
-    next[at] = { id, kind: "user", title: "you", body };
-    return next;
-}
-function toolCallsOf(message) {
-    return message.content.filter((part) => part.type === "toolCall").map((part) => ({ name: part.name, arguments: part.arguments }));
-}
-/** The tool-call ids of an assistant message, in order, to pair with results. */
-function callIdsOf(message) {
-    return message.content.filter((part) => part.type === "toolCall").map((part) => part.id);
-}
-/**
- * Replace a run of consecutive read/search items with one summary item.
- *
- * Done at item level rather than at render, because "consecutive" is a property
- * of the transcript and the renderer only ever sees one item. A run is broken by
- * anything that is not a read/search call: assistant prose, an edit, a shell
- * command, a result whose call was not collapsible. The rules and their
- * provenance are in `collapse.ts`.
- *
- * The replacement keeps the id of the FIRST call in the run, so the item's
- * position in the feed does not move and the entrance animation does not
- * re-fire for the rest.
- */
-function collapseItems(items) {
-    const calls = items.map((item) => ({
-        toolName: item.kind === "result" || item.kind === "tool" ? item.title : "",
-        line: item.call ?? item.body,
-    }));
-    const groups = collapseGroups(calls);
-    if (groups.length === 0)
-        return items;
-    const byStart = new Map(groups.map((group) => [group.start, group]));
-    const covered = new Set(groups.flatMap((group) => group.indices));
-    const out = [];
-    for (const [index, item] of items.entries()) {
-        const group = byStart.get(index);
-        if (group) {
-            const first = items[group.start];
-            out.push({
-                id: first?.id ?? `g-${group.start}`,
-                kind: "collapsed",
-                title: "collapsed",
-                body: group.summary,
-                // The individual calls are kept whole under the summary, so `ctrl+e`
-                // still reaches them. A collapse that discarded the detail would be a
-                // lossy render, and this is a view, not a transform.
-                full: group.indices.map((i) => items[i]?.call ?? items[i]?.body ?? "").filter(Boolean),
-            });
-            continue;
-        }
-        if (covered.has(index))
-            continue;
-        out.push(item);
-    }
-    return out;
-}
-export function itemsFromMessages(messages) {
-    const items = [];
-    for (const message of messages) {
-        if (message.role === "user") {
-            const body = textOf(message.content).trim();
-            if (!body)
-                continue;
-            // `u-` and not `you-`: the feed's own optimistic copy of this message
-            // carries `you-${Date.now()}`, and the two have to be told apart so the
-            // copy can be retired when the real turn arrives. See `sendTask`.
-            items.push({ id: `u-${message.timestamp}`, kind: "user", title: "you", body });
-        }
-        else if (message.role === "assistant") {
-            const body = textOf(message.content).trim();
-            const calls = toolCallsOf(message);
-            const callIds = callIdsOf(message);
-            if (body) {
-                items.push({
-                    id: `a-${message.timestamp}`,
-                    kind: message.stopReason === "error" ? "error" : "assistant",
-                    title: message.errorMessage ? "failed" : "fix",
-                    body: message.errorMessage ? `${message.errorMessage}\n\n${body}` : body,
-                });
-            }
-            else if (message.errorMessage) {
-                items.push({
-                    id: `e-${message.timestamp}`,
-                    kind: "error",
-                    title: "failed",
-                    body: message.errorMessage,
-                });
-            }
-            calls.forEach((call, index) => {
-                const toolCallId = callIds[index];
-                items.push({
-                    id: toolCallId ? `tool-${toolCallId}` : `c-${message.timestamp}-${index}`,
-                    kind: "tool",
-                    title: call.name,
-                    body: formatToolCall(call.name, call.arguments),
-                    // The id is remembered so the result that follows can settle THIS
-                    // item, the way the live path does. Replay used to push a separate
-                    // result row, which drew every call head first and every summary
-                    // under them - the same bug the live path had, still present here.
-                    ...(toolCallId ? { call: formatToolCall(call.name, call.arguments) } : {}),
-                });
-            });
-        }
-        else if (message.role === "toolResult") {
-            const body = formatToolResult(message.toolName, { content: message.content }, message.isError);
-            // Settle the call that produced this result, in place. One item per call,
-            // head then summary, so a count cannot sit under a call it came from
-            // somewhere else - and so a run of reads is a run of one kind of item.
-            const settled = items.find((entry) => entry.id === `tool-${message.toolCallId}`);
-            if (settled) {
-                settled.kind = "result";
-                settled.body = body;
-                settled.title = message.toolName;
-            }
-            else {
-                items.push({
-                    id: `r-${message.toolCallId}`,
-                    kind: "result",
-                    title: message.toolName,
-                    body,
-                });
-            }
-        }
-    }
-    return collapseItems(items);
-}
-function linesOf(text, width, color) {
-    return wrapTextWithAnsi(text, Math.max(8, width)).map((line) => fg(line, color));
-}
-/**
- * Markdown components, memoised per feed item.
- *
- * The SDK's `Markdown` caches its lexed output per instance on `(text, width)`,
- * so constructing one per render throws that cache away: the 90 ms spinner tick
- * re-lexes every message in the transcript while the agent streams, and a long
- * session pays for the whole scrollback on every frame. Reusing the instance
- * means a finalised item lexes once ever, and a streaming item lexes once per
- * content change instead of once per frame. The entry is dropped when the item
- * leaves the feed, so the map cannot outgrow the feed.
- */
-const markdownByItem = new Map();
-function markdownFor(item) {
-    const body = item.body || " ";
-    const cached = markdownByItem.get(item.id);
-    if (cached) {
-        if (cached.text !== body) {
-            cached.component.setText(body);
-            cached.text = body;
-        }
-        return cached.component;
-    }
-    const component = new Markdown(body, 0, 0, mdTheme);
-    markdownByItem.set(item.id, { text: body, component });
-    return component;
-}
-class Block {
-    item;
-    constructor(item) {
-        this.item = item;
-    }
-    invalidate() { }
-    /**
-     * Fade a colour in with the item. Assistant bodies come from the markdown
-     * renderer, which owns its own colours and its own memoised lex, so they are
-     * left alone: re-painting them per frame is exactly the cost that memo exists
-     * to avoid.
-     */
-    shade(color) {
-        const age = Date.now() - (this.item.born ?? 0);
-        return fade(ink.dim, color, entrance(age, ENTRANCE_MS));
-    }
-    render(width) {
-        const body = this.item.body;
-        if (this.item.kind === "user") {
-            // The queue notice. The run is still working and has not read this yet:
-            // without the line, the message sitting in the transcript above the
-            // agent's old plan reads as the agent ignoring it.
-            const head = this.item.pending ? [fg("  queued — the run reads this at its next step", ink.dim)] : [];
-            return ["", ...linesOf(`> ${body}`, width, this.shade(ink.user)), ...head];
-        }
-        // Tool call and result follow Claude Code's shape: a `⏺` head with the
-        // arguments, then an indented `⎿` line carrying the summary.
-        // A call in flight is marked with a spinner frame, because the absence of a
-        // result line is not a signal. Before this, a running call and a call whose
-        // result had simply not been drawn yet looked the same - one line, no
-        // marker - so a reader could not tell "working" from "nothing happened".
-        //
-        // The frame comes from the clock rather than from stored state, the same way
-        // the HUD's spinner does, and the tick that already runs while a run is live
-        // is what repaints it. No second timer.
-        if (this.item.kind === "tool") {
-            return [fg(`${spinnerFrame()} ${body}`, this.shade(ink.tool))];
-        }
-        // A collapsed run draws as one dim line with the expand marker, because the
-        // point of collapsing is that the reader does not have to look at it. The
-        // individual calls stay in `full`, so `ctrl+e` still reaches them.
-        if (this.item.kind === "collapsed") {
-            // The individual calls are kept in `full`, and ctrl+e has to reach them:
-            // a collapse that discarded the detail would be a lossy render, and the
-            // summary it leaves behind is a claim about calls the reader can no longer
-            // check. `full` holds call lines rather than output, so they draw as the
-            // calls themselves, dimmed - not under a `└` they did not come from.
-            const collapsedLines = [fg(`${EXPAND_MARKER} ${body}`, this.shade(ink.mute))];
-            const members = this.item.full ?? [];
-            if (members.length > 0) {
-                if (this.item.expanded === true) {
-                    for (const line of members)
-                        collapsedLines.push(fg(`  ${line}`, this.shade(ink.dim)));
-                }
-                else {
-                    collapsedLines.push(fg(`  ${members.length} call(s) · ctrl+e to expand`, ink.dim));
-                }
-            }
-            return collapsedLines;
-        }
-        if (this.item.kind === "result") {
-            const failed = body.startsWith("exit ") && body !== "exit 0";
-            // A panel owns its own full block: the two-pane view draws its own header,
-            // boxes and footer, so it must not be nested under a `└` summary line.
-            if (this.item.panel) {
-                return ["", ...this.item.panel(width), ...(body ? [fg(`  ${RESULT_MARKER}  ${body}`, failed ? ink.bad : ink.mute)] : [])];
-            }
-            // The call that produced this result is drawn first when the item kept it:
-            // a settled call is one item with two lines (`● Read(x)` then `└ 120 lines`),
-            // so a summary can never sit under a call it did not come from.
-            const lines = [];
-            if (this.item.call)
-                lines.push(fg(this.item.call, this.shade(ink.tool)));
-            const head = `  ${RESULT_MARKER}  ${body}`;
-            lines.push(fg(head, failed ? ink.bad : this.shade(ink.mute)));
-            // Detail lines cascade under the summary (a diff, the tail of a shell
-            // call) instead of landing in one slab: a line that has not had its turn
-            // is not drawn, so the block grows into place. An expanded item skips the
-            // cascade — the reader asked for the body, so making them wait line by line
-            // would fight the request.
-            const expanded = this.item.expanded === true && (this.item.full?.length ?? 0) > 0;
-            if (expanded) {
-                const hint = fg(`     ${this.item.full.length} line(s) · ctrl+e to collapse`, ink.dim);
-                lines.push(fg(`     ${EXPAND_MARKER}`, ink.dim));
-                for (const line of this.item.full) {
-                    const color = line.startsWith("+") ? ink.tool : line.startsWith("-") ? ink.bad : ink.dim;
-                    lines.push(fg(`     ${line}`, color));
-                }
-                lines.push(hint);
-                return lines;
-            }
-            const detail = this.item.detail ?? [];
-            const visible = revealedLines(Date.now() - (this.item.born ?? 0), detail.length);
-            for (const line of detail.slice(0, visible)) {
-                const color = line.startsWith("+") ? ink.tool : line.startsWith("-") ? ink.bad : ink.dim;
-                lines.push(fg(`     ${line}`, this.shade(color)));
-            }
-            // Tell the reader the body exists at all: a summary with no hint reads as
-            // the whole result.
-            if ((this.item.full?.length ?? 0) > 0) {
-                lines.push(fg(`     ${EXPAND_MARKER} ${this.item.full.length} line(s) · ctrl+e to expand`, ink.dim));
-            }
-            return lines;
-        }
-        if (this.item.kind === "error" || this.item.kind === "note") {
-            const color = this.item.kind === "error" ? ink.bad : ink.mute;
-            return ["", ...linesOf(body, width, this.shade(color))];
-        }
-        const markdown = markdownFor(this.item);
-        return ["", ...markdown.render(Math.max(8, width - 2))];
-    }
-}
-export class FeedView {
-    items = [];
-    status = "";
-    /**
-     * How many rows have been scrolled back from the newest line. The viewport
-     * hands the feed its height, so the feed can decide which slice of the
-     * transcript to draw: the pane scrolls its own content instead of asking the
-     * terminal to scroll the whole frame (which would take the footer with it).
-     */
-    scrollOffset = 0;
-    /**
-     * The transcript line the reader is parked on, or `undefined` when they are
-     * following the newest line.
-     *
-     * `scrollOffset` alone is a distance from the end, and that distance moves
-     * under the reader whenever output arrives: the same offset resolves to
-     * different content, so a parked reader drifts forward with every new line.
-     * Measured: parked 12 rows back, five new lines moved the window from
-     * BODY49..BODY53 to BODY54..BODY58 with no keystroke.
-     *
-     * The anchor is the fix: the resolved offset is turned into the line it points
-     * at, and that line is what the next frame keeps. It is cleared automatically
-     * when `scrollOffset` changes from the value `render` last settled on, so a
-     * deliberate scroll — from any caller, without needing to remember anything —
-     * is honoured as an end-relative request.
-     */
-    scrollAnchor;
-    /** The offset `render` last resolved, used to tell a new scroll from a settled one. */
-    settledOffset = 0;
-    /**
-     * Rows the pane has been given. Set by the workbench each frame before the
-     * render, because the feed is what decides how much of the transcript fits —
-     * the layout hands a component a width, never a height.
-     */
-    viewportHeight = 0;
-    invalidate() { }
-    /** True while any item is still fading in or revealing its detail, so the clock can keep running. */
-    entering() {
-        const now = Date.now();
-        return this.items.some((item) => {
-            if (item.born === undefined)
-                return false;
-            const age = now - item.born;
-            if (entering(age, ENTRANCE_MS))
-                return true;
-            // The cascade outlives the fade by design (450 ms of lines at worst), and
-            // a clock that stopped at 260 ms would leave the block half-drawn.
-            return (item.detail?.length ?? 0) > revealedLines(age, item.detail?.length ?? 0);
-        });
-    }
-    render(width) {
-        // Drop memoised renderers for items the feed no longer holds (the feed is
-        // reset on /new and /resume, and the session's items are rebuilt from the
-        // transcript), so the map tracks the feed rather than growing with it.
-        if (markdownByItem.size > this.items.length) {
-            const live = new Set(this.items.map((item) => item.id));
-            for (const id of markdownByItem.keys())
-                if (!live.has(id))
-                    markdownByItem.delete(id);
-        }
-        const lines = [];
-        for (const item of this.items) {
-            // First sight of an item is its birth: an item appended by the workbench
-            // arrives the frame after it is pushed, and an item rebuilt from the
-            // transcript is born fully opaque instead of replaying an entrance.
-            item.born ??= Date.now();
-            lines.push(...new Block(item).render(width));
-        }
-        if (this.status)
-            lines.push(fg(this.status, ink.mute));
-        // Draw only the window the viewport asked for.
-        //
-        // Rendering everything made the scroll view's content taller than its
-        // viewport, so it scrolled the whole frame — taking the footer with it —
-        // instead of the transcript.
-        //
-        // The window is anchored to *content*, not to the distance from the end.
-        // `scrollOffset` alone ("N rows back from the newest line") is a moving
-        // target: new output pushes the transcript's tail down, so the same offset
-        // resolves to different content and the reader drifts forward while they are
-        // reading. Measured: with the reader parked 12 rows back, five new lines
-        // moved them from BODY49..BODY53 to BODY54..BODY58 without a keystroke.
-        //
-        // So the offset is resolved to the line it points at and *that* is stored.
-        // While the reader is still, the anchored line is what they keep and
-        // `scrollOffset` is recomputed from it every frame, so the two never
-        // disagree; a scroll is detected by the offset moving and drops the anchor.
-        // When the anchor cannot be resolved — the transcript shrank under it — the
-        // anchor is kept and the offset is clamped for drawing, so the position is
-        // restored when the content grows back instead of being lost for good.
-        const height = this.viewportHeight;
-        if (height > 0 && lines.length > height) {
-            const maxOffset = lines.length - height;
-            // A new request means the caller moved `scrollOffset` since the last
-            // frame; that is a deliberate scroll, so the content anchor is dropped and
-            // the request is read against the end of the transcript, as intended.
-            if (this.scrollOffset !== this.settledOffset)
-                this.scrollAnchor = undefined;
-            const anchor = this.scrollAnchor;
-            let offset;
-            if (anchor !== undefined) {
-                const fromAnchor = lines.length - anchor;
-                if (fromAnchor >= 0 && fromAnchor <= maxOffset) {
-                    // The anchored line is still drawable: keep it exactly where it is.
-                    offset = fromAnchor;
-                }
-                else {
-                    // The anchored line is off the end for now: draw the nearest position
-                    // that is drawable but keep the anchor, so the reader's place is
-                    // restored when the transcript grows back rather than lost for good.
-                    offset = Math.max(0, Math.min(this.scrollOffset, maxOffset));
-                }
-            }
-            else {
-                offset = Math.max(0, Math.min(this.scrollOffset, maxOffset));
-            }
-            // The offset the reader asked for is kept when an anchor is held, so a
-            // later frame can resolve the anchor again; only the drawn offset moves.
-            if (anchor === undefined)
-                this.scrollOffset = offset;
-            this.settledOffset = this.scrollOffset;
-            if (offset === 0) {
-                // Following the tail is not a position to preserve.
-                this.scrollAnchor = undefined;
-            }
-            else if (this.scrollAnchor === undefined) {
-                this.scrollAnchor = lines.length - offset;
-            }
-            return lines.slice(maxOffset - offset, maxOffset - offset + height);
-        }
-        // Everything fits, so there is nothing to scroll and the whole transcript is
-        // drawn. `scrollOffset` is deliberately NOT cleared here.
-        //
-        // It used to be, and that made the position a measurement instead of an
-        // intent: one frame where the transcript was shorter than the viewport — a
-        // compaction summarizing the older turns, a session swap, the moment before
-        // a rebuild lands — zeroed it for good. When the transcript grew back the
-        // reader was snapped to the newest line with no way to return, which is the
-        // "it scrolls by itself after compaction" report a sibling harness carries
-        // (#1755: "resetting to top on content load"). The clamp above is enough;
-        // the intent survives it.
-        return lines;
-    }
-}