maka-agent 0.2.1-dev.80.20261012 → 0.2.1-dev.83.20261014

package/dist/acp/tool-event-mapper.js

@@ -86,7 +86,7 @@ export class AcpToolEventMapper {
                     return;
                 if (event.operationId)
                     tool.meta.operationId = event.operationId;
-                await this.#result(tool, event.isError, event.content, event.durationMs, event.contentOmitted === true);
+                await this.#result(tool, event.isError, event.content, event.durationMs, event.contentOmitted === true, event.outcome);
                 return;
         }
         await this.#publish(tool);
@@ -97,7 +97,7 @@ export class AcpToolEventMapper {
             await this.#call(tool, message);
         }
         else if (message.type === 'tool_result') {
-            await this.#result(this.#ensure(message.turnId, message.toolUseId), message.isError, message.content, message.durationMs, false);
+            await this.#result(this.#ensure(message.turnId, message.toolUseId), message.isError, message.content, message.durationMs, false, message.outcome);
         }
     }
     async pendingInteraction(pending) {
@@ -203,9 +203,10 @@ export class AcpToolEventMapper {
         }
         return tool;
     }
-    async #result(tool, isError, result, durationMs, omitted) {
+    async #result(tool, isError, result, durationMs, omitted, outcome) {
         const resultDigest = digestValue({
             isError,
+            outcome,
             result: omitted ? null : result,
             durationMs,
             omitted,
@@ -215,7 +216,7 @@ export class AcpToolEventMapper {
         if (omitted)
             tool.resultAnnounced = true;
         tool.terminal = true;
-        const hostStatus = toolResultActivityStatus(isError, omitted ? undefined : result);
+        const hostStatus = toolResultActivityStatus(isError, omitted ? undefined : result, outcome);
         tool.status = hostStatus === 'completed' ? 'completed' : 'failed';
         tool.meta.hostStatus = hostStatus;
         if (durationMs !== undefined)
@@ -315,7 +316,11 @@ export class AcpToolEventMapper {
                     type: 'text',
                     text: `[${output.stream}]${output.redacted ? ' [redacted]' : ''} ${output.chunk}`,
                     _meta: {
-                        maka: { sequence: output.seq, stream: output.stream, redacted: output.redacted },
+                        maka: {
+                            sequence: output.seq,
+                            stream: output.stream,
+                            redacted: output.redacted,
+                        },
                     },
                 },
             });
@@ -412,7 +417,10 @@ function bounded(text, max, suffix = '…') {
     const before = text.charCodeAt(length - 1);
     if (before >= 0xd800 && before <= 0xdbff)
         length -= 1;
-    return { text: `${text.slice(0, length)}${suffix}`, dropped: text.length - length };
+    return {
+        text: `${text.slice(0, length)}${suffix}`,
+        dropped: text.length - length,
+    };
 }
 function textContent(text) {
     return [{ type: 'content', content: { type: 'text', text } }];

package/dist/cli-core.js

@@ -668,6 +668,7 @@ export async function runMakaCli(argv = process.argv.slice(2), options = RELEASE
                 locale: locale.locale,
                 cwd: process.cwd(),
                 onProcessExit: handleMakaCliProcessExit,
+                buildVersion: version,
                 ...(command.resumeSessionId ? { resumeSessionId: command.resumeSessionId } : {}),
                 ...(command.resumeCwd ? { resumeCwd: command.resumeCwd } : {}),
                 ...(command.hostProfileId ? { hostProfileId: command.hostProfileId } : {}),

package/dist/fullscreen-mode.js

@@ -0,0 +1,165 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { spawn } from 'node:child_process';
+import { defineUiMessageCatalog, formatUiMessage, resolveUiMessageCatalog, } from '@maka/core/ui-locale';
+import { TUI_COPY_RESOURCES } from './tui-copy-catalog.js';
+/**
+ * Nightly trial switch for the fullscreen (alternate-screen) TUI, issue #4136.
+ *
+ * The fullscreen path swaps `TuiMainScreen` for `TuiAltScreen`: the composer
+ * and status line stay anchored to the bottom of the screen while the
+ * transcript scrolls in an application-owned viewport. This is a scoped
+ * product experiment, not a stable mode: it defaults on only for nightly
+ * builds and must not grow a permanent user-facing toggle until the nightly
+ * evidence is in (issue non-goals).
+ *
+ * Precedence, highest first:
+ *  1. `setting` — an explicit caller decision (`MakaPiTuiInput.tuiFullscreen`),
+ *     used by embeddings and tests.
+ *  2. `override` — the `MAKA_TUI_FULLSCREEN` environment variable. `1`/`true`
+ *     opts a release build in; `0`/`false` opts a nightly build out.
+ *  3. `packageVersion` — nightly default: on for `-dev.` versions (the
+ *     Product Nightly identity in scripts/product-nightly.mjs), off otherwise.
+ */
+export const TUI_FULLSCREEN_ENV = 'MAKA_TUI_FULLSCREEN';
+export function isNightlyPackageVersion(version) {
+    if (!version)
+        return false;
+    // Product Nightly versions look like `0.2.0-dev.<runNumber>.<YYYYMMDD>`;
+    // formal releases are always a stable product version.
+    return /-dev\.[1-9]\d*\.\d{8}$/u.test(version);
+}
+export function resolveTuiFullscreen(resolution = {}) {
+    if (typeof resolution.setting === 'boolean')
+        return resolution.setting;
+    const override = resolution.override?.trim().toLowerCase();
+    if (override === '1' || override === 'true')
+        return true;
+    if (override === '0' || override === 'false')
+        return false;
+    return isNightlyPackageVersion(resolution.packageVersion);
+}
+/**
+ * Counts transcript lines appended while the user is scrolled away from the
+ * bottom — the "unread / new output" signal for the anchored-composer trial.
+ *
+ * Updated once per frame with the current window snapshot: growth accumulates
+ * while the user is away, arriving at the bottom clears the count. Shrinks
+ * (collapsing tool output, re-wraps) never manufacture unread lines; the
+ * counter is approximate by design — it is an attention hint, not an exact
+ * diff.
+ */
+export class UnreadOutputCounter {
+    lastDocumentLines;
+    unreadLines = 0;
+    update(window) {
+        if (!window.followingEnd &&
+            this.lastDocumentLines !== undefined &&
+            window.documentLines > this.lastDocumentLines) {
+            this.unreadLines += window.documentLines - this.lastDocumentLines;
+        }
+        if (window.followingEnd)
+            this.unreadLines = 0;
+        this.lastDocumentLines = window.documentLines;
+        return this.unreadLines;
+    }
+}
+const TUI_UNREAD_INDICATOR_COPY = resolveUiMessageCatalog(defineUiMessageCatalog()(TUI_COPY_RESOURCES['unread-indicator']));
+/** The rendered unread line: accent-colored, one row, empty when nothing is new. */
+export function renderUnreadIndicator(unreadLines, accent, locale) {
+    if (unreadLines <= 0)
+        return [];
+    return [
+        accent(formatUiMessage(TUI_UNREAD_INDICATOR_COPY[locale].hint, { count: unreadLines }, locale)),
+    ];
+}
+/**
+ * URL schemes a model-authored OSC 8 link may be opened with, mirroring the
+ * desktop's external-link guard (apps/desktop/src/main/external-link-guard.ts):
+ * web and mail only. Assistant Markdown is rendered with the raw href, so
+ * everything else — `file:`, `javascript:`, unknown handlers, UNC paths —
+ * must never reach an OS opener from a click.
+ */
+const OPENABLE_URL_PROTOCOLS = new Set(['http:', 'https:', 'mailto:']);
+export function isOpenableExternalUrl(url) {
+    try {
+        return OPENABLE_URL_PROTOCOLS.has(new URL(url).protocol);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Opens an OSC 8 hyperlink activated by a primary-button click in the
+ * fullscreen viewport. Model-authored hrefs are untrusted input, so the
+ * opener is deliberately narrow:
+ *
+ * - Only `http:`, `https:`, and `mailto:` targets are handed off at all.
+ * - Windows never routes the URL through cmd.exe — `spawn`'s argument
+ *   quoting does not escape shell metacharacters (`&` would start a second
+ *   command under `cmd /c start`), so the opener is `rundll32
+ *   url.dll,FileProtocolHandler`, which receives the URL as a single argv
+ *   element and hands it to ShellExecute. The DLL/entrypoint half of the
+ *   command line is a compile-time constant, so a hostile URL cannot
+ *   redirect it.
+ * - macOS/Linux openers take the URL as a plain argv element (no shell).
+ *
+ * Failures are swallowed — a dead link must never take the TUI down.
+ */
+/**
+ * Spawns a detached, fire-and-forget opener process. `spawn` reports a
+ * missing binary (and other spawn failures) asynchronously via the child's
+ * `error` event — with no listener attached, Node re-emits it as an
+ * uncaughtException, which the TUI's handler treats as fatal and begins
+ * session teardown. The child is therefore kept and its error swallowed: a
+ * dead link must degrade to "nothing opened", never end the session.
+ * Synchronous throws (invalid arguments) are swallowed here as well.
+ */
+function spawnDetached(spawnProcess, command, args, windowsHide = false) {
+    try {
+        const child = spawnProcess(command, args, {
+            detached: true,
+            stdio: 'ignore',
+            ...(windowsHide ? { windowsHide: true } : {}),
+        });
+        child.on('error', () => { });
+        child.unref();
+    }
+    catch {
+        // Best-effort only; the terminal may also offer its own link handling.
+    }
+}
+export function openExternalUrl(url, platform = process.platform, spawnProcess = spawn) {
+    if (!isOpenableExternalUrl(url))
+        return;
+    if (platform === 'darwin') {
+        spawnDetached(spawnProcess, 'open', [url]);
+        return;
+    }
+    if (platform === 'win32') {
+        // Never cmd.exe: `spawn`'s argument quoting does not escape shell
+        // metacharacters, and `cmd /c start` would let a model-authored `&`
+        // start a second command. rundll32 receives the URL as a single argv
+        // element and hands it to ShellExecute; the DLL/entrypoint half is a
+        // compile-time constant, so a hostile URL cannot redirect what runs.
+        spawnDetached(spawnProcess, 'rundll32', ['url.dll,FileProtocolHandler', url], true);
+        return;
+    }
+    spawnDetached(spawnProcess, 'xdg-open', [url]);
+}

package/dist/mcp-capability-provider.js

@@ -103,6 +103,7 @@ function projectMcpTool(tool, wireServerId) {
 }
 function projectMcpResult(result) {
     return {
+        outcome: 'success',
         content: result.content.map((block) => structuredClone(block)),
         ...(result.structuredContent === undefined
             ? {}

package/dist/pi-transcript.js

@@ -544,7 +544,7 @@ export function applyMakaSessionEventToTranscript(state, event) {
             if (tool) {
                 if (tool.suppressed)
                     unsuppressToolAtTail(state, tool);
-                tool.callStatus = toolResultActivityStatus(event.isError, event.content);
+                tool.callStatus = toolResultActivityStatus(event.isError, event.content, event.outcome);
                 if (shellRun) {
                     if (tool.toolName === 'Bash') {
                         applyShellRunResult(tool, shellRun);
@@ -575,7 +575,7 @@ export function applyMakaSessionEventToTranscript(state, event) {
                     ...(!event.contentOmitted ? { result: event.content } : {}),
                     resultVersion: event.contentOmitted ? 0 : 1,
                     durationMs: event.durationMs,
-                    callStatus: toolResultActivityStatus(event.isError, event.content),
+                    callStatus: toolResultActivityStatus(event.isError, event.content, event.outcome),
                     expanded: state.expandAllTools,
                 });
             }
@@ -714,9 +714,21 @@ export function applyMakaSessionEventToTranscript(state, event) {
 }
 function storedMessagesToTranscriptEntries(messages) {
     const entries = [];
-    const resultsByToolUseId = new Map(messages
-        .filter((message) => message.type === 'tool_result')
-        .map((message) => [message.toolUseId, message]));
+    const latestCallsByUseId = new Map();
+    const resultsByCall = new Map();
+    // Append order bounds an opaque ID's ownership: a result belongs to the latest
+    // preceding call, and a later call with that ID starts a new interval.
+    for (const message of messages) {
+        if (message.type === 'tool_call') {
+            latestCallsByUseId.set(message.id, message);
+            continue;
+        }
+        if (message.type !== 'tool_result')
+            continue;
+        const call = latestCallsByUseId.get(message.toolUseId);
+        if (call)
+            resultsByCall.set(call, message);
+    }
     const turnStatusById = new Map(deriveTurnRecords(messages).map((turn) => [turn.turnId, turn.status]));
     for (const message of messages) {
         switch (message.type) {
@@ -750,7 +762,7 @@ function storedMessagesToTranscriptEntries(messages) {
                 break;
             }
             case 'tool_call':
-                entries.push(storedToolToTranscriptEntry(message, resultsByToolUseId.get(message.id), turnStatusById.get(message.turnId)));
+                entries.push(storedToolToTranscriptEntry(message, resultsByCall.get(message), turnStatusById.get(message.turnId)));
                 break;
             case 'system_note': {
                 const entry = systemNoteToTranscriptEntry(message);
@@ -780,7 +792,7 @@ function storedToolToTranscriptEntry(call, result, turnStatus) {
         resultVersion: result ? 1 : 0,
         ...(result?.durationMs !== undefined ? { durationMs: result.durationMs } : {}),
         callStatus: result
-            ? toolResultActivityStatus(result.isError, result.content)
+            ? toolResultActivityStatus(result.isError, result.content, result.outcome)
             : unfinishedToolActivityStatus(turnStatus),
         expanded: false,
     };

package/dist/pi-tui-layout.js

@@ -21,7 +21,16 @@ import { Container } from '@earendil-works/pi-tui';
 // compare the same canonical lines pi-tui diffs, and pi-tui normalizes Thai/Lao
 // AM sequences before its diff. Pinned to pi-tui 0.80.3.
 import { normalizeTerminalOutput } from '@earendil-works/pi-tui/dist/utils.js';
+// Separate statements, anchored below the deep import rather than appended to
+// the Container import: upstream inserts its UiLocale import directly after
+// the Container line and its TranscriptDocument import after the
+// pi-transcript block, and imports in this gap keep this PR's changes out of
+// both of those diff gaps so the three-way merge resolves cleanly.
+import { ScrollView } from '@earendil-works/pi-tui';
+import { renderUnreadIndicator, UnreadOutputCounter } from './fullscreen-mode.js';
 import { renderMakaPiActivityStrip, renderMakaPiPendingQueue, renderMakaPiStatusLine, renderMakaPiTranscript, } from './pi-transcript.js';
+/** Rows the transcript keeps in the fullscreen layout even on tiny terminals. */
+const FULLSCREEN_TRANSCRIPT_MIN_ROWS = 1;
 export function fitPendingQueueLines(lines, maxRows) {
     const rowBudget = Math.max(0, Math.floor(maxRows));
     if (lines.length <= rowBudget)
@@ -32,6 +41,28 @@ export function fitPendingQueueLines(lines, maxRows) {
         return [`… ${lines.length} more`];
     return [...lines.slice(0, rowBudget - 1), `… ${lines.length - rowBudget + 1} more`];
 }
+/**
+ * The fullscreen chrome's editor/pending-queue row account, isolated in one
+ * function so the budget and its consumers cannot drift apart: from the rows
+ * available below the transcript, reserve the editor's minimum viewport (the
+ * queue trims first), then give the editor whatever remains, never less than
+ * that minimum while any budget is left to reserve it from. `rowsAvailable` is
+ * everything already carved out of the terminal rows — the chrome subtracts the
+ * status line, activity strip, unread indicator, and the reserved transcript row
+ * before calling. The main-screen layout keeps its own (upstream-owned)
+ * accounting; its contract is identical, so the two can be unified onto this
+ * function after merge.
+ */
+function budgetEditorAndPendingRows(rowsAvailable, allPendingLines, editor) {
+    const budget = Math.max(0, Math.floor(rowsAvailable));
+    const minimumEditorRows = editor.minimumViewportRows();
+    const pendingRowsAvailable = Math.max(0, budget - minimumEditorRows);
+    const pendingLines = fitPendingQueueLines(allPendingLines, pendingRowsAvailable);
+    return {
+        pendingLines,
+        editorRows: budget === 0 ? 0 : Math.max(minimumEditorRows, budget - pendingLines.length),
+    };
+}
 export class MakaTranscriptComponent {
     state;
     metadata;
@@ -311,3 +342,238 @@ export class MakaPiLayoutComponent extends Container {
         return Math.max(current, tailTop);
     }
 }
+/**
+ * The ScrollView child of the fullscreen layout: renders the complete
+ * transcript document (the scroll view windows it) and exposes the rendered
+ * line count so the scroll view can count lines appended while the user is
+ * scrolled away. Lives in pi-tui-layout.ts alongside the other transcript
+ * adapters.
+ */
+export class MakaTranscriptDocumentComponent {
+    transcript;
+    /** Rendered transcript document lines from the most recent frame. */
+    documentLines = 0;
+    constructor(transcript) {
+        this.transcript = transcript;
+    }
+    invalidate() {
+        this.transcript.invalidate();
+    }
+    render(width) {
+        const lines = this.transcript.render(width);
+        this.documentLines = lines.length;
+        return lines;
+    }
+}
+/**
+ * The fullscreen layout's transcript scroll view. `ScrollView.updateLayout`
+ * runs at the layout pass with this frame's content height and scroll state —
+ * the one point in the frame where the window is fresh — so this subclass
+ * computes the unread count there and compares it with what the anchored
+ * chrome actually rendered (`presentedUnread`, written back by the chrome via
+ * its `UnreadOutputFeed`). The chrome is measured before the scroll view is
+ * laid out, so its view lags one frame; when the rendered count falls behind,
+ * a catch-up render is requested and the indicator settles deterministically.
+ */
+export class MakaTranscriptScrollView extends ScrollView {
+    document;
+    /** Unread count as of the most recent layout pass. */
+    computedUnread = 0;
+    /** Unread count the chrome last rendered. */
+    presentedUnread = 0;
+    counter = new UnreadOutputCounter();
+    constructor(document, options) {
+        super(document, options);
+        this.document = document;
+    }
+    updateLayout(contentHeight, viewportHeight, requestRender) {
+        super.updateLayout(contentHeight, viewportHeight, requestRender);
+        this.computedUnread = this.counter.update({
+            followingEnd: this.isFollowingEnd,
+            documentLines: this.document.documentLines,
+        });
+        if (this.computedUnread !== this.presentedUnread)
+            requestRender();
+    }
+}
+/**
+ * The anchored bottom chrome of the fullscreen layout (issue #4136): unread
+ * indicator, activity strip, pending queue, editor, and status line — stacked
+ * below the scrolling transcript and pinned to the screen bottom by the
+ * VStack. The transcript region above owns its own scrolling, so unlike
+ * `MakaPiLayoutComponent` this component emits only the chrome rows and never
+ * pads or windows the transcript.
+ *
+ * The unread count comes from the scroll view's `UnreadOutputFeed` (see
+ * `MakaTranscriptScrollView`): the layout engine measures this component
+ * before the scroll view is laid out, so the count it reads lags one frame and
+ * the scroll view requests a catch-up render whenever the rendered count falls
+ * behind.
+ *
+ * `renderGeometry.viewportTop` is pinned to 0: the app owns the whole screen,
+ * no rendered line sits in untouchable terminal scrollback, so the
+ * entry-freeze and viewport-restricted expansion toggles that main-screen mode
+ * needs (#1097, #1134, #4011) must not engage — every entry stays
+ * re-renderable and globally toggleable.
+ */
+export class MakaFullscreenChromeComponent extends Container {
+    state;
+    activityStrip;
+    pendingQueue;
+    editor;
+    statusLine;
+    terminal;
+    unreadFeed;
+    accent;
+    locale;
+    todoIndicator;
+    /**
+     * Host-owned blocking interaction (the inline user-question prompt). The
+     * fullscreen layout root renders and routes only the mounted tree, so in
+     * fullscreen this chrome owns the role `MakaPiLayoutComponent` owns on the
+     * main screen: it draws the interaction with the same row budgeting (the
+     * editor yields to it, the transcript keeps its minimum row) and mounts it
+     * as a child so input routing reaches it (#4136 review P1).
+     */
+    blockingInteraction;
+    constructor(state, activityStrip, pendingQueue, editor, statusLine, terminal, unreadFeed, accent, locale, todoIndicator) {
+        super();
+        this.state = state;
+        this.activityStrip = activityStrip;
+        this.pendingQueue = pendingQueue;
+        this.editor = editor;
+        this.statusLine = statusLine;
+        this.terminal = terminal;
+        this.unreadFeed = unreadFeed;
+        this.accent = accent;
+        this.locale = locale;
+        this.todoIndicator = todoIndicator;
+    }
+    setBlockingInteraction(interaction) {
+        if (this.blockingInteraction === interaction)
+            return;
+        if (this.blockingInteraction)
+            this.removeChild(this.blockingInteraction);
+        this.blockingInteraction = interaction;
+        if (interaction)
+            this.addChild(interaction);
+    }
+    render(width) {
+        const unreadLines = this.unreadFeed.current();
+        const indicatorLines = renderUnreadIndicator(unreadLines, this.accent, this.locale);
+        this.unreadFeed.present(unreadLines);
+        // App-owned viewport: no terminal scrollback exists, so expansion toggles
+        // may retarget any entry and no entry is ever frozen off-screen.
+        this.state.renderGeometry.viewportTop = 0;
+        const allActivityLines = this.activityStrip.render(width);
+        // The activity strip renders one row even when idle (an empty string);
+        // an all-empty strip would burn a permanent chrome row between the
+        // transcript and the editor, so it collapses to nothing when idle.
+        const activityRows = allActivityLines.some((line) => line.length > 0) ? allActivityLines : [];
+        // #1064's separator, fullscreen edition: keep "Working... Ns" from
+        // touching the last visible transcript line when a turn is running. This
+        // row is part of the chrome's emitted height, so the budget must count it
+        // too — otherwise the VStack clips the chrome's bottom (the status line)
+        // on short terminals while a Host question is live (#4136 review P2).
+        const activitySeparator = activityRows.length > 0 ? [''] : [];
+        const allPendingLines = this.pendingQueue.render(width);
+        const statusLines = this.statusLine.render(width);
+        const blockingInteraction = this.blockingInteraction;
+        // Same input selection as MakaPiLayoutComponent: an active blocking
+        // question replaces the composer in the chrome stack.
+        const input = blockingInteraction ?? this.editor;
+        const minimumInputRows = input.minimumViewportRows();
+        // Same row account as MakaPiLayoutComponent via budgetEditorAndPendingRows,
+        // with the unread indicator, the live-activity separator, the Todo row, and
+        // the transcript's minimum row reserved up front so the chrome's intrinsic
+        // height can never push the transcript below one row or overflow the
+        // allocation the VStack gives it.
+        let effectiveMargin = blockingInteraction ? 1 : 0;
+        const fixedChrome = indicatorLines.length +
+            activitySeparator.length +
+            activityRows.length +
+            statusLines.length +
+            effectiveMargin +
+            FULLSCREEN_TRANSCRIPT_MIN_ROWS;
+        const todoLines = this.todoIndicator &&
+            this.terminal.rows > fixedChrome + allPendingLines.length + minimumInputRows
+            ? (this.todoIndicator.render(width) ?? []).slice(0, 1)
+            : [];
+        // With a blocking question live, the pending queue yields to the question
+        // (budgeted against the question's minimum rows, as on the main screen)
+        // and the question then takes the remaining rows; without one, the editor
+        // and pending queue split the budget through the shared helper.
+        const budgetChrome = (fixed) => blockingInteraction
+            ? (() => {
+                const questionPending = fitPendingQueueLines(allPendingLines, Math.max(0, this.terminal.rows - fixed - todoLines.length - minimumInputRows));
+                return {
+                    pendingLines: questionPending,
+                    inputRows: this.terminal.rows - fixed - todoLines.length - questionPending.length,
+                };
+            })()
+            : (() => {
+                const budgeted = budgetEditorAndPendingRows(this.terminal.rows - fixed - todoLines.length, allPendingLines, this.editor);
+                return { pendingLines: budgeted.pendingLines, inputRows: budgeted.editorRows };
+            })();
+        let effectiveFixedChrome = fixedChrome;
+        let effectiveSeparator = activitySeparator;
+        let effectiveActivityRows = activityRows;
+        let effectiveIndicator = indicatorLines;
+        let { pendingLines, inputRows } = budgetChrome(effectiveFixedChrome);
+        // Squeeze rule (#4136 review P2): if the remaining budget cannot even give
+        // the input its own minimum, the input is load-bearing and clamps to that
+        // minimum, so decorative chrome rows yield in priority order until the
+        // frame fits the chrome's VStack allocation: the live activity strip and
+        // its separator first, then the question's blank margin row (pure
+        // decoration), and only as a last resort the unread banner — information
+        // yields after decoration. A user scrolled away can catch up after
+        // answering; a clipped status line or an unreachable answer field cannot.
+        // The second round of this review caught the residual case at the 8-row
+        // boundary: an unread banner plus a three-option question still pushed the
+        // chrome two rows past its allocation because only the strip yielded.
+        const yielders = [
+            () => {
+                const drop = effectiveSeparator.length + effectiveActivityRows.length;
+                if (drop === 0)
+                    return 0;
+                effectiveSeparator = [];
+                effectiveActivityRows = [];
+                return drop;
+            },
+            () => {
+                if (effectiveMargin === 0)
+                    return 0;
+                effectiveMargin = 0;
+                return 1;
+            },
+            () => {
+                const drop = effectiveIndicator.length;
+                if (drop === 0)
+                    return 0;
+                effectiveIndicator = [];
+                return drop;
+            },
+        ];
+        for (const yieldRows of yielders) {
+            if (inputRows >= minimumInputRows)
+                break;
+            const dropped = yieldRows();
+            if (dropped === 0)
+                continue;
+            effectiveFixedChrome -= dropped;
+            ({ pendingLines, inputRows } = budgetChrome(effectiveFixedChrome));
+        }
+        input.setViewportRows(inputRows);
+        const inputLines = input.render(width);
+        return [
+            ...effectiveIndicator,
+            ...effectiveSeparator,
+            ...effectiveActivityRows,
+            ...pendingLines,
+            ...todoLines,
+            ...inputLines,
+            ...(effectiveMargin > 0 ? [''] : []),
+            ...statusLines,
+        ];
+    }
+}